@scalar/workspace-store 0.1.0

package/dist/create-workspace-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-workspace-store.d.ts","sourceRoot":"","sources":["../src/create-workspace-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAa,MAAM,4BAA4B,CAAA;AAKjG,KAAK,0BAA0B,GAAG;IAAE,IAAI,CAAC,EAAE,qBAAqB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAChF,KAAK,sBAAsB,GACvB,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,0BAA0B,CAAC,GACpE,CAAC;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,0BAA0B,CAAC,GAC9C,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,0BAA0B,CAAC,CAAA;AAyCnD;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,cAAc,CAAC,EAAE;IAC1D,IAAI,CAAC,EAAE,aAAa,CAAA;IACpB,SAAS,CAAC,EAAE,sBAAsB,EAAE,CAAA;CACrC;IAiDG;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIH;;;;;;;OAOG;WACI,CAAC,SAAS,MAAM,aAAa,OAAO,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC;IAOrE;;;;;;;;;;;OAWG;mBACY,CAAC,SAAS,MAAM,qBAAqB,QAC5C,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,OACzB,CAAC,SACC,qBAAqB,CAAC,CAAC,CAAC;IAejC;;;;;;;;;;OAUG;oBACmB,MAAM,EAAE;IAsE9B;;;;;;;;;;;;;;;;;OAiBG;yBACwB,sBAAsB;GAapD"}

package/dist/create-workspace-store.js

