fumadocs-openapi 10.6.8 → 10.7.1

package/css/generated/shared.css

@@ -556,7 +556,6 @@
 @source inline("never");
 @source inline("new");
 @source inline("newKey");
-@source inline("next-themes");
 @source inline("no-cache");
 @source inline("node");
 @source inline("node:path");

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/general/create-limiter.js

@@ -0,0 +1,43 @@
+import { Queue } from "../queue/queue.js";
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/general/create-limiter.js
+/**
+* Creates a function that limits the number of concurrent executions of async functions.
+*
+* @param maxConcurrent - Maximum number of concurrent executions allowed
+* @returns A function that wraps async functions to limit their concurrent execution
+*
+* @example
+* ```ts
+* const limiter = createLimiter(2) // Allow max 2 concurrent executions
+*
+* // These will run with max 2 at a time
+* const results = await Promise.all([
+*   limiter(() => fetch('/api/1')),
+*   limiter(() => fetch('/api/2')),
+*   limiter(() => fetch('/api/3')),
+*   limiter(() => fetch('/api/4'))
+* ])
+* ```
+*/
+function createLimiter(maxConcurrent) {
+	let activeCount = 0;
+	const queue = new Queue();
+	const next = () => {
+		if (queue.isEmpty() || activeCount >= maxConcurrent) return;
+		const resolve = queue.dequeue();
+		if (resolve) resolve();
+	};
+	const run = async (fn) => {
+		if (activeCount >= maxConcurrent) await new Promise((resolve) => queue.enqueue(resolve));
+		activeCount++;
+		try {
+			return await fn();
+		} finally {
+			activeCount--;
+			next();
+		}
+	};
+	return run;
+}
+//#endregion
+export { createLimiter };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/is-object.js

@@ -0,0 +1,26 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/object/is-object.js
+/**
+* Returns true if the provided value is a record object
+* (i.e. not null, not an array, and has an actual object as the prototype).
+*
+* Differs from the previous isObject in that it returns false for Date,
+* RegExp, Error, Map, Set, WeakMap, WeakSet, Promise, and other non-plain objects.
+*
+* Examples:
+*   isObject({})                  // true
+*   isObject({ a: 1 })            // true
+*   isObject([])                  // false (Array)
+*   isObject(null)                // false
+*   isObject(123)                 // false
+*   isObject('string')            // false
+*   isObject(new Error('test'))   // false
+*   isObject(new Date())          // false
+*   isObject(Object.create(null)) // true
+*/
+const isObject = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+//#endregion
+export { isObject };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/prevent-pollution.js

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/object/prevent-pollution.js
+/**
+* Set of dangerous keys that can be used for prototype pollution attacks.
+* These keys should never be used as property names in dynamic object operations.
+*/
+const PROTOTYPE_POLLUTION_KEYS = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+/**
+* Validates that a key is safe to use and does not pose a prototype pollution risk.
+* Throws an error if a dangerous key is detected.
+*
+* @param key - The key to validate
+* @param context - Optional context string to help identify where the validation failed
+* @throws {Error} If the key matches a known prototype pollution vector
+*
+* @example
+* ```ts
+* preventPollution('__proto__') // throws Error
+* preventPollution('safeName') // passes
+* preventPollution('constructor', 'operation update') // throws Error with context
+* ```
+*/
+const preventPollution = (key, context) => {
+	if (PROTOTYPE_POLLUTION_KEYS.has(key)) {
+		const errorMessage = context ? `Prototype pollution key detected: "${key}" in ${context}` : `Prototype pollution key detected: "${key}"`;
+		throw new Error(errorMessage);
+	}
+};
+//#endregion
+export { preventPollution };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/queue/queue.js

