@tellegen/svelte 0.1.0

package/dist/styles.css

@@ -0,0 +1,393 @@
+/* tellegen design tokens: warm paper ground, burnt amber accent, the physics
+   owns all other saturation. */
+:root {
+	--bg: #ece9e2;
+	--panel: rgba(252, 251, 247, 0.92);
+	--line: #d9d3c6;
+	--ink: #20242b;
+	--ink-dim: #6e7378;
+	--ink-faint: #989b92;
+	--accent: #b25e00;
+	--accent-bright: #ffb000;
+	--accent-soft: rgba(178, 94, 0, 0.1);
+	--red: #b3261e;
+	--pos: #762a83;
+	--neg: #1b7837;
+
+	--font-display: 'Bricolage Grotesque Variable', system-ui, sans-serif;
+	--font-mono: 'IBM Plex Mono', ui-monospace, monospace;
+
+	/* channel forms of the grounds, so scrims and shadows derive from one source */
+	--bg-rgb: 236 233 226;
+	--ink-rgb: 32 36 43;
+	--accent-rgb: 178 94 0;
+	--paper: #fcfbf7;
+	--paper-rgb: 252 251 247;
+
+	/* Semantic role + scale layer, kept as the target vocabulary for a future
+	   migration. Most call sites still reference the raw primitives above and
+	   hardcoded values; only a handful of these (e.g. --radius-xs, --shadow-thumb,
+	   --dur-fast, --ease-out, the channel forms) are wired up so far. */
+	--surface-page: var(--bg);
+	--surface-panel: var(--panel);
+	--surface-chip: rgb(var(--paper-rgb) / 0.65);
+	--surface-control: rgb(var(--paper-rgb) / 0.55);
+	--border-default: var(--line);
+	--border-strong: var(--accent);
+	--text-primary: var(--ink);
+	/* --text-secondary/--text-tertiary/--text-accent are independent from
+	   --ink-dim/--ink-faint/--accent (below) rather than aliased to them:
+	   the primitives stay lighter/warmer for borders, focus rings, and
+	   active-state indicators (3:1 or no minimum applies), while the
+	   text-* tokens are tuned to clear WCAG AA 4.5:1 against --bg. */
+	--text-secondary: #4d5156;
+	--text-tertiary: #636657;
+	--text-accent: #8a4800;
+	--text-danger: var(--red);
+	--data-pos: var(--pos);
+	--data-neg: var(--neg);
+	--focus-ring: var(--accent);
+
+	/* type scale, anchored at the 15px body */
+	--fs-display-lg: 33px;
+	--fs-display: 22px;
+	--fs-title: 18px;
+	--fs-heading: 16px;
+	--fs-body: 15px;
+	--fs-data: 12.5px;
+	--fs-label: 12px;
+	--fs-control: 11px;
+	--fs-meta: 10px;
+	--fs-micro: 8.5px;
+	--lh-tight: 1.2;
+	--lh-snug: 1.35;
+	--lh-normal: 1.5;
+	--lh-relaxed: 1.55;
+
+	/* spacing scale */
+	--space-3xs: 2px;
+	--space-2xs: 4px;
+	--space-xs: 6px;
+	--space-sm: 8px;
+	--space-md: 10px;
+	--space-lg: 12px;
+	--space-xl: 16px;
+	--space-2xl: 20px;
+	--space-3xl: 24px;
+
+	/* radius and elevation */
+	--radius-xs: 2px;
+	--radius-sm: 3px;
+	--radius-full: 50%;
+	--elev-1: 0 2px 10px rgb(var(--ink-rgb) / 0.1);
+	--elev-2: 0 4px 24px rgb(var(--ink-rgb) / 0.08);
+	--shadow-thumb: 0 1px 4px rgb(var(--ink-rgb) / 0.3);
+	--inset-active: inset 0 -2px 0 var(--accent);
+
+	/* motion: durations and easings, zeroed under reduced-motion below */
+	--dur-fast: 0.15s;
+	--dur-med: 0.3s;
+	--dur-slow: 0.5s;
+	--delay-panel: 0.12s;
+	--delay-footer: 0.24s;
+	--dur-blink: 1.2s;
+	--dur-bob: 1.8s;
+	--ease-out: ease-out;
+	--ease-in-out: ease-in-out;
+	--ease-standard: ease;
+
+	/* z-index layers */
+	--z-chrome: 10;
+	--z-cue: 14;
+	--z-overlay: 20;
+	--z-grain: 9999;
+}
+
+* {
+	box-sizing: border-box;
+}
+
+html,
+body {
+	margin: 0;
+	height: 100%;
+	background: var(--bg);
+	color: var(--ink);
+	font-family: var(--font-display);
+	font-size: 15px;
+	-webkit-font-smoothing: antialiased;
+}
+
+/* faint grain over everything; keeps flat panels from looking sterile */
+body::after {
+	content: '';
+	position: fixed;
+	inset: 0;
+	pointer-events: none;
+	z-index: 9999;
+	opacity: 0.04;
+	background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2'/%3E%3C/filter%3E%3Crect width='160' height='160' filter='url(%23n)' opacity='0.6'/%3E%3C/svg%3E");
+}
+
+.mono {
+	font-family: var(--font-mono);
+	font-variant-numeric: tabular-nums;
+}
+
+a {
+	color: var(--text-accent);
+	text-decoration: none;
+}
+
+/* chrome classes shared by more than one split component; kept global so Svelte
+   scoping does not drop them. Moved verbatim from the page <style>. */
+.dim {
+	color: var(--text-secondary);
+}
+
+.arrow {
+	display: inline-block;
+	animation: bob 1.8s ease-in-out infinite alternate;
+}
+
+.sep {
+	width: 4px;
+	height: 4px;
+	margin: 0 10px;
+	background: var(--accent-bright);
+	opacity: 0.55;
+	transform: rotate(45deg);
+}
+
+@media (max-width: 760px) {
+	.sep {
+		margin: 0 8px;
+	}
+
+	.filedrop-ui {
+		display: none;
+	}
+}
+
+@media (hover: none), (pointer: coarse) {
+	.filedrop-ui {
+		display: none;
+	}
+}
+
+/* shared animations, global so split components can reference them */
+@keyframes drop {
+	from {
+		opacity: 0;
+		transform: translateY(-8px);
+	}
+}
+
+@keyframes rise {
+	from {
+		opacity: 0;
+		transform: translateY(8px);
+	}
+}
+
+@keyframes blink {
+	50% {
+		opacity: 0.35;
+	}
+}
+
+@keyframes bob {
+	to {
+		transform: translateY(2px);
+	}
+}
+
+@media (prefers-reduced-motion: reduce) {
+	:root {
+		--dur-fast: 0.01ms;
+		--dur-med: 0.01ms;
+		--dur-slow: 0.01ms;
+		--dur-blink: 0.01ms;
+		--dur-bob: 0.01ms;
+		--delay-panel: 0s;
+		--delay-footer: 0s;
+	}
+
+	.arrow {
+		animation: none;
+	}
+}
+
+/* control panel regions: classes used by more than one split region component
+   (NetworkStats, FormulationSelector, SensitivityReadout, DemandSlider,
+   TopMovers, DisplayControls, SizeLegend, LocalCaseDetails) plus ControlPanel
+   itself. Kept global so Svelte scoping does not drop them. Moved verbatim from
+   ControlPanel.svelte; the .mode / .display-mode / @media source order is
+   preserved so the cascade resolves exactly as before. */
+.region {
+	font-size: 10px;
+	font-weight: 400;
+	color: var(--text-secondary);
+	text-transform: uppercase;
+	letter-spacing: 0;
+	margin-left: 4px;
+}
+
+.mode {
+	display: flex;
+	align-items: center;
+	gap: 10px;
+	font-size: 12px;
+}
+
+/* Kept global (not scoped into SensitivityReadout) so the @media (max-width: 760px)
+   `.mode button { margin-left: 0 }` override below wins by source order, as it did
+   before the component split. Scoping this would raise its specificity past that rule. */
+.mode > button {
+	margin-left: auto;
+	font-size: 10.5px;
+	padding: 2px 7px;
+	background: none;
+	border: 1px solid var(--line);
+	border-radius: 2px;
+	color: var(--text-secondary);
+	cursor: pointer;
+}
+
+.mode > button:hover {
+	border-color: var(--accent);
+	color: var(--text-accent);
+}
+
+.display-mode {
+	gap: 8px;
+}
+
+.display-mode .segment button {
+	font-size: 11px;
+	padding: 2px 9px;
+}
+
+.small {
+	font-size: 12px;
+	line-height: 1.55;
+}
+
+.legend {
+	height: 6px;
+	border-radius: 3px;
+	margin-top: 6px;
+}
+
+.legend-labels {
+	display: flex;
+	justify-content: space-between;
+	font-size: 10.5px;
+	color: var(--text-tertiary);
+	margin-top: 4px;
+}
+
+.legend-labels.single {
+	justify-content: center;
+	text-align: center;
+}
+
+.hint-dot {
+	display: inline-grid;
+	place-items: center;
+	width: 15px;
+	height: 15px;
+	border: 1px solid var(--line);
+	border-radius: 999px;
+	color: var(--text-secondary);
+	background: var(--surface-control);
+	font-size: 10px;
+	line-height: 1;
+	cursor: help;
+}
+
+.segment {
+	display: inline-flex;
+	border: 1px solid var(--line);
+	border-radius: 2px;
+	overflow: hidden;
+	background: var(--surface-control);
+}
+
+.segment button {
+	padding: 2px 8px;
+	border: 0;
+	background: transparent;
+	color: var(--text-secondary);
+	font: inherit;
+	cursor: pointer;
+}
+
+.segment button + button {
+	border-left: 1px solid var(--line);
+}
+
+.segment button.active {
+	background: var(--accent-soft);
+	color: var(--text-accent);
+}
+
+.reset {
+	margin-top: 10px;
+	font-size: 10.5px;
+	padding: 3px 10px;
+	background: none;
+	border: 1px solid var(--line);
+	border-radius: 2px;
+	color: var(--text-secondary);
+	cursor: pointer;
+}
+
+.reset:hover {
+	border-color: var(--red);
+	color: var(--red);
+}
+
+.blink {
+	animation: blink 1.2s steps(2) infinite;
+}
+
+@media (max-width: 760px) {
+	.mode {
+		flex-wrap: wrap;
+		gap: 7px;
+	}
+
+	.mode button {
+		margin-left: 0;
+	}
+}
+
+/* Keyboard focus ring: one accent ring for every interactive element. */
+:focus-visible {
+	outline: 2px solid var(--focus-ring);
+	outline-offset: 2px;
+}
+
+/* Coarse pointers: comfortable hit targets for the toggle and reset controls. */
+@media (hover: none), (pointer: coarse) {
+	.segment button {
+		min-height: 36px;
+	}
+
+	.reset {
+		min-height: 36px;
+	}
+}
+
+/* Honor reduced-motion everywhere: collapse animations and transitions. */
+@media (prefers-reduced-motion: reduce) {
+	*,
+	*::before,
+	*::after {
+		animation-duration: 0.01ms !important;
+		animation-iteration-count: 1 !important;
+		transition-duration: 0.01ms !important;
+		scroll-behavior: auto !important;
+	}
+}

