@fumadocs/api-docs 0.0.1

package/dist/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/util/url.js

@@ -0,0 +1,315 @@
+import convertPathToPosix from "./convert-path-to-posix.js";
+import { isWindows } from "./is-windows.js";
+//#region ../../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/util/url.js
+const forwardSlashPattern = /\//g;
+const protocolPattern = /^(\w{2,}):\/\//i;
+const jsonPointerSlash = /~1/g;
+const jsonPointerTilde = /~0/g;
+const isAbsoluteWin32Path = /^[a-zA-Z]:[\\/]/;
+const urlEncodePatterns = [[/\?/g, "%3F"], [/#/g, "%23"]];
+const urlDecodePatterns = [
+	/%23/g,
+	"#",
+	/%24/g,
+	"$",
+	/%26/g,
+	"&",
+	/%2C/g,
+	",",
+	/%40/g,
+	"@"
+];
+const parse = (u) => new URL(u);
+/**
+* Returns resolved target URL relative to a base URL in a manner similar to that of a Web browser resolving an anchor tag HREF.
+*
+* @returns
+*/
+function resolve(from, to) {
+	const fromUrl = new URL(convertPathToPosix(from), "https://aaa.nonexistanturl.com");
+	const resolvedUrl = new URL(convertPathToPosix(to), fromUrl);
+	const endSpaces = to.match(/(\s*)$/)?.[1] || "";
+	if (resolvedUrl.hostname === "aaa.nonexistanturl.com") {
+		const { pathname, search, hash } = resolvedUrl;
+		return pathname + search + decodeURIComponent(hash) + endSpaces;
+	}
+	const resolved = resolvedUrl.toString() + endSpaces;
+	if (resolved.includes("#")) {
+		const [base, hash] = resolved.split("#", 2);
+		return base + "#" + decodeURIComponent(hash || "");
+	}
+	return resolved;
+}
+/**
+* Returns the current working directory (in Node) or the current page URL (in browsers).
+*
+* @returns
+*/
+function cwd() {
+	if (typeof window !== "undefined" && window.location && window.location.href) {
+		const href = window.location.href;
+		if (!href || !href.startsWith("http")) try {
+			new URL(href);
+			return href;
+		} catch {
+			return "/";
+		}
+		return href;
+	}
+	if (typeof process !== "undefined" && process.cwd) {
+		const path = process.cwd();
+		const lastChar = path.slice(-1);
+		if (lastChar === "/" || lastChar === "\\") return path;
+		else return path + "/";
+	}
+	return "/";
+}
+/**
+* Returns the protocol of the given URL, or `undefined` if it has no protocol.
+*
+* @param path
+* @returns
+*/
+function getProtocol(path) {
+	const match = protocolPattern.exec(path || "");
+	if (match) return match[1].toLowerCase();
+}
+/**
+* Returns the lowercased file extension of the given URL,
+* or an empty string if it has no extension.
+*
+* @param path
+* @returns
+*/
+function getExtension(path) {
+	const lastDot = path.lastIndexOf(".");
+	if (lastDot >= 0) return stripQuery(path.substring(lastDot).toLowerCase());
+	return "";
+}
+/**
+* Removes the query, if any, from the given path.
+*
+* @param path
+* @returns
+*/
+function stripQuery(path) {
+	const queryIndex = path.indexOf("?");
+	if (queryIndex >= 0) path = path.substring(0, queryIndex);
+	return path;
+}
+/**
+* Returns the hash (URL fragment), of the given path.
+* If there is no hash, then the root hash ("#") is returned.
+*
+* @param path
+* @returns
+*/
+function getHash(path) {
+	if (!path) return "#";
+	const hashIndex = path.indexOf("#");
+	if (hashIndex >= 0) return path.substring(hashIndex);
+	return "#";
+}
+/**
+* Removes the hash (URL fragment), if any, from the given path.
+*
+* @param path
+* @returns
+*/
+function stripHash(path) {
+	if (!path) return "";
+	const hashIndex = path.indexOf("#");
+	if (hashIndex >= 0) path = path.substring(0, hashIndex);
+	return path;
+}
+/**
+* Determines whether the given path is an HTTP(S) URL.
+*
+* @param path
+* @returns
+*/
+function isHttp(path) {
+	const protocol = getProtocol(path);
+	if (protocol === "http" || protocol === "https") return true;
+	else if (protocol === void 0) return typeof window !== "undefined";
+	else return false;
+}
+/**
+* Determines whether the given url is an unsafe or internal url.
+*
+* @param path - The URL or path to check
+* @returns true if the URL is unsafe/internal, false otherwise
+*/
+function isUnsafeUrl(path) {
+	if (!path || typeof path !== "string") return true;
+	const normalizedPath = path.trim().toLowerCase();
+	if (!normalizedPath) return true;
+	if (normalizedPath.startsWith("javascript:") || normalizedPath.startsWith("vbscript:") || normalizedPath.startsWith("data:")) return true;
+	if (normalizedPath.startsWith("file:")) return true;
+	if (typeof window !== "undefined" && window.location && window.location.href) return false;
+	const localPatterns = [
+		"localhost",
+		"127.0.0.1",
+		"::1",
+		"10.",
+		"172.16.",
+		"172.17.",
+		"172.18.",
+		"172.19.",
+		"172.20.",
+		"172.21.",
+		"172.22.",
+		"172.23.",
+		"172.24.",
+		"172.25.",
+		"172.26.",
+		"172.27.",
+		"172.28.",
+		"172.29.",
+		"172.30.",
+		"172.31.",
+		"192.168.",
+		"169.254.",
+		".local",
+		".internal",
+		".intranet",
+		".corp",
+		".home",
+		".lan"
+	];
+	try {
+		const url = new URL(normalizedPath.startsWith("//") ? "http:" + normalizedPath : normalizedPath);
+		const hostname = url.hostname.toLowerCase();
+		for (const pattern of localPatterns) if (hostname === pattern || hostname.startsWith(pattern) || hostname.endsWith(pattern)) return true;
+		if (isPrivateIP(hostname)) return true;
+		const port = url.port;
+		if (port && isInternalPort(parseInt(port))) return true;
+	} catch {
+		if (normalizedPath.startsWith("/") && !normalizedPath.startsWith("//")) return false;
+		for (const pattern of localPatterns) if (normalizedPath.includes(pattern)) return true;
+	}
+	return false;
+}
+/**
+* Helper function to check if an IP address is in a private range
+*/
+function isPrivateIP(ip) {
+	const match = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+	if (!match) return false;
+	const [, a, b, c, d] = match.map(Number);
+	if (a > 255 || b > 255 || c > 255 || d > 255) return false;
+	return a === 10 || a === 127 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+}
+/**
+* Helper function to check if a port is typically used for internal services
+*/
+function isInternalPort(port) {
+	return [
+		22,
+		23,
+		25,
+		53,
+		135,
+		139,
+		445,
+		993,
+		995,
+		1433,
+		1521,
+		3306,
+		3389,
+		5432,
+		5900,
+		6379,
+		8080,
+		8443,
+		9200,
+		27017
+	].includes(port);
+}
+/**
+* Determines whether the given path is a filesystem path.
+* This includes "file://" URLs.
+*
+* @param path
+* @returns
+*/
+function isFileSystemPath(path) {
+	if (typeof window !== "undefined" || typeof process !== "undefined" && process.browser) return false;
+	const protocol = getProtocol(path);
+	return protocol === void 0 || protocol === "file";
+}
+/**
+* Converts a filesystem path to a properly-encoded URL.
+*
+* This is intended to handle situations where JSON Schema $Ref Parser is called
+* with a filesystem path that contains characters which are not allowed in URLs.
+*
+* @example
+* The following filesystem paths would be converted to the following URLs:
+*
+*    <"!@#$%^&*+=?'>.json              ==>   %3C%22!@%23$%25%5E&*+=%3F\'%3E.json
+*    C:\\My Documents\\File (1).json   ==>   C:/My%20Documents/File%20(1).json
+*    file://Project #42/file.json      ==>   file://Project%20%2342/file.json
+*
+* @param path
+* @returns
+*/
+function fromFileSystemPath(path) {
+	if (isWindows()) {
+		const projectDir = cwd();
+		const upperPath = path.toUpperCase();
+		const posixUpper = convertPathToPosix(projectDir).toUpperCase();
+		const hasProjectDir = upperPath.includes(posixUpper);
+		const hasProjectUri = upperPath.includes(posixUpper);
+		const isAbsolutePath = isAbsoluteWin32Path.test(path) || path.startsWith("http://") || path.startsWith("https://") || path.startsWith("file://");
+		if (!(hasProjectDir || hasProjectUri || isAbsolutePath) && !projectDir.startsWith("http")) {
+			const join = (a, b) => {
+				if (a.endsWith("/") || a.endsWith("\\")) return a + b;
+				else return a + "/" + b;
+			};
+			path = join(projectDir, path);
+		}
+		path = convertPathToPosix(path);
+	}
+	path = encodeURI(path);
+	for (const pattern of urlEncodePatterns) path = path.replace(pattern[0], pattern[1]);
+	return path;
+}
+/**
+* Converts a URL to a local filesystem path.
+*/
+function toFileSystemPath(path, keepFileProtocol) {
+	path = path.replace(/%(?![0-9A-Fa-f]{2})/g, "%25");
+	path = decodeURI(path);
+	for (let i = 0; i < urlDecodePatterns.length; i += 2) path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1]);
+	let isFileUrl = path.toLowerCase().startsWith("file://");
+	if (isFileUrl) {
+		path = path.replace(/^file:\/\//, "").replace(/^\//, "");
+		if (isWindows() && path[1] === "/") path = `${path[0]}:${path.substring(1)}`;
+		if (keepFileProtocol) path = "file:///" + path;
+		else {
+			isFileUrl = false;
+			path = isWindows() ? path : "/" + path;
+		}
+	}
+	if (isWindows() && !isFileUrl) {
+		path = path.replace(forwardSlashPattern, "\\");
+		if (path.match(/^[a-z]:\\/i)) path = path[0].toUpperCase() + path.substring(1);
+	}
+	return path;
+}
+/**
+* Converts a $ref pointer to a valid JSON Path.
+*
+* @param pointer
+* @returns
+*/
+function safePointerToPath(pointer) {
+	if (pointer.length <= 1 || pointer[0] !== "#" || pointer[1] !== "/") return [];
+	return pointer.slice(2).split("/").map((value) => {
+		return value.replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
+	});
+}
+//#endregion
+export { cwd, fromFileSystemPath, getExtension, getHash, isFileSystemPath, isHttp, isUnsafeUrl, parse, resolve, safePointerToPath, stripHash, toFileSystemPath };

package/dist/node_modules/.pnpm/@fastify_deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js

@@ -0,0 +1,108 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/@fastify+deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js
+var require_deepmerge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const JSON_PROTO = Object.getPrototypeOf({});
+	function defaultIsMergeableObjectFactory() {
+		return function defaultIsMergeableObject(value) {
+			return typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Date);
+		};
+	}
+	function deepmergeConstructor(options) {
+		function isNotPrototypeKey(value) {
+			return value !== "constructor" && value !== "prototype" && value !== "__proto__";
+		}
+		function cloneArray(value) {
+			let i = 0;
+			const il = value.length;
+			const result = new Array(il);
+			for (; i < il; ++i) result[i] = clone(value[i]);
+			return result;
+		}
+		function cloneObject(target) {
+			const result = {};
+			if (cloneProtoObject && Object.getPrototypeOf(target) !== JSON_PROTO) return cloneProtoObject(target);
+			const targetKeys = getKeys(target);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && (result[key] = clone(target[key]));
+			return result;
+		}
+		function concatArrays(target, source) {
+			const tl = target.length;
+			const sl = source.length;
+			let i = 0;
+			const result = new Array(tl + sl);
+			for (; i < tl; ++i) result[i] = clone(target[i]);
+			for (i = 0; i < sl; ++i) result[i + tl] = clone(source[i]);
+			return result;
+		}
+		const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+		function getSymbolsAndKeys(value) {
+			const result = Object.keys(value);
+			const keys = Object.getOwnPropertySymbols(value);
+			for (let i = 0, il = keys.length; i < il; ++i) propertyIsEnumerable.call(value, keys[i]) && result.push(keys[i]);
+			return result;
+		}
+		const getKeys = options?.symbols ? getSymbolsAndKeys : Object.keys;
+		const cloneProtoObject = typeof options?.cloneProtoObject === "function" ? options.cloneProtoObject : void 0;
+		const isMergeableObject = typeof options?.isMergeableObject === "function" ? options.isMergeableObject : defaultIsMergeableObjectFactory();
+		const onlyDefinedProperties = options?.onlyDefinedProperties === true;
+		function isPrimitive(value) {
+			return typeof value !== "object" || value === null;
+		}
+		const mergeArray = options && typeof options.mergeArray === "function" ? options.mergeArray({
+			clone,
+			deepmerge: _deepmerge,
+			getKeys,
+			isMergeableObject
+		}) : concatArrays;
+		function clone(entry) {
+			return isMergeableObject(entry) ? Array.isArray(entry) ? cloneArray(entry) : cloneObject(entry) : entry;
+		}
+		function mergeObject(target, source) {
+			const result = {};
+			const targetKeys = getKeys(target);
+			const sourceKeys = getKeys(source);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && sourceKeys.indexOf(key) === -1 && (result[key] = clone(target[key]));
+			for (i = 0, il = sourceKeys.length; i < il; ++i) {
+				if (!isNotPrototypeKey(key = sourceKeys[i])) continue;
+				if (key in target) {
+					if (targetKeys.indexOf(key) !== -1) if (cloneProtoObject && isMergeableObject(source[key]) && Object.getPrototypeOf(source[key]) !== JSON_PROTO) result[key] = cloneProtoObject(source[key]);
+					else result[key] = _deepmerge(target[key], source[key]);
+				} else {
+					if (onlyDefinedProperties && typeof source[key] === "undefined") continue;
+					result[key] = clone(source[key]);
+				}
+			}
+			return result;
+		}
+		function _deepmerge(target, source) {
+			if (onlyDefinedProperties && typeof source === "undefined") return clone(target);
+			const sourceIsArray = Array.isArray(source);
+			const targetIsArray = Array.isArray(target);
+			if (isPrimitive(source)) return source;
+			else if (!isMergeableObject(target)) return clone(source);
+			else if (sourceIsArray && targetIsArray) return mergeArray(target, source);
+			else if (sourceIsArray !== targetIsArray) return clone(source);
+			else return mergeObject(target, source);
+		}
+		function _deepmergeAll() {
+			switch (arguments.length) {
+				case 0: return {};
+				case 1: return clone(arguments[0]);
+				case 2: return _deepmerge(arguments[0], arguments[1]);
+			}
+			let result;
+			for (let i = 0, il = arguments.length; i < il; ++i) result = _deepmerge(result, arguments[i]);
+			return result;
+		}
+		return options?.all ? _deepmergeAll : _deepmerge;
+	}
+	module.exports = deepmergeConstructor;
+	module.exports.default = deepmergeConstructor;
+	module.exports.deepmerge = deepmergeConstructor;
+	Object.defineProperty(module.exports, "isMergeableObject", { get: defaultIsMergeableObjectFactory });
+}));
+//#endregion
+export default require_deepmerge();
+export { require_deepmerge };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/2020.js

