@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/utils/preview-exhibitor.js

@@ -0,0 +1,19 @@
+import lzUtils from './lz-utils';
+/**
+ * `?__data=` / `?__lzdata=` — platform-editor glue: the exhibitor editor opens the floor plan
+ * with the draft exhibitor inlined in the URL (plain or lz-compressed JSON). Not part of the
+ * public URL grammar, stays a direct read (retirement plan §4.11).
+ *
+ * Read per call rather than at module load: a host that swaps plans changes the URL under us,
+ * and the draft exhibitor belongs to whichever event is being loaded now (ADR-0011).
+ */
+export default function getPreviewExhibitor() {
+    const params = new URL(window.location.href).searchParams;
+    const data = params.get('__data');
+    if (data)
+        return JSON.parse(data).exhibitors[0];
+    const lzdata = params.get('__lzdata');
+    if (lzdata)
+        return JSON.parse(lzUtils.decompress(lzdata)).exhibitors[0];
+    return null;
+}

package/dist/esm/utils/rasterize-svg.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Whether these bytes are an SVG.
+ *
+ * The test reads a prefix, not the whole type. A server may send `image/svg+xml; charset=utf-8`,
+ * and these images come from customer origins and CDNs, not only from this repository's own
+ * server. An exact match lets that form through to `createImageBitmap`, which rejects SVG bytes,
+ * and the image then disappears with no sign of why.
+ * @param blob - The bytes to test.
+ * @returns Whether the bytes are an SVG.
+ */
+export declare function isSvgBlob(blob: Blob): boolean;
+/**
+ * Draws an SVG into a canvas at its own intrinsic size.
+ *
+ * `createImageBitmap` refuses SVG bytes (`InvalidStateError`, measured in Chrome 153, even for an
+ * SVG with an explicit `width` and `height`), so an SVG cannot travel to the atlas worker as it is.
+ * An `<img>` element renders the same bytes. This function does that conversion once, at load time.
+ * @param blob - The SVG bytes.
+ * @returns The rasterized canvas, or null when the SVG does not render, or declares no size.
+ */
+export declare function rasterizeSvg(blob: Blob): Promise<HTMLCanvasElement | null>;
+/**
+ * Rasterizes an SVG and hands the pixels back as PNG bytes.
+ *
+ * The result is a `Blob` and not a canvas on purpose. A layer packs in the atlas worker only while
+ * every one of its sources is a `Blob`, so one canvas among a thousand booth logos would drop the
+ * whole layer back onto the main thread — the exact layer the worker exists for.
+ * @param blob - The SVG bytes.
+ * @returns The PNG bytes, or null when the SVG does not render.
+ */
+export declare function svgToPngBlob(blob: Blob): Promise<Blob | null>;
+//# sourceMappingURL=rasterize-svg.d.ts.map

package/dist/esm/utils/rasterize-svg.js

