@depup/nitro 3.0.260311-beta-depup.0

package/dist/_libs/perfect-debounce.mjs

@@ -0,0 +1,88 @@
+//#region node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+//#endregion
+export { debounce as t };

package/dist/_libs/pkg-types.d.mts

@@ -0,0 +1,23 @@
+import { CompilerOptions, TypeAcquisition } from "typescript";
+
+//#region node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.d.mts
+type StripEnums<T extends Record<string, any>> = { [K in keyof T]: T[K] extends boolean ? T[K] : T[K] extends string ? T[K] : T[K] extends object ? T[K] : T[K] extends Array<any> ? T[K] : T[K] extends undefined ? undefined : any };
+interface TSConfig {
+  compilerOptions?: StripEnums<CompilerOptions>;
+  exclude?: string[];
+  compileOnSave?: boolean;
+  extends?: string | string[];
+  files?: string[];
+  include?: string[];
+  typeAcquisition?: TypeAcquisition;
+  references?: {
+    path: string;
+  }[];
+}
+/**
+ * Defines a TSConfig structure.
+ * @param tsconfig - The contents of `tsconfig.json` as an object. See {@link TSConfig}.
+ * @returns the same `tsconfig.json` object.
+ */
+//#endregion
+export { TSConfig as t };

package/dist/_libs/plugin-alias.mjs

@@ -0,0 +1,64 @@
+import { n as __exportAll } from "../_common.mjs";
+import path from "node:path";
+//#region node_modules/.pnpm/@rollup+plugin-alias@6.0.0_rollup@4.59.0/node_modules/@rollup/plugin-alias/dist/index.js
+var dist_exports = /* @__PURE__ */ __exportAll({ default: () => alias });
+function matches(pattern, importee) {
+	if (pattern instanceof RegExp) return pattern.test(importee);
+	if (importee.length < pattern.length) return false;
+	if (importee === pattern) return true;
+	return importee.startsWith(pattern + "/");
+}
+function getEntries({ entries, customResolver }) {
+	if (!entries) return [];
+	const resolverFunctionFromOptions = resolveCustomResolver(customResolver);
+	if (Array.isArray(entries)) return entries.map((entry) => {
+		return {
+			find: entry.find,
+			replacement: entry.replacement,
+			resolverFunction: resolveCustomResolver(entry.customResolver) || resolverFunctionFromOptions
+		};
+	});
+	return Object.entries(entries).map(([key, value]) => {
+		return {
+			find: key,
+			replacement: value,
+			resolverFunction: resolverFunctionFromOptions
+		};
+	});
+}
+function getHookFunction(hook) {
+	if (typeof hook === "function") return hook;
+	if (hook && "handler" in hook && typeof hook.handler === "function") return hook.handler;
+	return null;
+}
+function resolveCustomResolver(customResolver) {
+	if (typeof customResolver === "function") return customResolver;
+	if (customResolver) return getHookFunction(customResolver.resolveId);
+	return null;
+}
+function alias(options = {}) {
+	const entries = getEntries(options);
+	if (entries.length === 0) return {
+		name: "alias",
+		resolveId: () => null
+	};
+	return {
+		name: "alias",
+		async buildStart(inputOptions) {
+			await Promise.all([...Array.isArray(options.entries) ? options.entries : [], options].map(({ customResolver }) => customResolver && getHookFunction(customResolver.buildStart)?.call(this, inputOptions)));
+		},
+		resolveId(importee, importer, resolveOptions) {
+			const matchedEntry = entries.find((entry) => matches(entry.find, importee));
+			if (!matchedEntry) return null;
+			const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+			if (matchedEntry.resolverFunction) return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
+			return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => {
+				if (resolved) return resolved;
+				if (!path.isAbsolute(updatedId)) this.warn(`rewrote ${importee} to ${updatedId} but was not an absolute path and was not handled by other plugins. This will lead to duplicated modules for the same path. To avoid duplicating modules, you should resolve to an absolute path.`);
+				return { id: updatedId };
+			});
+		}
+	};
+}
+//#endregion
+export { dist_exports as n, alias as t };

package/dist/_libs/plugin-inject.mjs

