@syntrologie/adapt-nav 2.8.0-canary.49 → 2.8.0-canary.490

package/dist/NavWidgetLit.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Adaptive Nav - NavWidgetLit Web Component
+ *
+ * Lit web component equivalent of NavWidget.tsx. Renders a collapsible
+ * navigation tips accordion with per-item conditional visibility, framework-aware
+ * navigation, and CSS variable theming.
+ *
+ * Decorator-free: uses `static override properties` (tsconfig has no
+ * experimentalDecorators).
+ *
+ * Uses light DOM (createRenderRoot returns this) so host-page CSS variables
+ * (--sc-*) are inherited without crossing a shadow boundary.
+ */
+import { LitElement } from 'lit';
+import type { NavConfig, NavWidgetRuntime } from './types';
+/** Browser side effects used by navigation clicks. Injectable for host adapters and tests. */
+export interface NavNavigationPort {
+    open(url: string): void;
+    fullNavigate(url: string): void;
+    pushState(url: string): void;
+}
+export declare class NavWidgetLit extends LitElement {
+    #private;
+    createRenderRoot(): this;
+    static properties: {
+        config: {
+            attribute: boolean;
+        };
+        runtime: {
+            attribute: boolean;
+        };
+        instanceId: {
+            type: StringConstructor;
+        };
+        _expandedIds: {
+            state: boolean;
+        };
+        _renderTick: {
+            state: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+    };
+    config: NavConfig;
+    runtime: NavWidgetRuntime | undefined;
+    instanceId: string;
+    navigationPort: NavNavigationPort;
+    /** @internal */ _expandedIds: Set<string>;
+    /** @internal */ _renderTick: number;
+    /** @internal */ _hoveredId: string | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export declare function registerNavWidgetLit(): void;
+declare global {
+    interface HTMLElementTagNameMap {
+        'syntro-nav-tips': NavWidgetLit;
+    }
+}
+//# sourceMappingURL=NavWidgetLit.d.ts.map

package/dist/NavWidgetLit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavWidgetLit.d.ts","sourceRoot":"","sources":["../src/NavWidgetLit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAMhD,OAAO,KAAK,EAAE,SAAS,EAAgB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAuGzE,8FAA8F;AAC9F,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAmBD,qBAAa,YAAa,SAAQ,UAAU;;IAGjC,gBAAgB;IAMzB,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;MAUxB;IAIF,MAAM,EAAE,SAAS,CAA4D;IAC7E,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAa;IAClD,UAAU,EAAE,MAAM,CAAgB;IAClC,cAAc,EAAE,iBAAiB,CAAyB;IAI1D,gBAAgB,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IACvD,gBAAgB,CAAC,WAAW,SAAK;IACjC,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;IASzC,iBAAiB,IAAI,IAAI;IAOzB,oBAAoB,IAAI,IAAI;IAO5B,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAyU5C,MAAM;CAuFhB;AAQD,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,iBAAiB,EAAE,YAAY,CAAC;KACjC;CACF"}

package/dist/NavWidgetLit.editable.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Adaptive Nav - NavWidgetLit.editable
+ *
+ * Editable variant of the Nav tips accordion for the canvas editor surface.
+ * Renders the same tip rows as <syntro-nav-tips> but adds:
+ *   - Pencil button per row (shows on hover, calls controller.editItem on click)
+ *   - Pencil click calls controller.editItem to open the modal editor
+ *   - Read-only fallback when controller is null
+ *   - Normal clicks pass through — only pencil and drag handle trigger edit actions
+ *
+ * Tag name: <syntro-nav-tips-editable>
+ *
+ * Decorator-free: uses `static override properties` (matches codebase pattern).
+ * Light DOM: inherits host-page CSS variables (same as <syntro-nav-tips>).
+ *
+ * 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. The real EditModeController satisfies ControllerLike
+ *   structurally.
+ *
+ *   Similarly, `makeSortable` is passed in as a `SortableFn` option rather than
+ *   imported directly — matching the FAQ editable widget pattern (Alternative C
+ *   from the architecture decision log). The sortable is wired via _attachSortable()
+ *   in the updated() lifecycle hook, exactly mirroring FAQAccordionEditableElement.
+ *
+ * Click strategy:
+ *   Row clicks pass through normally — the editable variant does NOT intercept
+ *   them. Only the pencil button (opens modal editor) and drag handle (reorder)
+ *   trigger edit-mode actions. This lets the underlying widget behavior (e.g.
+ *   navigation, scrolling) work as expected in the editor preview.
+ */
+import { LitElement } from 'lit';
+import type { NavConfig } 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 Nav 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 NavTipsEditableElement 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 NavWidgetLitEditableMountable.
+ * Phase 3.3 will actually wire this; it is accepted here for forward compat.
+ */
+export type SortableFn = (host: HTMLElement, opts: SortableOptions) => SortableHandle;
+/**
+ * <syntro-nav-tips-editable> — light-DOM Lit element.
+ *
+ * Set properties imperatively (no attribute serialisation for objects):
+ *   el.navConfig = { ... };
+ *   el.controller = editModeControllerInstance;  // null → read-only
+ */
+export declare class NavTipsEditableElement extends LitElement {
+    static properties: {
+        navConfig: {
+            attribute: boolean;
+        };
+        controller: {
+            attribute: boolean;
+        };
+        tileId: {
+            attribute: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+        _containerHovered: {
+            state: boolean;
+        };
+    };
+    navConfig: NavConfig;
+    /** Null when loaded without an editor context — renders read-only list. */
+    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 Nav tile (per-route navs). Empty string when unknown.
+     */
+    tileId: string;
+    /**
+     * The `makeSortable` factory to use. Injected by NavWidgetLitEditableMountable
+     * 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.
+     */
+    liveRegion: HTMLElement | null;
+    _hoveredId: 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 _renderRow;
+    render(): import("lit-html").TemplateResult<1>;
+}
+/**
+ * Mountable for <syntro-nav-tips-editable>.
+ *
+ * Follows the same mount pattern as NavWidgetLitMountable in runtime.ts.
+ * Accepts a `controller` in addition to `navConfig` so the editor can
+ * wire up the EditModeController at mount time.
+ */
+export declare const NavWidgetLitEditableMountable: {
+    mount(container: HTMLElement, config?: NavConfig & {
+        instanceId?: string;
+        controller?: ControllerLike | null;
+        /** makeSortable factory injected by editor-sdk bootstrap. Phase 3.3 wires this. */
+        sortable?: SortableFn | null;
+        /** Shared aria-live region from the modal host for sortable announcements. */
+        liveRegion?: HTMLElement | null;
+    }): () => void;
+};
+//# sourceMappingURL=NavWidgetLit.editable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NavWidgetLit.editable.d.ts","sourceRoot":"","sources":["../src/NavWidgetLit.editable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,SAAS,CAAC;AAMvD;;;;;;;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,2EAA2E;AAC3E,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;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,KAAK,cAAc,CAAC;AA6JtF;;;;;;GAMG;AACH,qBAAa,sBAAuB,SAAQ,UAAU;IAKpD,OAAgB,UAAU;;;;;;;;;;;;;;;;MAQxB;IAMF,SAAS,EAAE,SAAS,CAIlB;IAEF,2EAA2E;IAC3E,UAAU,EAAE,cAAc,GAAG,IAAI,CAAQ;IAEzC;;;;OAIG;IACH,MAAM,SAAM;IAEZ;;;;;;OAMG;IACH,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAQ;IAEnC;;;OAGG;IACH,UAAU,EAAE,WAAW,GAAG,IAAI,CAAQ;IAEtC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;IACjC,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;IAsBvB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,UAAU;IAqDT,MAAM;CA8EhB;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;CAiCJ,CAAC"}

package/dist/NavWidgetLit.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * NavWidgetLit — Vitest + @open-wc/testing-helpers unit tests
+ *
+ * Tests cover: rendering, expand/collapse, nav-tip-clicked event, XSS rejection,
+ * empty state, category grouping, and visibility filtering (triggerWhen).
+ */
+export {};
+//# sourceMappingURL=NavWidgetLit.test.d.ts.map

package/dist/NavWidgetLit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavWidgetLit.test.d.ts","sourceRoot":"","sources":["../src/NavWidgetLit.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/cdn.d.ts

@@ -1,13 +1,16 @@
 /**
  * CDN Entry Point for Adaptive Nav
  *
- * This module is bundled for CDN delivery and self-registers with the global
- * SynOS app registry when loaded dynamically via the AppLoader.
- */
-import NavEditor from './editor';
-/**
- * App manifest for registry registration.
- * Follows the AppManifest interface expected by AppLoader/AppRegistry.
+ * Bundled for CDN delivery and loaded on-demand by the host runtime's
+ * AppLoader when a config references navigation/nav actions/widgets. Part of the
+ * kernel diet (ADR 2026-07-17-runtime-kernel-vs-lazy-presentation):
+ * this app left the builtin list — it has 1s+ loading tolerance, unlike
+ * adaptive-content which must act inside the anti-flicker window.
+ *
+ * Mirrors adaptive-gamification/src/cdn.ts: builds the manifest from the
+ * runtime export, then self-registers with the host's app registry on
+ * import. Without this entry, build-adaptives-only.js silently skips the
+ * package and the app is "lazy in name only" (no bundle on disk).
  */
 export declare const manifest: {
     id: string;
@@ -22,10 +25,9 @@ export declare const manifest: {
         widgets: {
             id: string;
             component: {
-                mount(container: HTMLElement, config?: import("./types").NavConfig & {
+                mount(container: HTMLElement, config?: (import("./types").NavConfig & import("packages/sdk-contracts/dist").MountPlumbing & {
                     runtime?: import("./types").NavWidgetRuntime;
-                    instanceId?: string;
-                }): () => void;
+                }) | null): () => void;
             };
             metadata: {
                 name: string;
@@ -33,30 +35,21 @@ export declare const manifest: {
                 icon: string;
             };
         }[];
-        notifyWatchers: (props: Record<string, unknown>) => {
-            id: string;
-            strategy: import("./types").DecisionStrategy<boolean>;
-            eventName: string;
-            eventProps: {
-                tipId: string;
-                title: string | undefined;
-                body: string | undefined;
-                icon: string | undefined;
-            };
-        }[];
-    };
-    editor: {
-        component: typeof NavEditor;
-        panel: {
-            title: string;
-            icon: string;
-            description: string;
-        };
-        getActionLabel(action: Record<string, unknown>): string;
+        notifyWatchers: unknown;
+        events: unknown;
     };
     metadata: {
         isBuiltIn: boolean;
     };
 };
+declare global {
+    interface Window {
+        SynOS?: {
+            appRegistry?: {
+                register?: (m: unknown) => void;
+            };
+        };
+    }
+}
 export default manifest;
 //# sourceMappingURL=cdn.d.ts.map

package/dist/cdn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../src/cdn.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,SAA0B,MAAM,UAAU,CAAC;AAGlD;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;2BAsCmymB,CAAC;8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAtB7zmB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;CAQjD,CAAC;AAaF,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../src/cdn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;2BAkC81J,CAAC;;;;;;;;;;;;;;;CApBn3J,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,KAAK,CAAC,EAAE;YACN,WAAW,CAAC,EAAE;gBACZ,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;aACjC,CAAC;SACH,CAAC;KACH;CACF;AASD,eAAe,QAAQ,CAAC"}

package/dist/cdn.js

@@ -1,48 +1,33 @@
-/**
- * CDN Entry Point for Adaptive Nav
- *
- * This module is bundled for CDN delivery and self-registers with the global
- * SynOS app registry when loaded dynamically via the AppLoader.
- */
-import NavEditor, { editorPanel } from './editor';
-import { executors, runtime } from './runtime';
-/**
- * App manifest for registry registration.
- * Follows the AppManifest interface expected by AppLoader/AppRegistry.
- */
-export const manifest = {
-    id: 'adaptive-nav',
-    version: runtime.version,
-    name: runtime.name,
-    description: runtime.description,
-    runtime: {
-        actions: executors.map(({ kind, executor }) => ({
-            kind,
-            executor,
-        })),
-        widgets: runtime.widgets,
-        notifyWatchers: runtime.notifyWatchers,
-    },
-    editor: {
-        component: NavEditor,
-        panel: editorPanel,
-        getActionLabel(action) {
-            const config = action.config || {};
-            return config.title || action.kind || 'nav:tip';
-        },
-    },
-    metadata: {
-        isBuiltIn: false,
-    },
+import {
+  runtime
+} from "./chunk-VG3E3ALH.js";
+import "./chunk-XO4TLMHA.js";
+
+// src/cdn.ts
+var manifest = {
+  id: runtime.id,
+  version: runtime.version,
+  name: runtime.name,
+  description: runtime.description,
+  runtime: {
+    actions: (runtime.executors ?? []).map(({ kind, executor }) => ({ kind, executor })),
+    widgets: runtime.widgets,
+    notifyWatchers: runtime.notifyWatchers,
+    events: runtime.eventHandlers
+  },
+  metadata: {
+    isBuiltIn: false
+  }
 };
-/**
- * Self-register with global registry if available.
- * This happens when loaded via script tag (UMD).
- */
-if (typeof window !== 'undefined') {
-    const registry = window.SynOS?.appRegistry;
-    if (registry && typeof registry.register === 'function') {
-        registry.register(manifest);
-    }
+if (typeof window !== "undefined") {
+  const registry = window.SynOS?.appRegistry;
+  if (registry && typeof registry.register === "function") {
+    registry.register(manifest);
+  }
 }
-export default manifest;
+var cdn_default = manifest;
+export {
+  cdn_default as default,
+  manifest
+};
+//# sourceMappingURL=cdn.js.map

package/dist/cdn.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cdn.ts"],
+  "sourcesContent": ["/**\n * CDN Entry Point for Adaptive Nav\n *\n * Bundled for CDN delivery and loaded on-demand by the host runtime's\n * AppLoader when a config references navigation/nav actions/widgets. Part of the\n * kernel diet (ADR 2026-07-17-runtime-kernel-vs-lazy-presentation):\n * this app left the builtin list \u2014 it has 1s+ loading tolerance, unlike\n * adaptive-content which must act inside the anti-flicker window.\n *\n * Mirrors adaptive-gamification/src/cdn.ts: builds the manifest from the\n * runtime export, then self-registers with the host's app registry on\n * import. Without this entry, build-adaptives-only.js silently skips the\n * package and the app is \"lazy in name only\" (no bundle on disk).\n */\n\nimport { runtime } from './runtime';\n\nexport const manifest = {\n  id: runtime.id,\n  version: runtime.version,\n  name: runtime.name,\n  description: runtime.description,\n  runtime: {\n    actions: (runtime.executors ?? []).map(({ kind, executor }) => ({ kind, executor })),\n    widgets: runtime.widgets,\n    notifyWatchers: (runtime as { notifyWatchers?: unknown }).notifyWatchers,\n    events: (runtime as { eventHandlers?: unknown }).eventHandlers,\n  },\n  metadata: {\n    isBuiltIn: false,\n  },\n};\n\ndeclare global {\n  interface Window {\n    SynOS?: {\n      appRegistry?: {\n        register?: (m: unknown) => void;\n      };\n    };\n  }\n}\n\nif (typeof window !== 'undefined') {\n  const registry = window.SynOS?.appRegistry;\n  if (registry && typeof registry.register === 'function') {\n    registry.register(manifest);\n  }\n}\n\nexport default manifest;\n"],
+  "mappings": ";;;;;;AAiBO,IAAM,WAAW;AAAA,EACtB,IAAI,QAAQ;AAAA,EACZ,SAAS,QAAQ;AAAA,EACjB,MAAM,QAAQ;AAAA,EACd,aAAa,QAAQ;AAAA,EACrB,SAAS;AAAA,IACP,UAAU,QAAQ,aAAa,CAAC,GAAG,IAAI,CAAC,EAAE,MAAM,SAAS,OAAO,EAAE,MAAM,SAAS,EAAE;AAAA,IACnF,SAAS,QAAQ;AAAA,IACjB,gBAAiB,QAAyC;AAAA,IAC1D,QAAS,QAAwC;AAAA,EACnD;AAAA,EACA,UAAU;AAAA,IACR,WAAW;AAAA,EACb;AACF;AAYA,IAAI,OAAO,WAAW,aAAa;AACjC,QAAM,WAAW,OAAO,OAAO;AAC/B,MAAI,YAAY,OAAO,SAAS,aAAa,YAAY;AACvD,aAAS,SAAS,QAAQ;AAAA,EAC5B;AACF;AAEA,IAAO,cAAQ;",
+  "names": []
+}