@@ -0,0 +1,78 @@
+import { loadImage } from './loadImage';
+/**
+ * Whether these bytes are an SVG.
+ *
+ * The test reads a prefix, not the whole type. A server may send `image/svg+xml; charset=utf-8`,
+ * and these images come from customer origins and CDNs, not only from this repository's own
+ * server. An exact match lets that form through to `createImageBitmap`, which rejects SVG bytes,
+ * and the image then disappears with no sign of why.
+ * @param blob - The bytes to test.
+ * @returns Whether the bytes are an SVG.
+ */
+export function isSvgBlob(blob) {
+    return blob.type.startsWith('image/svg+xml');
+}
+/**
+ * Draws an SVG into a canvas at its own intrinsic size.
+ *
+ * `createImageBitmap` refuses SVG bytes (`InvalidStateError`, measured in Chrome 153, even for an
+ * SVG with an explicit `width` and `height`), so an SVG cannot travel to the atlas worker as it is.
+ * An `<img>` element renders the same bytes. This function does that conversion once, at load time.
+ * @param blob - The SVG bytes.
+ * @returns The rasterized canvas, or null when the SVG does not render, or declares no size.
+ */
+export async function rasterizeSvg(blob) {
+    const url = URL.createObjectURL(blob);
+    try {
+        const image = await loadImage(url);
+        // An SVG with neither a `width`/`height` nor a rasterizable viewBox reports a size of 0.
+        // A zero-sized `drawImage` call throws in some browsers.
+        if (!image?.naturalWidth || !image.naturalHeight)
+            return null;
+        const canvas = document.createElement('canvas');
+        canvas.width = image.naturalWidth;
+        canvas.height = image.naturalHeight;
+        const context = canvas.getContext('2d');
+        if (!context)
+            return null;
+        context.drawImage(image, 0, 0);
+        return canvas;
+    }
+    finally {
+        // The object URL is revoked either way. A leaked object URL pins the Blob's bytes for the
+        // life of the document.
+        URL.revokeObjectURL(url);
+    }
+}
+/**
+ * Rasterizes an SVG and hands the pixels back as PNG bytes.
+ *
+ * The result is a `Blob` and not a canvas on purpose. A layer packs in the atlas worker only while
+ * every one of its sources is a `Blob`, so one canvas among a thousand booth logos would drop the
+ * whole layer back onto the main thread — the exact layer the worker exists for.
+ * @param blob - The SVG bytes.
+ * @returns The PNG bytes, or null when the SVG does not render.
+ */
+export async function svgToPngBlob(blob) {
+    const canvas = await rasterizeSvg(blob);
+    if (!canvas)
+        return null;
+    return toPngBlob(canvas);
+}
+/**
+ * Reads a canvas back as PNG bytes.
+ * @param canvas - The canvas to read.
+ * @returns The bytes, or null when the canvas will not give them up.
+ */
+function toPngBlob(canvas) {
+    return new Promise((resolve) => {
+        try {
+            canvas.toBlob((encoded) => resolve(encoded), 'image/png');
+        }
+        catch {
+            // An SVG that pulls in a cross-origin image taints the canvas, and a tainted canvas refuses
+            // to hand its bytes back. The caller drops the image.
+            resolve(null);
+        }
+    });
+}

package/dist/esm/utils/responsiveClass.d.ts

@@ -0,0 +1,2 @@
+export declare function getResponsiveClass(width: number): string;
+//# sourceMappingURL=responsiveClass.d.ts.map

package/dist/esm/utils/responsiveClass.js

@@ -0,0 +1,25 @@
+const breakpoints = {
+    xs: 0,
+    sm: 480,
+    md: 768,
+    lg: 998,
+    xl: 1100,
+};
+export function getResponsiveClass(width) {
+    const { sm, md, lg, xl } = breakpoints;
+    if (width < sm) {
+        return 'xs';
+    }
+    else if (width >= sm && width < md) {
+        return 'sm';
+    }
+    else if (width >= md && width < lg) {
+        return 'md';
+    }
+    else if (width >= lg && width < xl) {
+        return 'lg';
+    }
+    else {
+        return 'xl';
+    }
+}

package/dist/esm/utils/rtl.d.ts

@@ -0,0 +1,2 @@
+export declare function isArabicText(text: string): boolean;
+//# sourceMappingURL=rtl.d.ts.map

package/dist/esm/utils/rtl.js

@@ -0,0 +1,4 @@
+const ARABIC_REGEX = /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/u;
+export function isArabicText(text) {
+    return ARABIC_REGEX.test(text);
+}

package/dist/esm/utils/sanitizeHtml.d.ts

@@ -0,0 +1,3 @@
+declare const sanitizeHTML: (html: string, tags?: string[], attributes?: string[]) => string;
+export default sanitizeHTML;
+//# sourceMappingURL=sanitizeHtml.d.ts.map

package/dist/esm/utils/sanitizeHtml.js

@@ -0,0 +1,21 @@
+const sanitizeHTML = (html, tags, attributes) => {
+    const allowedTags = tags || ['p', 'span', 'strong', 'em', 'ul', 'ol', 'li', 'a'];
+    const allowedAttributes = attributes || ['href', 'target', 'rel'];
+    const container = document.createElement('template');
+    container.innerHTML = html;
+    const element = container.content;
+    Array.from(element.querySelectorAll('*')).forEach((el) => {
+        if (!allowedTags.includes(el.tagName.toLowerCase())) {
+            el.remove();
+        }
+    });
+    Array.from(element.querySelectorAll('*')).forEach((el) => {
+        Array.from(el.attributes).forEach((attr) => {
+            if (!allowedAttributes.includes(attr.name.toLowerCase())) {
+                el.removeAttribute(attr.name);
+            }
+        });
+    });
+    return container.innerHTML;
+};
+export default sanitizeHTML;

