nitro-nightly 3.0.1-20260119-145349-d0c4950f → 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.mjs

@@ -1,5 +1,5 @@
 import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "../_common.mjs";
-import { At as dirname$1, Dt as resolveModulePath, It as resolve$1, Nt as join$1, Pt as normalize$1, jt as extname$1, kt as basename$1, vt as findWorkspaceDir, xt as readPackageJSON } from "../_build/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";
@@ -653,10 +653,10 @@ function getDotEnvVars(targetEnvironment) {
 }
 const _normalize = (p) => p?.replace(/\\/g, "/");
 const ASYNC_LOADERS = {
-	".yaml": () => import("./confbox.mjs").then((n) => n.o).then((r) => r.parseYAML),
-	".yml": () => import("./confbox.mjs").then((n) => n.o).then((r) => r.parseYAML),
+	".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.c).then((r) => r.parseJSON5),
+	".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([
@@ -924,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("./chokidar.mjs").then((n) => n.i).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,
@@ -969,4 +969,4 @@ async function watchConfig(options) {
 }
 
 //#endregion
-export { setupDotenv as a, loadDotenv as i, dist_exports as n, watchConfig as o, loadConfig as r, debounce as s, SUPPORTED_EXTENSIONS as t };
+export { debounce as i, loadConfig as n, watchConfig as r, dist_exports as t };

package/dist/_libs/chokidar.mjs

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "../_common.mjs";
-import { stat, unwatchFile, watch, watchFile } from "node:fs";
+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";
 import * as sp from "node:path";
@@ -1608,4 +1608,4 @@ var chokidar_default = {
 };
 
 //#endregion
-export { watch$1 as a, chokidar_exports 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 };

package/dist/_libs/confbox.mjs

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "../_common.mjs";
-import { Et as N$1, Tt as C$2, wt as h$1 } from "../_build/common.mjs";
+import { Q as N$1, X as h$1, Z as C$2 } from "../_build/common.mjs";
 
 //#region node_modules/.pnpm/confbox@0.2.2/node_modules/confbox/dist/json5.mjs
 var json5_exports = /* @__PURE__ */ __exportAll({ parseJSON5: () => Cu });
@@ -2506,4 +2506,4 @@ function Q(e) {
 var jsonc_exports = /* @__PURE__ */ __exportAll({ parseJSONC: () => h$1 });
 
 //#endregion
-export { mr as a, json5_exports as c, gr as i, Q as n, yaml_exports as o, toml_exports as r, Cu as s, jsonc_exports as t };
+export { yaml_exports as a, gr as i, Q as n, json5_exports as o, toml_exports as r, jsonc_exports as t };

package/dist/_libs/esbuild.d.mts

@@ -0,0 +1,20 @@
+//#region node_modules/.pnpm/esbuild@0.27.2/node_modules/esbuild/lib/main.d.ts
+// Note: These declarations exist to avoid type errors when you omit "dom" from
+// "lib" in your "tsconfig.json" file. TypeScript confusingly declares the
+// global "WebAssembly" type in "lib.dom.d.ts" even though it has nothing to do
+// with the browser DOM and is present in many non-browser JavaScript runtimes
+// (e.g. node and deno). Declaring it here allows esbuild's API to be used in
+// these scenarios.
+//
+// There's an open issue about getting this problem corrected (although these
+// declarations will need to remain even if this is fixed for backward
+// compatibility with older TypeScript versions):
+//
+//   https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/826
+//
+declare global {
+  namespace WebAssembly {
+    interface Module {}
+  }
+  interface URL {}
+}