@fumadocs/api-docs 0.0.1

package/dist/node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js

@@ -0,0 +1,282 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {(value: string) => boolean} */
+	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+	/**
+	* @param {Array<string>} input
+	* @returns {string}
+	*/
+	function stringArrayToHexStripped(input) {
+		let acc = "";
+		let code = 0;
+		let i = 0;
+		for (i = 0; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (code === 48) continue;
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+			break;
+		}
+		for (i += 1; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+		}
+		return acc;
+	}
+	/**
+	* @typedef {Object} GetIPV6Result
+	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
+	* @property {string} address - The parsed IPv6 address.
+	* @property {string} [zone] - The zone identifier, if present.
+	*/
+	/**
+	* @param {string} value
+	* @returns {boolean}
+	*/
+	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+	/**
+	* @param {Array<string>} buffer
+	* @returns {boolean}
+	*/
+	function consumeIsZone(buffer) {
+		buffer.length = 0;
+		return true;
+	}
+	/**
+	* @param {Array<string>} buffer
+	* @param {Array<string>} address
+	* @param {GetIPV6Result} output
+	* @returns {boolean}
+	*/
+	function consumeHextets(buffer, address, output) {
+		if (buffer.length) {
+			const hex = stringArrayToHexStripped(buffer);
+			if (hex !== "") address.push(hex);
+			else {
+				output.error = true;
+				return false;
+			}
+			buffer.length = 0;
+		}
+		return true;
+	}
+	/**
+	* @param {string} input
+	* @returns {GetIPV6Result}
+	*/
+	function getIPV6(input) {
+		let tokenCount = 0;
+		const output = {
+			error: false,
+			address: "",
+			zone: ""
+		};
+		/** @type {Array<string>} */
+		const address = [];
+		/** @type {Array<string>} */
+		const buffer = [];
+		let endipv6Encountered = false;
+		let endIpv6 = false;
+		let consume = consumeHextets;
+		for (let i = 0; i < input.length; i++) {
+			const cursor = input[i];
+			if (cursor === "[" || cursor === "]") continue;
+			if (cursor === ":") {
+				if (endipv6Encountered === true) endIpv6 = true;
+				if (!consume(buffer, address, output)) break;
+				if (++tokenCount > 7) {
+					output.error = true;
+					break;
+				}
+				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
+				address.push(":");
+				continue;
+			} else if (cursor === "%") {
+				if (!consume(buffer, address, output)) break;
+				consume = consumeIsZone;
+			} else {
+				buffer.push(cursor);
+				continue;
+			}
+		}
+		if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
+		else if (endIpv6) address.push(buffer.join(""));
+		else address.push(stringArrayToHexStripped(buffer));
+		output.address = address.join("");
+		return output;
+	}
+	/**
+	* @typedef {Object} NormalizeIPv6Result
+	* @property {string} host - The normalized host.
+	* @property {string} [escapedHost] - The escaped host.
+	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	*/
+	/**
+	* @param {string} host
+	* @returns {NormalizeIPv6Result}
+	*/
+	function normalizeIPv6(host) {
+		if (findToken(host, ":") < 2) return {
+			host,
+			isIPV6: false
+		};
+		const ipv6 = getIPV6(host);
+		if (!ipv6.error) {
+			let newHost = ipv6.address;
+			let escapedHost = ipv6.address;
+			if (ipv6.zone) {
+				newHost += "%" + ipv6.zone;
+				escapedHost += "%25" + ipv6.zone;
+			}
+			return {
+				host: newHost,
+				isIPV6: true,
+				escapedHost
+			};
+		} else return {
+			host,
+			isIPV6: false
+		};
+	}
+	/**
+	* @param {string} str
+	* @param {string} token
+	* @returns {number}
+	*/
+	function findToken(str, token) {
+		let ind = 0;
+		for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
+		return ind;
+	}
+	/**
+	* @param {string} path
+	* @returns {string}
+	*
+	* @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+	*/
+	function removeDotSegments(path) {
+		let input = path;
+		const output = [];
+		let nextSlash = -1;
+		let len = 0;
+		while (len = input.length) {
+			if (len === 1) if (input === ".") break;
+			else if (input === "/") {
+				output.push("/");
+				break;
+			} else {
+				output.push(input);
+				break;
+			}
+			else if (len === 2) {
+				if (input[0] === ".") {
+					if (input[1] === ".") break;
+					else if (input[1] === "/") {
+						input = input.slice(2);
+						continue;
+					}
+				} else if (input[0] === "/") {
+					if (input[1] === "." || input[1] === "/") {
+						output.push("/");
+						break;
+					}
+				}
+			} else if (len === 3) {
+				if (input === "/..") {
+					if (output.length !== 0) output.pop();
+					output.push("/");
+					break;
+				}
+			}
+			if (input[0] === ".") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(3);
+						continue;
+					}
+				} else if (input[1] === "/") {
+					input = input.slice(2);
+					continue;
+				}
+			} else if (input[0] === "/") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(2);
+						continue;
+					} else if (input[2] === ".") {
+						if (input[3] === "/") {
+							input = input.slice(3);
+							if (output.length !== 0) output.pop();
+							continue;
+						}
+					}
+				}
+			}
+			if ((nextSlash = input.indexOf("/", 1)) === -1) {
+				output.push(input);
+				break;
+			} else {
+				output.push(input.slice(0, nextSlash));
+				input = input.slice(nextSlash);
+			}
+		}
+		return output.join("");
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @param {boolean} esc
+	* @returns {import('../types/index').URIComponent}
+	*/
+	function normalizeComponentEncoding(component, esc) {
+		const func = esc !== true ? escape : unescape;
+		if (component.scheme !== void 0) component.scheme = func(component.scheme);
+		if (component.userinfo !== void 0) component.userinfo = func(component.userinfo);
+		if (component.host !== void 0) component.host = func(component.host);
+		if (component.path !== void 0) component.path = func(component.path);
+		if (component.query !== void 0) component.query = func(component.query);
+		if (component.fragment !== void 0) component.fragment = func(component.fragment);
+		return component;
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @returns {string|undefined}
+	*/
+	function recomposeAuthority(component) {
+		const uriTokens = [];
+		if (component.userinfo !== void 0) {
+			uriTokens.push(component.userinfo);
+			uriTokens.push("@");
+		}
+		if (component.host !== void 0) {
+			let host = unescape(component.host);
+			if (!isIPv4(host)) {
+				const ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
+				else host = component.host;
+			}
+			uriTokens.push(host);
+		}
+		if (typeof component.port === "number" || typeof component.port === "string") {
+			uriTokens.push(":");
+			uriTokens.push(String(component.port));
+		}
+		return uriTokens.length ? uriTokens.join("") : void 0;
+	}
+	module.exports = {
+		nonSimpleDomain,
+		recomposeAuthority,
+		normalizeComponentEncoding,
+		removeDotSegments,
+		isIPv4,
+		isUUID,
+		normalizeIPv6,
+		stringArrayToHexStripped
+	};
+}));
+//#endregion
+export default require_utils();
+export { require_utils };

