@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/tools/report-error.js

@@ -0,0 +1,134 @@
+// @ts-nocheck
+import logger from './logger';
+let timeoutId;
+export default function reportError(e) {
+    if (timeoutId || e.filename.indexOf('expofp.com') === -1)
+        return;
+    const ignoredErrors = [
+        /loading chunk \d{1,2}\b/i,
+        /zaloJS/i,
+        /e.target.name/i,
+        /ResizeObserver loop/i,
+        /ChunkLoadError/i,
+        /FloorPlan not ready/i,
+    ];
+    const ignoreError = ignoredErrors.some((err) => err.test(e.message));
+    if (ignoreError)
+        return;
+    timeoutId = window.setTimeout(async function () {
+        //const ipData = await getIpData();
+        const language = navigator.languages && navigator.languages.length
+            ? navigator.languages[0]
+            : navigator.language;
+        const data = {
+            host: document.location.host,
+            message: e.message,
+            filename: e.filename,
+            lineno: e.lineno,
+            colno: e.colno,
+            stack: e.error?.stack,
+            log: logger.messages.join('\n'),
+            userAgent: navigator.userAgent,
+            language,
+            group: 'FP',
+            url: document.location,
+            subject: 'FP JS error: ' + document.location.host, // + " in " + ipData.country,
+            //...ipData
+        };
+        logger.info('Sending error report', data);
+        await Promise.all([sendEmailMessage(data), sendSlackMessage(data)]);
+    }, 2000);
+}
+async function sendEmailMessage(data) {
+    if (process.env.NODE_ENV !== 'production')
+        return;
+    const rawResponse = await fetch('https://app.expofp.com/api/report-error', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+    });
+    logger.log('Reporter response: ', await rawResponse.text());
+}
+async function sendSlackMessage(data) {
+    if (process.env.NODE_ENV !== 'production')
+        return;
+    const slackObj = createSlackMessage(data);
+    const rawResponse = await fetch('https://msg.expofp.com/v1/post-message/' + window.location.hostname, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(slackObj),
+    });
+    logger.log('Slack reporter response: ', await rawResponse.text());
+}
+// sendSlackMessage({
+//     subject: "123",
+//     someData: "123",
+//     someData2: "123"
+// });
+function createSlackMessage(data) {
+    const blocksData = JSON.parse(JSON.stringify(data));
+    delete blocksData.subject;
+    delete blocksData.message;
+    delete blocksData.stack;
+    delete blocksData.log;
+    const blocks = [];
+    blocks.push({
+        type: 'section',
+        text: {
+            type: 'mrkdwn',
+            text: `:warning:* ${data.subject}*`,
+        },
+    });
+    blocks.push({
+        type: 'section',
+        text: {
+            type: 'plain_text',
+            text: data.message + ' → ' + (data.stack || '').split('\n')[0],
+        },
+    });
+    // blocks.push({
+    //     type: "divider"
+    // });
+    // for (const key of Object.keys(blocksData)) {
+    //     blocks.push({
+    //         type: "section",
+    //         text: {
+    //             type: "mrkdwn",
+    //             text: `*${key}*`
+    //         }
+    //     });
+    //     blocks.push({
+    //         type: "section",
+    //         text: {
+    //             type: "plain_text",
+    //             text: (blocksData[key] || "undefined").toString()
+    //         }
+    //     });
+    // }
+    const res = {
+        channel: '#fp-errors',
+        username: 'error-reporter-bot',
+        type: 'mrkdwn',
+        text: data.subject,
+        blocks: blocks,
+    };
+    return res;
+}
+// async function getIpData() {
+//     try {
+//         const ipInfoRequest = await fetch("https://geo.ipify.org/api/v1?apiKey=at_3dMzE1vaZp2Kd8NxMV7HukiFFjutg");
+//         const ipInfo = await ipInfoRequest.json();
+//         logger.log("ipify", ipInfo, ipInfoRequest);
+//         if (ipInfoRequest.ok) {
+//             return {
+//                 ip: ipInfo.ip,
+//                 ...ipInfo.location,
+//             };
+//         } else {
+//             return { ip: ipInfo.messages };
+//         }
+//     } catch (e) {
+//         logger.error(e);
+//         return { ip: e.message };
+//     }
+// }