@@ -0,0 +1,106 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/queue/queue.js
+/**
+* Represents a node in a singly linked list structure, used internally by the Queue.
+*
+* Example:
+*   const node = new Node<number>(42);
+*   console.log(node.data); // 42
+*   console.log(node.next); // null
+*/
+var Node = class {
+	data;
+	next;
+	constructor(data) {
+		this.data = data;
+		this.next = null;
+	}
+};
+/**
+* A generic queue implementation using a singly linked list.
+*
+* Example usage:
+*
+*   const q = new Queue<number>();
+*   q.enqueue(1);
+*   q.enqueue(2);
+*   q.enqueue(3);
+*   console.log(q.dequeue()); // 1
+*   console.log(q.peek());    // 2
+*   console.log(q.getSize()); // 2
+*   console.log(q.toString()); // "2 -> 3"
+*   console.log(q.isEmpty()); // false
+*/
+var Queue = class {
+	front;
+	rear;
+	size;
+	constructor() {
+		this.front = null;
+		this.rear = null;
+		this.size = 0;
+	}
+	/**
+	* Adds an element to the end of the queue.
+	* @param data - The data to add to the queue.
+	*/
+	enqueue(data) {
+		const newNode = new Node(data);
+		if (this.isEmpty() || !this.rear) {
+			this.front = newNode;
+			this.rear = newNode;
+		} else {
+			this.rear.next = newNode;
+			this.rear = newNode;
+		}
+		this.size++;
+	}
+	/**
+	* Removes and returns the front element of the queue.
+	* @returns The data from the removed node, or null if the queue is empty.
+	*/
+	dequeue() {
+		if (this.isEmpty() || !this.front) return null;
+		const removedNode = this.front;
+		this.front = this.front.next;
+		if (this.front === null) this.rear = null;
+		this.size--;
+		return removedNode.data;
+	}
+	/**
+	* Returns the front element of the queue without removing it.
+	* @returns The front data, or null if the queue is empty.
+	*/
+	peek() {
+		if (this.isEmpty() || !this.front) return null;
+		return this.front.data;
+	}
+	/**
+	* Checks whether the queue is empty.
+	* @returns True if the queue has no elements, false otherwise.
+	*/
+	isEmpty() {
+		return this.size === 0;
+	}
+	/**
+	* Returns the number of elements in the queue.
+	* @returns The size of the queue.
+	*/
+	getSize() {
+		return this.size;
+	}
+	/**
+	* Returns a string representation of the queue.
+	* @returns Elements of the queue separated by ' -> '.
+	*/
+	toString() {
+		let current = this.front;
+		const elements = [];
+		while (current) {
+			elements.push(current.data);
+			current = current.next;
+		}
+		return elements.join(" -> ");
+	}
+};
+//#endregion
+export { Queue };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/string/generate-hash.js