package/dist/node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js

@@ -0,0 +1,78 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
+var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var traverse = module.exports = function(schema, opts, cb) {
+		if (typeof opts == "function") {
+			cb = opts;
+			opts = {};
+		}
+		cb = opts.cb || cb;
+		var pre = typeof cb == "function" ? cb : cb.pre || function() {};
+		var post = cb.post || function() {};
+		_traverse(opts, pre, post, schema, "", schema);
+	};
+	traverse.keywords = {
+		additionalItems: true,
+		items: true,
+		contains: true,
+		additionalProperties: true,
+		propertyNames: true,
+		not: true,
+		if: true,
+		then: true,
+		else: true
+	};
+	traverse.arrayKeywords = {
+		items: true,
+		allOf: true,
+		anyOf: true,
+		oneOf: true
+	};
+	traverse.propsKeywords = {
+		$defs: true,
+		definitions: true,
+		properties: true,
+		patternProperties: true,
+		dependencies: true
+	};
+	traverse.skipKeywords = {
+		default: true,
+		enum: true,
+		const: true,
+		required: true,
+		maximum: true,
+		minimum: true,
+		exclusiveMaximum: true,
+		exclusiveMinimum: true,
+		multipleOf: true,
+		maxLength: true,
+		minLength: true,
+		pattern: true,
+		format: true,
+		maxItems: true,
+		minItems: true,
+		uniqueItems: true,
+		maxProperties: true,
+		minProperties: true
+	};
+	function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+		if (schema && typeof schema == "object" && !Array.isArray(schema)) {
+			pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+			for (var key in schema) {
+				var sch = schema[key];
+				if (Array.isArray(sch)) {
+					if (key in traverse.arrayKeywords) for (var i = 0; i < sch.length; i++) _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+				} else if (key in traverse.propsKeywords) {
+					if (sch && typeof sch == "object") for (var prop in sch) _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+				} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+			}
+			post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+		}
+	}
+	function escapeJsonPtr(str) {
+		return str.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+}));
+//#endregion
+export default require_json_schema_traverse();
+export { require_json_schema_traverse };