@@ -0,0 +1,131 @@
+import { S as MagicString, c as walk, i as createFilter, r as attachScopes, s as makeLegalIdentifier } from "../_build/common.mjs";
+import { sep } from "path";
+//#region node_modules/.pnpm/@rollup+plugin-inject@5.0.5_rollup@4.59.0/node_modules/@rollup/plugin-inject/dist/es/index.js
+var escape = function(str) {
+	return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
+};
+var isReference = function(node, parent) {
+	if (node.type === "MemberExpression") return !node.computed && isReference(node.object, node);
+	if (node.type === "Identifier") {
+		if (parent.type === "MemberExpression") return parent.computed || node === parent.object;
+		if (parent.type === "Property" && node !== parent.value) return false;
+		if (parent.type === "MethodDefinition") return false;
+		if (parent.type === "ExportSpecifier" && node !== parent.local) return false;
+		if (parent.type === "ImportSpecifier" && node === parent.imported) return false;
+		return true;
+	}
+	return false;
+};
+var flatten = function(startNode) {
+	var parts = [];
+	var node = startNode;
+	while (node.type === "MemberExpression") {
+		parts.unshift(node.property.name);
+		node = node.object;
+	}
+	var name = node.name;
+	parts.unshift(name);
+	return {
+		name,
+		keypath: parts.join(".")
+	};
+};
+function inject(options) {
+	if (!options) throw new Error("Missing options");
+	var filter = createFilter(options.include, options.exclude);
+	var modules = options.modules;
+	if (!modules) {
+		modules = Object.assign({}, options);
+		delete modules.include;
+		delete modules.exclude;
+		delete modules.sourceMap;
+		delete modules.sourcemap;
+	}
+	var modulesMap = new Map(Object.entries(modules));
+	if (sep !== "/") modulesMap.forEach(function(mod, key) {
+		modulesMap.set(key, Array.isArray(mod) ? [mod[0].split(sep).join("/"), mod[1]] : mod.split(sep).join("/"));
+	});
+	var firstpass = new RegExp("(?:" + Array.from(modulesMap.keys()).map(escape).join("|") + ")", "g");
+	var sourceMap = options.sourceMap !== false && options.sourcemap !== false;
+	return {
+		name: "inject",
+		transform: function transform(code, id) {
+			if (!filter(id)) return null;
+			if (code.search(firstpass) === -1) return null;
+			if (sep !== "/") id = id.split(sep).join("/");
+			var ast = null;
+			try {
+				ast = this.parse(code);
+			} catch (err) {
+				this.warn({
+					code: "PARSE_ERROR",
+					message: "rollup-plugin-inject: failed to parse " + id + ". Consider restricting the plugin to particular files via options.include"
+				});
+			}
+			if (!ast) return null;
+			var imports = /* @__PURE__ */ new Set();
+			ast.body.forEach(function(node) {
+				if (node.type === "ImportDeclaration") node.specifiers.forEach(function(specifier) {
+					imports.add(specifier.local.name);
+				});
+			});
+			var scope = attachScopes(ast, "scope");
+			var magicString = new MagicString(code);
+			var newImports = /* @__PURE__ */ new Map();
+			function handleReference(node, name, keypath) {
+				var mod = modulesMap.get(keypath);
+				if (mod && !imports.has(name) && !scope.contains(name)) {
+					if (typeof mod === "string") mod = [mod, "default"];
+					if (mod[0] === id) return false;
+					var hash = keypath + ":" + mod[0] + ":" + mod[1];
+					var importLocalName = name === keypath ? name : makeLegalIdentifier("$inject_" + keypath);
+					if (!newImports.has(hash)) {
+						var modName = mod[0].replace(/[''\\]/g, "\\$&");
+						if (mod[1] === "*") newImports.set(hash, "import * as " + importLocalName + " from '" + modName + "';");
+						else newImports.set(hash, "import { " + mod[1] + " as " + importLocalName + " } from '" + modName + "';");
+					}
+					if (name !== keypath) magicString.overwrite(node.start, node.end, importLocalName, { storeName: true });
+					return true;
+				}
+				return false;
+			}
+			walk(ast, {
+				enter: function enter(node, parent) {
+					if (sourceMap) {
+						magicString.addSourcemapLocation(node.start);
+						magicString.addSourcemapLocation(node.end);
+					}
+					if (node.scope) scope = node.scope;
+					if (node.type === "Property" && node.shorthand && node.value.type === "Identifier") {
+						var name = node.key.name;
+						handleReference(node, name, name);
+						this.skip();
+						return;
+					}
+					if (isReference(node, parent)) {
+						var ref$1 = flatten(node);
+						var name$1 = ref$1.name;
+						var keypath = ref$1.keypath;
+						if (handleReference(node, name$1, keypath)) this.skip();
+					}
+				},
+				leave: function leave(node) {
+					if (node.scope) scope = scope.parent;
+				}
+			});
+			if (newImports.size === 0) return {
+				code,
+				ast,
+				map: sourceMap ? magicString.generateMap({ hires: true }) : null
+			};
+			var importBlock = Array.from(newImports.values()).join("\n\n");
+			magicString.prepend(importBlock + "\n\n");
+			return {
+				code: magicString.toString(),
+				map: sourceMap ? magicString.generateMap({ hires: true }) : null
+			};
+		}
+	};
+}
+//#endregion
+export { inject as t };

package/dist/_libs/plugin-json.mjs

@@ -0,0 +1,34 @@
+import { a as dataToEsm, i as createFilter } from "../_build/common.mjs";
+//#region node_modules/.pnpm/@rollup+plugin-json@6.1.0_rollup@4.59.0/node_modules/@rollup/plugin-json/dist/es/index.js
+function json(options) {
+	if (options === void 0) options = {};
+	var filter = createFilter(options.include, options.exclude);
+	var indent = "indent" in options ? options.indent : "	";
+	return {
+		name: "json",
+		transform: function transform(code, id) {
+			if (id.slice(-5) !== ".json" || !filter(id)) return null;
+			try {
+				return {
+					code: dataToEsm(JSON.parse(code), {
+						preferConst: options.preferConst,
+						compact: options.compact,
+						namedExports: options.namedExports,
+						includeArbitraryNames: options.includeArbitraryNames,
+						indent
+					}),
+					map: { mappings: "" }
+				};
+			} catch (err) {
+				this.error({
+					message: "Could not parse JSON file",
+					id,
+					cause: err
+				});
+				return null;
+			}
+		}
+	};
+}
+//#endregion
+export { json as t };