@@ -0,0 +1,186 @@
+import { reactive, toRaw } from "vue";
+import { createMagicProxy, getRaw } from "./helpers/proxy.js";
+import { fetchUrl, isObject, readLocalFile, resolveContents } from "./helpers/general.js";
+import { getValueByPath, parseJsonPointer } from "./helpers/json-path-utils.js";
+async function loadDocument(workspaceDocument) {
+  if ("url" in workspaceDocument) {
+    return fetchUrl(workspaceDocument.url);
+  }
+  if ("path" in workspaceDocument) {
+    return readLocalFile(workspaceDocument.path);
+  }
+  return {
+    ok: true,
+    data: workspaceDocument.document
+  };
+}
+async function createWorkspaceStore(workspaceProps) {
+  const workspace = reactive({
+    ...workspaceProps?.meta,
+    documents: (await Promise.all(
+      (workspaceProps?.documents ?? []).map(async (data) => {
+        const resolved = await loadDocument(data);
+        if (!resolved.ok) {
+          console.error(`Can not load the document '${data.name}'`);
+          return {
+            name: data.name,
+            meta: data.meta,
+            document: {}
+          };
+        }
+        return {
+          name: data.name,
+          meta: data.meta,
+          document: isObject(resolved.data) ? resolved.data : {}
+        };
+      })
+    )).reduce((acc, { name, meta, document }) => {
+      acc[name] = createMagicProxy({ ...document, ...meta });
+      return acc;
+    }, {}),
+    /**
+     * Returns the currently active document from the workspace.
+     * The active document is determined by the 'x-scalar-active-document' metadata field,
+     * falling back to the first document in the workspace if no active document is specified.
+     *
+     * @returns The active document or undefined if no document is found
+     */
+    get activeDocument() {
+      const activeDocumentKey = workspace["x-scalar-active-document"] ?? Object.keys(workspace.documents)[0] ?? "";
+      return workspace.documents[activeDocumentKey];
+    }
+  });
+  return {
+    /**
+     * Returns the raw (non-reactive) workspace object
+     */
+    get rawWorkspace() {
+      return toRaw(workspace);
+    },
+    /**
+     * Returns the reactive workspace object with an additional activeDocument getter
+     */
+    get workspace() {
+      return workspace;
+    },
+    /**
+     * Updates a specific metadata field in the workspace
+     * @param key - The metadata field to update
+     * @param value - The new value for the field
+     * @example
+     * // Update the workspace title
+     * update('x-scalar-active-document', 'document-name')
+     */
+    update(key, value) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        throw new Error("Invalid key: cannot modify prototype");
+      }
+      Object.assign(workspace, { [key]: value });
+    },
+    /**
+     * Updates a specific metadata field in a document
+     * @param name - The name of the document to update ('active' or a specific document name)
+     * @param key - The metadata field to update
+     * @param value - The new value for the field
+     * @throws Error if the specified document doesn't exist
+     * @example
+     * // Update the auth of the active document
+     * updateDocument('active', 'x-scalar-active-auth', 'Bearer')
+     * // Update the auth of a specific document
+     * updateDocument('document-name', 'x-scalar-active-auth', 'Bearer')
+     */
+    updateDocument(name, key, value) {
+      const currentDocument = workspace.documents[name === "active" ? workspace["x-scalar-active-document"] ?? workspaceProps?.documents?.[0].name ?? "" : name];
+      if (!currentDocument) {
+        throw "Please select a valid document";
+      }
+      Object.assign(currentDocument, { [key]: value });
+    },
+    /**
+     * Resolves a reference in the active document by following the provided path and resolving any external $ref references.
+     * This method traverses the document structure following the given path and resolves any $ref references it encounters.
+     * During resolution, it sets a loading status and updates the reference with the resolved content.
+     *
+     * @param path - Array of strings representing the path to the reference (e.g. ['paths', '/users', 'get', 'responses', '200'])
+     * @throws Error if the path is invalid or empty
+     * @example
+     * // Resolve a reference in the active document
+     * resolve(['paths', '/users', 'get', 'responses', '200'])
+     */
+    resolve: async (path) => {
+      if (path.length <= 1) {
+        throw "Please provide a valid path";
+      }
+      const lastPathSegment = path.pop();
+      const activeDocument = workspace.documents[workspace["x-scalar-active-document"] ?? Object.keys(workspace.documents)[0] ?? ""];
+      let parent = activeDocument;
+      for (const p of path) {
+        parent = parent[p];
+      }
+      const processedObjects = /* @__PURE__ */ new WeakSet();
+      const resolveRecursive = async (root, targetKey) => {
+        if (!root && !isObject(root)) {
+          return;
+        }
+        const target = root[targetKey];
+        if (!target || !isObject(target)) {
+          return;
+        }
+        const rawTarget = getRaw(target);
+        if (processedObjects.has(rawTarget)) {
+          return;
+        }
+        processedObjects.add(rawTarget);
+        if (typeof target === "object" && "$ref" in target && typeof target["$ref"] === "string") {
+          const ref = target["$ref"];
+          Object.assign(target, { "$status": "loading" });
+          const [path2, pointer] = ref.split("#");
+          const result = await resolveContents(path2);
+          if (result.ok) {
+            if (targetKey === "__proto__" || targetKey === "constructor" || targetKey === "prototype") {
+              throw new Error("Invalid key: cannot modify prototype");
+            }
+            Object.assign(root, { [targetKey]: getValueByPath(result.data, parseJsonPointer(pointer)) });
+            await resolveRecursive(root, targetKey);
+          } else {
+            Object.assign(target, { "$status": "error" });
+          }
+          return;
+        }
+        await Promise.all(Object.keys(target).map((key) => resolveRecursive(target, key)));
+      };
+      return resolveRecursive(parent, lastPathSegment);
+    },
+    /**
+     * Adds a new document to the workspace
+     * @param document - The document content to add. This should be a valid OpenAPI/Swagger document or other supported format
+     * @param meta - Metadata for the document, including its name and other properties defined in WorkspaceDocumentMeta
+     * @example
+     * // Add a new OpenAPI document to the workspace
+     * store.addDocument({
+     *   name: 'name',
+     *   document: {
+     *     openapi: '3.0.0',
+     *     info: { title: 'title' },
+     *   },
+     *   meta: {
+     *     'x-scalar-active-auth': 'Bearer',
+     *     'x-scalar-active-server': 'production'
+     *   }
+     * })
+     */
+    addDocument: async (input) => {
+      const { name, meta } = input;
+      const resolve = await loadDocument(input);
+      if (!resolve.ok || !isObject(resolve.data)) {
+        console.error(`Can not load the document '${name}'`);
+        return;
+      }
+      workspace.documents[name] = createMagicProxy({ ...resolve.data, ...meta });
+    }
+  };
+}
+export {
+  createWorkspaceStore
+};
+//# sourceMappingURL=create-workspace-store.js.map