package/dist/schema/bundle.d.ts

@@ -0,0 +1,2 @@
+import { bundle } from "../node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.js";
+export { bundle };

package/dist/schema/bundle.js

@@ -0,0 +1,2 @@
+import { bundle } from "../node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.js";
+export { bundle };

package/dist/schema/dereference.d.ts

@@ -0,0 +1,19 @@
+import { NoReferenceSwallow } from "./index.js";
+import { JSONSchema } from "json-schema-typed/draft-2020-12";
+
+//#region src/schema/dereference.d.ts
+interface DereferenceOptions {
+  /**
+   * Return `true` to keep the Reference Object at `pointer` without inlining.
+   */
+  preserveRef?: (pointer: string) => boolean;
+  setOriginalRef?: (schema: JSONSchema, ref: string) => void;
+}
+/**
+ * Resolves all $ref pointers in a schema and returns a new schema without any $ref pointers,
+ * except at locations where `preserveRef` returns `true`.
+ */
+declare function dereferenceSync(schema: JSONSchema, options?: DereferenceOptions): JSONSchema;
+declare function dereferenceShallow<T>(schema: T, full: unknown): NoReferenceSwallow<T>;
+//#endregion
+export { DereferenceOptions, dereferenceShallow, dereferenceSync };

package/dist/schema/dereference.js

@@ -0,0 +1,49 @@
+import { appendInternalRefPath } from "./ref.js";
+import { isPlainObject } from "../utils/is-plain-object.js";
+import { resolveRefSync } from "./resolve-ref.js";
+//#region src/schema/dereference.ts
+/**
+* Resolves all $ref pointers in a schema and returns a new schema without any $ref pointers,
+* except at locations where `preserveRef` returns `true`.
+*/
+function dereferenceSync(schema, options = {}) {
+	const { preserveRef, setOriginalRef = () => {} } = options;
+	if (typeof schema === "boolean") return schema;
+	const visitedNodes = /* @__PURE__ */ new Set();
+	const cloned = structuredClone(schema);
+	function resolve(current, pointer) {
+		if (visitedNodes.has(current)) return current;
+		visitedNodes.add(current);
+		if (Array.isArray(current)) for (let index = 0; index < current.length; index++) current[index] = resolve(current[index], appendInternalRefPath(pointer, index));
+		else if (isPlainObject(current)) {
+			if (typeof current.$ref === "string") {
+				if (preserveRef?.(pointer)) return current;
+				const ref = current["$ref"];
+				delete current["$ref"];
+				const resolved = resolve(resolveRefSync(ref, cloned), pointer);
+				setOriginalRef(resolved, ref);
+				setOriginalRef(current, ref);
+				if (typeof resolved === "boolean") throw new Error("invalid schema");
+				for (const k in resolved) if (!(k in current)) current[k] = resolved[k];
+			}
+			for (const key in current) current[key] = resolve(current[key], appendInternalRefPath(pointer, key));
+		}
+		return current;
+	}
+	return resolve(cloned, "#");
+}
+function dereferenceShallow(schema, full) {
+	if (isPlainObject(schema)) {
+		if (typeof schema.$ref !== "string") return schema;
+		const { $ref, ...rest } = schema;
+		const resolved = dereferenceShallow(resolveRefSync($ref, full), full);
+		if (typeof resolved !== "object") throw new Error(`invalid schema referenced via "${$ref}"`);
+		return {
+			...resolved,
+			...rest
+		};
+	}
+	return schema;
+}
+//#endregion
+export { dereferenceShallow, dereferenceSync };

package/dist/schema/index.d.ts

