nitro-nightly 3.0.1-20260120-020848-6786d069 → 3.0.1-20260120-133205-cbfce96c

package/dist/_libs/c12.d.mts

@@ -0,0 +1,214 @@
+import { Stats } from "node:fs";
+import { Jiti, JitiOptions } from "jiti";
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+import { diff } from "ohash/utils";
+
+//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.d.ts
+type AWF = {
+  stabilityThreshold: number;
+  pollInterval: number;
+};
+type BasicOpts = {
+  persistent: boolean;
+  ignoreInitial: boolean;
+  followSymlinks: boolean;
+  cwd?: string;
+  usePolling: boolean;
+  interval: number;
+  binaryInterval: number;
+  alwaysStat?: boolean;
+  depth?: number;
+  ignorePermissionErrors: boolean;
+  atomic: boolean | number;
+};
+type ChokidarOptions = Partial<BasicOpts & {
+  ignored: Matcher | Matcher[];
+  awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+type MatchFunction = (val: string, stats?: Stats) => boolean;
+interface MatcherObject {
+  path: string;
+  recursive?: boolean;
+}
+type Matcher = string | RegExp | MatchFunction | MatcherObject;
+//#endregion
+//#region node_modules/.pnpm/giget@2.0.0/node_modules/giget/dist/index.d.mts
+interface TemplateInfo {
+  name: string;
+  tar: string;
+  version?: string;
+  subdir?: string;
+  url?: string;
+  defaultDir?: string;
+  headers?: Record<string, string | undefined>;
+  source?: never;
+  dir?: never;
+  [key: string]: any;
+}
+type TemplateProvider = (input: string, options: {
+  auth?: string;
+}) => TemplateInfo | Promise<TemplateInfo> | null;
+interface DownloadTemplateOptions {
+  provider?: string;
+  force?: boolean;
+  forceClean?: boolean;
+  offline?: boolean;
+  preferOffline?: boolean;
+  providers?: Record<string, TemplateProvider>;
+  dir?: string;
+  registry?: false | string;
+  cwd?: string;
+  auth?: string;
+  install?: boolean;
+  silent?: boolean;
+}
+//#endregion
+//#region node_modules/.pnpm/c12@3.3.3_magicast@0.5.1/node_modules/c12/dist/index.d.mts
+//#region src/dotenv.d.ts
+interface DotenvOptions {
+  /**
+     * The project root directory (either absolute or relative to the current working directory).
+     *
+     * Defaults to `options.cwd` in `loadConfig` context, or `process.cwd()` when used as standalone.
+     */
+  cwd?: string;
+  /**
+     * What file or files to look in for environment variables (either absolute or relative
+     * to the current working directory). For example, `.env`.
+     * With the array type, the order enforce the env loading priority (last one overrides).
+     */
+  fileName?: string | string[];
+  /**
+     * Whether to interpolate variables within .env.
+     *
+     * @example
+     * ```env
+     * BASE_DIR="/test"
+     * # resolves to "/test/further"
+     * ANOTHER_DIR="${BASE_DIR}/further"
+     * ```
+     */
+  interpolate?: boolean;
+  /**
+     * An object describing environment variables (key, value pairs).
+     */
+  env?: NodeJS.ProcessEnv;
+}
+declare global {
+  var __c12_dotenv_vars__: Map<Record<string, any>, Set<string>>;
+} //#endregion
+//#region src/types.d.ts
+interface ConfigLayerMeta {
+  name?: string;
+  [key: string]: any;
+}
+type UserInputConfig = Record<string, any>;
+interface C12InputConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  $test?: T;
+  $development?: T;
+  $production?: T;
+  $env?: Record<string, T>;
+  $meta?: MT;
+}
+interface SourceOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  /** Custom meta for layer */
+  meta?: MT;
+  /** Layer config overrides */
+  overrides?: T;
+  [key: string]: any;
+  /**
+     * Options for cloning remote sources
+     *
+     * @see https://giget.unjs.io
+     */
+  giget?: DownloadTemplateOptions;
+  /**
+     * Install dependencies after cloning
+     *
+     * @see https://nypm.unjs.io
+     */
+  install?: boolean;
+  /**
+     * Token for cloning private sources
+     *
+     * @see https://giget.unjs.io#providing-token-for-private-repositories
+     */
+  auth?: string;
+}
+interface ConfigLayer<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  config: T | null;
+  source?: string;
+  sourceOptions?: SourceOptions<T, MT>;
+  meta?: MT;
+  cwd?: string;
+  configFile?: string;
+}
+interface ResolvedConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> extends ConfigLayer<T, MT> {
+  config: T;
+  layers?: ConfigLayer<T, MT>[];
+  cwd?: string;
+  _configFile?: string;
+}
+type ConfigSource = "overrides" | "main" | "rc" | "packageJson" | "defaultConfig";
+interface ConfigFunctionContext {
+  [key: string]: any;
+}
+interface ResolvableConfigContext<T extends UserInputConfig = UserInputConfig> {
+  configs: Record<ConfigSource, T | null | undefined>;
+  rawConfigs: Record<ConfigSource, ResolvableConfig<T> | null | undefined>;
+}
+type MaybePromise<T> = T | Promise<T>;
+type ResolvableConfig<T extends UserInputConfig = UserInputConfig> = MaybePromise<T | null | undefined> | ((ctx: ResolvableConfigContext<T>) => MaybePromise<T | null | undefined>);
+interface LoadConfigOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  name?: string;
+  cwd?: string;
+  configFile?: string;
+  rcFile?: false | string;
+  globalRc?: boolean;
+  dotenv?: boolean | DotenvOptions;
+  envName?: string | false;
+  packageJson?: boolean | string | string[];
+  defaults?: T;
+  defaultConfig?: ResolvableConfig<T>;
+  overrides?: ResolvableConfig<T>;
+  omit$Keys?: boolean;
+  /** Context passed to config functions */
+  context?: ConfigFunctionContext;
+  resolve?: (id: string, options: LoadConfigOptions<T, MT>) => null | undefined | ResolvedConfig<T, MT> | Promise<ResolvedConfig<T, MT> | undefined | null>;
+  jiti?: Jiti;
+  jitiOptions?: JitiOptions;
+  giget?: false | DownloadTemplateOptions;
+  merger?: (...sources: Array<T | null | undefined>) => T;
+  extend?: false | {
+    extendKey?: string | string[];
+  };
+  configFileRequired?: boolean;
+}
+//#endregion
+//#region src/watch.d.ts
+type DiffEntries = ReturnType<typeof diff>;
+type ConfigWatcher<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> = ResolvedConfig<T, MT> & {
+  watchingFiles: string[];
+  unwatch: () => Promise<void>;
+};
+interface WatchConfigOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> extends LoadConfigOptions<T, MT> {
+  chokidarOptions?: ChokidarOptions;
+  debounce?: false | number;
+  onWatch?: (event: {
+    type: "created" | "updated" | "removed";
+    path: string;
+  }) => void | Promise<void>;
+  acceptHMR?: (context: {
+    getDiff: () => DiffEntries;
+    newConfig: ResolvedConfig<T, MT>;
+    oldConfig: ResolvedConfig<T, MT>;
+  }) => void | boolean | Promise<void | boolean>;
+  onUpdate?: (context: {
+    getDiff: () => ReturnType<typeof diff>;
+    newConfig: ResolvedConfig<T, MT>;
+    oldConfig: ResolvedConfig<T, MT>;
+  }) => void | Promise<void>;
+}
+//#endregion
+export { WatchConfigOptions as a, ResolvedConfig as i, ConfigWatcher as n, ChokidarOptions as o, DotenvOptions as r, C12InputConfig as t };