package/dist/create-workspace-store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/create-workspace-store.ts"],
+  "sourcesContent": ["import { reactive, toRaw } from 'vue'\nimport type { WorkspaceMeta, WorkspaceDocumentMeta, Workspace } from './schemas/server-workspace'\nimport { createMagicProxy, getRaw } from './helpers/proxy'\nimport { fetchUrl, isObject, readLocalFile, resolveContents } from '@/helpers/general'\nimport { getValueByPath, parseJsonPointer } from '@/helpers/json-path-utils'\n\ntype WorkspaceDocumentMetaInput = { meta?: WorkspaceDocumentMeta; name: string }\ntype WorkspaceDocumentInput =\n  | ({ document: Record<string, unknown> } & WorkspaceDocumentMetaInput)\n  | ({ url: string } & WorkspaceDocumentMetaInput)\n  | ({ path: string } & WorkspaceDocumentMetaInput)\n\n/**\n * Resolves a workspace document from various input sources (URL, local file, or direct document object).\n *\n * @param workspaceDocument - The document input to resolve, which can be:\n *   - A URL to fetch the document from\n *   - A local file path to read the document from\n *   - A direct document object\n * @returns A promise that resolves to an object containing:\n *   - ok: boolean indicating if the resolution was successful\n *   - data: The resolved document data\n *\n * @example\n * // Resolve from URL\n * const urlDoc = await loadDocument({ name: 'api', url: 'https://api.example.com/openapi.json' })\n *\n * // Resolve from local file\n * const fileDoc = await loadDocument({ name: 'local', path: './openapi.json' })\n *\n * // Resolve direct document\n * const directDoc = await loadDocument({\n *   name: 'inline',\n *   document: { openapi: '3.0.0', paths: {} }\n * })\n */\nasync function loadDocument(workspaceDocument: WorkspaceDocumentInput) {\n  if ('url' in workspaceDocument) {\n    return fetchUrl(workspaceDocument.url)\n  }\n\n  if ('path' in workspaceDocument) {\n    return readLocalFile(workspaceDocument.path)\n  }\n\n  return {\n    ok: true as const,\n    data: workspaceDocument.document,\n  }\n}\n\n/**\n * Creates a reactive workspace store that manages documents and their metadata.\n * The store provides functionality for accessing, updating, and resolving document references.\n *\n * @param workspaceProps - Configuration object for the workspace\n * @param workspaceProps.meta - Optional metadata for the workspace\n * @param workspaceProps.documents - Optional record of documents to initialize the workspace with\n * @returns An object containing methods and getters for managing the workspace\n */\nexport async function createWorkspaceStore(workspaceProps?: {\n  meta?: WorkspaceMeta\n  documents?: WorkspaceDocumentInput[]\n}) {\n  // Create a reactive workspace object with proxied documents\n  // Each document is wrapped in a proxy to enable reactive updates and reference resolution\n  const workspace = reactive({\n    ...workspaceProps?.meta,\n    documents: (\n      await Promise.all(\n        (workspaceProps?.documents ?? []).map<\n          Promise<{ name: string; meta?: WorkspaceDocumentMeta; document: Record<string, unknown> }>\n        >(async (data) => {\n          const resolved = await loadDocument(data)\n\n          if (!resolved.ok) {\n            console.error(`Can not load the document '${data.name}'`)\n            return {\n              name: data.name,\n              meta: data.meta,\n              document: {},\n            }\n          }\n\n          return {\n            name: data.name,\n            meta: data.meta,\n            document: isObject(resolved.data) ? (resolved.data as Record<string, unknown>) : {},\n          }\n        }),\n      )\n    ).reduce<Record<string, Record<string, unknown>>>((acc, { name, meta, document }) => {\n      /**\n       * We wrap each document in the magic proxy to enable auto-resolving of references\n       */\n      acc[name] = createMagicProxy({ ...document, ...meta })\n      return acc\n    }, {}),\n    /**\n     * Returns the currently active document from the workspace.\n     * The active document is determined by the 'x-scalar-active-document' metadata field,\n     * falling back to the first document in the workspace if no active document is specified.\n     *\n     * @returns The active document or undefined if no document is found\n     */\n    get activeDocument(): (typeof workspace.documents)[number] | undefined {\n      const activeDocumentKey = workspace['x-scalar-active-document'] ?? Object.keys(workspace.documents)[0] ?? ''\n      return workspace.documents[activeDocumentKey]\n    },\n  }) as Workspace\n\n  return {\n    /**\n     * Returns the raw (non-reactive) workspace object\n     */\n    get rawWorkspace() {\n      return toRaw(workspace)\n    },\n    /**\n     * Returns the reactive workspace object with an additional activeDocument getter\n     */\n    get workspace() {\n      return workspace\n    },\n    /**\n     * Updates a specific metadata field in the workspace\n     * @param key - The metadata field to update\n     * @param value - The new value for the field\n     * @example\n     * // Update the workspace title\n     * update('x-scalar-active-document', 'document-name')\n     */\n    update<K extends keyof WorkspaceMeta>(key: K, value: WorkspaceMeta[K]) {\n      // @ts-ignore\n      if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n        throw new Error('Invalid key: cannot modify prototype')\n      }\n      Object.assign(workspace, { [key]: value })\n    },\n    /**\n     * Updates a specific metadata field in a document\n     * @param name - The name of the document to update ('active' or a specific document name)\n     * @param key - The metadata field to update\n     * @param value - The new value for the field\n     * @throws Error if the specified document doesn't exist\n     * @example\n     * // Update the auth of the active document\n     * updateDocument('active', 'x-scalar-active-auth', 'Bearer')\n     * // Update the auth of a specific document\n     * updateDocument('document-name', 'x-scalar-active-auth', 'Bearer')\n     */\n    updateDocument<K extends keyof WorkspaceDocumentMeta>(\n      name: 'active' | (string & {}),\n      key: K,\n      value: WorkspaceDocumentMeta[K],\n    ) {\n      const currentDocument =\n        workspace.documents[\n          name === 'active'\n            ? (workspace['x-scalar-active-document'] ?? workspaceProps?.documents?.[0].name ?? '')\n            : name\n        ]\n\n      if (!currentDocument) {\n        throw 'Please select a valid document'\n      }\n\n      Object.assign(currentDocument, { [key]: value })\n    },\n    /**\n     * Resolves a reference in the active document by following the provided path and resolving any external $ref references.\n     * This method traverses the document structure following the given path and resolves any $ref references it encounters.\n     * During resolution, it sets a loading status and updates the reference with the resolved content.\n     *\n     * @param path - Array of strings representing the path to the reference (e.g. ['paths', '/users', 'get', 'responses', '200'])\n     * @throws Error if the path is invalid or empty\n     * @example\n     * // Resolve a reference in the active document\n     * resolve(['paths', '/users', 'get', 'responses', '200'])\n     */\n    resolve: async (path: string[]) => {\n      if (path.length <= 1) {\n        throw 'Please provide a valid path'\n      }\n\n      const lastPathSegment = path.pop()! // We are sure there is at least an element on the array\n\n      const activeDocument =\n        workspace.documents[workspace['x-scalar-active-document'] ?? Object.keys(workspace.documents)[0] ?? '']\n\n      let parent = activeDocument as Record<string, any>\n\n      for (const p of path) {\n        parent = parent[p]\n      }\n\n      // Keep track of objects we've already processed to prevent infinite loops\n      const processedObjects = new WeakSet()\n\n      const resolveRecursive = async (root: unknown, targetKey: string) => {\n        if (!root && !isObject(root)) {\n          return\n        }\n\n        const target = (root as Record<string, unknown>)[targetKey]\n\n        if (!target || !isObject(target)) {\n          return\n        }\n\n        // Unwrap the target from the proxy\n        const rawTarget = getRaw(target)\n\n        // Skip if we've already processed this object\n        if (processedObjects.has(rawTarget)) {\n          return\n        }\n\n        // Mark this object as processed\n        processedObjects.add(rawTarget)\n\n        if (typeof target === 'object' && '$ref' in target && typeof target['$ref'] === 'string') {\n          const ref = target['$ref']\n\n          // Set the status to loading while we resolve the ref\n          Object.assign(target, { '$status': 'loading' })\n\n          const [path, pointer] = ref.split('#')\n          const result = await resolveContents(path)\n\n          if (result.ok) {\n            if (targetKey === '__proto__' || targetKey === 'constructor' || targetKey === 'prototype') {\n              throw new Error('Invalid key: cannot modify prototype')\n            }\n\n            Object.assign(root as object, { [targetKey]: getValueByPath(result.data, parseJsonPointer(pointer)) })\n\n            await resolveRecursive(root, targetKey)\n          } else {\n            Object.assign(target, { '$status': 'error' })\n          }\n\n          return\n        }\n\n        await Promise.all(Object.keys(target).map((key) => resolveRecursive(target, key)))\n      }\n\n      return resolveRecursive(parent, lastPathSegment)\n    },\n    /**\n     * Adds a new document to the workspace\n     * @param document - The document content to add. This should be a valid OpenAPI/Swagger document or other supported format\n     * @param meta - Metadata for the document, including its name and other properties defined in WorkspaceDocumentMeta\n     * @example\n     * // Add a new OpenAPI document to the workspace\n     * store.addDocument({\n     *   name: 'name',\n     *   document: {\n     *     openapi: '3.0.0',\n     *     info: { title: 'title' },\n     *   },\n     *   meta: {\n     *     'x-scalar-active-auth': 'Bearer',\n     *     'x-scalar-active-server': 'production'\n     *   }\n     * })\n     */\n    addDocument: async (input: WorkspaceDocumentInput) => {\n      const { name, meta } = input\n\n      const resolve = await loadDocument(input)\n\n      if (!resolve.ok || !isObject(resolve.data)) {\n        console.error(`Can not load the document '${name}'`)\n        return\n      }\n\n      workspace.documents[name] = createMagicProxy({ ...(resolve.data as Record<string, unknown>), ...meta })\n    },\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["path"]
+}