package/dist/esm/tools/reset.d.ts

@@ -0,0 +1,2 @@
+export declare function resetGlobalVariables(): void;
+//# sourceMappingURL=reset.d.ts.map

package/dist/esm/tools/reset.js

@@ -0,0 +1,35 @@
+/* eslint-disable prefer-const */
+// @ts-nocheck
+export function resetGlobalVariables() {
+    deleteKey('floorplan');
+    deleteKey('__searchi');
+    deleteKey('__mobxGlobals');
+    deleteKey('__store');
+    deleteKey('__mobxInstanceCount');
+    // Neither of these matches the `__fp` / `__efp` sweep below, so both have to
+    // be named: `__resett` is the kiosk idle-reset timer bound to the plan's UI
+    // (`store/init/init-ui.ts`) and `__expofpReady` is the ready CustomEvent
+    // whose `detail.floorplan` is the instance itself (`load.ts`). Left behind,
+    // each roots its whole dead plan graph from `window`.
+    deleteKey('__resett');
+    deleteKey('__expofpReady');
+    for (let key in window) {
+        if (key === '__efpStyleElements')
+            continue;
+        if (key.includes('__fp') || key.includes('__efp')) {
+            deleteKey(key);
+        }
+    }
+}
+function deleteKey(key) {
+    if (canDelete(key)) {
+        delete window[key];
+    }
+    else {
+        window[key] = undefined;
+    }
+}
+function canDelete(key) {
+    let desc = Object.getOwnPropertyDescriptor(window, key);
+    return desc && desc.configurable;
+}

package/dist/esm/tools/sdk-telemetry.d.ts

@@ -0,0 +1,10 @@
+/** Sends one event while SDK telemetry is on. Never throws. */
+export declare function sendSdkTelemetry(event: string): void;
+/**
+ * Queues one `selectCurrentPosition` call in localStorage, where it outlives
+ * the page, and sends the queue as one event once the previous request is done
+ * and the interval since it has passed. A batch that never reached the intake
+ * (offline, network error) stays queued for the next send.
+ */
+export declare function queuePositionTelemetry(item: Record<string, unknown>): void;
+//# sourceMappingURL=sdk-telemetry.d.ts.map

package/dist/esm/tools/sdk-telemetry.js

