fumadocs-openapi 10.10.1 → 10.10.2

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

@@ -1,120 +0,0 @@
-//#region ../../node_modules/.pnpm/@scalar+helpers@0.8.0/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.14/node_modules/@scalar/json-magic/dist/bundle/bundle.js

@@ -1,357 +0,0 @@
-import { isObject } from "../../../../../../@scalar_helpers@0.8.0/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.14/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 = {
-	/**
-	* Custom OpenAPI extension key used to store external references.
-	* This key will contain all bundled external documents.
-	* The x-ext key is used to maintain a clean separation between the main
-	* OpenAPI document and its bundled external references.
-	*/
-	externalDocuments: "x-ext",
-	/**
-	* Custom OpenAPI extension key used to maintain a mapping between
-	* hashed keys and their original URLs in x-ext.
-	* This mapping is essential for tracking the source of bundled references
-	*/
-	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.14/node_modules/@scalar/json-magic/dist/bundle/plugins/fetch-urls/index.js

@@ -1,73 +0,0 @@
-import { isHttpUrl } from "../../../helpers/is-http-url.js";
-import { createLimiter } from "../../../../../../../../@scalar_helpers@0.8.0/node_modules/@scalar/helpers/dist/general/create-limiter.js";
-import { normalize } from "../../../helpers/normalize.js";
-//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.14/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.14/node_modules/@scalar/json-magic/dist/bundle/plugins/node.js

@@ -1,3 +0,0 @@
-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.14/node_modules/@scalar/json-magic/dist/bundle/plugins/parse-yaml/index.js

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

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

@@ -1,51 +0,0 @@
-import { isFilePath } from "../../../helpers/is-file-path.js";
-import { normalize } from "../../../helpers/normalize.js";
-//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.14/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 };