package/dist/helpers/general.d.ts

@@ -0,0 +1,88 @@
+export type UnknownObject = Record<string, unknown>;
+/**
+ * Returns true if the value is a non-null object (but not an array).
+ *
+ * @example
+ * ```ts
+ * isObject({}) // true
+ * isObject([]) // false
+ * isObject(null) // false
+ * ```
+ */
+export declare function isObject(value: unknown): value is UnknownObject;
+/**
+ * Checks if a string is a remote URL (starts with http:// or https://)
+ * @param value - The URL string to check
+ * @returns true if the string is a remote URL, false otherwise
+ * @example
+ * ```ts
+ * isRemoteUrl('https://example.com/schema.json') // true
+ * isRemoteUrl('http://api.example.com/schemas/user.json') // true
+ * isRemoteUrl('#/components/schemas/User') // false
+ * isRemoteUrl('./local-schema.json') // false
+ * ```
+ */
+export declare function isRemoteUrl(value: string): boolean;
+/**
+ * Checks if a string is a local reference (starts with #)
+ * @param value - The reference string to check
+ * @returns true if the string is a local reference, false otherwise
+ * @example
+ * ```ts
+ * isLocalRef('#/components/schemas/User') // true
+ * isLocalRef('https://example.com/schema.json') // false
+ * isLocalRef('./local-schema.json') // false
+ * ```
+ */
+export declare function isLocalRef(value: string): boolean;
+type ResolveResult = {
+    ok: false;
+} | {
+    ok: true;
+    data: unknown;
+};
+/**
+ * Fetches and parses JSON data from a remote URL.
+ *
+ * @param value - The URL to fetch data from
+ * @returns A result object containing either the parsed JSON data or an error indicator
+ * @example
+ * ```ts
+ * const result = await fetchUrl('https://api.example.com/data')
+ * if (result.ok) {
+ *   console.log(result.data) // The parsed JSON data
+ * }
+ * ```
+ */
+export declare function fetchUrl(value: string): Promise<ResolveResult>;
+/**
+ * Reads and parses a local JSON file from the filesystem.
+ *
+ * @param value - The file path to read from
+ * @returns A result object containing either the parsed JSON data or an error indicator
+ * @example
+ * ```ts
+ * const result = await readLocalFile('./data.json')
+ * if (result.ok) {
+ *   console.log(result.data) // The parsed JSON data
+ * }
+ * ```
+ */
+export declare function readLocalFile(value: string): Promise<ResolveResult>;
+/**
+ * Resolves a reference by attempting to fetch data from either a remote URL or local filesystem.
+ * The function automatically determines whether to use fetchUrl() for remote URLs or readLocalFile() for local paths.
+ *
+ * @param value - The reference string to resolve (URL or file path)
+ * @returns A result object containing either the resolved data or an error indicator
+ * @example
+ * ```ts
+ * const result = await resolveContents('https://api.example.com/data')
+ * if (result.ok) {
+ *   console.log(result.data) // The resolved data
+ * }
+ * ```
+ */
+export declare function resolveContents(value: string): Promise<ResolveResult>;
+export {};
+//# sourceMappingURL=general.d.ts.map