@@ -0,0 +1,122 @@
+import { peekConfig } from '@expofp/config';
+import debug from 'debug';
+/**
+ * SDK telemetry, sent while the `sdkTelemetry` flag is on to the intake the
+ * playbook's `development/sdk-telemetry.md` describes. The intake has no rate
+ * limit, so position batches go one request at a time, at least a second
+ * apart, and further apart while the intake keeps failing. An event the intake
+ * answered is never sent again, whatever the answer. Position items carry the
+ * `selectCurrentPosition` arguments as the host passed them, coordinates included.
+ */
+const log = debug('efp:sdk-telemetry');
+/** The last segment names this SDK as the source in Loki. */
+const INTAKE_URL = 'https://sdk-telemetry.expofp.com/sdk-data/floorplan-sdk-web';
+/** Public by nature in a browser: per the playbook it only keeps junk out. */
+const INTAKE_TOKEN = 'KaptzDWTgJ_GXhb5Jg7ByTW0KK_poitr21X_-IcJeE4';
+/** The localStorage queue of `selectCurrentPosition` calls; the expo ends the key. */
+const POSITION_QUEUE_KEY = 'efp-sdk-telemetry-positions:';
+/** The queue keeps the newest calls past this, which also holds a batch under the intake's 1 MiB. */
+const MAX_QUEUED_POSITIONS = 3_000;
+/** The least time between two position requests; each failure in a row doubles it, up to the max. */
+const MIN_SEND_INTERVAL_MS = 1_000;
+const MAX_SEND_INTERVAL_MS = 60_000;
+/** A position send is scheduled or in flight: anything queued meanwhile goes with the next one. */
+let positionSendBusy = false;
+/** When the last position request started, by `performance.now()`. */
+let lastPositionSendAt = -Infinity;
+/** Position requests in a row the intake did not accept. */
+let failedPositionSends = 0;
+/** Sends one event while SDK telemetry is on. Never throws. */
+export function sendSdkTelemetry(event) {
+    const config = enabledConfig();
+    if (config)
+        void post(config.expo, { event });
+}
+/**
+ * Queues one `selectCurrentPosition` call in localStorage, where it outlives
+ * the page, and sends the queue as one event once the previous request is done
+ * and the interval since it has passed. A batch that never reached the intake
+ * (offline, network error) stays queued for the next send.
+ */
+export function queuePositionTelemetry(item) {
+    const config = enabledConfig();
+    if (!config)
+        return;
+    const key = POSITION_QUEUE_KEY + config.expo;
+    storeQueue(key, [...readQueue(key), { ts: new Date().toISOString(), ...item }]);
+    schedulePositionSend();
+}
+function schedulePositionSend() {
+    if (positionSendBusy)
+        return;
+    positionSendBusy = true;
+    const interval = Math.min(MIN_SEND_INTERVAL_MS * 2 ** failedPositionSends, MAX_SEND_INTERVAL_MS);
+    const wait = Math.max(0, lastPositionSendAt + interval - performance.now());
+    setTimeout(() => void sendPositionQueue(), wait);
+}
+async function sendPositionQueue() {
+    const config = enabledConfig();
+    const key = POSITION_QUEUE_KEY + (config?.expo ?? '');
+    const items = readQueue(key);
+    // offline, the queue stays as it is until a later call schedules a send
+    if (!config || items.length === 0 || navigator.onLine === false) {
+        positionSendBusy = false;
+        return;
+    }
+    storeQueue(key, []);
+    lastPositionSendAt = performance.now();
+    const status = await post(config.expo, { event: 'selectCurrentPosition', items });
+    // a batch that never reached the intake goes back, ahead of calls queued meanwhile
+    if (status === undefined)
+        storeQueue(key, [...items, ...readQueue(key)]);
+    failedPositionSends = status === 200 ? 0 : failedPositionSends + 1;
+    positionSendBusy = false;
+    if (readQueue(key).length > 0)
+        schedulePositionSend();
+}
+/** Resolves to the intake's HTTP status, or `undefined` when the request never reached it. */
+async function post(expo, fields) {
+    try {
+        const response = await fetch(INTAKE_URL, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${INTAKE_TOKEN}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                ts: new Date().toISOString(),
+                version: typeof __BUILD_INFO__ === 'undefined' ? undefined : __BUILD_INFO__.version,
+                expo,
+                ...fields,
+            }),
+        });
+        if (response.status !== 200) {
+            log('event refused', response.status, await response.text().catch(() => ''));
+        }
+        return response.status;
+    }
+    catch (error) {
+        log('event not sent', error);
+        return undefined;
+    }
+}
+function readQueue(key) {
+    try {
+        return JSON.parse(localStorage.getItem(key) ?? '[]');
+    }
+    catch {
+        return [];
+    }
+}
+function storeQueue(key, items) {
+    try {
+        if (items.length === 0)
+            localStorage.removeItem(key);
+        else
+            localStorage.setItem(key, JSON.stringify(items.slice(-MAX_QUEUED_POSITIONS)));
+    }
+    catch (error) {
+        log('position queue not stored', error);
+    }
+}
+function enabledConfig() {
+    const config = peekConfig();
+    return config?.sdkTelemetry === true ? config : undefined;
+}

package/dist/esm/tools/sentry.d.ts

@@ -0,0 +1,7 @@
+interface SentryConfig {
+    eventId?: string;
+    isWebview: boolean;
+}
+export declare function initSentry(options: SentryConfig): void;
+export {};
+//# sourceMappingURL=sentry.d.ts.map

package/dist/esm/tools/sentry.js