package/dist/esm/utils/sanitizeText.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sanitizes the input string by trimming whitespace and removing non-alphanumeric characters.
+ *
+ * @param {string} str - The input string to sanitize.
+ * @returns {string} - The sanitized string containing only alphanumeric characters.
+ */
+export declare const sanitizeStr: (str: string) => string;
+export declare function sanitizeSearch(input: string, patterns?: string[]): string;
+//# sourceMappingURL=sanitizeText.d.ts.map

package/dist/esm/utils/sanitizeText.js

@@ -0,0 +1,19 @@
+import { getSlug } from '../components/Kiosk/SetKiosk';
+import { TRACKING_PARAM_PATTERNS } from './trackingParams';
+/**
+ * Sanitizes the input string by trimming whitespace and removing non-alphanumeric characters.
+ *
+ * @param {string} str - The input string to sanitize.
+ * @returns {string} - The sanitized string containing only alphanumeric characters.
+ */
+export const sanitizeStr = (str) => str.trim().replace(/[^a-z0-9]/gi, '');
+export function sanitizeSearch(input, patterns = []) {
+    if (!input) {
+        return '';
+    }
+    const arr = [...TRACKING_PARAM_PATTERNS, 'ref=', 'lp_id=', 'lp_token=', `${getSlug()}=`].concat(patterns);
+    const regex = new RegExp(`(^|\\?|&)(${arr.join('|')})[^&]*`, 'g');
+    return input
+        .replace(regex, '')
+        .replace(/(^|[?&])([^=&#]+)=(?=&|$)/g, (_match, sep, key) => `${sep}${key}`);
+}

package/dist/esm/utils/scene-bounds.d.ts

@@ -0,0 +1,64 @@
+import { Box } from '@expofp/geometry';
+import { type SceneDef } from '@expofp/renderer';
+/**
+ * Bounding box (in local SVG units) of all drawn scene content, excluding the
+ * background "areamap" layer. This is the real venue extent and the rect that
+ * Fit-to-screen should target — the full SVG area (`svgArea`) instead spans the
+ * whole surrounding map (e.g. an entire city), which makes the fit zoom out far
+ * too much.
+ *
+ * Uses the same name-based areamap exclusion as MaplibreWrapper, so it needs no
+ * layer flags and degrades to "all content" for venue-only floorplans.
+ */
+export declare function getSceneVenueRect(sceneDef: SceneDef | null | undefined): Box | null;
+/**
+ * Margin to leave around the venue when fitting, as a fraction of the venue
+ * size. Mirrors the legacy renderer's adaptive rule: a venue that is tiny
+ * relative to its surroundings gets more breathing room than one that already
+ * fills most of the available area.
+ */
+export declare function getVenueFitMarginPercent(venueRect: Box, baseRect: Box): number;
+/** Grow a rect outward by `pct` of its size on each side. */
+export declare function expandRectByPercent(rect: Box, pct: number): Box;
+/**
+ * Canonical Fit-to-screen target: the venue extent grown by its adaptive margin.
+ * `baseRect` is the surrounding map area (`svgArea`) used to scale the margin.
+ * Returns null when the scene has no fittable content.
+ */
+export declare function getVenueFitRect(sceneDef: SceneDef | null | undefined, baseRect: Box): Box | null;
+/** Where a resolved Fit-to-screen rectangle came from (most → least specific). */
+export type VenueFitSource = 'layer-viewbox' | 'explicit-viewbox' | 'layer-rectangle' | 'scene-derived' | 'svg-area';
+/**
+ * Whether a resolved fit rect *is* the framing, so a fit must show it exactly:
+ * true for the authored boxes, and for the scene-derived one because it already
+ * carries its adaptive margin. The remaining sources are bare geometry and still
+ * want each renderer's own breathing room around them.
+ */
+export declare function fitRectIsFraming(source: VenueFitSource): boolean;
+export interface VenueFitInputs {
+    /** Union of authored per-layer viewboxes (`LayerStore.viewboxRectangle`). */
+    layerViewbox?: Box | null;
+    /** `svgArea` when it was explicitly authored (`__viewbox` / `rect#VIEWBOX`). */
+    explicitArea?: Box | null;
+    /** Current-level geometry rect in radio mode (`LayerStore.rectangle`). */
+    layerRectangle?: Box | null;
+    /** Scene to derive the venue extent from when nothing above is authored. */
+    sceneDef?: SceneDef | null;
+    /** Whole-canvas fallback and margin base. */
+    svgArea: Box;
+}
+/**
+ * Single source of truth for the Fit-to-screen / initial-view target. Picks the
+ * most specific available reference in priority order. This is the seam a future
+ * multi-venue model plugs into: it would resolve the *active* venue's box here,
+ * leaving every call site unchanged.
+ *
+ * Authored boxes (`layer-viewbox`, `explicit-viewbox`) are returned as-is — the
+ * caller's fit already adds viewport padding. Geometry-derived boxes
+ * (`scene-derived`) carry their adaptive breathing-room margin.
+ */
+export declare function resolveVenueFitRect(inputs: VenueFitInputs): {
+    rect: Box;
+    source: VenueFitSource;
+};
+//# sourceMappingURL=scene-bounds.d.ts.map

package/dist/esm/utils/scene-bounds.js

@@ -0,0 +1,127 @@
+import { Box, isBox } from '@expofp/geometry';
+import { isLayerDef, isLineDef, isShapeDef, } from '@expofp/renderer';
+/** Background-map layer name (case-insensitive), excluded from the venue extent. */
+const AREAMAP_LAYER_NAME = 'areamap';
+/**
+ * Bounding box (in local SVG units) of all drawn scene content, excluding the
+ * background "areamap" layer. This is the real venue extent and the rect that
+ * Fit-to-screen should target — the full SVG area (`svgArea`) instead spans the
+ * whole surrounding map (e.g. an entire city), which makes the fit zoom out far
+ * too much.
+ *
+ * Uses the same name-based areamap exclusion as MaplibreWrapper, so it needs no
+ * layer flags and degrades to "all content" for venue-only floorplans.
+ */
+export function getSceneVenueRect(sceneDef) {
+    const children = sceneDef?.rootLayer?.children;
+    if (!children?.length)
+        return null;
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const expand = (x, y) => {
+        if (!Number.isFinite(x) || !Number.isFinite(y))
+            return;
+        if (x < minX)
+            minX = x;
+        if (y < minY)
+            minY = y;
+        if (x > maxX)
+            maxX = x;
+        if (y > maxY)
+            maxY = y;
+    };
+    const expandBox = (box) => {
+        expand(box.min.x, box.min.y);
+        expand(box.max.x, box.max.y);
+    };
+    const visit = (def) => {
+        if (isLayerDef(def)) {
+            def.children.forEach(visit);
+            return;
+        }
+        if (isShapeDef(def)) {
+            // A geometry Box is its own bounding box; a Rect, Polygon or Mesh reports one, the Rect's
+            // aware of its rotation.
+            expandBox(isBox(def.shape) ? def.shape : def.shape.bounds);
+            return;
+        }
+        if (isLineDef(def)) {
+            expand(def.points.p0.x, def.points.p0.y);
+            expand(def.points.p1.x, def.points.p1.y);
+            return;
+        }
+        // Images, text and models all carry a Rect.
+        expandBox(def.bounds.bounds);
+    };
+    for (const child of children) {
+        const name = child.name;
+        if (typeof name === 'string' && name.toLowerCase() === AREAMAP_LAYER_NAME)
+            continue;
+        visit(child);
+    }
+    if (minX > maxX || minY > maxY)
+        return null;
+    return Box.fromMinMax({ x: minX, y: minY }, { x: maxX, y: maxY });
+}
+/**
+ * Margin to leave around the venue when fitting, as a fraction of the venue
+ * size. Mirrors the legacy renderer's adaptive rule: a venue that is tiny
+ * relative to its surroundings gets more breathing room than one that already
+ * fills most of the available area.
+ */
+export function getVenueFitMarginPercent(venueRect, baseRect) {
+    if (!venueRect || !baseRect || baseRect.area <= 0)
+        return 0.15;
+    const ratio = venueRect.area / baseRect.area;
+    return ratio > 0.1 ? 0.15 : 0.25;
+}
+/** Grow a rect outward by `pct` of its size on each side. */
+export function expandRectByPercent(rect, pct) {
+    if (!pct)
+        return rect;
+    return rect.expand({ x: rect.size.width * pct, y: rect.size.height * pct });
+}
+/**
+ * Canonical Fit-to-screen target: the venue extent grown by its adaptive margin.
+ * `baseRect` is the surrounding map area (`svgArea`) used to scale the margin.
+ * Returns null when the scene has no fittable content.
+ */
+export function getVenueFitRect(sceneDef, baseRect) {
+    const venue = getSceneVenueRect(sceneDef);
+    if (!venue)
+        return null;
+    return expandRectByPercent(venue, getVenueFitMarginPercent(venue, baseRect));
+}
+/**
+ * Whether a resolved fit rect *is* the framing, so a fit must show it exactly:
+ * true for the authored boxes, and for the scene-derived one because it already
+ * carries its adaptive margin. The remaining sources are bare geometry and still
+ * want each renderer's own breathing room around them.
+ */
+export function fitRectIsFraming(source) {
+    return source === 'layer-viewbox' || source === 'explicit-viewbox' || source === 'scene-derived';
+}
+/**
+ * Single source of truth for the Fit-to-screen / initial-view target. Picks the
+ * most specific available reference in priority order. This is the seam a future
+ * multi-venue model plugs into: it would resolve the *active* venue's box here,
+ * leaving every call site unchanged.
+ *
+ * Authored boxes (`layer-viewbox`, `explicit-viewbox`) are returned as-is — the
+ * caller's fit already adds viewport padding. Geometry-derived boxes
+ * (`scene-derived`) carry their adaptive breathing-room margin.
+ */
+export function resolveVenueFitRect(inputs) {
+    if (inputs.layerViewbox)
+        return { rect: inputs.layerViewbox, source: 'layer-viewbox' };
+    if (inputs.explicitArea)
+        return { rect: inputs.explicitArea, source: 'explicit-viewbox' };
+    if (inputs.layerRectangle)
+        return { rect: inputs.layerRectangle, source: 'layer-rectangle' };
+    const derived = getVenueFitRect(inputs.sceneDef, inputs.svgArea);
+    if (derived)
+        return { rect: derived, source: 'scene-derived' };
+    return { rect: inputs.svgArea, source: 'svg-area' };
+}

package/dist/esm/utils/shortenName.d.ts

@@ -0,0 +1,2 @@
+export declare function shortenName(name: string): string;
+//# sourceMappingURL=shortenName.d.ts.map

package/dist/esm/utils/shortenName.js

@@ -0,0 +1,19 @@
+export function shortenName(name) {
+    if (typeof name !== 'string')
+        return name;
+    return name
+        .split(' ')
+        .map((word) => {
+        const cleaned = word.replace(/[^A-Z0-9+-]/gi, '');
+        const numberMatch = cleaned.match(/^[-+]?\d+$/);
+        if (numberMatch) {
+            return numberMatch[0];
+        }
+        const isAcronym = /^[A-Z]{2,4}$/.test(cleaned);
+        if (isAcronym) {
+            return cleaned;
+        }
+        return cleaned.charAt(0).toUpperCase();
+    })
+        .join('');
+}

package/dist/esm/utils/silence-mobx-react-lite-warning.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=silence-mobx-react-lite-warning.d.ts.map

package/dist/esm/utils/silence-mobx-react-lite-warning.js

@@ -0,0 +1,24 @@
+// ============================================================================
+// !!! TEMPORARY — DELETE THIS FILE WHEN MIGRATING OFF mobx-react-lite 1.5 !!!
+// ============================================================================
+// Silences a React 19 dev-only warning ("Can't perform a React state update on
+// a component that hasn't mounted yet") that mobx-react-lite@1.5.2 produces
+// because its forceUpdate dispatches setState on sibling fibers React 19
+// considers not-yet-mounted. The warning is a library-level false positive,
+// not a real bug in this codebase. React strips this warning in production
+// builds, so this wrapper is a no-op there.
+//
+// Once we migrate to MobX 6 + mobx-react 9 (which uses useSyncExternalStore
+// and does not trigger this warning), DELETE THIS FILE and remove its import
+// from load.ts.
+// ============================================================================
+if (typeof console !== 'undefined' && typeof console.error === 'function') {
+    const originalError = console.error.bind(console);
+    const SILENCED_WARNING = "Can't perform a React state update on a component that hasn't mounted yet";
+    console.error = (...args) => {
+        if (typeof args[0] === 'string' && args[0].includes(SILENCED_WARNING))
+            return;
+        originalError(...args);
+    };
+}
+export {};

package/dist/esm/utils/strEqual.d.ts

@@ -0,0 +1,2 @@
+export declare function strEqual(a: string, b: string): boolean;
+//# sourceMappingURL=strEqual.d.ts.map

package/dist/esm/utils/strEqual.js

@@ -0,0 +1,3 @@
+export function strEqual(a, b) {
+    return a?.localeCompare(b, undefined, { sensitivity: 'base' }) === 0;
+}

package/dist/esm/utils/swappable-proxy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A stable object that forwards every operation to whatever instance is live
+ * at the moment of access — the mechanism behind the one-live-plan contract
+ * (ADR-0011). Importers hold the proxy forever; a plan swap replaces the
+ * instance underneath it, and the dead window between `destroy()` and the next
+ * `load()` (when `resolve` yields nothing) makes every access throw rather than
+ * silently serve a dead object.
+ *
+ * MobX 5 tolerates this because its administration lives on the instance and
+ * every trap dereferences afresh — proven end-to-end by the spike recorded in
+ * `docs/2026-08-27-plan-swap-proxy-spike-verdict.md` and locked in by
+ * `store/live-store.spec.tsx`. The one thing it cannot paper over: a reaction
+ * created before a swap stays subscribed to the old instance, which is why
+ * `destroy()` disposes every reaction it owns.
+ *
+ * Used by the store barrel (`store/live-store.ts`) and by the event-data
+ * bindings that importers hold as objects rather than call as functions —
+ * `data/index.ts` and `tools/settings.ts`.
+ *
+ * Note that proxy identity is not instance identity — `store.uiState` is not
+ * `===` the `uiState` export. No store-object identity comparisons exist in
+ * `src` today; don't introduce one.
+ *
+ * @param name How the proxy is known to importers, used in the dead-window error.
+ * @param resolve Yields the live instance, or a nullish value while none is.
+ */
+export declare function createSwappableProxy<T extends object>(name: string, resolve: () => T | null | undefined): T;
+//# sourceMappingURL=swappable-proxy.d.ts.map

package/dist/esm/utils/swappable-proxy.js

@@ -0,0 +1,71 @@
+/**
+ * A stable object that forwards every operation to whatever instance is live
+ * at the moment of access — the mechanism behind the one-live-plan contract
+ * (ADR-0011). Importers hold the proxy forever; a plan swap replaces the
+ * instance underneath it, and the dead window between `destroy()` and the next
+ * `load()` (when `resolve` yields nothing) makes every access throw rather than
+ * silently serve a dead object.
+ *
+ * MobX 5 tolerates this because its administration lives on the instance and
+ * every trap dereferences afresh — proven end-to-end by the spike recorded in
+ * `docs/2026-08-27-plan-swap-proxy-spike-verdict.md` and locked in by
+ * `store/live-store.spec.tsx`. The one thing it cannot paper over: a reaction
+ * created before a swap stays subscribed to the old instance, which is why
+ * `destroy()` disposes every reaction it owns.
+ *
+ * Used by the store barrel (`store/live-store.ts`) and by the event-data
+ * bindings that importers hold as objects rather than call as functions —
+ * `data/index.ts` and `tools/settings.ts`.
+ *
+ * Note that proxy identity is not instance identity — `store.uiState` is not
+ * `===` the `uiState` export. No store-object identity comparisons exist in
+ * `src` today; don't introduce one.
+ *
+ * @param name How the proxy is known to importers, used in the dead-window error.
+ * @param resolve Yields the live instance, or a nullish value while none is.
+ */
+export function createSwappableProxy(name, resolve) {
+    const live = () => {
+        const instance = resolve();
+        if (!instance)
+            throw new Error(`${name} accessed after destroy`);
+        return instance;
+    };
+    // The target is a throwaway `{}` — every trap ignores it and answers from the
+    // live instance instead.
+    return new Proxy({}, {
+        // `get`/`set` pass the instance as receiver so `@computed` getters run with
+        // `this` bound to it and reach the MobX administration directly.
+        get: (_target, property) => {
+            const instance = live();
+            return Reflect.get(instance, property, instance);
+        },
+        set: (_target, property, value) => {
+            const instance = live();
+            return Reflect.set(instance, property, value, instance);
+        },
+        has: (_target, property) => Reflect.has(live(), property),
+        deleteProperty: (_target, property) => Reflect.deleteProperty(live(), property),
+        ownKeys: () => Reflect.ownKeys(live()),
+        getOwnPropertyDescriptor: (_target, property) => {
+            const descriptor = Reflect.getOwnPropertyDescriptor(live(), property);
+            // Reporting a non-configurable property the empty target doesn't have
+            // violates a proxy invariant, and spread/`Object.keys` would throw.
+            return descriptor && { ...descriptor, configurable: true };
+        },
+        defineProperty: (_target, property, descriptor) => Reflect.defineProperty(live(), property, descriptor),
+        getPrototypeOf: () => Reflect.getPrototypeOf(live()),
+        setPrototypeOf: (_target, prototype) => Reflect.setPrototypeOf(live(), prototype),
+        // The empty target is always extensible, so these two must answer for it
+        // rather than for the instance — but still refuse to answer at all once the
+        // plan is gone.
+        isExtensible: () => {
+            live();
+            return true;
+        },
+        preventExtensions: () => {
+            live();
+            return false;
+        },
+    });
+}

package/dist/esm/utils/trackingParams.d.ts

@@ -0,0 +1,3 @@
+export declare const TRACKING_PARAM_PATTERNS: string[];
+export declare function stripTrackingParams(search: string): string | null;
+//# sourceMappingURL=trackingParams.d.ts.map

package/dist/esm/utils/trackingParams.js

@@ -0,0 +1,24 @@
+// Third-party analytics/tracking query params (Google Analytics, Google Ads, Facebook, utm_*) — single source of truth.
+export const TRACKING_PARAM_PATTERNS = [
+    '_gl',
+    '_ga',
+    '_ga_[\\w-]+',
+    'gclid',
+    'gclsrc',
+    'gbraid',
+    'wbraid',
+    'gad_source',
+    'fbclid',
+    'utm_[\\w-]+',
+];
+const TRACKING_PARAM_NAME = new RegExp(`^(${TRACKING_PARAM_PATTERNS.join('|')})$`, 'i');
+// Removes tracking params from a raw `?...` search, preserving other segments verbatim (split on `&`, not
+// URLSearchParams, which would mangle route slugs' `:`). Returns null when nothing changed.
+export function stripTrackingParams(search) {
+    const raw = search.startsWith('?') ? search.slice(1) : search;
+    if (!raw)
+        return null;
+    const segments = raw.split('&');
+    const kept = segments.filter((segment) => !TRACKING_PARAM_NAME.test(segment.split('=')[0]));
+    return kept.length === segments.length ? null : kept.join('&');
+}

package/dist/esm/utils/urlEncoding.d.ts

@@ -0,0 +1,7 @@
+export declare function encodeStringArray(array: string[]): string;
+export declare function decodeStringArray(encodedString: string): string[];
+export declare function encodeString(str: string | null): string | null;
+export declare function decodeString(encodedString: string | null): string | null;
+export declare function toLowerCaseArray(array: string[]): string[];
+export declare function toLowerCaseString(str: string | null): string | null;
+//# sourceMappingURL=urlEncoding.d.ts.map