package/dist/helpers/general.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../src/helpers/general.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEnD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAE/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,KAAK,aAAa,GAAG;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAA;AAEhE;;;;;;;;;;;;GAYG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CASpE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAQzE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAE3E"}

package/dist/helpers/general.js

@@ -0,0 +1,38 @@
+import fs from "node:fs/promises";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRemoteUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+function isLocalRef(value) {
+  return value.startsWith("#");
+}
+async function fetchUrl(value) {
+  const response = await fetch(value);
+  if (response.ok) {
+    const body = await response.json();
+    return { ok: true, data: body };
+  }
+  return { ok: false };
+}
+async function readLocalFile(value) {
+  try {
+    const contents = await fs.readFile(value, "utf-8");
+    return { ok: true, data: JSON.parse(contents) };
+  } catch {
+    return { ok: false };
+  }
+}
+async function resolveContents(value) {
+  return isRemoteUrl(value) ? await fetchUrl(value) : await readLocalFile(value);
+}
+export {
+  fetchUrl,
+  isLocalRef,
+  isObject,
+  isRemoteUrl,
+  readLocalFile,
+  resolveContents
+};
+//# sourceMappingURL=general.js.map

package/dist/helpers/general.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/general.ts"],
+  "sourcesContent": ["import fs from 'node:fs/promises'\n\nexport type UnknownObject = Record<string, unknown>\n\n/**\n * Returns true if the value is a non-null object (but not an array).\n *\n * @example\n * ```ts\n * isObject({}) // true\n * isObject([]) // false\n * isObject(null) // false\n * ```\n */\nexport function isObject(value: unknown): value is UnknownObject {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\n/**\n * Checks if a string is a remote URL (starts with http:// or https://)\n * @param value - The URL string to check\n * @returns true if the string is a remote URL, false otherwise\n * @example\n * ```ts\n * isRemoteUrl('https://example.com/schema.json') // true\n * isRemoteUrl('http://api.example.com/schemas/user.json') // true\n * isRemoteUrl('#/components/schemas/User') // false\n * isRemoteUrl('./local-schema.json') // false\n * ```\n */\nexport function isRemoteUrl(value: string): boolean {\n  return value.startsWith('http://') || value.startsWith('https://')\n}\n\n/**\n * Checks if a string is a local reference (starts with #)\n * @param value - The reference string to check\n * @returns true if the string is a local reference, false otherwise\n * @example\n * ```ts\n * isLocalRef('#/components/schemas/User') // true\n * isLocalRef('https://example.com/schema.json') // false\n * isLocalRef('./local-schema.json') // false\n * ```\n */\nexport function isLocalRef(value: string): boolean {\n  return value.startsWith('#')\n}\n\ntype ResolveResult = { ok: false } | { ok: true; data: unknown }\n\n/**\n * Fetches and parses JSON data from a remote URL.\n *\n * @param value - The URL to fetch data from\n * @returns A result object containing either the parsed JSON data or an error indicator\n * @example\n * ```ts\n * const result = await fetchUrl('https://api.example.com/data')\n * if (result.ok) {\n *   console.log(result.data) // The parsed JSON data\n * }\n * ```\n */\nexport async function fetchUrl(value: string): Promise<ResolveResult> {\n  const response = await fetch(value)\n\n  if (response.ok) {\n    const body = await response.json()\n    return { ok: true, data: body }\n  }\n\n  return { ok: false }\n}\n\n/**\n * Reads and parses a local JSON file from the filesystem.\n *\n * @param value - The file path to read from\n * @returns A result object containing either the parsed JSON data or an error indicator\n * @example\n * ```ts\n * const result = await readLocalFile('./data.json')\n * if (result.ok) {\n *   console.log(result.data) // The parsed JSON data\n * }\n * ```\n */\nexport async function readLocalFile(value: string): Promise<ResolveResult> {\n  try {\n    const contents = await fs.readFile(value, 'utf-8')\n\n    return { ok: true, data: JSON.parse(contents) }\n  } catch {\n    return { ok: false }\n  }\n}\n\n/**\n * Resolves a reference by attempting to fetch data from either a remote URL or local filesystem.\n * The function automatically determines whether to use fetchUrl() for remote URLs or readLocalFile() for local paths.\n *\n * @param value - The reference string to resolve (URL or file path)\n * @returns A result object containing either the resolved data or an error indicator\n * @example\n * ```ts\n * const result = await resolveContents('https://api.example.com/data')\n * if (result.ok) {\n *   console.log(result.data) // The resolved data\n * }\n * ```\n */\nexport async function resolveContents(value: string): Promise<ResolveResult> {\n  return isRemoteUrl(value) ? await fetchUrl(value) : await readLocalFile(value)\n}\n"],
+  "mappings": "AAAA,OAAO,QAAQ;AAcR,SAAS,SAAS,OAAwC;AAC/D,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAcO,SAAS,YAAY,OAAwB;AAClD,SAAO,MAAM,WAAW,SAAS,KAAK,MAAM,WAAW,UAAU;AACnE;AAaO,SAAS,WAAW,OAAwB;AACjD,SAAO,MAAM,WAAW,GAAG;AAC7B;AAiBA,eAAsB,SAAS,OAAuC;AACpE,QAAM,WAAW,MAAM,MAAM,KAAK;AAElC,MAAI,SAAS,IAAI;AACf,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO,EAAE,IAAI,MAAM,MAAM,KAAK;AAAA,EAChC;AAEA,SAAO,EAAE,IAAI,MAAM;AACrB;AAeA,eAAsB,cAAc,OAAuC;AACzE,MAAI;AACF,UAAM,WAAW,MAAM,GAAG,SAAS,OAAO,OAAO;AAEjD,WAAO,EAAE,IAAI,MAAM,MAAM,KAAK,MAAM,QAAQ,EAAE;AAAA,EAChD,QAAQ;AACN,WAAO,EAAE,IAAI,MAAM;AAAA,EACrB;AACF;AAgBA,eAAsB,gBAAgB,OAAuC;AAC3E,SAAO,YAAY,KAAK,IAAI,MAAM,SAAS,KAAK,IAAI,MAAM,cAAc,KAAK;AAC/E;",
+  "names": []
+}

