@syntrologie/adapt-faq 2.8.0-canary.42 → 2.8.0-canary.421

package/dist/FAQWidgetLit.d.ts

@@ -0,0 +1,280 @@
+/**
+ * Adaptive FAQ - FAQWidgetLit
+ *
+ * Lit web component equivalent of FAQWidget.tsx.
+ * Renders a collapsible Q&A accordion with search, category grouping,
+ * feedback, and markdown rendering — all as a custom element with no
+ * Shadow DOM (light DOM via createRenderRoot).
+ *
+ * Tag name: <syntro-faq-accordion>
+ *
+ * Decorator-free: uses `static override properties` (tsconfig has no
+ * experimentalDecorators).
+ */
+import { LitElement, nothing } from 'lit';
+import type { FAQWidgetRuntime } from './faq-types';
+import type { FAQConfig, FeedbackValue } from './types';
+/**
+ * <syntro-faq-accordion> — light-DOM Lit web component.
+ *
+ * Set properties imperatively (no attribute serialisation for objects):
+ *   el.faqConfig = { expandBehavior: 'single', ... };
+ *   el.runtime   = runtimeInstance;
+ *   el.instanceId = 'my-faq';
+ */
+export declare class FAQAccordionElement extends LitElement {
+    #private;
+    static properties: {
+        faqConfig: {
+            attribute: boolean;
+        };
+        runtime: {
+            attribute: boolean;
+        };
+        instanceId: {
+            type: StringConstructor;
+        };
+        _openId: {
+            state: boolean;
+        };
+        _activeFace: {
+            state: boolean;
+        };
+        _flipAnimating: {
+            state: boolean;
+        };
+        _flipDir: {
+            state: boolean;
+        };
+        _highlightId: {
+            state: boolean;
+        };
+        _searchQuery: {
+            state: boolean;
+        };
+        _feedbackState: {
+            state: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+    };
+    faqConfig: FAQConfig;
+    runtime: FAQWidgetRuntime | null;
+    instanceId: string;
+    private _generatedUid;
+    _openId: string | null;
+    _activeFace: 'front' | 'back';
+    _flipAnimating: boolean;
+    _flipDir: 'in' | 'out';
+    _highlightId: string | null;
+    _searchQuery: string;
+    _feedbackState: Map<string, FeedbackValue>;
+    _hoveredId: string | null;
+    private _flipSettleTimer;
+    private _pendingFocus;
+    private _focusReturnId;
+    private _unsubContext;
+    private _unsubAccumulator;
+    private _unsubCta;
+    private _unsubDeepLink;
+    private _unsubSessionMetrics;
+    private _highlightTimer;
+    private _unsubCompositional;
+    private _tileId;
+    /** Instance ids already appended via the compositional bus — dedups
+     *  the subscribe-then-replay path (and re-subscribes on runtime change). */
+    private _llmAppendedIds;
+    constructor();
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProps: Map<string, unknown>): void;
+    /**
+     * Move focus to the face that just became active after a flip (a11y). On
+     * flip-to-back, focus the ‹ Back button; on flip-to-front, focus the question
+     * row that originally opened the detail (so keyboard/AT users land back where
+     * they were). No-op when nothing is pending or the target isn't in the DOM
+     * yet (the flip-to-front row may not exist if the list changed).
+     */
+    private _applyPendingFocus;
+    private _subscribeAll;
+    /**
+     * Subscribe to `element.compositional_*` events targeting this accordion's
+     * tile, and ask the element store to replay any items it already holds for
+     * us (covers the case where the accordion mounts AFTER the item did — the
+     * inline-slot hydration race that otherwise silently drops the question).
+     */
+    private _subscribeCompositional;
+    /** Tile id for compositional filtering: the enclosing tile card's
+     *  `data-tile-id` (set by SyntroTileCard), falling back to `instanceId`
+     *  when the accordion is mounted outside a tile card. */
+    private _resolveTileId;
+    /** Append (or prepend) a faq:question the LLM mounted. The wire shape is a
+     *  fully-formed `{kind, config}` envelope, so we store it verbatim. */
+    private _insertItem;
+    /** Replace an existing question's content (full replacement). */
+    private _patchItem;
+    /** Remove a question by instance id. */
+    private _removeItem;
+    /**
+     * Re-evaluate whether the open question is still visible, then re-render.
+     * Called from the subscription-driven re-render paths (context / accumulator /
+     * sessionMetric changes). Those subscriptions can flip an open question's
+     * `triggerWhen` to false WITHOUT a compositional patch/remove — so without
+     * this hook the stale-open reset (`_resetFaceIfOpenStale`, otherwise only
+     * invoked on patch/remove) would never fire on the triggerWhen path, and an
+     * open question gated out this way would snap straight to the back face on
+     * re-appearance. `_resetFaceIfOpenStale` mutates reactive state (which itself
+     * schedules an update), and we still `requestUpdate()` for the no-op case.
+     */
+    private _reevaluateOpenAndUpdate;
+    /**
+     * If `_openId` no longer resolves against the visible/ordered list (gated out
+     * by triggerWhen, removed, or patched away), reset BOTH `_openId` and
+     * `_activeFace` to the front (and clear the pending a11y focus intent).
+     * Resolves against the SAME `ordered` list render() uses (visible + ordered,
+     * NOT search-filtered). Also cancels any pending back-clear timer. Invoked on
+     * compositional patch/remove AND on the subscription-driven re-render paths
+     * (via {@link _reevaluateOpenAndUpdate}) so the triggerWhen-gated-out case is
+     * genuinely covered. Keeping `_activeFace` on 'back' after the open id went
+     * stale is the bug this guards: render() would force the front face locally
+     * but leave state on 'back', so a later re-appearance snaps to the back face
+     * with no animation.
+     */
+    private _resetFaceIfOpenStale;
+    private _unsubscribeAll;
+    /**
+     * Master→detail takeover: tapping a list row opens its single-Q&A detail
+     * view (the whole widget swaps), so a long answer fills — and never
+     * overflows — the bounded velvet tile. There is no simultaneous multi-expand;
+     * one question owns the tile at a time.
+     */
+    private _handleOpen;
+    /**
+     * Put the widget into the DETAIL (back) face for `id` and flip to it. Shared
+     * by the tap handler and the event-driven entry points (faq:open CTA,
+     * notification.deep_link) so every "open this question" path flips the same
+     * way. Cancels any pending back-clear timer (a re-open before the flip-out
+     * finishes must keep the detail mounted). Remembers the originating question
+     * id so focus can return to that exact row on flip-to-front (a11y), and moves
+     * focus to the ‹ Back button once the back face renders.
+     */
+    private _openToDetail;
+    /** Back affordance: FLIP from the detail (back) face to the list (front) face.
+     *  We flip immediately but keep `_openId` (so the back face stays populated
+     *  through the rotation, never blank mid-flip); the id clears once the
+     *  transition completes. With reduced motion there's no transition, so it
+     *  clears synchronously.
+     *
+     *  Timer/token coupling: the tear-down delay is {@link _flipDurationMs} — the
+     *  computed `--vc-transition-duration` token (clamped to be >= our fallback),
+     *  NOT a hardcoded constant. A host that sets the token slower than the
+     *  fallback would otherwise clear `_openId` (blanking the back face) before
+     *  the rotation finished. Focus returns to the originating question row. */
+    private _handleBack;
+    /** Tear down the flip's 3D machinery so the shown face renders FLAT. Fired by
+     *  the container's `animationend`, the belt timer, or synchronously under
+     *  reduced motion. A flip-OUT (back→front) also clears `_openId` here — the
+     *  moment it's finally safe to empty the back face without blanking it
+     *  mid-rotation. */
+    private _settleFlip;
+    /** animationend on the flip container → the rotation is done, render flat. */
+    private _onFlipAnimationEnd;
+    private _clearFlipSettleTimer;
+    private _handleFeedback;
+    /**
+     * Unified render list. Merges compositionally-appended rows
+     * (`faqConfig.actions`, the container-then-stream path) with atomically
+     * authored rows (`faqConfig.questions`, the struct_list path) normalized
+     * into the same `FAQQuestionAction` shape. The atomic path is how the LLM
+     * mounts a complete FAQ in one call — so it renders whole, never empty.
+     */
+    private _allQuestions;
+    private _visibleQuestions;
+    private _orderedQuestions;
+    private _filteredQuestions;
+    private _categoryGroups;
+    /**
+     * The `data-adaptive-id` scope for this element's injected <style>. When
+     * `instanceId` is left at the shared default (`'faq-widget'`), two tiles would
+     * both scope to `[data-adaptive-id="faq-widget"]` and cross-style each other.
+     * In that case we fall back to a per-element generated uid so each default tile
+     * gets its own scope. A caller-provided instanceId is used verbatim.
+     */
+    private get _scopeId();
+    /**
+     * The flip transition duration in ms, coupled to the CSS. Reads the computed
+     * `--vc-transition-duration` token off this element at runtime so the JS timer
+     * that tears down the back face (see {@link _handleBack}) is ALWAYS >= the CSS
+     * transition — a host that sets the token slower than our hardcoded default no
+     * longer blanks the back face before the flip visually finishes. Falls back to
+     * {@link FLIP_TRANSITION_MS} when the token is absent/unreadable (no live
+     * layout, jsdom). We add a small buffer and take the max of the token and the
+     * fallback so the timer never undershoots either.
+     */
+    private _flipDurationMs;
+    /**
+     * Self-injected flip CSS. The FAQ tile is a light-DOM widget mounted across
+     * several canvases (velvet, default, onflow) and standalone — velvet ships a
+     * GENERIC, unscoped `[data-active-face]` flip rule (for the product card), but
+     * the other hosts don't. So the FAQ carries its own copy of the SAME 3D-flip
+     * technique, scoped to THIS instance (`[data-adaptive-id="…"]`) so it can't
+     * leak onto a sibling widget.
+     *
+     * Two deliberate departures from a naive copy of velvet's rule:
+     *
+     *  1. PERSPECTIVE goes on the PARENT viewport wrapper
+     *     (`[data-faq-flip-viewport]`), NOT on the rotating `[data-faq-flip]`
+     *     element. CSS `perspective` only gives depth to a DESCENDANT's transform —
+     *     putting it on the element that itself rotates does nothing (a flat
+     *     squash). We ALSO fold `perspective(...)` into the
+     *     rotate transform itself as a belt-and-braces measure, so the flip has
+     *     real 3D depth even inside velvet's bounded `overflow:hidden` deck card
+     *     (which can otherwise flatten a parent `perspective`).
+     *  2. The active-face attribute is NAMESPACED (`data-faq-active-face`), so
+     *     velvet's generic `[data-active-face]` rotate rule can't ALSO reach this
+     *     container and double-apply its (perspective-less) transform.
+     *
+     * It mirrors the product card / velvet house style: rotateY, preserve-3d,
+     * backface-visibility, and the `--vc-transition-duration` / `--vc-transition-
+     * easing` tokens (with a ~240ms fallback) so the two tiles feel consistent.
+     * `prefers-reduced-motion` disables the rotation — the JS (see
+     * {@link _handleBack}) clears state synchronously in that case.
+     */
+    private _renderFlipStyles;
+    private _renderAnswer;
+    private _renderFeedback;
+    /**
+     * LIST-view row. A tappable question with its chevron \u2014 but NO inline answer
+     * body. Tapping it takes over the tile with the question's detail view (see
+     * {@link _renderDetail}). Keeps the per-row look/markers/highlight from the
+     * old accordion minus the inline-expanded answer that overflowed the tile.
+     */
+    private _renderItem;
+    private _renderItems;
+    /**
+     * DETAIL view \u2014 the master\u2192detail takeover. Renders ONLY the open question:
+     * a back affordance, the question prominently, and its full answer via the
+     * SAME {@link _renderAnswer}/`renderAnswerHtml` path (all answer formats still
+     * work). The answer area scrolls if extremely long, so a single answer fills
+     * the bounded velvet tile and never pushes content past the `overflow:hidden`
+     * clip.
+     */
+    private _renderDetail;
+    /**
+     * "Dive deeper" (items 4/5) — hand the open question's context back to the
+     * CHAT as a deep-dive turn, so a clamped answer never leaves the visitor
+     * stuck. Canvas-agnostic: dispatches the neutral DIVE_DEEPER_EVENT; the
+     * chat-bar mountable turns it into a user-visible turn. The answer text rides
+     * along as (trimmed) context so the agent grounds its fuller reply.
+     */
+    private _handleDiveDeeper;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    /** The FRONT face — search box, the question list (optionally grouped by
+     *  category), and the no-results message. Extracted so both faces can live in
+     *  the DOM at once for the flip. */
+    private _renderListFace;
+}
+export default FAQAccordionElement;
+//# sourceMappingURL=FAQWidgetLit.d.ts.map