package/dist/_libs/{c12+dotenv+rc9.mjs → c12.mjs}

@@ -1,7 +1,5 @@
-import { n as __require, r as __toESM, t as __commonJSMin } from "../_chunks/nitro.mjs";
-import { a as join$1, n as dirname$1, o as normalize$1, r as extname$1, t as basename$1, u as resolve$1 } from "./pathe.mjs";
-import { l as resolveModulePath, o as readPackageJSON, r as findWorkspaceDir } from "./confbox+exsolve+pkg-types.mjs";
-import { t as debounce } from "./perfect-debounce.mjs";
+import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "../_common.mjs";
+import { $ as resolveModulePath, Y as readPackageJSON, at as join$1, ct as resolve$1, nt as dirname$1, ot as normalize$1, q as findWorkspaceDir, rt as extname$1, tt as basename$1 } from "../_build/common.mjs";
 import { existsSync, promises, readFileSync, statSync } from "node:fs";
 import { readFile, rm } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
@@ -481,8 +479,103 @@ function readUser(options) {
 	return read(options);
 }
 
+//#endregion
+//#region node_modules/.pnpm/perfect-debounce@2.0.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$2) => {
+			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$2(leadingValue);
+			} else resolveList.push(resolve$2);
+		});
+	};
+	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
 //#region node_modules/.pnpm/c12@3.3.3_magicast@0.5.1/node_modules/c12/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({