@@ -0,0 +1,166 @@
+import { makeOfflineTransport } from '@sentry/core';
+import { captureException, init, makeFetchTransport, setTag, setUser } from '@sentry/react';
+const SENTRY_ENVIRONMENT = process.env.NODE_ENV || 'development';
+const SENTRY_RELEASE = process.env.SENTRY_RELEASE || undefined;
+// Create a store based on localStorage for storing events in offline mode
+function createLocalStorageStore() {
+    const STORAGE_KEY = 'sentry_offline_queue';
+    const MAX_QUEUE_SIZE = 50; // Limit queue size
+    return {
+        async push(envelope) {
+            try {
+                const queue = JSON.parse(localStorage?.getItem(STORAGE_KEY) || '[]');
+                queue.push({ envelope, timestamp: Date.now() });
+                // Limit queue size by removing oldest events
+                if (queue.length > MAX_QUEUE_SIZE) {
+                    queue.shift();
+                }
+                localStorage?.setItem(STORAGE_KEY, JSON.stringify(queue));
+            }
+            catch {
+                // Best-effort: ignore localStorage write/parse failures (quota, private mode).
+            }
+        },
+        async unshift(envelope) {
+            try {
+                const queue = JSON.parse(localStorage?.getItem(STORAGE_KEY) || '[]');
+                queue.unshift({ envelope, timestamp: Date.now() });
+                // Limit queue size
+                if (queue.length > MAX_QUEUE_SIZE) {
+                    queue.pop();
+                }
+                localStorage?.setItem(STORAGE_KEY, JSON.stringify(queue));
+            }
+            catch {
+                // Best-effort: ignore localStorage write/parse failures (quota, private mode).
+            }
+        },
+        async shift() {
+            try {
+                const queue = JSON.parse(localStorage?.getItem(STORAGE_KEY) || '[]');
+                if (queue.length === 0) {
+                    // Clear localStorage if queue is empty
+                    localStorage?.removeItem(STORAGE_KEY);
+                    return;
+                }
+                const item = queue.shift();
+                // Update queue in localStorage
+                if (queue.length === 0) {
+                    // If queue became empty, completely remove the key
+                    localStorage?.removeItem(STORAGE_KEY);
+                }
+                else {
+                    localStorage?.setItem(STORAGE_KEY, JSON.stringify(queue));
+                }
+                return item?.envelope;
+            }
+            catch {
+                return;
+            }
+        },
+    };
+}
+export function initSentry(options) {
+    // Wrap fetch transport in offline transport with localStorage store
+    const createOfflineTransport = makeOfflineTransport(makeFetchTransport);
+    init({
+        dsn: 'https://b2eafc5a038fa2c535099e431de219f2@o4510697102114816.ingest.us.sentry.io/4510697103097856',
+        release: SENTRY_RELEASE,
+        environment: SENTRY_ENVIRONMENT,
+        sendDefaultPii: true,
+        transport: (options) => {
+            return createOfflineTransport({
+                ...options,
+                createStore: () => createLocalStorageStore(),
+                flushAtStartup: true, // Attempt to send queued events on startup
+                shouldStore: async (_envelope, error) => {
+                    // Store events only if offline or network error
+                    if (!navigator.onLine) {
+                        return true;
+                    }
+                    // Store on network errors
+                    if (error &&
+                        (error.message?.includes('Failed to fetch') ||
+                            error.message?.includes('NetworkError') ||
+                            error.message?.includes('Network request failed'))) {
+                        return true;
+                    }
+                    return false;
+                },
+            });
+        },
+        // Performance Monitoring
+        tracesSampleRate: 0.1,
+        ignoreErrors: [
+            /loading chunk \d{1,2}\b/i,
+            /zaloJS/i,
+            /e\.target\.name/i,
+            /ResizeObserver loop/i,
+            /ChunkLoadError/i,
+            /FloorPlan not ready/i,
+            /NetworkError/i,
+            /network error occurred/i,
+            /network request failed/i,
+            /failed to fetch/i,
+            /abort/i,
+        ],
+        beforeSend(event) {
+            if (SENTRY_ENVIRONMENT !== 'production') {
+                return null;
+            }
+            return event;
+        },
+    });
+    if (options.eventId) {
+        setTag('eventId', options.eventId);
+    }
+    setTag('isWebview', options.isWebview);
+    setTag('source', 'main');
+    // Set anonymous user identity so Sentry can count affected users
+    setUser({ ip_address: '{{auto}}' });
+    // Set up global error handlers
+    setupGlobalErrorHandlers();
+}
+function setupGlobalErrorHandlers() {
+    // Handle unhandled promise rejections
+    window.addEventListener('unhandledrejection', (event) => {
+        captureException(event.reason, {
+            contexts: {
+                unhandledRejection: {
+                    promise: event.promise,
+                },
+            },
+        });
+    });
+    // Handle window errors (already handled by Sentry by default, but we can add custom logic)
+    const originalOnError = window.onerror;
+    window.onerror = (message, source, lineno, colno, error) => {
+        if (error) {
+            captureException(error, {
+                contexts: {
+                    windowError: {
+                        message,
+                        source,
+                        lineno,
+                        colno,
+                    },
+                },
+            });
+        }
+        // Call original handler if it exists
+        if (originalOnError) {
+            originalOnError.call(window, message, source, lineno, colno, error);
+        }
+        return false; // Don't prevent default error handling
+    };
+    // Monitor connection restoration for immediate sending of queued events
+    window.addEventListener('online', () => {
+        // Sentry will automatically attempt to send queued events
+        // thanks to flushAtStartup and retry mechanism in offline transport
+        // We can also manually call flush if needed
+        const client = window.__SENTRY__?.hub?.getClient();
+        if (client) {
+            client.flush().catch(() => undefined);
+        }
+    });
+}

