fumadocs-openapi 10.6.7 → 10.7.0

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/bundle.js

@@ -0,0 +1,346 @@
+import { isObject } from "../../../../../../@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/is-object.js";
+import { convertToLocalRef } from "../helpers/convert-to-local-ref.js";
+import { getId, getSchemas } from "../helpers/get-schemas.js";
+import { getValueByPath } from "../helpers/get-value-by-path.js";
+import { isHttpUrl } from "../helpers/is-http-url.js";
+import { isFilePath } from "../helpers/is-file-path.js";
+import { resolveReferencePath } from "../helpers/resolve-reference-path.js";
+import { getSegmentsFromPath } from "../helpers/get-segments-from-path.js";
+import { setValueAtPath } from "../helpers/set-value-at-path.js";
+import { toRelativePath } from "../helpers/to-relative-path.js";
+import { escapeJsonPointer } from "../helpers/escape-json-pointer.js";
+import { getHash, uniqueValueGeneratorFactory } from "./value-generator.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/bundle.js
+/** Type guard to check if a value is an object with a $ref property */
+const hasRef = (value) => isObject(value) && "$ref" in value && typeof value["$ref"] === "string";
+/**
+* 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
+* ```
+*/
+function isLocalRef(value) {
+	return value.startsWith("#");
+}
+/**
+* Resolves a string by finding and executing the appropriate plugin.
+* @param value - The string to resolve (URL, file path, etc)
+* @param plugins - Array of plugins that can handle different types of strings
+* @returns A promise that resolves to either the content or an error result
+* @example
+* // Using a URL plugin
+* await resolveContents('https://example.com/schema.json', [urlPlugin])
+* // Using a file plugin
+* await resolveContents('./schemas/user.json', [filePlugin])
+* // No matching plugin returns { ok: false }
+* await resolveContents('#/components/schemas/User', [urlPlugin, filePlugin])
+*/
+function resolveContents(value, plugins) {
+	const plugin = plugins.find((p) => p.validate(value));
+	if (plugin) return plugin.exec(value);
+	return Promise.resolve({ ok: false });
+}
+/**
+* Prefixes an internal JSON reference with a given path prefix.
+* Takes a local reference (starting with #) and prepends the provided prefix segments.
+*
+* @param input - The internal reference string to prefix (must start with #)
+* @param prefix - Array of path segments to prepend to the reference
+* @returns The prefixed reference string
+* @throws Error if input is not a local reference
+* @example
+* prefixInternalRef('#/components/schemas/User', ['definitions'])
+* // Returns: '#/definitions/components/schemas/User'
+*/
+function prefixInternalRef(input, prefix) {
+	if (!isLocalRef(input)) throw "Please provide an internal ref";
+	return `#/${prefix.map(escapeJsonPointer).join("/")}${input.substring(1)}`;
+}
+/**
+* Updates internal references in an object by adding a prefix to their paths.
+* Recursively traverses the input object and modifies any local $ref references
+* by prepending the given prefix to their paths. This is used when embedding external
+* documents to maintain correct reference paths relative to the main document.
+*
+* @param input - The object to update references in
+* @param prefix - Array of path segments to prepend to internal reference paths
+* @returns void
+* @example
+* ```ts
+* const input = {
+*   foo: {
+*     $ref: '#/components/schemas/User'
+*   }
+* }
+* prefixInternalRefRecursive(input, ['definitions'])
+* // Result:
+* // {
+* //   foo: {
+* //     $ref: '#/definitions/components/schemas/User'
+* //   }
+* // }
+* ```
+*/
+function prefixInternalRefRecursive(input, prefix) {
+	if (Array.isArray(input)) {
+		input.forEach((el) => prefixInternalRefRecursive(el, prefix));
+		return;
+	}
+	if (!isObject(input)) return;
+	Object.values(input).forEach((el) => prefixInternalRefRecursive(el, prefix));
+	if (typeof input === "object" && "$ref" in input && typeof input["$ref"] === "string") {
+		const ref = input["$ref"];
+		if (!isLocalRef(ref)) return;
+		input["$ref"] = prefixInternalRef(ref, prefix);
+	}
+}
+/**
+* Resolves and copies referenced values from a source document to a target document.
+* This function traverses the document and copies referenced values to the target document,
+* while tracking processed references to avoid duplicates. It only processes references
+* that belong to the same external document.
+*
+* @param targetDocument - The document to copy referenced values to
+* @param sourceDocument - The source document containing the references
+* @param referencePath - The JSON pointer path to the reference
+* @param externalRefsKey - The key used for external references (e.g. 'x-ext')
+* @param documentKey - The key identifying the external document
+* @param bundleLocalRefs - Also bundles the local refs
+* @param processedNodes - Set of already processed nodes to prevent duplicates
+* @example
+* ```ts
+* const source = {
+*   components: {
+*     schemas: {
+*       User: {
+*         $ref: '#/x-ext/users~1schema/definitions/Person'
+*       }
+*     }
+*   }
+* }
+*
+* const target = {}
+* resolveAndCopyReferences(
+*   target,
+*   source,
+*   '/components/schemas/User',
+*   'x-ext',
+*   'users/schema'
+* )
+* // Result: target will contain the User schema with resolved references
+* ```
+*/
+const resolveAndCopyReferences = (targetDocument, sourceDocument, referencePath, externalRefsKey, documentKey, bundleLocalRefs = false, processedNodes = /* @__PURE__ */ new Set()) => {
+	const referencedValue = getValueByPath(sourceDocument, getSegmentsFromPath(referencePath)).value;
+	if (processedNodes.has(referencedValue)) return;
+	processedNodes.add(referencedValue);
+	setValueAtPath(targetDocument, referencePath, referencedValue);
+	const traverse = (node) => {
+		if (!node || typeof node !== "object") return;
+		if ("$ref" in node && typeof node["$ref"] === "string") {
+			if (node["$ref"].startsWith(`#/${externalRefsKey}/${escapeJsonPointer(documentKey)}`)) resolveAndCopyReferences(targetDocument, sourceDocument, node["$ref"].substring(1), externalRefsKey, documentKey, bundleLocalRefs, processedNodes);
+			else if (bundleLocalRefs) resolveAndCopyReferences(targetDocument, sourceDocument, node["$ref"].substring(1), externalRefsKey, documentKey, bundleLocalRefs, processedNodes);
+		}
+		for (const value of Object.values(node)) traverse(value);
+	};
+	traverse(referencedValue);
+};
+/**
+* Extension keys used for bundling external references in OpenAPI documents.
+* These custom extensions help maintain the structure and traceability of bundled documents.
+*/
+const extensions = {
+	externalDocuments: "x-ext",
+	externalDocumentsMappings: "x-ext-urls"
+};
+/**
+* Bundles an OpenAPI specification by resolving all external references.
+* This function traverses the input object recursively and embeds external $ref
+* references into an x-ext section. External references can be URLs or local files.
+* The original $refs are updated to point to their embedded content in the x-ext section.
+* If the input is an object, it will be modified in place by adding an x-ext
+* property to store resolved external references.
+*
+* @param input - The OpenAPI specification to bundle. Can be either an object or string.
+*                If a string is provided, it will be resolved using the provided plugins.
+*                If no plugin can process the input, the onReferenceError hook will be invoked
+*                and an error will be emitted to the console.
+* @param config - Configuration object containing plugins and options for bundling OpenAPI specifications
+* @returns A promise that resolves to the bundled specification with all references embedded
+* @example
+* // Example with object input
+* const spec = {
+*   paths: {
+*     '/users': {
+*       $ref: 'https://example.com/schemas/users.yaml'
+*     }
+*   }
+* }
+*
+* const bundled = await bundle(spec, {
+*   plugins: [fetchUrls()],
+*   treeShake: true,
+*   urlMap: true,
+*   hooks: {
+*     onResolveStart: (ref) => console.log('Resolving:', ref.$ref),
+*     onResolveSuccess: (ref) => console.log('Resolved:', ref.$ref),
+*     onResolveError: (ref) => console.log('Failed to resolve:', ref.$ref)
+*   }
+* })
+* // Result:
+* // {
+* //   paths: {
+* //     '/users': {
+* //       $ref: '#/x-ext/abc123'
+* //     }
+* //   },
+* //   'x-ext': {
+* //     'abc123': {
+* //       // Resolved content from users.yaml
+* //     }
+* //   },
+* //   'x-ext-urls': {
+* //     'https://example.com/schemas/users.yaml': 'abc123'
+* //   }
+* // }
+*
+* // Example with URL input
+* const bundledFromUrl = await bundle('https://example.com/openapi.yaml', {
+*   plugins: [fetchUrls()],
+*   treeShake: true,
+*   urlMap: true,
+*   hooks: {
+*     onResolveStart: (ref) => console.log('Resolving:', ref.$ref),
+*     onResolveSuccess: (ref) => console.log('Resolved:', ref.$ref),
+*     onResolveError: (ref) => console.log('Failed to resolve:', ref.$ref)
+*   }
+* })
+* // The function will first fetch the OpenAPI spec from the URL,
+* // then bundle all its external references into the x-ext section
+*/
+async function bundle(input, config) {
+	config.externalDocumentsKey = config.externalDocumentsKey ?? extensions.externalDocuments;
+	config.externalDocumentsMappingsKey = config.externalDocumentsMappingsKey ?? extensions.externalDocumentsMappings;
+	const cache = config.cache ?? /* @__PURE__ */ new Map();
+	const loaderPlugins = config.plugins.filter((it) => it.type === "loader");
+	const lifecyclePlugin = config.plugins.filter((it) => it.type === "lifecycle");
+	/**
+	* Resolves the input value by either returning it directly if it's not a string,
+	* or attempting to resolve it using the provided plugins if it is a string.
+	* @returns The resolved input data or throws an error if resolution fails
+	*/
+	const resolveInput = async () => {
+		if (typeof input !== "string") return input;
+		const result = await resolveContents(input, loaderPlugins);
+		if (result.ok && typeof result.data === "object") return result.data;
+		throw new Error("Failed to resolve input: Please provide a valid string value or pass a loader to process the input");
+	};
+	const rawSpecification = await resolveInput();
+	const documentRoot = config.root ?? rawSpecification;
+	const schemas = getSchemas(documentRoot);
+	const isPartialBundling = config.root !== void 0 && config.root !== rawSpecification || config.depth !== void 0;
+	const processedNodes = config.visitedNodes ?? /* @__PURE__ */ new Set();
+	const getDefaultOrigin = () => {
+		const id = getId(documentRoot);
+		if (id) return id;
+		if (config.origin) return config.origin;
+		if (typeof input !== "string") return "/";
+		if (isHttpUrl(input) || isFilePath(input)) return input;
+		return "/";
+	};
+	const defaultOrigin = getDefaultOrigin();
+	if (documentRoot[config.externalDocumentsMappingsKey] === void 0) documentRoot[config.externalDocumentsMappingsKey] = {};
+	const { generate } = uniqueValueGeneratorFactory(config.compress ?? getHash, documentRoot[config.externalDocumentsMappingsKey]);
+	/**
+	* Executes lifecycle hooks defined both in the bundler configuration and any extended lifecycle plugins.
+	* This utility function ensures that all relevant hooks for a given event type are called in order:
+	* - First, the hook directly provided via the config (if present)
+	* - Then, all matching hooks from registered lifecycle plugins (if present)
+	*
+	* Hooks are awaited in sequence for the given event type and argument list.
+	*
+	* @param type The hook event type, corresponding to a key of Config['hooks'].
+	* @param args Arguments to pass to the hook function, matching HookFn<T>.
+	*/
+	const executeHooks = async (type, ...args) => {
+		const hook = config.hooks?.[type];
+		if (hook) await hook(...args);
+		for (const plugin of lifecyclePlugin) {
+			const pluginHook = plugin[type];
+			if (pluginHook) await pluginHook(...args);
+		}
+	};
+	const bundler = async (root, origin = defaultOrigin, isChunkParent = false, depth = 0, currentPath = [], parent = null) => {
+		if (config.depth !== void 0 && depth > config.depth) return;
+		if (!isObject(root) && !Array.isArray(root)) return;
+		if (processedNodes.has(root)) return;
+		processedNodes.add(root);
+		const context = {
+			path: currentPath,
+			resolutionCache: cache,
+			parentNode: parent,
+			rootNode: documentRoot,
+			loaders: loaderPlugins
+		};
+		await executeHooks("onBeforeNodeProcess", root, context);
+		const id = getId(root);
+		if (hasRef(root)) {
+			const ref = root["$ref"];
+			const isChunk = "$global" in root && typeof root["$global"] === "boolean" && root["$global"];
+			const localRef = convertToLocalRef(ref, id ?? origin, schemas);
+			if (localRef !== void 0) {
+				if (isPartialBundling) {
+					const segments = getSegmentsFromPath(`/${localRef}`);
+					const parent = segments.length > 0 ? getValueByPath(documentRoot, segments.slice(0, -1)).value : void 0;
+					const targetValue = getValueByPath(documentRoot, segments);
+					await bundler(targetValue.value, targetValue.context, isChunkParent, depth + 1, segments, parent);
+				}
+				await executeHooks("onAfterNodeProcess", root, context);
+				return;
+			}
+			const [prefix, path = ""] = ref.split("#", 2);
+			const resolvedPath = resolveReferencePath(id ?? origin, prefix);
+			const relativePath = toRelativePath(resolvedPath, defaultOrigin);
+			const compressedPath = await generate(relativePath);
+			const seen = cache.has(relativePath);
+			if (!seen) cache.set(relativePath, resolveContents(resolvedPath, loaderPlugins));
+			await executeHooks("onResolveStart", root);
+			const result = await cache.get(relativePath);
+			if (result.ok) {
+				if (!seen) {
+					if (!isChunk) prefixInternalRefRecursive(result.data, [extensions.externalDocuments, compressedPath]);
+					await bundler(result.data, isChunk ? origin : resolvedPath, isChunk, depth + 1, [
+						config.externalDocumentsKey,
+						compressedPath,
+						documentRoot[config.externalDocumentsMappingsKey]
+					]);
+					setValueAtPath(documentRoot, `/${config.externalDocumentsMappingsKey}/${escapeJsonPointer(compressedPath)}`, relativePath);
+				}
+				if (config.treeShake === true) resolveAndCopyReferences(documentRoot, { [config.externalDocumentsKey]: { [compressedPath]: result.data } }, prefixInternalRef(`#${path}`, [config.externalDocumentsKey, compressedPath]).substring(1), config.externalDocumentsKey, compressedPath);
+				else if (!seen) setValueAtPath(documentRoot, `/${config.externalDocumentsKey}/${compressedPath}`, result.data);
+				root.$ref = prefixInternalRef(`#${path}`, [config.externalDocumentsKey, compressedPath]);
+				await executeHooks("onResolveSuccess", root);
+				await executeHooks("onAfterNodeProcess", root, context);
+				return;
+			}
+			await executeHooks("onResolveError", root);
+			await executeHooks("onAfterNodeProcess", root, context);
+			return console.warn(`Failed to resolve external reference "${resolvedPath}". The reference may be invalid, inaccessible, or missing a loader for this type of reference.`);
+		}
+		for (const key in root) {
+			if (key === config.externalDocumentsKey || key === config.externalDocumentsMappingsKey) continue;
+			await bundler(root[key], id ?? origin, isChunkParent, depth + 1, [...currentPath, key], root);
+		}
+		await executeHooks("onAfterNodeProcess", root, context);
+	};
+	await bundler(rawSpecification);
+	if (!config.urlMap && !isPartialBundling) delete documentRoot[config.externalDocumentsMappingsKey];
+	return rawSpecification;
+}
+//#endregion
+export { bundle };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/plugins/fetch-urls/index.js

