The OSINT investigator's workbench. One case, one folder, every tool. Local-first: your media and your investigations never leave your machine.
JavaScript
/*
* The engine's own chrome, dressed as one of the app's surfaces.
*
* These selectors are the engine's DOM, not ours, which is why they live beside
* the module that builds it rather than in whichever tool happens to hold a map:
* a second map surface would otherwise inherit the widget's default white
* speech-bubble look, and swapping the engine would have to hunt for these rules
* in a tool's stylesheet.
*
* The popup is here for the same reason and one more: MapLibre draws the card's
* pointer as a border triangle, built differently for each of the eight sides a
* card can open towards. That is eight rules of engine trivia, and no tool
* should have to know it. A tool names its own card class and sets what is
* genuinely its own — the width it needs — through `--popup-min-width`.
*
* Loaded by `engine.js`, so it arrives with the engine and leaves with it.
*/
.maplibregl-map {
font-family: var(--font-sans);
background: var(--bg-2);
/* A stacking context of its own, so the widget basemap's negative layer
(below) stays inside this element: paints over its background, under its
canvas. Without it the layer drops behind that background and the basemap
is simply a black rectangle. */
isolation: isolate;
}
/* The engine puts its grab cursor on the canvas, which would win over a tool's
own rule for an armed mode. Hold the cursor on the surface instead, where a
tool can say `crosshair` and be obeyed. */
.map-surface {
cursor: grab;
}
.map-surface:active {
cursor: grabbing;
}
.map-surface .maplibregl-canvas-container.maplibregl-interactive,
.map-surface .maplibregl-canvas-container.maplibregl-interactive:active {
cursor: inherit;
}
.maplibregl-ctrl.maplibregl-ctrl-attrib {
background: rgba(24, 24, 24, 0.85);
color: var(--text-3);
font-size: 10px;
}
.maplibregl-ctrl-attrib a {
color: var(--text-2);
}
/* The engine parks its control corners at z-index 2, which is under the ground
overlays every tool paints in the 500s (rules, detections, marks). The zoom
buttons and the attribution ended up behind a translucent layer: still there,
still clickable, and looking broken. They climb over the overlays and stay
under the tool's own chrome, which starts at 600. */
.maplibregl-ctrl-top-left,
.maplibregl-ctrl-top-right,
.maplibregl-ctrl-bottom-left,
.maplibregl-ctrl-bottom-right {
z-index: 580;
}
/* A tool fades a map's picture with `--map-fade`, set on the map or above it.
The picture fades and its control corners do not: faded whole, the map would
be a stacking context again and shut its buttons under what a tool lays
beside it. */
.map-surface > :not(.maplibregl-control-container) {
opacity: var(--map-fade, 1);
}
/* zoom +/- (topleft) sits directly under the tool cluster instead of the
engine's default corner margin, which used to land it on top of that cluster.
How far down is the tool's own business — a map with no cluster over it says
so with `--map-controls-top` — but that it is stacked rather than cornered is
the engine's. */
.maplibregl-ctrl-top-left .maplibregl-ctrl {
margin: var(--map-controls-top, 58px) 0 8px 12px;
}
.maplibregl-ctrl-group {
background: var(--bg-2);
box-shadow: 0 0 0 1px var(--border);
}
.maplibregl-ctrl-group button + button {
border-top-color: var(--border);
}
.maplibregl-ctrl-group button:hover {
background: var(--bg-3);
}
/* The engine's +/- glyphs are dark-on-light images, not text, so they are
turned rather than recoloured — and turned back under the light theme, where
dark on white is what the button already wants. */
.maplibregl-ctrl-group .maplibregl-ctrl-icon {
filter: invert(1);
}
:root[data-theme='light'] .maplibregl-ctrl-group .maplibregl-ctrl-icon {
filter: none;
}
/* …except on a surface kept dark in both themes, whose buttons stay dark */
:root[data-theme='light'] .dark-surface .maplibregl-ctrl-group .maplibregl-ctrl-icon {
filter: invert(1);
}
/* Slim ruler-style scale: no boxed panel, just a light bracket + label floating
directly on the map so it stays readable over any imagery. */
.maplibregl-ctrl-scale {
border-color: rgba(255, 255, 255, 0.92);
border-width: 0 1.5px 1.5px;
background: transparent;
padding: 0 4px 1px;
/* aligned with the coordinates card above it, which a tool insets by 12 */
margin: 0 0 10px 12px;
color: #fff;
font-size: 10px;
font-weight: 600;
line-height: 1.3;
text-shadow:
0 1px 2px rgba(0, 0, 0, 0.85),
0 0 4px rgba(0, 0, 0, 0.5);
}
/* The map was given the keyboard by a hand on it, not by Tab (`facade.js` focus). */
.maplibregl-canvas[data-hand-focus]:focus-visible {
outline: none;
}
/* A tilted view has no one scale (`engine.js` sets the class while it leans). */
.map-surface.tilted .maplibregl-ctrl-scale {
display: none;
}
/* The card a mark opens, over imagery: one of the app's surfaces, not the
engine's white bubble. A tool sets `--popup-min-width` for the width its own
content needs.
The selector carries the container so it outweighs the engine's own
`.maplibregl-popup-anchor-* .maplibregl-popup-content`, which flattens one
corner of the card to seat the wedge replaced below. */
.maplibregl-popup .maplibregl-popup-content {
min-width: var(--popup-min-width, 0);
padding: 12px 14px;
border: 1px solid var(--border-strong);
border-radius: var(--r-lg);
background: var(--bg-1);
box-shadow: var(--shadow-2);
color: var(--text-1);
line-height: 1.4;
}
/* Closing the card, as a chip on its corner rather than a cross inside it: the
engine hangs the button over the top-right of the content, which lands it on
the first line of whatever the card says — a title, a stack's tally. Out on
the corner it has nothing to overlap, whatever a card puts on that line. */
.maplibregl-popup-close-button {
top: -10px;
right: -10px;
display: grid;
place-items: center;
width: 20px;
height: 20px;
padding: 0;
border: 1px solid var(--border-strong);
border-radius: 50%;
background: var(--bg-2);
color: var(--text-2);
font-size: 13px;
line-height: 1;
}
.maplibregl-popup-close-button:hover {
background: var(--bg-3);
color: var(--text-1);
}
/* The pointer, as a notch of the card rather than a triangle parked against it.
The engine draws a border triangle: unoutlined, filled by whichever of eight
border colours matches the side the card opened on, and squared off into a
wedge on the four corners. This is one 13 px square turned 45°, wearing the
card's own surface and edge and pushed halfway into it — the two sides facing
the card are simply not drawn, the two facing the point carry the card's
outline on, and the same shape serves all eight sides. */
.maplibregl-popup .maplibregl-popup-tip {
width: 13px;
height: 13px;
border: 1px solid var(--border-strong);
background: var(--bg-1);
transform: rotate(45deg);
}
/* Which two sides face the point, per side the card opened on. A square turned
45° clockwise points its original bottom-right pair downwards. */
.maplibregl-popup-anchor-top .maplibregl-popup-tip,
.maplibregl-popup-anchor-top-left .maplibregl-popup-tip,
.maplibregl-popup-anchor-top-right .maplibregl-popup-tip {
margin-bottom: -7px;
border-right: none;
border-bottom: none;
}
.maplibregl-popup-anchor-bottom .maplibregl-popup-tip,
.maplibregl-popup-anchor-bottom-left .maplibregl-popup-tip,
.maplibregl-popup-anchor-bottom-right .maplibregl-popup-tip {
margin-top: -7px;
border-top: none;
border-left: none;
}
.maplibregl-popup-anchor-left .maplibregl-popup-tip {
margin-right: -7px;
border-top: none;
border-right: none;
}
.maplibregl-popup-anchor-right .maplibregl-popup-tip {
margin-left: -7px;
border-bottom: none;
border-left: none;
}
/* A card opened on a corner is pinned by that corner, so the engine seats the
notch right on it, half off the card. Held in far enough to sit on a straight
edge instead — the point is a dozen pixels away, and the notch still reads as
pointing at it. */
.maplibregl-popup-anchor-top-left .maplibregl-popup-tip,
.maplibregl-popup-anchor-bottom-left .maplibregl-popup-tip {
margin-left: 12px;
}
.maplibregl-popup-anchor-top-right .maplibregl-popup-tip,
.maplibregl-popup-anchor-bottom-right .maplibregl-popup-tip {
margin-right: 12px;
}
/* The Google widget basemap (lib/map/gmaps.js) renders in its own map, under
the engine's canvas. A negative z-index is what puts it there: inside the
stacking context above, it paints over the container's background and under
everything in flow, the canvas included. It never takes the pointer — our map
owns every gesture — but the credit line does, so Google's terms link stays
clickable. */
.map-glass {
position: absolute;
inset: 0;
z-index: -1;
overflow: hidden;
pointer-events: none;
}
.map-glass-turn {
position: absolute;
transform-origin: 50% 50%;
}
.map-glass-map {
width: 100%;
height: 100%;
}
.map-glass-credit {
position: absolute;
right: 0;
bottom: 0;
display: flex;
gap: 8px;
padding: 1px 5px;
background: rgba(24, 24, 24, 0.85);
color: var(--text-3);
font-size: 10px;
pointer-events: auto;
}
.map-glass-credit a {
color: var(--text-2);
}
/* What a shape says about itself under the cursor: the reading on a sky ray,
the label on a sheet point. Never a card — it carries no controls and closes
itself, so it takes no chrome and no pointer. */
.maplibregl-popup.map-tip {
z-index: 700;
}
.map-tip .maplibregl-popup-content {
min-width: 0;
padding: 4px 8px;
border-radius: var(--r-sm);
background: color-mix(in srgb, var(--bg-0) 92%, transparent);
box-shadow: var(--shadow-1);
color: var(--text-1);
font-size: var(--fs-xs);
white-space: nowrap;
}
.map-tip .maplibregl-popup-tip {
display: none;
}
/* A finished line's corner (lib/map/handles.js), for Measure and Elevation
profile: a handle the hand can take, larger than the dots a line is drawn with. */
.path-handle {
cursor: grab;
}
/* the hand takes a handle well round the dot it sees, not only on it */
.path-handle::before {
content: '';
position: absolute;
inset: -9px;
border-radius: 50%;
}
.path-handle span {
display: block;
width: 14px;
height: 14px;
border-radius: 50%;
background: #f5a623;
border: 2px solid #fff;
box-sizing: border-box;
box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.45), 0 1px 4px rgba(0, 0, 0, 0.5);
}
/* the two ends of a line of sight, named A and B */
.path-handle.named span {
width: 20px;
height: 20px;
display: grid;
place-items: center;
color: #0b1a24;
font: 700 11px/1 var(--font-sans);
}
/* the dot halfway along a leg, taken to bend the line there */
.path-handle.ghost span {
width: 10px;
height: 10px;
background: rgba(255, 255, 255, 0.85);
border: 2px solid #f5a623;
opacity: 0.8;
}
.path-handle:hover span,
.maplibregl-marker-dragging.path-handle span {
transform: scale(1.25);
}
.maplibregl-marker-dragging.path-handle {
cursor: grabbing;
}
/* The words a measure writes beside itself: a leg's length and bearing, a
line's whole length, the angle at a corner, an area's size. They read the
map and never take a click from it. */
.measure-word {
pointer-events: none;
}
.measure-word span {
display: block;
padding: 2px 6px;
border-radius: 4px;
background: rgba(14, 14, 14, 0.82);
backdrop-filter: blur(3px);
color: #fff;
font: 600 11px/1.3 var(--font-mono);
letter-spacing: 0.01em;
white-space: nowrap;
box-shadow: 0 1px 4px rgba(0, 0, 0, 0.45), 0 0 0 1px rgba(245, 166, 35, 0.35);
}
.measure-word.mine span {
box-shadow: 0 0 0 1px rgba(245, 166, 35, 0.9);
}
.measure-word.total span,
.measure-word.area span,
.measure-word.use span {
background: #f5a623;
color: #111;
}
/* a ring's radius and a viewshed's share, in the cyan of what a line is used as */
.measure-word.ring span,
.measure-word.reach span {
background: #2de0ff;
color: #04232a;
box-shadow: 0 1px 4px rgba(0, 0, 0, 0.45);
}
/* the angle at a corner, set outside the corner (state/measure.svelte.js) */
.measure-word.angle span {
background: rgba(12, 12, 12, 0.6);
font-weight: 500;
}
/* the words of a measure not in hand step back */
.measure-word:not(.mine) span {
opacity: 0.8;
}
/* where two measured lines cross: what two bearings point at */
.measure-crossing {
cursor: copy;
}
.measure-crossing span {
display: block;
width: 14px;
height: 14px;
border-radius: 50%;
background: #fff;
border: 3px solid #f5a623;
box-sizing: border-box;
box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.5), 0 0 8px rgba(245, 166, 35, 0.8);
}
/* The Horizon tab's eye on its map: where the view is seen from. The colours
of these glyphs come with them, from lib/horizon/marks.js. */
.horizon-eye {
cursor: grab;
}
.horizon-eye span {
display: block;
width: 16px;
height: 16px;
border-radius: 50%;
border: 2px solid #fff;
box-sizing: border-box;
box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.5), 0 1px 5px rgba(0, 0, 0, 0.55);
}
.maplibregl-marker-dragging.horizon-eye {
cursor: grabbing;
}
/* …the knob at the end of the view's middle line, which turns it from the map */
.horizon-look {
cursor: grab;
}
.horizon-look span {
display: block;
width: 12px;
height: 12px;
border-radius: 50%;
background: #fff;
box-sizing: border-box;
box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.55), 0 1px 4px rgba(0, 0, 0, 0.5);
}
.horizon-look:hover span,
.maplibregl-marker-dragging.horizon-look span {
transform: scale(1.2);
}
.maplibregl-marker-dragging.horizon-look {
cursor: grabbing;
}
/* …and the view's own glyphs: the marked point's pin, in sight or hidden, and
the crosshair on the ground clicked in the view */
.horizon-pin span {
display: block;
width: 0;
height: 0;
border-left: 7px solid transparent;
border-right: 7px solid transparent;
border-top: 13px solid;
filter: drop-shadow(0 0 1px rgba(0, 0, 0, 0.9));
}
.horizon-crosshair svg {
display: block;
overflow: visible;
fill: none;
stroke-width: 2;
filter: drop-shadow(0 0 1px rgba(0, 0, 0, 0.9));
}
/* Under the globe (`under-globe`, tools/satellite/MapSurface.svelte) the map
shows neither its picture nor its buttons, which would move the hidden map,
and lets the pointer through to the globe; its markers and cards stay over
it and answer the hand. */
.under-globe .maplibregl-canvas,
.under-globe .maplibregl-control-container {
visibility: hidden;
}
.under-globe .maplibregl-canvas-container {
pointer-events: none;
}
.under-globe .maplibregl-marker,
.under-globe .maplibregl-popup {
pointer-events: auto;
}