+	SUPPORTED_EXTENSIONS: () => SUPPORTED_EXTENSIONS,
+	loadConfig: () => loadConfig,
+	loadDotenv: () => loadDotenv,
+	setupDotenv: () => setupDotenv,
+	watchConfig: () => watchConfig
+});
 var import_main = /* @__PURE__ */ __toESM(require_main(), 1);
 /**
 * Load and interpolate environment variables into `process.env`.
@@ -560,11 +653,11 @@ function getDotEnvVars(targetEnvironment) {
 }
 const _normalize = (p) => p?.replace(/\\/g, "/");
 const ASYNC_LOADERS = {
-	".yaml": () => import("./_.mjs").then((r) => r.parseYAML),
-	".yml": () => import("./_.mjs").then((r) => r.parseYAML),
-	".jsonc": () => import("./confbox4.mjs").then((r) => r.parseJSONC),
-	".json5": () => import("./confbox2.mjs").then((r) => r.parseJSON5),
-	".toml": () => import("./_2.mjs").then((r) => r.parseTOML)
+	".yaml": () => import("./confbox.mjs").then((n) => n.a).then((r) => r.parseYAML),
+	".yml": () => import("./confbox.mjs").then((n) => n.a).then((r) => r.parseYAML),
+	".jsonc": () => import("./confbox.mjs").then((n) => n.t).then((r) => r.parseJSONC),
+	".json5": () => import("./confbox.mjs").then((n) => n.o).then((r) => r.parseJSON5),
+	".toml": () => import("./confbox.mjs").then((n) => n.r).then((r) => r.parseTOML)
 };
 const SUPPORTED_EXTENSIONS = Object.freeze([
 	".js",
@@ -750,7 +843,7 @@ async function resolveConfig(source, options, sourceOptions = {}) {
 	const customProviderKeys = Object.keys(sourceOptions.giget?.providers || {}).map((key) => `${key}:`);
 	const gigetPrefixes = customProviderKeys.length > 0 ? [...new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
 	if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
-		const { downloadTemplate } = await import("./giget+node-fetch-native.mjs");
+		const { downloadTemplate } = await import("./giget.mjs").then((n) => n.t);
 		const { digest } = await import("ohash");
 		const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
 		let cloneDir;
@@ -831,7 +924,7 @@ async function watchConfig(options) {
 		options.rcFile && resolve$1(l.cwd, typeof options.rcFile === "string" ? options.rcFile : `.${configName}rc`),
 		options.packageJson && resolve$1(l.cwd, "package.json")
 	]).filter(Boolean))];
-	const watch$1 = await import("./_6.mjs").then((r) => r.watch || r.default || r);
+	const watch$1 = await import("./chokidar.mjs").then((n) => n.t).then((r) => r.watch || r.default || r);
 	const { diff } = await import("ohash/utils");
 	const _fswatcher = watch$1(watchingFiles, {
 		ignoreInitial: true,
@@ -876,4 +969,4 @@ async function watchConfig(options) {
 }
 
 //#endregion
-export { watchConfig as a, setupDotenv as i, loadConfig as n, loadDotenv as r, SUPPORTED_EXTENSIONS as t };
+export { debounce as i, loadConfig as n, watchConfig as r, dist_exports as t };

package/dist/_libs/{chokidar+readdirp.mjs → chokidar.mjs}

@@ -1,3 +1,4 @@
+import { n as __exportAll } from "../_common.mjs";
 import { Stats, stat, unwatchFile, watch, watchFile } from "node:fs";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
 import { type } from "node:os";
@@ -957,6 +958,12 @@ var NodeFsHandler = class {
 //#endregion
 //#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 /*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+var chokidar_exports = /* @__PURE__ */ __exportAll({
+	FSWatcher: () => FSWatcher,
+	WatchHelper: () => WatchHelper,
+	default: () => chokidar_default,
+	watch: () => watch$1
+});
 const SLASH = "/";
 const SLASH_SLASH = "//";
 const ONE_DOT = ".";
@@ -1601,4 +1608,4 @@ var chokidar_default = {
 };
 
 //#endregion
-export { watch$1 as i, WatchHelper as n, chokidar_default as r, FSWatcher as t };
+export { watch$1 as n, chokidar_exports as t };

package/dist/_libs/compatx.d.mts

@@ -0,0 +1,47 @@
+//#region node_modules/.pnpm/compatx@0.2.0/node_modules/compatx/dist/index.d.mts
+/**
+ * Known platform names
+ */
+declare const platforms: readonly ["aws", "azure", "cloudflare", "deno", "firebase", "netlify", "vercel"];
+/**
+ * Known platform name
+ */
+type PlatformName = typeof platforms[number] | string & {};
+/**
+ * Normalize the compatibility dates from input config and defaults.
+ */
+type Year = `${number}${number}${number}${number}`;
+type Month = `${"0" | "1"}${number}`;
+type Day = `${"0" | "1" | "2" | "3"}${number}`;
+/**
+ * Typed date string in `YYYY-MM-DD` format
+ *
+ * Empty string is used to represent an "unspecified" date.
+ *
+ * "latest" is used to represent the latest date available (date of today).
+ */
+type DateString = "" | "latest" | `${Year}-${Month}-${Day}`;
+/**
+ * Last known compatibility dates for platforms
+ *
+ * @example
+ * {
+ *  "default": "2024-01-01",
+ *  "cloudflare": "2024-03-01",
+ * }
+ */
+type CompatibilityDates = {
+  /**
+       * Default compatibility date for all unspecified platforms (required)
+       */
+  default: DateString;
+} & Partial<Record<PlatformName, DateString>>;
+/**
+ * Last known compatibility date for the used platform
+ */
+type CompatibilityDateSpec = DateString | Partial<CompatibilityDates>;
+/**
+ * Get compatibility updates applicable for the user given platform and date range.
+ */
+//#endregion
+export { CompatibilityDates as n, DateString as r, CompatibilityDateSpec as t };