@@ -0,0 +1,73 @@
+import { isHttpUrl } from "../../../helpers/is-http-url.js";
+import { createLimiter } from "../../../../../../../../@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/general/create-limiter.js";
+import { normalize } from "../../../helpers/normalize.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/plugins/fetch-urls/index.js
+/**
+* Safely checks for host from a URL
+* Needed because we cannot create a URL from a relative remote URL ex: examples/openapi.json
+*/
+const getHost = (url) => {
+	try {
+		return new URL(url).host;
+	} catch {
+		return null;
+	}
+};
+/**
+* Fetches and normalizes data from a remote URL
+* @param url - The URL to fetch data from
+* @returns A promise that resolves to either the normalized data or an error result
+* @example
+* ```ts
+* const result = await fetchUrl('https://api.example.com/data.json')
+* if (result.ok) {
+*   console.log(result.data) // The normalized data
+* } else {
+*   console.log('Failed to fetch data')
+* }
+* ```
+*/
+async function fetchUrl(url, limiter, config) {
+	try {
+		const host = getHost(url);
+		const headers = config?.headers?.find((a) => a.domains.find((d) => d === host) !== void 0)?.headers;
+		const exec = config?.fetch ?? fetch;
+		const result = await limiter(() => exec(url, { headers }));
+		if (result.ok) {
+			const body = await result.text();
+			return {
+				ok: true,
+				data: normalize(body),
+				raw: body
+			};
+		}
+		const contentType = result.headers.get("Content-Type") ?? "";
+		if (["text/html", "application/xml"].includes(contentType)) console.warn(`[WARN] We only support JSON/YAML formats, received ${contentType}`);
+		console.warn(`[WARN] Fetch failed with status ${result.status} ${result.statusText} for URL: ${url}`);
+		return { ok: false };
+	} catch {
+		console.warn(`[WARN] Failed to parse JSON/YAML from URL: ${url}`);
+		return { ok: false };
+	}
+}
+/**
+* Creates a plugin for handling remote URL references.
+* This plugin validates and fetches data from HTTP/HTTPS URLs.
+*
+* @returns A plugin object with validate and exec functions
+* @example
+* const urlPlugin = fetchUrls()
+* if (urlPlugin.validate('https://example.com/schema.json')) {
+*   const result = await urlPlugin.exec('https://example.com/schema.json')
+* }
+*/
+function fetchUrls(config) {
+	const limiter = config?.limit ? createLimiter(config.limit) : (fn) => fn();
+	return {
+		type: "loader",
+		validate: isHttpUrl,
+		exec: (value) => fetchUrl(value, limiter, config)
+	};
+}
+//#endregion
+export { fetchUrls };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/plugins/node.js