package/dist/helpers/json-path-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Parses a JSON Pointer string into an array of path segments
+ *
+ * @example
+ * ```ts
+ * parseJsonPointer('#/components/schemas/User')
+ *
+ * ['components', 'schemas', 'User']
+ * ```
+ */
+export declare function parseJsonPointer(pointer: string): string[];
+/**
+ * Retrieves a nested value from the source document using a path array
+ *
+ * @example
+ * ```ts
+ * getValueByPath(document, ['components', 'schemas', 'User'])
+ *
+ * { id: '123', name: 'John Doe' }
+ * ```
+ */
+export declare function getValueByPath(obj: any, pointer: string[]): unknown;
+//# sourceMappingURL=json-path-utils.d.ts.map

package/dist/helpers/json-path-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-path-utils.d.ts","sourceRoot":"","sources":["../../src/helpers/json-path-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAOnE"}

package/dist/helpers/json-path-utils.js

@@ -0,0 +1,16 @@
+function parseJsonPointer(pointer) {
+  return pointer.split("/").filter((segment, index) => (index !== 0 || segment !== "#") && segment);
+}
+function getValueByPath(obj, pointer) {
+  return pointer.reduce((acc, part) => {
+    if (acc === void 0 || acc === null) {
+      return void 0;
+    }
+    return acc[part];
+  }, obj);
+}
+export {
+  getValueByPath,
+  parseJsonPointer
+};
+//# sourceMappingURL=json-path-utils.js.map

