fumadocs-openapi 10.6.8 → 10.7.0

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

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

@@ -0,0 +1,42 @@
+import { getId } from "./get-schemas.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/get-value-by-path.js
+/**
+* Traverses an object using an array of string segments (path keys) and returns
+* the value at the specified path along with its context (id if available).
+*
+* @param target - The root object to traverse.
+* @param segments - An array of string keys representing the path to traverse.
+* @returns An object containing the final context (id or previous context) and the value at the path.
+*
+* @example
+* const obj = {
+*   foo: {
+*     bar: {
+*       baz: 42
+*     }
+*   }
+* };
+* // Returns: { context: '', value: 42 }
+* getValueByPath(obj, ['foo', 'bar', 'baz']);
+*/
+function getValueByPath(target, segments) {
+	return segments.reduce((acc, key) => {
+		if (acc.value === void 0) return {
+			context: "",
+			value: void 0
+		};
+		if (typeof acc.value !== "object" || acc.value === null) return {
+			context: "",
+			value: void 0
+		};
+		return {
+			context: getId(acc.value) ?? acc.context,
+			value: acc.value?.[key]
+		};
+	}, {
+		context: "",
+		value: target
+	});
+}
+//#endregion
+export { getValueByPath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-file-path.js

@@ -0,0 +1,23 @@
+import { isHttpUrl } from "./is-http-url.js";
+import { isJsonObject } from "./is-json-object.js";
+import { isYaml } from "./is-yaml.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-file-path.js
+/**
+* Checks if a string represents a file path by ensuring it's not a remote URL,
+* YAML content, or JSON content.
+*
+* @param value - The string to check
+* @returns true if the string appears to be a file path, false otherwise
+* @example
+* ```ts
+* isFilePath('./schemas/user.json') // true
+* isFilePath('https://example.com/schema.json') // false
+* isFilePath('{"type": "object"}') // false
+* isFilePath('type: object') // false
+* ```
+*/
+function isFilePath(value) {
+	return !isHttpUrl(value) && !isYaml(value) && !isJsonObject(value);
+}
+//#endregion
+export { isFilePath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-http-url.js

@@ -0,0 +1,23 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-http-url.js
+/**
+* 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
+* isHttpUrl('https://example.com/schema.json') // true
+* isHttpUrl('http://api.example.com/schemas/user.json') // true
+* isHttpUrl('#/components/schemas/User') // false
+* isHttpUrl('./local-schema.json') // false
+* ```
+*/
+function isHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { isHttpUrl };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-json-object.js

@@ -0,0 +1,28 @@
+import { isObject } from "../../../../../../@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/is-object.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-json-object.js
+/**
+* Determines if a string represents a valid JSON object (i.e., a plain object, not an array, primitive, or null).
+* The function first checks if the string appears to start with an opening curly brace (ignoring leading whitespace),
+* which is a quick heuristic to rule out arrays, primitives, and most invalid JSON. If this check passes,
+* it attempts to parse the string with JSON.parse. The result is then checked to ensure it is a plain object
+* (not an array, null, or primitive) using the isObject utility.
+*
+* @param value - The string to evaluate
+* @returns true if the string is valid JSON and parses to a plain object, false otherwise
+*
+* @example
+* isJsonObject('{"foo": "bar"}') // true
+* isJsonObject('[1,2,3]') // false
+* isJsonObject('not json') // false
+* isJsonObject('42') // false
+*/
+function isJsonObject(value) {
+	if (!/^\s*(\{)/.test(value.slice(0, 500))) return false;
+	try {
+		return isObject(JSON.parse(value));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { isJsonObject };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-yaml.js

@@ -0,0 +1,21 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-yaml.js
+/**
+* Checks if a string appears to be YAML content.
+* This function uses a simple heuristic: it looks for a line that starts with an optional dash,
+* followed by a key (alphanumeric or dash), a colon, and a value, and then at least one more line.
+* This is not a full YAML parser, but works for basic detection.
+*
+* @param value - The string to check
+* @returns true if the string looks like YAML, false otherwise
+*
+* @example
+* isYaml('openapi: 3.0.0\ninfo:\n  title: Example') // true
+* isYaml('{"openapi": "3.0.0", "info": {"title": "Example"}}') // false
+* isYaml('- name: value\n- name: value2') // true
+* isYaml('type: object') // false (only one line)
+*/
+function isYaml(value) {
+	return /^\s*(?:-\s*)?[\w\-]+\s*:\s*.+\n.*/.test(value);
+}
+//#endregion
+export { isYaml };

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

@@ -0,0 +1,26 @@
+import { parse } from "../../../../../../yaml@2.8.3/node_modules/yaml/browser/dist/public-api.js";
+import "../../../../../../yaml@2.8.3/node_modules/yaml/browser/index.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/normalize.js
+/**
+* Normalize a string (YAML, JSON, object) to a JavaScript datatype.
+*/
+function normalize(content) {
+	if (content === null) return;
+	if (typeof content === "string") {
+		if (content.trim() === "") return;
+		try {
+			return JSON.parse(content);
+		} catch (_error) {
+			const hasColon = /^[^:]+:/.test(content);
+			const isJson = content.slice(0, 50).trimStart().startsWith("{");
+			if (!hasColon || isJson) return;
+			return parse(content, {
+				maxAliasCount: 1e4,
+				merge: true
+			});
+		}
+	}
+	return content;
+}
+//#endregion
+export { normalize };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/resolve-reference-path.js

@@ -0,0 +1,30 @@
+import { isHttpUrl } from "./is-http-url.js";
+import { posix } from "../../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/resolve-reference-path.js
+/**
+* Resolves a reference path by combining a base path with a relative path.
+* Handles both remote URLs and local file paths.
+*
+* @param base - The base path (can be a URL or local file path)
+* @param relativePath - The relative path to resolve against the base
+* @returns The resolved absolute path
+* @example
+* // Resolve remote URL
+* resolveReferencePath('https://example.com/api/schema.json', 'user.json')
+* // Returns: 'https://example.com/api/user.json'
+*
+* // Resolve local path
+* resolveReferencePath('/path/to/schema.json', 'user.json')
+* // Returns: '/path/to/user.json'
+*/
+const resolveReferencePath = (base, relativePath) => {
+	if (isHttpUrl(relativePath)) return relativePath;
+	if (isHttpUrl(base)) {
+		const baseUrl = new URL(base);
+		baseUrl.pathname = posix.posix.resolve("/", posix.dirname(baseUrl.pathname), relativePath);
+		return baseUrl.toString();
+	}
+	return posix.resolve(posix.dirname(base), relativePath);
+};
+//#endregion
+export { resolveReferencePath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/set-value-at-path.js

@@ -0,0 +1,70 @@
+import { preventPollution } from "../../../../../../@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/prevent-pollution.js";
+import { getSegmentsFromPath } from "./get-segments-from-path.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/set-value-at-path.js
+/**
+* Sets a value at a specified path in an object, creating intermediate objects/arrays as needed.
+* This function traverses the object structure and creates any missing intermediate objects
+* or arrays based on the path segments. If the next segment is a numeric string, it creates
+* an array instead of an object.
+*
+* ⚠️ Warning: Be careful with object keys that look like numbers (e.g. "123") as this function
+* will interpret them as array indices and create arrays instead of objects. If you need to
+* use numeric-looking keys, consider prefixing them with a non-numeric character.
+*
+* @param obj - The target object to set the value in
+* @param path - The JSON pointer path where the value should be set
+* @param value - The value to set at the specified path
+* @throws {Error} If attempting to set a value at the root path ('')
+*
+* @example
+* const obj = {}
+* setValueAtPath(obj, '/foo/bar/0', 'value')
+* // Result:
+* // {
+* //   foo: {
+* //     bar: ['value']
+* //   }
+* // }
+*
+* @example
+* const obj = { existing: { path: 'old' } }
+* setValueAtPath(obj, '/existing/path', 'new')
+* // Result:
+* // {
+* //   existing: {
+* //     path: 'new'
+* //   }
+* // }
+*
+* @example
+* // ⚠️ Warning: This will create an array instead of an object with key "123"
+* setValueAtPath(obj, '/foo/123/bar', 'value')
+* // Result:
+* // {
+* //   foo: [
+* //     undefined,
+* //     undefined,
+* //     undefined,
+* //     { bar: 'value' }
+* //   ]
+* // }
+*/
+function setValueAtPath(obj, path, value) {
+	if (path === "") throw new Error("Cannot set value at root ('') pointer");
+	const parts = getSegmentsFromPath(path);
+	parts.forEach((part) => preventPollution(part));
+	let current = obj;
+	for (let i = 0; i < parts.length; i++) {
+		const key = parts[i];
+		const isLast = i === parts.length - 1;
+		const nextKey = parts[i + 1];
+		const shouldBeArray = /^\d+$/.test(nextKey ?? "");
+		if (isLast) current[key] = value;
+		else {
+			if (!(key in current) || typeof current[key] !== "object") current[key] = shouldBeArray ? [] : {};
+			current = current[key];
+		}
+	}
+}
+//#endregion
+export { setValueAtPath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/to-relative-path.js

@@ -0,0 +1,33 @@
+import { isHttpUrl } from "./is-http-url.js";
+import { posix } from "../../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/to-relative-path.js
+/**
+* Converts an input path or URL to a relative path based on the provided base.
+* Handles both remote URLs and local file system paths.
+* - If both input and base are remote URLs and share the same origin, computes the relative pathname.
+* - If base is a remote URL but input is local, returns a remote URL with a relative pathname.
+* - If input is a remote URL but base is local, returns input as is.
+* - Otherwise, computes the relative path between two local paths.
+*/
+const toRelativePath = (input, base) => {
+	if (isHttpUrl(input) && isHttpUrl(base)) {
+		const inputUrl = new URL(input);
+		const baseUrl = new URL(base);
+		if (inputUrl.origin !== baseUrl.origin) return input;
+		const baseDir = posix.dirname(posix.posix.resolve("/", baseUrl.pathname));
+		const inputPath = posix.posix.resolve("/", inputUrl.pathname);
+		return posix.posix.relative(baseDir, inputPath);
+	}
+	if (isHttpUrl(base)) {
+		const baseUrl = new URL(base);
+		const baseDir = posix.dirname(posix.posix.resolve("/", baseUrl.pathname));
+		baseUrl.pathname = posix.posix.relative(baseDir, posix.posix.resolve("/", input));
+		return baseUrl.toString();
+	}
+	if (isHttpUrl(input)) return input;
+	const baseDir = posix.dirname(posix.resolve(base));
+	const inputPath = posix.resolve(input);
+	return posix.relative(baseDir, inputPath);
+};
+//#endregion
+export { toRelativePath };

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

@@ -0,0 +1,12 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/unescape-json-pointer.js
+/**
+* Unescape JSON pointer
+*
+* Examples:
+* /foo~1bar~0baz -> /foo/bar~baz
+*/
+function unescapeJsonPointer(uri) {
+	return decodeURI(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+//#endregion
+export { unescapeJsonPointer };