@scalar/workspace-store 0.63.0 → 0.64.0

package/dist/client.js

@@ -16,9 +16,11 @@ import { reactive } from 'vue';
 import YAML from 'yaml';
 import { createAuthStore } from './entities/auth/index.js';
 import { createHistoryStore } from './entities/history/index.js';
+import { expandChunkIndex } from './helpers/chunk-index.js';
 import { deepClone } from './helpers/deep-clone.js';
 import { createDetectChangesProxy } from './helpers/detect-changes-proxy.js';
 import { bumpDocumentRevision } from './helpers/document-revision.js';
+import { createExternalExampleResolver } from './helpers/external-examples.js';
 import { safeAssign } from './helpers/general.js';
 import { getFetch } from './helpers/get-fetch.js';
 import { mergeObjects } from './helpers/merge-object.js';
@@ -156,7 +158,7 @@ const purgeInternalDocumentKeys = (input) => {
  * @returns An object containing methods and getters for managing the workspace
  */
 export const createWorkspaceStore = (workspaceProps) => {
-    const { verbose = false } = workspaceProps ?? {};
+    const { verbose = false, reactive: isReactiveWorkspace = true } = workspaceProps ?? {};
     const withMeasurementSync = (name, fn) => (verbose ? measureSync(name, fn) : fn());
     const withMeasurementAsync = (name, fn) => verbose ? measureAsync(name, fn) : fn();
     /**
@@ -165,6 +167,11 @@ export const createWorkspaceStore = (workspaceProps) => {
      * This can include settings that can not be persisted between sessions (not JSON serializable)
      */
     const extraDocumentConfigurations = {};
+    const externalExampleResolvers = new WeakMap();
+    const fallbackExternalExamples = createExternalExampleResolver({
+        fetch: workspaceProps?.fetch,
+        fileLoader: workspaceProps?.fileLoader,
+    });
     /**
      * Notifies all workspace plugins of a workspace state change event.
      *
@@ -177,20 +184,9 @@ export const createWorkspaceStore = (workspaceProps) => {
         workspaceProps?.plugins?.forEach((plugin) => plugin.hooks?.onWorkspaceStateChanges?.(event));
     };
     /**
-     * An object containing the reactive workspace state.
-     *
-     * Every change to the workspace, is tracked and broadcast to all registered plugins.
-     * allowing for change tracking.
-     *
-     * NOTE:
-     * The detect changes proxy is applied separately beacause the vue reactitvity proxy have to be the outer most proxy.
-     * If the order is reversed, Vue cannot properly track mutations, leading to lost reactivity and bugs.
-     * By wrapping the contents with the detect changes proxy first, and then passing the result to Vue's `reactive`,
-     * we ensure that Vue manages its reactivity as expected and our change detection hooks
-     * are also triggered reliably.
-     * Do not reverse this order‼️
+     * The plain workspace state, before any observability wrappers are applied.
      */
-    const workspace = reactive(createDetectChangesProxy({
+    const workspaceState = {
         ...workspaceProps?.meta,
         documents: {},
         /**
@@ -203,88 +199,105 @@ export const createWorkspaceStore = (workspaceProps) => {
         get activeDocument() {
             return workspace.documents[getActiveDocumentName()];
         },
-    }, {
-        hooks: {
-            onAfterChange(path) {
-                const type = path[0];
-                /** Document changes */
-                if (type === 'documents') {
-                    // We are overriding the while documents object, ignore. This should not happen
-                    if (path.length < 2) {
-                        console.log('[WARN]: Overriding entire documents object is not supported');
+    };
+    /**
+     * An object containing the reactive workspace state.
+     *
+     * Every change to the workspace, is tracked and broadcast to all registered plugins.
+     * allowing for change tracking.
+     *
+     * With `reactive: false` the state is used as-is, so reads cost nothing beyond the plain object and
+     * nothing observes a write. See the `reactive` option for the full list of what stops happening.
+     *
+     * NOTE:
+     * The detect changes proxy is applied separately beacause the vue reactitvity proxy have to be the outer most proxy.
+     * If the order is reversed, Vue cannot properly track mutations, leading to lost reactivity and bugs.
+     * By wrapping the contents with the detect changes proxy first, and then passing the result to Vue's `reactive`,
+     * we ensure that Vue manages its reactivity as expected and our change detection hooks
+     * are also triggered reliably.
+     * Do not reverse this order‼️
+     */
+    const workspace = !isReactiveWorkspace
+        ? workspaceState
+        : reactive(createDetectChangesProxy(workspaceState, {
+            hooks: {
+                onAfterChange(path) {
+                    const type = path[0];
+                    /** Document changes */
+                    if (type === 'documents') {
+                        // We are overriding the while documents object, ignore. This should not happen
+                        if (path.length < 2) {
+                            console.log('[WARN]: Overriding entire documents object is not supported');
+                            return;
+                        }
+                        const documentName = path[1];
+                        const document = workspace.documents[documentName] ?? {
+                            openapi: '3.1.0',
+                            info: { title: '', version: '' },
+                            'x-scalar-original-document-hash': '',
+                        };
+                        // Every write through the store passes here, which is what makes the revision a
+                        // complete record of the document changing.
+                        bumpDocumentRevision(document);
+                        const event = {
+                            type: 'documents',
+                            documentName,
+                            value: unpackProxyObject(document),
+                            path: path.slice(2),
+                        };
+                        // Don't mark as dirty when the document is first created or when
+                        // only metadata-only fields change. `x-scalar-registry-meta` is
+                        // updated programmatically (commit hash, conflict cache) and
+                        // does not represent a user edit.
+                        if (event.path.length > 0 && !METADATA_ONLY_DOCUMENT_KEYS.has(event.path[0])) {
+                            // The document has been modified since it was last saved
+                            document['x-scalar-is-dirty'] = true;
+                        }
+                        fireWorkspaceChange(event);
                         return;
                     }
-                    const documentName = path[1];
-                    const document = workspace.documents[documentName] ?? {
-                        openapi: '3.1.0',
-                        info: { title: '', version: '' },
-                        'x-scalar-original-document-hash': '',
-                    };
-                    // Every write through the store passes here, which is what makes the revision a
-                    // complete record of the document changing.
-                    bumpDocumentRevision(document);
-                    const event = {
-                        type: 'documents',
-                        documentName,
-                        value: unpackProxyObject(document),
-                        path: path.slice(2),
-                    };
-                    // Don't mark as dirty when the document is first created or when
-                    // only metadata-only fields change. `x-scalar-registry-meta` is
-                    // updated programmatically (commit hash, conflict cache) and
-                    // does not represent a user edit.
-                    if (event.path.length > 0 && !METADATA_ONLY_DOCUMENT_KEYS.has(event.path[0])) {
-                        // The document has been modified since it was last saved
-                        document['x-scalar-is-dirty'] = true;
+                    /** Active document changes */
+                    if (type === 'activeDocument') {
+                        const documentName = getActiveDocumentName();
+                        const document = workspace.documents[documentName] ?? {
+                            openapi: '3.1.0',
+                            info: { title: '', version: '' },
+                            'x-scalar-original-document-hash': '',
+                        };
+                        bumpDocumentRevision(document);
+                        // Active document changed
+                        const event = {
+                            type: 'documents',
+                            documentName,
+                            value: unpackProxyObject(document),
+                            path: path.slice(2),
+                        };
+                        // Don't mark as dirty when the document is first created or when
+                        // only metadata-only fields change. `x-scalar-registry-meta` is
+                        // updated programmatically (commit hash, conflict cache) and
+                        // does not represent a user edit.
+                        if (event.path.length > 0 && !METADATA_ONLY_DOCUMENT_KEYS.has(event.path[0])) {
+                            // The document has been modified since it was last saved
+                            document['x-scalar-is-dirty'] = true;
+                        }
+                        fireWorkspaceChange(event);
+                        return;
                     }
-                    fireWorkspaceChange(event);
-                    return;
-                }
-                /** Active document changes */
-                if (type === 'activeDocument') {
-                    const documentName = getActiveDocumentName();
-                    const document = workspace.documents[documentName] ?? {
-                        openapi: '3.1.0',
-                        info: { title: '', version: '' },
-                        'x-scalar-original-document-hash': '',
-                    };
-                    bumpDocumentRevision(document);
-                    // Active document changed
+                    /** Workspace meta changes */
+                    const { activeDocument: _a, documents: _d, ...meta } = workspace;
                     const event = {
-                        type: 'documents',
-                        documentName,
-                        value: unpackProxyObject(document),
-                        path: path.slice(2),
+                        type: 'meta',
+                        value: unpackProxyObject(meta, { depth: 1 }),
                     };
-                    // Don't mark as dirty when the document is first created or when
-                    // only metadata-only fields change. `x-scalar-registry-meta` is
-                    // updated programmatically (commit hash, conflict cache) and
-                    // does not represent a user edit.
-                    if (event.path.length > 0 && !METADATA_ONLY_DOCUMENT_KEYS.has(event.path[0])) {
-                        // The document has been modified since it was last saved
-                        document['x-scalar-is-dirty'] = true;
-                    }
                     fireWorkspaceChange(event);
                     return;
-                }
-                /** Workspace meta changes */
-                const { activeDocument: _a, documents: _d, ...meta } = workspace;
-                const event = {
-                    type: 'meta',
-                    value: unpackProxyObject(meta, { depth: 1 }),
-                };
-                fireWorkspaceChange(event);
-                return;
+                },
             },
-        },
-    }));
+        }));
     /**
-     * An object containing all the workspace state, wrapped in a detect changes proxy.
-     *
-     * Every change to the workspace state (documents, configs, metadata, etc.) can be detected here,
-     * allowing for change tracking.
+     * The plain document snapshot maps, before the detect changes proxy is applied.
      */
-    const { originalDocuments, intermediateDocuments, overrides } = createDetectChangesProxy({
+    const documentSnapshots = {
         /**
          * Holds the original, unmodified documents as they were initially loaded into the workspace.
          * These documents are stored in their raw form—prior to any reactive wrapping, dereferencing, or bundling.
@@ -316,46 +329,57 @@ export const createWorkspaceStore = (workspaceProps) => {
          * OpenAPI document representing the overridden fields.
          */
         overrides: {},
-    }, {
-        hooks: {
-            onAfterChange(path) {
-                const type = path[0];
-                if (!type) {
-                    return;
-                }
-                if (path.length < 2) {
-                    return;
-                }
-                const documentName = path[1];
-                if (type === 'originalDocuments') {
-                    const event = {
-                        type,
-                        documentName: documentName,
-                        value: unpackProxyObject(originalDocuments[documentName] ?? {}),
-                        path: path.splice(2),
-                    };
-                    fireWorkspaceChange(event);
-                }
-                if (type === 'intermediateDocuments') {
-                    const event = {
-                        type,
-                        documentName: documentName,
-                        value: unpackProxyObject(intermediateDocuments[documentName] ?? {}),
-                        path: path.splice(2),
-                    };
-                    fireWorkspaceChange(event);
-                }
-                if (type === 'overrides') {
-                    const event = {
-                        type,
-                        documentName: documentName,
-                        value: unpackProxyObject(overrides[documentName] ?? {}),
-                    };
-                    fireWorkspaceChange(event);
-                }
+    };
+    /**
+     * An object containing all the workspace state, wrapped in a detect changes proxy.
+     *
+     * Every change to the workspace state (documents, configs, metadata, etc.) can be detected here,
+     * allowing for change tracking.
+     *
+     * With `reactive: false` the maps are used as-is and a write to them notifies nobody.
+     */
+    const { originalDocuments, intermediateDocuments, overrides } = !isReactiveWorkspace
+        ? documentSnapshots
+        : createDetectChangesProxy(documentSnapshots, {
+            hooks: {
+                onAfterChange(path) {
+                    const type = path[0];
+                    if (!type) {
+                        return;
+                    }
+                    if (path.length < 2) {
+                        return;
+                    }
+                    const documentName = path[1];
+                    if (type === 'originalDocuments') {
+                        const event = {
+                            type,
+                            documentName: documentName,
+                            value: unpackProxyObject(originalDocuments[documentName] ?? {}),
+                            path: path.splice(2),
+                        };
+                        fireWorkspaceChange(event);
+                    }
+                    if (type === 'intermediateDocuments') {
+                        const event = {
+                            type,
+                            documentName: documentName,
+                            value: unpackProxyObject(intermediateDocuments[documentName] ?? {}),
+                            path: path.splice(2),
+                        };
+                        fireWorkspaceChange(event);
+                    }
+                    if (type === 'overrides') {
+                        const event = {
+                            type,
+                            documentName: documentName,
+                            value: unpackProxyObject(overrides[documentName] ?? {}),
+                        };
+                        fireWorkspaceChange(event);
+                    }
+                },
             },
-        },
-    });
+        });
     /**
      * This store is used to track the history of requests and responses for documents and operations.
      */
@@ -387,6 +411,17 @@ export const createWorkspaceStore = (workspaceProps) => {
             },
         },
     });
+    /**
+     * Whether a document needs to be wrapped in the overrides proxy.
+     *
+     * A reactive workspace always wraps, so the default mode keeps every document the same shape it has
+     * always had. A non-reactive workspace wraps only a document that actually has overrides: with an
+     * empty override map the proxy resolves to the target on every read and write anyway, so all it adds
+     * is a proxy hop on every nested read. Nothing outside this file reads the proxy's identity, and the
+     * store rebuilds the document from the current override map whenever the map changes, so a document
+     * that gains overrides later gains the proxy along with them.
+     */
+    const needsOverridesProxy = (documentOverrides) => isReactiveWorkspace || (isObject(documentOverrides) && Object.keys(documentOverrides).length > 0);
     /**
      * Returns the name of the currently active document in the workspace.
      * The active document is determined by the 'x-scalar-active-document' metadata field,
@@ -440,6 +475,10 @@ export const createWorkspaceStore = (workspaceProps) => {
         const { name } = input;
         const meta = deepClone(input.meta);
         const clonedRawInputDocument = withMeasurementSync('deepClone', () => deepClone(input.document));
+        // A compact sparse document is expanded back into per-node chunk references before anything
+        // else reads it, so every step below — including the check for a server-generated navigation —
+        // sees the document a non-compact server store would have sent.
+        withMeasurementSync('expandChunkIndex', () => expandChunkIndex(clonedRawInputDocument));
         withMeasurementSync('initialize', () => {
             if (input.initialize !== false) {
                 // Store the original document in the originalDocuments map
@@ -502,9 +541,10 @@ export const createWorkspaceStore = (workspaceProps) => {
                 const navigation = traverseAsyncApiDocument(name, asyncApiDocument, navigationOptions);
                 asyncApiDocument[extensions.document.navigation] = navigation;
             }
-            workspace.documents[name] = createOverridesProxy(asyncApiDocument, {
-                overrides: unpackProxyObject(overrides[name]),
-            });
+            const asyncApiOverrides = unpackProxyObject(overrides[name]);
+            workspace.documents[name] = needsOverridesProxy(asyncApiOverrides)
+                ? createOverridesProxy(asyncApiDocument, { overrides: asyncApiOverrides })
+                : asyncApiDocument;
             return;
         }
         const inputDocument = withMeasurementSync('upgrade', () => upgrade(deepClone(clonedRawInputDocument), '3.1'));
@@ -524,7 +564,7 @@ export const createWorkspaceStore = (workspaceProps) => {
                 plugins: [
                     ...loaders,
                     normalizeRefs(),
-                    externalValueResolver(),
+                    externalValueResolver({ lazy: true }),
                     refsEverywhere(),
                     normalizeAuthSchemes(),
                     syncPathParameters(),
@@ -555,9 +595,11 @@ export const createWorkspaceStore = (workspaceProps) => {
         // Create a proxied document with magic proxy and apply any overrides, then store it in the workspace documents map
         // We create a new proxy here in order to hide internal properties after validation and processing
         // This ensures that the workspace document only exposes the intended OpenAPI properties and extensions
-        workspace.documents[name] = createOverridesProxy(createMagicProxy(getRaw(strictDocument)), {
-            overrides: unpackProxyObject(overrides[name]),
-        });
+        const documentOverrides = unpackProxyObject(overrides[name]);
+        const magicDocument = createMagicProxy(getRaw(strictDocument));
+        workspace.documents[name] = needsOverridesProxy(documentOverrides)
+            ? createOverridesProxy(magicDocument, { overrides: documentOverrides })
+            : magicDocument;
     }
     // Asynchronously adds a new document to the workspace by loading and validating the input.
     // If loading fails, a placeholder error document is added instead.
@@ -692,6 +734,22 @@ export const createWorkspaceStore = (workspaceProps) => {
     // This is needed because we are doing partial bundle operations
     const visitedNodesCache = new Set();
     return {
+        externalExamples: (documentName) => {
+            const name = documentName ?? getActiveDocumentName();
+            const document = workspace.documents[name];
+            if (!document)
+                return fallbackExternalExamples;
+            const existing = externalExampleResolvers.get(document);
+            if (existing)
+                return existing;
+            const resolver = createExternalExampleResolver({
+                origin: document['x-scalar-original-source-url'],
+                fileLoader: workspaceProps?.fileLoader,
+                fetch: extraDocumentConfigurations[name]?.fetch ?? workspaceProps?.fetch,
+            });
+            externalExampleResolvers.set(document, resolver);
+            return resolver;
+        },
         get workspace() {
             return workspace;
         },
@@ -761,7 +819,15 @@ export const createWorkspaceStore = (workspaceProps) => {
                 root: activeDocument,
                 origin: activeDocument?.['x-scalar-original-source-url'],
                 treeShake: false,
-                plugins: [fetchUrls(), loadingStatus(), externalValueResolver()],
+                plugins: [
+                    fetchUrls({
+                        fetch: extraDocumentConfigurations[getActiveDocumentName()]?.fetch ?? workspaceProps?.fetch,
+                        limit: EXTERNAL_FETCH_CONCURRENCY_LIMIT,
+                    }),
+                    ...(workspaceProps?.fileLoader ? [workspaceProps.fileLoader] : []),
+                    loadingStatus(),
+                    externalValueResolver({ lazy: true }),
+                ],
                 urlMap: true,
                 visitedNodes: visitedNodesCache,
             });
@@ -855,12 +921,23 @@ export const createWorkspaceStore = (workspaceProps) => {
             };
         },
         loadWorkspace(input) {
-            safeAssign(workspace.documents, Object.fromEntries(Object.entries(input.documents).map(([name, doc]) => [
-                name,
-                createOverridesProxy(createMagicProxy(doc), {
-                    overrides: input.overrides[name],
-                }),
-            ])));
+            // A workspace from a compact server store carries an index rather than per-node chunk
+            // references; expanded here for the same reason `addInMemoryDocument` expands.
+            for (const document of Object.values(input.documents)) {
+                expandChunkIndex(document);
+            }
+            safeAssign(workspace.documents, Object.fromEntries(Object.entries(input.documents).map(([name, doc]) => {
+                // Hydration only rewraps: an exported document has already been upgraded, bundled, coerced
+                // and given its navigation, so nothing here re-processes it.
+                const magicDocument = createMagicProxy(doc);
+                const documentOverrides = input.overrides[name];
+                return [
+                    name,
+                    needsOverridesProxy(documentOverrides)
+                        ? createOverridesProxy(magicDocument, { overrides: documentOverrides })
+                        : magicDocument,
+                ];
+            })));
             safeAssign(originalDocuments, input.originalDocuments);
             safeAssign(intermediateDocuments, input.intermediateDocuments);
             safeAssign(overrides, input.overrides);

package/dist/helpers/chunk-index.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The extension key a compact sparse document carries its chunk index under.
+ *
+ * It exists on the wire only: the client expands the index back into per-node references while the
+ * document is ingested and removes the key, so nothing downstream ever sees it.
+ */
+export declare const CHUNK_INDEX_KEY = "x-scalar-chunk-index";
+/** Where a document's chunks live, which decides how each reference to one is spelled. */
+export type ChunkMode = 'static' | 'ssr';
+/** The `$ref` template for each kind of chunk, with `{…}` slots the reader fills in. */
+export type ChunkRefTemplates = {
+    /** Slots: `{type}`, `{name}`. */
+    components: string;
+    /** Slots: `{path}`, `{method}`. */
+    operations: string;
+    /** No slots. */
+    navigation: string;
+};
+/**
+ * The compact stand-in for a sparse document's `components` and `paths`.
+ *
+ * Every reference the non-compact form spells out node by node is derivable from where that node
+ * sits, so the index carries the positions and one template per kind instead. What a path item
+ * keeps besides its operations is not derivable, so it rides along verbatim.
+ */
+export type ChunkIndex = {
+    mode: ChunkMode;
+    refs: ChunkRefTemplates;
+    /** Component names per component type, in document order. */
+    components: Record<string, string[]>;
+    /**
+     * Each path item with its operations replaced by a placeholder.
+     *
+     * The whole path item is kept rather than a list of methods so that both its key order and the
+     * keys that were never externalized survive: `parameters`, `summary`, `servers` and extensions
+     * all stay inline in the non-compact form.
+     */
+    paths: Record<string, Record<string, unknown>>;
+};
+/**
+ * Fills the `{slot}`s of a chunk-reference template.
+ *
+ * `{{` and `}}` stand for literal braces, so text the writer inlined into a template — a document
+ * name, a base URL — may contain braces without being read back as a slot. An unknown slot is left
+ * alone rather than blanked, so a template from a newer writer fails visibly instead of resolving
+ * to the wrong chunk.
+ */
+export declare const fillChunkRef: (template: string, values?: Record<string, string>) => string;
+/**
+ * Builds the reference templates for one document.
+ *
+ * Filled, these produce exactly the references `externalizeComponentReferences` and
+ * `externalizePathReferences` write, so a client that expands the index lands on the same chunk.
+ */
+export declare const chunkRefTemplates: (meta: {
+    mode: "ssr";
+    name: string;
+    baseUrl: string;
+} | {
+    mode: "static";
+    name: string;
+}) => ChunkRefTemplates;
+/** The reference a lazily loaded chunk is reached through. */
+export declare const chunkReference: (ref: string) => {
+    $ref: string;
+    $global: true;
+};
+/**
+ * Compacts a sparse document's `components` and `paths` into an index.
+ *
+ * Takes the sections the externalizers produced rather than the document itself, so the index is
+ * built from the very references it replaces and the two cannot come to describe different sets of
+ * chunks.
+ */
+export declare const buildChunkIndex: ({ mode, refs, components, paths, }: {
+    mode: ChunkMode;
+    refs: ChunkRefTemplates;
+    components: Record<string, Record<string, unknown>>;
+    paths: Record<string, Record<string, unknown>>;
+}) => ChunkIndex;
+/**
+ * Expands a compact sparse document into the one a non-compact server store would have sent.
+ *
+ * Mutates the document in place and drops the index key, so what the rest of the store sees is an
+ * ordinary sparse document: `resolve()`, the bundler and anything enumerating `paths` or
+ * `components` are looking at the shape they always have.
+ *
+ * A document without an index is left alone, which is every document a non-compact server store or
+ * an author produces.
+ *
+ * @param document - The document to expand, mutated in place
+ * @returns Whether an index was found and expanded
+ */
+export declare const expandChunkIndex: (document: unknown) => boolean;
+//# sourceMappingURL=chunk-index.d.ts.map

package/dist/helpers/chunk-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-index.d.ts","sourceRoot":"","sources":["../../src/helpers/chunk-index.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,yBAAyB,CAAA;AAKrD,0FAA0F;AAC1F,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAA;AAExC,wFAAwF;AACxF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,iBAAiB,CAAA;IACvB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IACpC;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/C,CAAA;AAKD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,EAAE,SAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,KAAG,MAGlF,CAAA;AAwBH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KACtF,iBAkBF,CAAA;AAED,8DAA8D;AAC9D,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,KAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAsC,CAAA;AAEhH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,oCAK7B;IACD,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,iBAAiB,CAAA;IACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACnD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/C,KAAG,UAYF,CAAA;AAUF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,OAAO,KAAG,OAqDpD,CAAA"}