package/dist/helpers/json-path-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/json-path-utils.ts"],
+  "sourcesContent": ["/**\n * Parses a JSON Pointer string into an array of path segments\n *\n * @example\n * ```ts\n * parseJsonPointer('#/components/schemas/User')\n *\n * ['components', 'schemas', 'User']\n * ```\n */\nexport function parseJsonPointer(pointer: string): string[] {\n  return (\n    pointer\n      // Split on '/'\n      .split('/')\n      // Remove the leading '#' if present\n      .filter((segment, index) => (index !== 0 || segment !== '#') && segment)\n  )\n}\n\n/**\n * Retrieves a nested value from the source document using a path array\n *\n * @example\n * ```ts\n * getValueByPath(document, ['components', 'schemas', 'User'])\n *\n * { id: '123', name: 'John Doe' }\n * ```\n */\nexport function getValueByPath(obj: any, pointer: string[]): unknown {\n  return pointer.reduce((acc, part) => {\n    if (acc === undefined || acc === null) {\n      return undefined\n    }\n    return acc[part]\n  }, obj)\n}\n"],
+  "mappings": "AAUO,SAAS,iBAAiB,SAA2B;AAC1D,SACE,QAEG,MAAM,GAAG,EAET,OAAO,CAAC,SAAS,WAAW,UAAU,KAAK,YAAY,QAAQ,OAAO;AAE7E;AAYO,SAAS,eAAe,KAAU,SAA4B;AACnE,SAAO,QAAQ,OAAO,CAAC,KAAK,SAAS;AACnC,QAAI,QAAQ,UAAa,QAAQ,MAAM;AACrC,aAAO;AAAA,IACT;AACA,WAAO,IAAI,IAAI;AAAA,EACjB,GAAG,GAAG;AACR;",
+  "names": []
+}

package/dist/helpers/proxy.d.ts

@@ -0,0 +1,63 @@
+import type { UnknownObject } from './general.js';
+export declare const TARGET_SYMBOL: unique symbol;
+/**
+ * Creates a proxy that automatically resolves JSON references ($ref) in an object.
+ * The proxy intercepts property access and automatically resolves any $ref references
+ * to their target values in the source document.
+ *
+ * @param targetObject - The object to create a proxy for
+ * @param sourceDocument - The source document containing the reference targets (defaults to targetObject)
+ * @param resolvedProxyCache - Optional cache to store resolved proxies and prevent duplicate proxies
+ * @returns A proxy that automatically resolves $ref references
+ *
+ * @example
+ * // Basic usage with local references
+ * const doc = {
+ *   components: {
+ *     schemas: {
+ *       User: { type: 'object', properties: { name: { type: 'string' } } }
+ *     }
+ *   },
+ *   paths: {
+ *     '/users': {
+ *       get: {
+ *         responses: {
+ *           200: {
+ *             content: {
+ *               'application/json': {
+ *                 schema: { $ref: '#/components/schemas/User' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const proxy = createMagicProxy(doc)
+ * // Accessing the schema will automatically resolve the $ref
+ * console.log(proxy.paths['/users'].get.responses[200].content['application/json'].schema)
+ * // Output: { type: 'object', properties: { name: { type: 'string' } } }
+ *
+ * @example
+ * // Using with a cache to prevent duplicate proxies
+ * const cache = new WeakMap()
+ * const proxy1 = createMagicProxy(doc, doc, cache)
+ * const proxy2 = createMagicProxy(doc, doc, cache)
+ * // proxy1 and proxy2 are the same instance due to caching
+ * console.log(proxy1 === proxy2) // true
+ */
+export declare function createMagicProxy<T extends UnknownObject>(targetObject: T, sourceDocument?: T, resolvedProxyCache?: WeakMap<object, T>): T;
+/**
+ * Gets the raw (non-proxied) version of an object created by createMagicProxy.
+ * This is useful when you need to access the original object without the magic proxy wrapper.
+ *
+ * @param obj - The magic proxy object to get the raw version of
+ * @returns The raw version of the object
+ * @example
+ * const proxy = createMagicProxy({ foo: { $ref: '#/bar' } })
+ * const raw = getRaw(proxy) // { foo: { $ref: '#/bar' } }
+ */
+export declare function getRaw(obj: UnknownObject): UnknownObject;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/helpers/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/helpers/proxy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,eAAO,MAAM,aAAa,eAAmB,CAAA;AAoH7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,aAAa,EACtD,YAAY,EAAE,CAAC,EACf,cAAc,GAAE,CAAgB,EAChC,kBAAkB,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,GACtC,CAAC,CAyBH;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,aAAa,iBAExC"}