package/dist/esm/tools/settings.d.ts

@@ -0,0 +1,36 @@
+export declare class FpSettings {
+    boothLabelColor: string;
+    boothBorderColor: string;
+    backgroundColor: string;
+    boothBorderWidth?: number;
+    heatmapColors: string[];
+    maxZoom?: number;
+}
+declare class Settings extends FpSettings {
+    EXPO: string;
+    borderless: boolean;
+    wayfinding: boolean;
+    colors: {
+        booths: {
+            default: string;
+            defaultHold: string;
+            defaultSold: string;
+            seectedLight: string | null;
+            selected: string;
+            selectedBorder: null;
+            wayfinding: {
+                selected: string;
+                selectedBorder: null;
+            };
+            empty: string;
+        };
+    };
+}
+/**
+ * The live event's settings. Every property read forwards to the settings of
+ * whichever plan is loaded now, so importers can keep holding this binding
+ * across a plan swap — capturing a field from it at module scope cannot.
+ */
+declare const _default: Settings;
+export default _default;
+//# sourceMappingURL=settings.d.ts.map

package/dist/esm/tools/settings.js

@@ -0,0 +1,110 @@
+// Legacy provider being migrated to @expofp/schema + getConfig() (@expofp/config).
+// Prefer that path for new fields, defaults, and per-expo overrides, and shrink
+// this file when a change makes it cheap — extend it only when the config path
+// can't host the data cleanly yet.
+import { getConfig } from '@expofp/config';
+import deepmerge from 'deepmerge';
+import { getFpSvgJs, getWfData } from '../data/fp-payloads.js';
+import { createSwappableProxy } from '../utils/swappable-proxy.js';
+import { eventScopedValue } from './event-scoped-cache.js';
+// TODO create complex solution to check if color input is valid (color none is fails run time)
+export class FpSettings {
+    constructor() {
+        this.boothLabelColor = '#fff';
+        this.boothBorderColor = '#fff';
+        this.backgroundColor = '#ebebeb';
+        this.heatmapColors = [
+            '#FDE7C7',
+            '#FDDBAE',
+            '#FDC48D',
+            '#FCB37C',
+            '#FCA26D',
+            '#F67B5B',
+            '#EB483E',
+            '#E03143',
+            '#6C0022',
+        ];
+    }
+}
+class Settings extends FpSettings {
+    constructor() {
+        super(...arguments);
+        // this is not replaced with const, so calls to settings.EXPO won't get replaced with const
+        // this is done for template to work
+        // Same value as `window.__efpEvent`, but read from the config the load path
+        // has already installed — the global is only written later, in the loader's
+        // constructor, so reading it here could latch the previous event's id.
+        this.EXPO = getConfig().expo;
+        this.borderless = false;
+        this.wayfinding = false;
+        // borderWidth: 1,
+        this.colors = {
+            // base: "#ebebeb",
+            booths: {
+                default: '#41b6e7',
+                defaultHold: '#48484A',
+                defaultSold: '#41b6e7',
+                seectedLight: null,
+                selected: '#fb3e59',
+                selectedBorder: null,
+                wayfinding: {
+                    selected: '#0088D6',
+                    selectedBorder: null,
+                },
+                empty: '#aaaaaa', // this is #aaa for default BG #d6d6d6d
+            },
+        };
+    }
+}
+/**
+ * Builds the settings object for whichever event is live. Called lazily, once
+ * per plan: the result is a single mutable object (call sites read it as one),
+ * so it is event-scoped state rather than a per-call derivation — hence the
+ * memo rather than the `fp-payloads.ts` read-per-call pattern (ADR-0011).
+ */
+function buildSettings() {
+    let settings = new Settings();
+    if (settings.EXPO.startsWith('sxsw2024')) {
+        settings.colors.booths.selected = '#FF6400';
+        settings.colors.booths.seectedLight = '#808080';
+    }
+    else if (settings.EXPO === 'whxdubai2026') {
+        settings.colors.booths.selected = '#2B66FE';
+        settings.maxZoom = 450;
+    }
+    else if (settings.EXPO === 'whxlabs2026') {
+        settings.colors.booths.selected = '#2B66FE';
+    }
+    else if (settings.EXPO === 'wineparis2026') {
+        settings.maxZoom = 450;
+    }
+    else if (settings.EXPO === 'rdemo2025') {
+        settings.maxZoom = 450;
+    }
+    // else if (settings.EXPO === "eventtechlive2019") {
+    //     settings.borderless = true;
+    // }
+    const globalSettings = window.__settings;
+    const fpSettings = getFpSvgJs().__fpSettings ?? {};
+    settings = deepmerge(settings, globalSettings ?? fpSettings);
+    settings = deepmerge(settings, fpSettings);
+    // Wayfinding availability is a property of the event's data, not of the
+    // drawing module that used to poke it in here as an import side effect.
+    // Assigned after the merges, exactly where the old side effect landed.
+    settings.wayfinding = !getConfig().hideDirections && getWfData() ? true : false;
+    // Config wins over the plan payload: an organizer-set selection color
+    // applies to booths, spaces and outdoor POI pins alike.
+    const configSelectionColor = getConfig().selectionColor;
+    if (configSelectionColor) {
+        settings.colors.booths.selected = configSelectionColor;
+        settings.colors.booths.wayfinding.selected = configSelectionColor;
+    }
+    return settings;
+}
+const liveSettings = eventScopedValue(buildSettings);
+/**
+ * The live event's settings. Every property read forwards to the settings of
+ * whichever plan is loaded now, so importers can keep holding this binding
+ * across a plan swap — capturing a field from it at module scope cannot.
+ */
+export default createSwappableProxy('settings', liveSettings);