@@ -0,0 +1,21 @@
+import { JSONSchema } from "json-schema-typed/draft-2020-12";
+
+//#region src/schema/index.d.ts
+type ReferenceObject = {
+  $ref: string;
+};
+type NoReference<T> = T extends (infer I)[] ? NoReference<I>[] : T extends ReferenceObject ? Exclude<T, ReferenceObject> : T extends object ? { [K in keyof T]: NoReference<T[K]> } : T;
+type NoReferenceSwallow<T> = T extends ReferenceObject ? Exclude<T, ReferenceObject> : T;
+type ParsedSchema = (JSONSchema & {
+  'x-playground-lazy'?: boolean;
+  discriminator?: {
+    propertyName?: string;
+    mapping?: Record<string, string>;
+  };
+}) | boolean;
+type SchemaResolver = (schema: ParsedSchema) => {
+  /** shallowly dereferenced schema */dereferenced: ParsedSchema; /** the ref value (if dereferenced) */
+  $ref?: string;
+};
+//#endregion
+export { NoReference, NoReferenceSwallow, ParsedSchema, SchemaResolver };

package/dist/schema/merge.d.ts

@@ -0,0 +1,12 @@
+import { ParsedSchema } from "./index.js";
+
+//#region src/schema/merge.d.ts
+interface Options {
+  dereference?: (schema: ParsedSchema) => ParsedSchema | undefined;
+}
+/**
+ * Merge `allOf` object schema
+ */
+declare function mergeAllOf(schema: ParsedSchema, options?: Options): ParsedSchema;
+//#endregion
+export { mergeAllOf };

package/dist/schema/merge.js

@@ -0,0 +1,156 @@
+import { deepEqual } from "../utils/deep-equal.js";
+//#region src/schema/merge.ts
+/**
+* Merge `allOf` object schema
+*/
+function mergeAllOf(schema, options = {}) {
+	if (typeof schema === "boolean") return schema;
+	const { dereference } = options;
+	if (dereference && "$ref" in schema && typeof schema.$ref === "string") schema = dereference(schema) ?? schema;
+	if (typeof schema === "boolean" || !schema.allOf) return schema;
+	const { allOf, ...rest } = schema;
+	let result = rest;
+	for (const item of allOf) result = intersection(result, item, options);
+	return result;
+}
+function intersection(a, b, options) {
+	a = mergeAllOf(a, options);
+	b = mergeAllOf(b, options);
+	if (typeof a === "boolean" && typeof b === "boolean") return a && b;
+	if (typeof a === "boolean") return a;
+	if (typeof b === "boolean") return b;
+	for (const unionField of ["anyOf", "oneOf"]) {
+		if (a[unionField] === void 0 && b[unionField] !== void 0) return {
+			...b,
+			[unionField]: b[unionField].map((item) => intersection(item, a, options))
+		};
+		if (a[unionField] !== void 0 && b[unionField] === void 0) return {
+			...a,
+			[unionField]: a[unionField].map((item) => intersection(item, b, options))
+		};
+	}
+	const result = { ...a };
+	for (const _k in b) {
+		const key = _k;
+		switch (key) {
+			case "$id":
+			case "$comment":
+			case "description":
+			case "examples":
+			case "allOf":
+			case "writeOnly":
+			case "readOnly": break;
+			case "title": {
+				const value = b[key];
+				if (value === void 0) break;
+				if (result[key]) result[key] = `${result[key]} & ${value}`;
+				else result[key] = value;
+				break;
+			}
+			case "minItems":
+			case "minimum":
+			case "exclusiveMinimum":
+			case "minProperties":
+			case "minContains":
+			case "minLength": {
+				const value = b[key];
+				if (value === void 0) break;
+				result[key] = result[key] === void 0 ? value : Math.max(result[key], value);
+				break;
+			}
+			case "maxContains":
+			case "maxItems":
+			case "maxLength":
+			case "maxProperties":
+			case "maximum":
+			case "exclusiveMaximum": {
+				const value = b[key];
+				if (value === void 0) break;
+				result[key] = result[key] === void 0 ? value : Math.min(result[key], value);
+				break;
+			}
+			case "enum": {
+				const value = b[key];
+				if (value === void 0) break;
+				result[key] = result[key] === void 0 ? value : intersectArray(result[key], value);
+				break;
+			}
+			case "anyOf":
+			case "oneOf": {
+				const value = b[key];
+				if (value !== void 0 && result[key] !== void 0) {
+					const product = [];
+					for (const aItem of result[key]) for (const bItem of value) {
+						const merged = intersection(aItem, bItem, options);
+						if (merged !== false) product.push(merged);
+					}
+					result[key] = product;
+				}
+				break;
+			}
+			case "format":
+			case "const":
+			case "type": {
+				const value = b[key];
+				if (value === void 0) break;
+				result[key] ??= value;
+				if (!deepEqual(result[key], value)) return false;
+				break;
+			}
+			case "required": {
+				const value = b[key];
+				if (value === void 0) break;
+				result[key] = [...result[key] ?? [], ...value];
+				break;
+			}
+			case "properties":
+			case "patternProperties": {
+				const value = b[key];
+				if (value === void 0) break;
+				if (result[key] === void 0) {
+					result[key] = value;
+					break;
+				}
+				const out = {};
+				const allProps = /* @__PURE__ */ new Set();
+				for (const k in result[key]) allProps.add(k);
+				for (const k in value) allProps.add(k);
+				for (const prop of allProps) {
+					const aProp = result[key][prop];
+					const bProp = value[prop];
+					if (aProp === void 0) out[prop] = bProp;
+					else if (bProp === void 0) out[prop] = aProp;
+					else out[prop] = intersection(aProp, bProp, options);
+				}
+				result[key] = out;
+				break;
+			}
+			case "additionalProperties":
+			case "additionalItems":
+			case "contains":
+			case "items": {
+				const value = b[key];
+				if (value === void 0) break;
+				result[key] = result[key] === void 0 ? value : intersection(result[key], value, options);
+				break;
+			}
+			case "not": {
+				const value = b[key];
+				if (value === void 0) break;
+				if (result[key] && value) result.not = { anyOf: [result[key], value] };
+				else if (value) result.not = value;
+				break;
+			}
+			default: result[key] = b[key];
+		}
+	}
+	return result;
+}
+function intersectArray(a, b) {
+	const out = /* @__PURE__ */ new Set();
+	for (const item of a) if (b.includes(item)) out.add(item);
+	for (const item of b) if (a.includes(item)) out.add(item);
+	return Array.from(out);
+}
+//#endregion
+export { mergeAllOf };