package/dist/FAQWidgetLit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAQWidgetLit.d.ts","sourceRoot":"","sources":["../src/FAQWidgetLit.ts"],"names":[],"mappings":"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"}

package/dist/FAQWidgetLit.editable.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Adaptive FAQ - FAQWidgetLit.editable
+ *
+ * Editable variant of the FAQ accordion for the canvas editor surface.
+ * Renders the same Q&A rows as <syntro-faq-accordion> but adds:
+ *   - Pencil button per row (shows on hover, calls controller.editItem on click)
+ *   - Click on question text expands/collapses to show the answer (normal FAQ behavior)
+ *   - Drag handle per row when items.length >= 2
+ *   - Drag-and-drop reorder via the sortable utility (injected via mount config)
+ *   - Read-only fallback when controller is null
+ *
+ * Tag name: <syntro-faq-accordion-editable>
+ *
+ * Decorator-free: uses `static override properties` (matches codebase convention).
+ * Light DOM: inherits host-page CSS variables (same as <syntro-faq-accordion>).
+ *
+ * Cross-package import safety:
+ *   The controller is typed as a structural `ControllerLike` interface defined
+ *   locally — NOT imported from @syntrologie/editor-sdk. This prevents a
+ *   dependency cycle (editor-sdk imports adapt-faq's editable; adapt-faq cannot
+ *   import editor-sdk). The real EditModeController satisfies ControllerLike
+ *   structurally.
+ *
+ *   Similarly, `makeSortable` is passed in as a `SortableFn` option rather than
+ *   imported directly. The editor-sdk bootstrap (setupEditModeBootstrap.ts) threads
+ *   the real makeSortable through the FAQWidgetLitEditableMountable.mount() call.
+ *   This is Alternative C from the architecture decision log, and matches the
+ *   structural-interface pattern already used for the controller.
+ */
+import { LitElement } from 'lit';
+import type { FAQConfig } from './types';
+/**
+ * Structural interface — describes only the methods the editable widget needs.
+ * The real EditModeController satisfies this by structural subtyping.
+ *
+ * `tileId` (the host tile's id, threaded in via `instanceId` at mount) scopes
+ * controller calls to the active tile when a canvas has multiple FAQ tiles.
+ * It is optional so single-tile and v2 actions-shape canvases continue to work.
+ */
+export interface ControllerLike {
+    editItem(adaptive: string, itemId: string, tileId?: string): void;
+    editContainer(adaptive: string, tileId?: string): void;
+    isModalOpen(): boolean;
+    reorderItems(adaptive: string, newOrder: string[], tileId?: string): void;
+}
+/** Return value from makeSortable. */
+export interface SortableHandle {
+    destroy(): void;
+}
+/** Options subset that FAQAccordionEditableElement passes into the sortable. */
+export interface SortableOptions {
+    itemSelector: string;
+    handleSelector: string;
+    getItems: () => string[];
+    onReorder: (newOrder: string[]) => void;
+    liveRegion: HTMLElement;
+}
+/**
+ * Structural type matching `makeSortable` from editor-sdk's sortable.ts.
+ * Injected at mount time by FAQWidgetLitEditableMountable.
+ */
+export type SortableFn = (host: HTMLElement, opts: SortableOptions) => SortableHandle;
+/**
+ * <syntro-faq-accordion-editable> — light-DOM Lit element.
+ *
+ * Set properties imperatively (no attribute serialisation for objects):
+ *   el.faqConfig = { ... };
+ *   el.controller = editModeControllerInstance;  // null → read-only
+ */
+export declare class FAQAccordionEditableElement extends LitElement {
+    static properties: {
+        faqConfig: {
+            attribute: boolean;
+        };
+        controller: {
+            attribute: boolean;
+        };
+        tileId: {
+            attribute: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+        _expandedId: {
+            state: boolean;
+        };
+        _containerHovered: {
+            state: boolean;
+        };
+    };
+    faqConfig: FAQConfig;
+    /** Null when loaded without an editor context — renders read-only accordion. */
+    controller: ControllerLike | null;
+    /**
+     * Host tile id, threaded in via the mountable's `instanceId`. Scopes every
+     * controller call so the right tile is targeted when the canvas has more
+     * than one FAQ tile (per-route FAQs). Empty string when unknown.
+     */
+    tileId: string;
+    /**
+     * The `makeSortable` factory to use. Injected by FAQWidgetLitEditableMountable
+     * from the editor-sdk bootstrap so there is no direct import from editor-sdk
+     * into this package (which would create a circular dependency).
+     *
+     * Null when running without the editor context (read-only mode).
+     */
+    sortable: SortableFn | null;
+    /**
+     * Shared aria-live region from the modal host, threaded in via mount config.
+     * Falls back to a detached element when running outside the editor context.
+     *
+     * TODO(phase-2-a11y): wire shared live region from modal host for real a11y.
+     */
+    liveRegion: HTMLElement | null;
+    _hoveredId: string | null;
+    _expandedId: string | null;
+    _containerHovered: boolean;
+    private _sortableHandle;
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    /**
+     * Wire (or re-wire) the sortable whenever the properties it depends on change.
+     * `updated()` fires after every render, including the first, so we don't need
+     * a separate `firstUpdated()` call — using `updated()` alone avoids a double
+     * attach on mount (firstUpdated + updated both fire on first render).
+     */
+    protected updated(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    private _attachSortable;
+    private _handleEdit;
+    private _handlePencilClick;
+    private _handleContainerEdit;
+    private _toggleExpand;
+    private _renderRow;
+    render(): import("lit-html").TemplateResult<1>;
+}
+/**
+ * Mountable for <syntro-faq-accordion-editable>.
+ *
+ * Follows the same mount pattern as FAQWidgetLitMountable in runtime.ts.
+ * Accepts a `controller` in addition to `faqConfig` so the editor can
+ * wire up the EditModeController at mount time.
+ */
+export declare const FAQWidgetLitEditableMountable: {
+    mount(container: HTMLElement, config?: FAQConfig & {
+        instanceId?: string;
+        controller?: ControllerLike | null;
+        /** makeSortable factory injected by editor-sdk bootstrap. Null → drag disabled. */
+        sortable?: SortableFn | null;
+        /** Shared aria-live region from the modal host for sortable announcements. */
+        liveRegion?: HTMLElement | null;
+    }): () => void;
+};
+//# sourceMappingURL=FAQWidgetLit.editable.d.ts.map

package/dist/FAQWidgetLit.editable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAQWidgetLit.editable.d.ts","sourceRoot":"","sources":["../src/FAQWidgetLit.editable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAIhD,OAAO,KAAK,EAAE,SAAS,EAAqB,MAAM,SAAS,CAAC;AAM5D;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvD,WAAW,IAAI,OAAO,CAAC;IACvB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3E;AAMD,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC7B,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACxC,UAAU,EAAE,WAAW,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,KAAK,cAAc,CAAC;AAuJtF;;;;;;GAMG;AACH,qBAAa,2BAA4B,SAAQ,UAAU;IAKzD,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;MASxB;IAMF,SAAS,EAAE,SAAS,CAKlB;IAEF,gFAAgF;IAChF,UAAU,EAAE,cAAc,GAAG,IAAI,CAAQ;IAEzC;;;;OAIG;IACH,MAAM,SAAM;IAEZ;;;;;;OAMG;IACH,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAQ;IAEnC;;;;;OAKG;IACH,UAAU,EAAE,WAAW,GAAG,IAAI,CAAQ;IAEtC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;IACjC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAQ;IAClC,iBAAiB,UAAS;IAM1B,OAAO,CAAC,eAAe,CAA+B;IAM7C,gBAAgB;IAIhB,iBAAiB,IAAI,IAAI;IASlC;;;;;OAKG;cACgB,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAQtD,oBAAoB,IAAI,IAAI;IAMrC,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,UAAU;IA2DT,MAAM;CAuEhB;AAcD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;qBAE3B,WAAW,WACb,SAAS,GAAG;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;QACnC,mFAAmF;QACnF,QAAQ,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;QAC7B,8EAA8E;QAC9E,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;KACjC;CAkCJ,CAAC"}

package/dist/answerRendering.d.ts

@@ -0,0 +1,4 @@
+import type { FAQAnswer } from './types';
+export declare function getAnswerText(answer: FAQAnswer): string;
+export declare function renderAnswerHtml(answer: FAQAnswer): string;
+//# sourceMappingURL=answerRendering.d.ts.map

package/dist/answerRendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answerRendering.d.ts","sourceRoot":"","sources":["../src/answerRendering.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIzC,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAIvD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAQ1D"}

package/dist/chunk-7DTOSQNC.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __commonJS,
+  __toESM,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod
+};
+//# sourceMappingURL=chunk-7DTOSQNC.js.map

package/dist/chunk-7DTOSQNC.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}