@@ -0,0 +1,3 @@
+import "./fetch-urls/index.js";
+import "./parse-yaml/index.js";
+import "./read-files/index.js";

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/plugins/parse-yaml/index.js

@@ -0,0 +1 @@
+import "../../../../../../../../yaml@2.8.3/node_modules/yaml/browser/index.js";

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/plugins/read-files/index.js

@@ -0,0 +1,51 @@
+import { isFilePath } from "../../../helpers/is-file-path.js";
+import { normalize } from "../../../helpers/normalize.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/plugins/read-files/index.js
+/**
+* Reads and normalizes data from a local file
+* @param path - The file path to read from
+* @returns A promise that resolves to either the normalized data or an error result
+* @example
+* ```ts
+* const result = await readFile('./schemas/user.json')
+* if (result.ok) {
+*   console.log(result.data) // The normalized data
+* } else {
+*   console.log('Failed to read file')
+* }
+* ```
+*/
+async function readFile(path) {
+	const fs = typeof window === "undefined" ? await import("node:fs/promises") : void 0;
+	if (fs === void 0) throw "Can not use readFiles plugin outside of a node environment";
+	try {
+		const fileContents = await fs.readFile(path, { encoding: "utf-8" });
+		return {
+			ok: true,
+			data: normalize(fileContents),
+			raw: fileContents
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+/**
+* Creates a plugin for handling local file references.
+* This plugin validates and reads data from local filesystem paths.
+*
+* @returns A plugin object with validate and exec functions
+* @example
+* const filePlugin = readFiles()
+* if (filePlugin.validate('./local-schema.json')) {
+*   const result = await filePlugin.exec('./local-schema.json')
+* }
+*/
+function readFiles() {
+	return {
+		type: "loader",
+		validate: isFilePath,
+		exec: readFile
+	};
+}
+//#endregion
+export { readFiles };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/value-generator.js

@@ -0,0 +1,88 @@
+import { generateHash } from "../../../../../../@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/string/generate-hash.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/bundle/value-generator.js
+/**
+* Generates a short hash from a string value using xxhash.
+*
+* This function is used to create unique identifiers for external references
+* while keeping the hash length manageable. It uses xxhash-wasm instead of
+* crypto.subtle because crypto.subtle is only available in secure contexts (HTTPS) or on localhost.
+* Returns the first 7 characters of the hash string.
+* If the hash would be all numbers, it ensures at least one letter is included.
+*
+* @param value - The string to hash
+* @returns A Promise that resolves to a 7-character hexadecimal hash with at least one letter
+* @example
+* // Returns "2ae91d7"
+* getHash("https://example.com/schema.json")
+*/
+function getHash(value) {
+	const hash = generateHash(value).substring(0, 7);
+	return hash.match(/^\d+$/) ? "a" + hash.substring(1) : hash;
+}
+/**
+* Generates a unique compressed value for a string, handling collisions by recursively compressing
+* until a unique value is found. This is used to create unique identifiers for external
+* references in the bundled OpenAPI document.
+*
+* @param compress - Function that generates a compressed value from a string
+* @param value - The original string value to compress
+* @param compressedToValue - Object mapping compressed values to their original values
+* @param prevCompressedValue - Optional previous compressed value to use as input for generating a new value
+* @param depth - Current recursion depth to prevent infinite loops
+* @returns A unique compressed value that doesn't conflict with existing values
+*
+* @example
+* const valueMap = {}
+* // First call generates compressed value for "example.com/schema.json"
+* const value1 = await generateUniqueValue(compress, "example.com/schema.json", valueMap)
+* // Returns something like "2ae91d7"
+*
+* // Second call with same value returns same compressed value
+* const value2 = await generateUniqueValue(compress, "example.com/schema.json", valueMap)
+* // Returns same value as value1
+*
+* // Call with different value generates new unique compressed value
+* const value3 = await generateUniqueValue(compress, "example.com/other.json", valueMap)
+* // Returns different value like "3bf82e9"
+*/
+async function generateUniqueValue(compress, value, compressedToValue, prevCompressedValue, depth = 0) {
+	if (depth >= 100) throw "Can not generate unique compressed values";
+	const compressedValue = await compress(prevCompressedValue ?? value);
+	if (compressedToValue[compressedValue] !== void 0 && compressedToValue[compressedValue] !== value) return generateUniqueValue(compress, value, compressedToValue, compressedValue, depth + 1);
+	compressedToValue[compressedValue] = value;
+	return compressedValue;
+}
+/**
+* Factory function that creates a value generator with caching capabilities.
+* The generator maintains a bidirectional mapping between original values and their compressed forms.
+*
+* @param compress - Function that generates a compressed value from a string
+* @param compressedToValue - Initial mapping of compressed values to their original values
+* @returns An object with a generate method that produces unique compressed values
+*
+* @example
+* const compress = (value) => value.substring(0, 6) // Simple compression example
+* const initialMap = { 'abc123': 'example.com/schema.json' }
+* const generator = uniqueValueGeneratorFactory(compress, initialMap)
+*
+* // Generate compressed value for new string
+* const compressed = await generator.generate('example.com/other.json')
+* // Returns something like 'example'
+*
+* // Generate compressed value for existing string
+* const cached = await generator.generate('example.com/schema.json')
+* // Returns 'abc123' from cache
+*/
+const uniqueValueGeneratorFactory = (compress, compressedToValue) => {
+	const valueToCompressed = Object.fromEntries(Object.entries(compressedToValue).map(([key, value]) => [value, key]));
+	return { generate: async (value) => {
+		const cache = valueToCompressed[value];
+		if (cache) return cache;
+		const generatedValue = await generateUniqueValue(compress, value, compressedToValue);
+		const compressedValue = generatedValue.match(/^\d+$/) ? `a${generatedValue}` : generatedValue;
+		valueToCompressed[value] = compressedValue;
+		return compressedValue;
+	} };
+};
+//#endregion
+export { getHash, uniqueValueGeneratorFactory };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/convert-to-local-ref.js

@@ -0,0 +1,24 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/convert-to-local-ref.js
+/**
+* Translates a JSON Reference ($ref) to a local object path within the root schema.
+*
+* @param ref - The JSON Reference string (e.g., "#/foo/bar", "other.json#/baz", "other.json#anchor")
+* @param currentContext - The current base context (usually the $id of the current schema or parent)
+* @param schemas - A map of schema identifiers ($id, $anchor) to their local object paths
+* @returns The local object path as a string, or undefined if the reference cannot be resolved
+*/
+const convertToLocalRef = (ref, currentContext, schemas) => {
+	const [baseUrl, pathOrAnchor] = ref.split("#", 2);
+	if (baseUrl) {
+		if (!schemas.has(baseUrl)) return;
+		if (!pathOrAnchor) return schemas.get(baseUrl);
+		if (pathOrAnchor.startsWith("/")) return `${schemas.get(baseUrl)}${pathOrAnchor}`;
+		return schemas.get(`${baseUrl}#${pathOrAnchor}`);
+	}
+	if (pathOrAnchor) {
+		if (pathOrAnchor.startsWith("/")) return pathOrAnchor.slice(1);
+		return schemas.get(`${currentContext}#${pathOrAnchor}`);
+	}
+};
+//#endregion
+export { convertToLocalRef };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/escape-json-pointer.js

@@ -0,0 +1,11 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/escape-json-pointer.js
+/**
+* Escapes a JSON pointer string.
+*
+* Example: `/foo/bar~baz` -> `'~1foo~1bar~0baz'`
+*/
+function escapeJsonPointer(str) {
+	return str.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+//#endregion
+export { escapeJsonPointer };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/get-schemas.js

@@ -0,0 +1,44 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/get-schemas.js
+/**
+* Retrieves the $id property from the input object if it exists and is a string.
+*
+* @param input - The object to extract the $id from.
+* @returns The $id string if present, otherwise undefined.
+*/
+const getId = (input) => {
+	if (input && typeof input === "object" && input["$id"] && typeof input["$id"] === "string") return input["$id"];
+};
+/**
+* Joins an array of path segments into a single string separated by '/'.
+*
+* @param segments - The array of path segments.
+* @returns The joined path string.
+*/
+const getPath = (segments) => {
+	return segments.join("/");
+};
+/**
+* Recursively traverses the input object to collect all schemas identified by $id and $anchor properties.
+*
+* - If an object has a $id property, it is added to the map with its $id as the key.
+* - If an object has a $anchor property, it is added to the map with a key composed of the current base and the anchor.
+* - The function performs a depth-first search (DFS) through all nested objects.
+*
+* @param input - The input object to traverse.
+* @param base - The current base URI, used for resolving anchors.
+* @param map - The map collecting found schemas.
+* @returns A map of schema identifiers to their corresponding objects.
+*/
+const getSchemas = (input, base = "", segments = [], map = /* @__PURE__ */ new Map(), visited = /* @__PURE__ */ new WeakSet()) => {
+	if (typeof input !== "object" || input === null) return map;
+	if (visited.has(input)) return map;
+	visited.add(input);
+	const id = getId(input);
+	if (id) map.set(id, getPath(segments));
+	const newBase = id ?? base;
+	if (input["$anchor"] && typeof input["$anchor"] === "string") map.set(`${newBase}#${input["$anchor"]}`, getPath(segments));
+	for (const key in input) if (typeof input[key] === "object" && input[key] !== null) getSchemas(input[key], newBase, [...segments, key], map, visited);
+	return map;
+};
+//#endregion
+export { getId, getSchemas };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/get-segments-from-path.js

@@ -0,0 +1,10 @@
+import { unescapeJsonPointer } from "./unescape-json-pointer.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/get-segments-from-path.js
+/**
+* Translate `/paths/~1test` to `['paths', '/test']`
+*/
+function getSegmentsFromPath(path) {
+	return path.split("/").slice(1).map(unescapeJsonPointer);
+}
+//#endregion
+export { getSegmentsFromPath };