package/dist/esm/tools/slug.d.ts

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

package/dist/esm/tools/slug.js

@@ -0,0 +1,27 @@
+import slugify from 'slugify';
+import { eventScopedValue } from './event-scoped-cache.js';
+// function slugify(text: string) {
+//     return text.toString().toLowerCase()
+//         .replace(/\s+/g, '-')           // Replace spaces with -
+//         .replace(/[^\w\-]+/g, '')       // Remove all non-word chars
+//         .replace(/\-\-+/g, '-')         // Replace multiple - with single -
+//         .replace(/^-+/, '')             // Trim - from start of text
+//         .replace(/-+$/, '');            // Trim - from end of text
+// }
+/**
+ * The slugs handed out for the live event. Uniqueness is per event: carrying
+ * the previous plan's slugs over would make the next event's booths collide
+ * with names nothing on the page has any more, and suffix them (ADR-0011).
+ */
+const generatedSlugs = eventScopedValue(() => new Set());
+export function generateUniqueSlug(text) {
+    const slugs = generatedSlugs();
+    let append = 0;
+    const slugBase = slugify(text, { remove: /[*+~.()'"!:@]/g, lower: true });
+    let slug;
+    do {
+        slug = slugBase + (append++ > 0 || !slugBase ? append : '');
+    } while (slugs.has(slug));
+    slugs.add(slug);
+    return slug;
+}

package/dist/esm/tools/strip-html.d.ts

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

package/dist/esm/tools/strip-html.js

@@ -0,0 +1,7 @@
+export function stripHtml(html) {
+    if (typeof document === 'undefined')
+        return html;
+    const div = document.createElement('div');
+    div.innerHTML = html;
+    return div.textContent ?? '';
+}