@@ -0,0 +1,120 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/string/generate-hash.js
+/**
+* MurmurHash3 implementation
+*
+* Generate a hash from a string using the MurmurHash3 algorithm
+* Provides 64-bit hash output with excellent speed and distribution
+*
+* We had to move away from xxhash-wasm since it was causing issues with content security policy (CSP) violations.
+*
+* We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.
+*
+* @param input - The string to hash
+* @returns The 64-bit hash of the input string as a 16-character hex string
+*/
+const generateHash = (input) => {
+	const seed = 0;
+	let h1 = seed;
+	let h2 = seed;
+	const len = input.length;
+	const remainder = len & 15;
+	const bytes = len - remainder;
+	const c1 = 2277735313;
+	const c2 = 1291169091;
+	const c3 = 1390208809;
+	const c4 = 944331445;
+	for (let i = 0; i < bytes; i += 16) {
+		let k1 = input.charCodeAt(i) & 255 | (input.charCodeAt(i + 1) & 255) << 8 | (input.charCodeAt(i + 2) & 255) << 16 | (input.charCodeAt(i + 3) & 255) << 24;
+		let k2 = input.charCodeAt(i + 4) & 255 | (input.charCodeAt(i + 5) & 255) << 8 | (input.charCodeAt(i + 6) & 255) << 16 | (input.charCodeAt(i + 7) & 255) << 24;
+		let k3 = input.charCodeAt(i + 8) & 255 | (input.charCodeAt(i + 9) & 255) << 8 | (input.charCodeAt(i + 10) & 255) << 16 | (input.charCodeAt(i + 11) & 255) << 24;
+		let k4 = input.charCodeAt(i + 12) & 255 | (input.charCodeAt(i + 13) & 255) << 8 | (input.charCodeAt(i + 14) & 255) << 16 | (input.charCodeAt(i + 15) & 255) << 24;
+		k1 = Math.imul(k1, c1);
+		k1 = k1 << 15 | k1 >>> 17;
+		k1 = Math.imul(k1, c2);
+		h1 ^= k1;
+		h1 = h1 << 13 | h1 >>> 19;
+		h1 = Math.imul(h1, 5) + 3864292196;
+		k2 = Math.imul(k2, c2);
+		k2 = k2 << 16 | k2 >>> 16;
+		k2 = Math.imul(k2, c3);
+		h2 ^= k2;
+		h2 = h2 << 17 | h2 >>> 15;
+		h2 = Math.imul(h2, 5) + 461845907;
+		k3 = Math.imul(k3, c3);
+		k3 = k3 << 17 | k3 >>> 15;
+		k3 = Math.imul(k3, c4);
+		h1 ^= k3;
+		h1 = h1 << 15 | h1 >>> 17;
+		h1 = Math.imul(h1, 5) + 1390208809;
+		k4 = Math.imul(k4, c4);
+		k4 = k4 << 18 | k4 >>> 14;
+		k4 = Math.imul(k4, c1);
+		h2 ^= k4;
+		h2 = h2 << 13 | h2 >>> 19;
+		h2 = Math.imul(h2, 5) + 944331445;
+	}
+	if (remainder > 0) {
+		let k1 = 0;
+		let k2 = 0;
+		let k3 = 0;
+		let k4 = 0;
+		if (remainder >= 15) k4 ^= (input.charCodeAt(bytes + 14) & 255) << 16;
+		if (remainder >= 14) k4 ^= (input.charCodeAt(bytes + 13) & 255) << 8;
+		if (remainder >= 13) {
+			k4 ^= input.charCodeAt(bytes + 12) & 255;
+			k4 = Math.imul(k4, c4);
+			k4 = k4 << 18 | k4 >>> 14;
+			k4 = Math.imul(k4, c1);
+			h2 ^= k4;
+		}
+		if (remainder >= 12) k3 ^= (input.charCodeAt(bytes + 11) & 255) << 24;
+		if (remainder >= 11) k3 ^= (input.charCodeAt(bytes + 10) & 255) << 16;
+		if (remainder >= 10) k3 ^= (input.charCodeAt(bytes + 9) & 255) << 8;
+		if (remainder >= 9) {
+			k3 ^= input.charCodeAt(bytes + 8) & 255;
+			k3 = Math.imul(k3, c3);
+			k3 = k3 << 17 | k3 >>> 15;
+			k3 = Math.imul(k3, c4);
+			h1 ^= k3;
+		}
+		if (remainder >= 8) k2 ^= (input.charCodeAt(bytes + 7) & 255) << 24;
+		if (remainder >= 7) k2 ^= (input.charCodeAt(bytes + 6) & 255) << 16;
+		if (remainder >= 6) k2 ^= (input.charCodeAt(bytes + 5) & 255) << 8;
+		if (remainder >= 5) {
+			k2 ^= input.charCodeAt(bytes + 4) & 255;
+			k2 = Math.imul(k2, c2);
+			k2 = k2 << 16 | k2 >>> 16;
+			k2 = Math.imul(k2, c3);
+			h2 ^= k2;
+		}
+		if (remainder >= 4) k1 ^= (input.charCodeAt(bytes + 3) & 255) << 24;
+		if (remainder >= 3) k1 ^= (input.charCodeAt(bytes + 2) & 255) << 16;
+		if (remainder >= 2) k1 ^= (input.charCodeAt(bytes + 1) & 255) << 8;
+		if (remainder >= 1) {
+			k1 ^= input.charCodeAt(bytes) & 255;
+			k1 = Math.imul(k1, c1);
+			k1 = k1 << 15 | k1 >>> 17;
+			k1 = Math.imul(k1, c2);
+			h1 ^= k1;
+		}
+	}
+	h1 ^= len;
+	h2 ^= len;
+	h1 += h2;
+	h2 += h1;
+	h1 ^= h1 >>> 16;
+	h1 = Math.imul(h1, 2246822507);
+	h1 ^= h1 >>> 13;
+	h1 = Math.imul(h1, 3266489909);
+	h1 ^= h1 >>> 16;
+	h2 ^= h2 >>> 16;
+	h2 = Math.imul(h2, 2246822507);
+	h2 ^= h2 >>> 13;
+	h2 = Math.imul(h2, 3266489909);
+	h2 ^= h2 >>> 16;
+	h1 += h2;
+	h2 += h1;
+	return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+};
+//#endregion
+export { generateHash };

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 };