package/dist/schema/ref.d.ts

@@ -0,0 +1,20 @@
+//#region src/schema/ref.d.ts
+/**
+ * RFC 6901 reference-token encoding for JSON Pointer fragments used in in-document `$ref` (`#/…`).
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc6901
+ */
+/**
+ * Build an in-document `$ref` string from logical path segments (e.g. `['components','schemas','Pet']` → `#/components/schemas/Pet`).
+ */
+declare function encodeInternalRef(segments: readonly string[]): string;
+/**
+ * Append a segment to an in-document JSON Pointer (e.g. `#` + `components` → `#/components`).
+ */
+declare function appendInternalRefPath(base: string, segment: string | number): string;
+/**
+ * Parse an in-document `$ref` (`#/…`) into decoded path segments for walking the root document.
+ */
+declare function decodeInternalRef(ref: string): string[];
+//#endregion
+export { appendInternalRefPath, decodeInternalRef, encodeInternalRef };

package/dist/schema/ref.js

@@ -0,0 +1,43 @@
+//#region src/schema/ref.ts
+/**
+* RFC 6901 reference-token encoding for JSON Pointer fragments used in in-document `$ref` (`#/…`).
+*
+* @see https://datatracker.ietf.org/doc/html/rfc6901
+*/
+function encodeSegment(segment) {
+	return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function decodeSegment(segment) {
+	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+/**
+* Build an in-document `$ref` string from logical path segments (e.g. `['components','schemas','Pet']` → `#/components/schemas/Pet`).
+*/
+function encodeInternalRef(segments) {
+	if (segments.length === 0) return "#/";
+	return `#/${segments.map(encodeSegment).join("/")}`;
+}
+/**
+* Append a segment to an in-document JSON Pointer (e.g. `#` + `components` → `#/components`).
+*/
+function appendInternalRefPath(base, segment) {
+	const encoded = encodeSegment(String(segment));
+	if (base === "#") return `#/${encoded}`;
+	return `${base}/${encoded}`;
+}
+/**
+* Parse an in-document `$ref` (`#/…`) into decoded path segments for walking the root document.
+*/
+function decodeInternalRef(ref) {
+	if (!ref.startsWith("#")) throw new Error("expected in-document $ref starting with `#`");
+	const raw = ref.slice(1);
+	const out = [];
+	if (raw.length === 0) return out;
+	for (const token of raw.split("/")) {
+		if (token.length === 0) continue;
+		out.push(decodeSegment(token));
+	}
+	return out;
+}
+//#endregion
+export { appendInternalRefPath, decodeInternalRef, encodeInternalRef };