@@ -0,0 +1,110 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "./compile/codegen/index.js";
+import { require_validate } from "./compile/validate/index.js";
+import { require_validation_error } from "./runtime/validation_error.js";
+import { require_ref_error } from "./compile/ref_error.js";
+import { require_core } from "./core.js";
+import { require_draft2020 } from "./vocabularies/draft2020.js";
+import { require_discriminator } from "./vocabularies/discriminator/index.js";
+import { require_json_schema_2020_12 } from "./refs/json-schema-2020-12/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/2020.js
+var require__2020 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
+	const core_1 = require_core();
+	const draft2020_1 = require_draft2020();
+	const discriminator_1 = require_discriminator();
+	const json_schema_2020_12_1 = require_json_schema_2020_12();
+	const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+	var Ajv2020 = class extends core_1.default {
+		constructor(opts = {}) {
+			super({
+				...opts,
+				dynamicRef: true,
+				next: true,
+				unevaluated: true
+			});
+		}
+		_addVocabularies() {
+			super._addVocabularies();
+			draft2020_1.default.forEach((v) => this.addVocabulary(v));
+			if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
+		}
+		_addDefaultMetaSchema() {
+			super._addDefaultMetaSchema();
+			const { $data, meta } = this.opts;
+			if (!meta) return;
+			json_schema_2020_12_1.default.call(this, $data);
+			this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+		}
+		defaultMeta() {
+			return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+		}
+	};
+	exports.Ajv2020 = Ajv2020;
+	module.exports = exports = Ajv2020;
+	module.exports.Ajv2020 = Ajv2020;
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = Ajv2020;
+	var validate_1 = require_validate();
+	Object.defineProperty(exports, "KeywordCxt", {
+		enumerable: true,
+		get: function() {
+			return validate_1.KeywordCxt;
+		}
+	});
+	var codegen_1 = require_codegen();
+	Object.defineProperty(exports, "_", {
+		enumerable: true,
+		get: function() {
+			return codegen_1._;
+		}
+	});
+	Object.defineProperty(exports, "str", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.str;
+		}
+	});
+	Object.defineProperty(exports, "stringify", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.stringify;
+		}
+	});
+	Object.defineProperty(exports, "nil", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.nil;
+		}
+	});
+	Object.defineProperty(exports, "Name", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.Name;
+		}
+	});
+	Object.defineProperty(exports, "CodeGen", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.CodeGen;
+		}
+	});
+	var validation_error_1 = require_validation_error();
+	Object.defineProperty(exports, "ValidationError", {
+		enumerable: true,
+		get: function() {
+			return validation_error_1.default;
+		}
+	});
+	var ref_error_1 = require_ref_error();
+	Object.defineProperty(exports, "MissingRefError", {
+		enumerable: true,
+		get: function() {
+			return ref_error_1.default;
+		}
+	});
+}));
+//#endregion
+export default require__2020();
+export { require__2020 };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js