package/dist/helpers/proxy.js

@@ -0,0 +1,100 @@
+import { isReactive, toRaw } from "vue";
+import { getValueByPath, parseJsonPointer } from "./json-path-utils.js";
+import { isLocalRef, isObject } from "./general.js";
+const TARGET_SYMBOL = Symbol("target");
+function createProxyHandler(sourceDocument, resolvedProxyCache) {
+  return {
+    get(target, property, receiver) {
+      if (property === TARGET_SYMBOL) {
+        return target;
+      }
+      if (property === "__isProxy") {
+        return true;
+      }
+      const value = Reflect.get(target, property, receiver);
+      const deepResolveNestedRefs = (value2) => {
+        if (!isObject(value2)) {
+          return value2;
+        }
+        if ("$ref" in value2) {
+          const ref = value2.$ref;
+          if (isLocalRef(ref)) {
+            const referencePath = parseJsonPointer(ref);
+            const resolvedValue = getValueByPath(sourceDocument, referencePath);
+            return deepResolveNestedRefs(resolvedValue);
+          }
+        }
+        return createMagicProxy(value2, sourceDocument, resolvedProxyCache);
+      };
+      return deepResolveNestedRefs(value);
+    },
+    set(target, property, newValue, receiver) {
+      const rawTarget = isReactive(target) ? toRaw(target) : target;
+      const currentValue = rawTarget[property];
+      if (isObject(currentValue) && "$ref" in currentValue && typeof currentValue.$ref === "string" && isLocalRef(currentValue.$ref)) {
+        const referencePath = parseJsonPointer(currentValue.$ref);
+        const targetObject = getValueByPath(sourceDocument, referencePath.slice(0, -1));
+        const lastPathSegment = referencePath[referencePath.length - 1];
+        if (targetObject && lastPathSegment) {
+          targetObject[lastPathSegment] = newValue;
+        }
+      } else {
+        Reflect.set(rawTarget, property, newValue, receiver);
+      }
+      return true;
+    },
+    has(target, key) {
+      if (typeof key === "string" && key !== "$ref" && typeof target.$ref === "string" && isLocalRef(target.$ref)) {
+        const referencePath = parseJsonPointer(target["$ref"]);
+        const resolvedValue = getValueByPath(sourceDocument, referencePath);
+        return resolvedValue ? key in resolvedValue : false;
+      }
+      return key in target;
+    },
+    ownKeys(target) {
+      if ("$ref" in target && typeof target.$ref === "string" && isLocalRef(target.$ref)) {
+        const referencePath = parseJsonPointer(target["$ref"]);
+        const resolvedValue = getValueByPath(sourceDocument, referencePath);
+        return resolvedValue ? Reflect.ownKeys(resolvedValue) : [];
+      }
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, key) {
+      if ("$ref" in target && key !== "$ref" && typeof target.$ref === "string" && isLocalRef(target.$ref)) {
+        const referencePath = parseJsonPointer(target["$ref"]);
+        const resolvedValue = getValueByPath(sourceDocument, referencePath);
+        if (resolvedValue) {
+          return Object.getOwnPropertyDescriptor(resolvedValue, key);
+        }
+      }
+      return Object.getOwnPropertyDescriptor(target, key);
+    }
+  };
+}
+function createMagicProxy(targetObject, sourceDocument = targetObject, resolvedProxyCache) {
+  if (!isObject(targetObject)) {
+    return targetObject;
+  }
+  const rawTarget = isReactive(targetObject) ? toRaw(targetObject) : targetObject;
+  if (resolvedProxyCache?.has(rawTarget)) {
+    const cachedValue = resolvedProxyCache.get(rawTarget);
+    if (cachedValue) {
+      return cachedValue;
+    }
+  }
+  const handler = createProxyHandler(sourceDocument, resolvedProxyCache);
+  const proxy = new Proxy(rawTarget, handler);
+  if (resolvedProxyCache) {
+    resolvedProxyCache.set(rawTarget, proxy);
+  }
+  return proxy;
+}
+function getRaw(obj) {
+  return obj[TARGET_SYMBOL];
+}
+export {
+  TARGET_SYMBOL,
+  createMagicProxy,
+  getRaw
+};
+//# sourceMappingURL=proxy.js.map