package/dist/synthetic-layout.d.ts

@@ -0,0 +1,12 @@
+import type { NetworkBranch, NetworkBus } from './api.js';
+import type { Topology } from '@tellegen/engine';
+export interface PlacedNetwork {
+    buses: NetworkBus[];
+    branches: NetworkBranch[];
+}
+export interface PlacementCenter {
+    lon: number;
+    lat: number;
+}
+export declare function placeSyntheticTopology(topology: Topology, center: PlacementCenter): PlacedNetwork;
+//# sourceMappingURL=synthetic-layout.d.ts.map

package/dist/synthetic-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthetic-layout.d.ts","sourceRoot":"","sources":["../src/lib/synthetic-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACZ;AAKD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,GAAG,aAAa,CAuCjG"}

package/dist/synthetic-layout.js

@@ -0,0 +1,271 @@
+import { extent } from './format.js';
+const ALL_PAIRS_LIMIT = 500;
+export function placeSyntheticTopology(topology, center) {
+    const buses = [...topology.buses].sort((a, b) => a.id - b.id);
+    const index = new Map(buses.map((bus, i) => [bus.id, i]));
+    const edges = topology.branches
+        .filter((branch) => branch.status !== 0 && index.has(branch.from) && index.has(branch.to))
+        .map((branch) => [index.get(branch.from), index.get(branch.to)])
+        .filter(([from, to]) => from !== to);
+    const unit = forceLayout(buses.length, edges);
+    const span = Math.min(4.5, Math.max(0.32, Math.sqrt(Math.max(buses.length, 1)) * 0.08));
+    const lonScale = Math.max(Math.cos((center.lat * Math.PI) / 180), 0.25);
+    const latSpan = span;
+    const lonSpan = span / lonScale;
+    const coords = new Map();
+    for (let i = 0; i < buses.length; i++) {
+        const p = unit[i] ?? { x: 0.5, y: 0.5 };
+        coords.set(buses[i].id, [
+            center.lon + (p.x - 0.5) * lonSpan,
+            center.lat + (p.y - 0.5) * latSpan
+        ]);
+    }
+    return {
+        buses: buses.map((bus) => {
+            const [lon, lat] = coords.get(bus.id);
+            return { id: bus.id, uid: bus.uid, lon, lat, demand_mw: bus.demand_mw, gen_mw: bus.gen_mw };
+        }),
+        branches: topology.branches
+            .filter((branch) => coords.has(branch.from) && coords.has(branch.to))
+            .map((branch) => ({
+            id: branch.id,
+            uid: branch.uid,
+            from: branch.from,
+            to: branch.to,
+            rate_mw: branch.rate_mw,
+            status: branch.status,
+            path: [coords.get(branch.from), coords.get(branch.to)]
+        }))
+    };
+}
+function forceLayout(n, edges) {
+    if (n === 0)
+        return [];
+    if (n === 1)
+        return [{ x: 0.5, y: 0.5 }];
+    if (n > ALL_PAIRS_LIMIT)
+        return fastGraphLayout(n, edges);
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    const pos = Array.from({ length: n }, (_, i) => {
+        const r = 0.44 * Math.sqrt((i + 0.5) / n);
+        const theta = i * golden;
+        return {
+            x: 0.5 + r * Math.cos(theta) + 1e-4 * Math.sin(0.7 * (i + 1)),
+            y: 0.5 + r * Math.sin(theta) + 1e-4 * Math.cos(1.3 * (i + 1))
+        };
+    });
+    const disp = Array.from({ length: n }, () => ({ x: 0, y: 0 }));
+    const k2 = 1 / n;
+    const k = Math.sqrt(k2);
+    const iters = n <= 120 ? 180 : n <= 500 ? 100 : 32;
+    for (let iter = 0; iter < iters; iter++) {
+        for (const d of disp) {
+            d.x = 0;
+            d.y = 0;
+        }
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                const dx = pos[i].x - pos[j].x;
+                const dy = pos[i].y - pos[j].y;
+                const f = k2 / (dx * dx + dy * dy + 1e-6);
+                disp[i].x += dx * f;
+                disp[i].y += dy * f;
+                disp[j].x -= dx * f;
+                disp[j].y -= dy * f;
+            }
+        }
+        for (const [i, j] of edges) {
+            const dx = pos[i].x - pos[j].x;
+            const dy = pos[i].y - pos[j].y;
+            const f = Math.sqrt(dx * dx + dy * dy) / k;
+            disp[i].x -= dx * f;
+            disp[i].y -= dy * f;
+            disp[j].x += dx * f;
+            disp[j].y += dy * f;
+        }
+        const t = 0.1 * (1 - iter / iters) + 1e-3;
+        for (let i = 0; i < n; i++) {
+            const d = Math.hypot(disp[i].x, disp[i].y) + 1e-9;
+            const s = Math.min(d, t) / d;
+            pos[i].x = clamp(pos[i].x + disp[i].x * s);
+            pos[i].y = clamp(pos[i].y + disp[i].y * s);
+        }
+    }
+    return normalize(pos);
+}
+function fastGraphLayout(n, edges) {
+    const adjacency = graph(n, edges);
+    const components = connectedComponents(adjacency);
+    const cols = Math.ceil(Math.sqrt(components.length));
+    const rows = Math.ceil(components.length / cols);
+    const pos = Array.from({ length: n }, () => ({ x: 0.5, y: 0.5 }));
+    const cellScale = 0.82 / Math.max(cols, rows);
+    for (let c = 0; c < components.length; c++) {
+        const nodes = components[c];
+        const local = componentLayout(nodes, adjacency);
+        const col = c % cols;
+        const row = Math.floor(c / cols);
+        const cx = (col + 0.5) / cols;
+        const cy = (row + 0.5) / rows;
+        for (const node of nodes) {
+            const p = local.get(node) ?? { x: 0.5, y: 0.5 };
+            pos[node] = {
+                x: cx + (p.x - 0.5) * cellScale,
+                y: cy + (p.y - 0.5) * cellScale
+            };
+        }
+    }
+    return normalize(pos);
+}
+function graph(n, edges) {
+    const adjacency = Array.from({ length: n }, () => []);
+    const seen = new Set();
+    for (const [from, to] of edges) {
+        if (from < 0 || to < 0 || from >= n || to >= n || from === to)
+            continue;
+        const a = Math.min(from, to);
+        const b = Math.max(from, to);
+        const key = a * n + b;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        adjacency[a].push(b);
+        adjacency[b].push(a);
+    }
+    for (const neighbors of adjacency)
+        neighbors.sort((a, b) => a - b);
+    return adjacency;
+}
+function connectedComponents(adjacency) {
+    const seen = new Uint8Array(adjacency.length);
+    const components = [];
+    for (let start = 0; start < adjacency.length; start++) {
+        if (seen[start])
+            continue;
+        const nodes = [];
+        const stack = [start];
+        seen[start] = 1;
+        while (stack.length > 0) {
+            const node = stack.pop();
+            nodes.push(node);
+            for (const next of adjacency[node]) {
+                if (seen[next])
+                    continue;
+                seen[next] = 1;
+                stack.push(next);
+            }
+        }
+        nodes.sort((a, b) => a - b);
+        components.push(nodes);
+    }
+    components.sort((a, b) => b.length - a.length || a[0] - b[0]);
+    return components;
+}
+function componentLayout(nodes, adjacency) {
+    if (nodes.length === 1)
+        return new Map([[nodes[0], { x: 0.5, y: 0.5 }]]);
+    const nodeToLocal = new Map(nodes.map((node, i) => [node, i]));
+    const seed = nodes.reduce((best, node) => adjacency[node].length > adjacency[best].length ||
+        (adjacency[node].length === adjacency[best].length && node < best)
+        ? node
+        : best);
+    const order = bfsOrder(seed, adjacency);
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    const pos = Array.from({ length: nodes.length }, () => ({ x: 0.5, y: 0.5 }));
+    const initial = Array.from({ length: nodes.length }, () => ({ x: 0.5, y: 0.5 }));
+    for (let rank = 0; rank < order.length; rank++) {
+        const local = nodeToLocal.get(order[rank]);
+        if (local === undefined)
+            continue;
+        const r = 0.47 * Math.sqrt((rank + 0.5) / nodes.length);
+        const theta = rank * golden;
+        const p = {
+            x: 0.5 + r * Math.cos(theta),
+            y: 0.5 + r * Math.sin(theta)
+        };
+        pos[local] = { ...p };
+        initial[local] = p;
+    }
+    const localEdges = [];
+    for (const node of nodes) {
+        const a = nodeToLocal.get(node);
+        for (const next of adjacency[node]) {
+            if (next <= node)
+                continue;
+            const b = nodeToLocal.get(next);
+            if (b !== undefined)
+                localEdges.push([a, b]);
+        }
+    }
+    relaxEdges(pos, initial, localEdges);
+    const out = new Map();
+    const normalized = normalize(pos);
+    for (const [i, node] of nodes.entries())
+        out.set(node, normalized[i]);
+    return out;
+}
+function bfsOrder(seed, adjacency) {
+    const seen = new Uint8Array(adjacency.length);
+    const order = [];
+    const queue = [seed];
+    seen[seed] = 1;
+    for (let head = 0; head < queue.length; head++) {
+        const node = queue[head];
+        order.push(node);
+        for (const next of adjacency[node]) {
+            if (seen[next])
+                continue;
+            seen[next] = 1;
+            queue.push(next);
+        }
+    }
+    return order;
+}
+function relaxEdges(pos, initial, edges) {
+    const n = pos.length;
+    const disp = Array.from({ length: n }, () => ({ x: 0, y: 0 }));
+    const rest = Math.max(0.012, Math.min(0.06, 1.4 / Math.sqrt(n)));
+    const iters = n <= 2000 ? 72 : n <= 10000 ? 42 : 24;
+    for (let iter = 0; iter < iters; iter++) {
+        for (const d of disp) {
+            d.x = 0;
+            d.y = 0;
+        }
+        for (const [i, j] of edges) {
+            const dx = pos[j].x - pos[i].x;
+            const dy = pos[j].y - pos[i].y;
+            const dist = Math.hypot(dx, dy) + 1e-9;
+            const f = (dist - rest) * 0.045;
+            const fx = (dx / dist) * f;
+            const fy = (dy / dist) * f;
+            disp[i].x += fx;
+            disp[i].y += fy;
+            disp[j].x -= fx;
+            disp[j].y -= fy;
+        }
+        for (let i = 0; i < n; i++) {
+            disp[i].x += (initial[i].x - pos[i].x) * 0.012;
+            disp[i].y += (initial[i].y - pos[i].y) * 0.012;
+        }
+        const t = 0.055 * (1 - iter / iters) + 0.002;
+        for (let i = 0; i < n; i++) {
+            const d = Math.hypot(disp[i].x, disp[i].y) + 1e-9;
+            const s = Math.min(d, t) / d;
+            pos[i].x = clamp(pos[i].x + disp[i].x * s);
+            pos[i].y = clamp(pos[i].y + disp[i].y * s);
+        }
+    }
+}
+function normalize(pos) {
+    const { min: minX, max: maxX } = extent(pos.map((p) => p.x));
+    const { min: minY, max: maxY } = extent(pos.map((p) => p.y));
+    const sx = maxX - minX || 1;
+    const sy = maxY - minY || 1;
+    return pos.map((p) => ({
+        x: 0.04 + ((p.x - minX) / sx) * 0.92,
+        y: 0.04 + ((p.y - minY) / sy) * 0.92
+    }));
+}
+function clamp(v) {
+    return Math.max(0, Math.min(1, v));
+}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+export type { CaseSummary, DemandDeltas, Network, NetworkBranch, NetworkBus, SensitivityColumn, Solution, SolveIteration, SolveStreamHandlers } from './api.js';
+export type { DisplayOption } from './display.js';
+export type { PlacedNetwork, PlacementCenter } from './synthetic-layout.js';
+export type { DemandRangeMode, DisplayMode, FallbackTarget, LocalCaseInit, LocalSubstations, SolvableCase, SolveBackend } from './state.svelte.js';
+export type { AppliedGeoCase, CaseFileSummary, DisplayPreview, Formulation, GeoApplyReport, IngestedCase, ParsedGeoLayer, StampedLayoutCase, Topology, TopologyBranch, TopologyBus } from '@tellegen/engine';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/lib/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACX,WAAW,EACX,YAAY,EACZ,OAAO,EACP,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,cAAc,EACd,mBAAmB,EACnB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC5E,YAAY,EACX,eAAe,EACf,WAAW,EACX,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACX,cAAc,EACd,eAAe,EACf,cAAc,EACd,WAAW,EACX,cAAc,EACd,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,QAAQ,EACR,cAAc,EACd,WAAW,EACX,MAAM,kBAAkB,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};