@@ -0,0 +1,138 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
+var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
+	var _CodeOrName = class {};
+	exports._CodeOrName = _CodeOrName;
+	exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+	var Name = class extends _CodeOrName {
+		constructor(s) {
+			super();
+			if (!exports.IDENTIFIER.test(s)) throw new Error("CodeGen: name must be a valid identifier");
+			this.str = s;
+		}
+		toString() {
+			return this.str;
+		}
+		emptyStr() {
+			return false;
+		}
+		get names() {
+			return { [this.str]: 1 };
+		}
+	};
+	exports.Name = Name;
+	var _Code = class extends _CodeOrName {
+		constructor(code) {
+			super();
+			this._items = typeof code === "string" ? [code] : code;
+		}
+		toString() {
+			return this.str;
+		}
+		emptyStr() {
+			if (this._items.length > 1) return false;
+			const item = this._items[0];
+			return item === "" || item === "\"\"";
+		}
+		get str() {
+			var _a;
+			return (_a = this._str) !== null && _a !== void 0 ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
+		}
+		get names() {
+			var _a;
+			return (_a = this._names) !== null && _a !== void 0 ? _a : this._names = this._items.reduce((names, c) => {
+				if (c instanceof Name) names[c.str] = (names[c.str] || 0) + 1;
+				return names;
+			}, {});
+		}
+	};
+	exports._Code = _Code;
+	exports.nil = new _Code("");
+	function _(strs, ...args) {
+		const code = [strs[0]];
+		let i = 0;
+		while (i < args.length) {
+			addCodeArg(code, args[i]);
+			code.push(strs[++i]);
+		}
+		return new _Code(code);
+	}
+	exports._ = _;
+	const plus = new _Code("+");
+	function str(strs, ...args) {
+		const expr = [safeStringify(strs[0])];
+		let i = 0;
+		while (i < args.length) {
+			expr.push(plus);
+			addCodeArg(expr, args[i]);
+			expr.push(plus, safeStringify(strs[++i]));
+		}
+		optimize(expr);
+		return new _Code(expr);
+	}
+	exports.str = str;
+	function addCodeArg(code, arg) {
+		if (arg instanceof _Code) code.push(...arg._items);
+		else if (arg instanceof Name) code.push(arg);
+		else code.push(interpolate(arg));
+	}
+	exports.addCodeArg = addCodeArg;
+	function optimize(expr) {
+		let i = 1;
+		while (i < expr.length - 1) {
+			if (expr[i] === plus) {
+				const res = mergeExprItems(expr[i - 1], expr[i + 1]);
+				if (res !== void 0) {
+					expr.splice(i - 1, 3, res);
+					continue;
+				}
+				expr[i++] = "+";
+			}
+			i++;
+		}
+	}
+	function mergeExprItems(a, b) {
+		if (b === "\"\"") return a;
+		if (a === "\"\"") return b;
+		if (typeof a == "string") {
+			if (b instanceof Name || a[a.length - 1] !== "\"") return;
+			if (typeof b != "string") return `${a.slice(0, -1)}${b}"`;
+			if (b[0] === "\"") return a.slice(0, -1) + b.slice(1);
+			return;
+		}
+		if (typeof b == "string" && b[0] === "\"" && !(a instanceof Name)) return `"${a}${b.slice(1)}`;
+	}
+	function strConcat(c1, c2) {
+		return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
+	}
+	exports.strConcat = strConcat;
+	function interpolate(x) {
+		return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
+	}
+	function stringify(x) {
+		return new _Code(safeStringify(x));
+	}
+	exports.stringify = stringify;
+	function safeStringify(x) {
+		return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+	}
+	exports.safeStringify = safeStringify;
+	function getProperty(key) {
+		return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
+	}
+	exports.getProperty = getProperty;
+	function getEsmExportName(key) {
+		if (typeof key == "string" && exports.IDENTIFIER.test(key)) return new _Code(`${key}`);
+		throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
+	}
+	exports.getEsmExportName = getEsmExportName;
+	function regexpCode(rx) {
+		return new _Code(rx.toString());
+	}
+	exports.regexpCode = regexpCode;
+}));
+//#endregion
+export default require_code();
+export { require_code };