nitro-nightly 3.0.1-20260119-145349-d0c4950f → 3.0.1-20260120-133205-cbfce96c

package/dist/_libs/httpxy.d.mts

@@ -0,0 +1,79 @@
+import http, { IncomingMessage, OutgoingMessage } from "node:http";
+import { EventEmitter } from "node:events";
+import * as stream from "node:stream";
+
+//#region node_modules/.pnpm/httpxy@0.1.7/node_modules/httpxy/dist/index.d.ts
+interface ProxyTargetDetailed {
+  host: string;
+  port: number;
+  protocol?: string;
+  hostname?: string;
+  socketPath?: string;
+  key?: string;
+  passphrase?: string;
+  pfx?: Buffer | string;
+  cert?: string;
+  ca?: string;
+  ciphers?: string;
+  secureProtocol?: string;
+}
+type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
+type ProxyTargetUrl = string | Partial<URL>;
+interface ProxyServerOptions {
+  /** URL string to be parsed with the url module. */
+  target?: ProxyTarget;
+  /** URL string to be parsed with the url module. */
+  forward?: ProxyTargetUrl;
+  /** Object to be passed to http(s).request. */
+  agent?: any;
+  /** Object to be passed to https.createServer(). */
+  ssl?: any;
+  /** If you want to proxy websockets. */
+  ws?: boolean;
+  /** Adds x- forward headers. */
+  xfwd?: boolean;
+  /** Verify SSL certificate. */
+  secure?: boolean;
+  /** Explicitly specify if we are proxying to another proxy. */
+  toProxy?: boolean;
+  /** Specify whether you want to prepend the target's path to the proxy path. */
+  prependPath?: boolean;
+  /** Specify whether you want to ignore the proxy path of the incoming request. */
+  ignorePath?: boolean;
+  /** Local interface string to bind for outgoing connections. */
+  localAddress?: string;
+  /** Changes the origin of the host header to the target URL. */
+  changeOrigin?: boolean;
+  /** specify whether you want to keep letter case of response header key */
+  preserveHeaderKeyCase?: boolean;
+  /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
+  auth?: string;
+  /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
+  hostRewrite?: string;
+  /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
+  autoRewrite?: boolean;
+  /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
+  protocolRewrite?: string;
+  /** Rewrites domain of set-cookie headers. */
+  cookieDomainRewrite?: false | string | {
+    [oldDomain: string]: string;
+  };
+  /** Rewrites path of set-cookie headers. Default: false */
+  cookiePathRewrite?: false | string | {
+    [oldPath: string]: string;
+  };
+  /** Object with extra headers to be added to target requests. */
+  headers?: {
+    [header: string]: string;
+  };
+  /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
+  proxyTimeout?: number;
+  /** Timeout (in milliseconds) for incoming requests */
+  timeout?: number;
+  /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
+  selfHandleResponse?: boolean;
+  /** Buffer */
+  buffer?: stream.Stream;
+}
+//#endregion
+export { ProxyServerOptions as t };

package/dist/_libs/httpxy.mjs

@@ -412,4 +412,4 @@ function _createProxyFn(type, server) {
 }
 
 //#endregion
-export { createProxyServer as n, dist_exports as r, ProxyServer as t };
+export { dist_exports as n, createProxyServer as t };

package/dist/_libs/magic-string.d.mts

@@ -0,0 +1,220 @@
+//#region node_modules/.pnpm/magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.d.mts
+interface SourceMapOptions {
+  /**
+  	 * Whether the mapping should be high-resolution.
+  	 * Hi-res mappings map every single character, meaning (for example) your devtools will always
+  	 * be able to pinpoint the exact location of function calls and so on.
+  	 * With lo-res mappings, devtools may only be able to identify the correct
+  	 * line - but they're quicker to generate and less bulky.
+  	 * You can also set `"boundary"` to generate a semi-hi-res mappings segmented per word boundary
+  	 * instead of per character, suitable for string semantics that are separated by words.
+  	 * If sourcemap locations have been specified with s.addSourceMapLocation(), they will be used here.
+  	 */
+  hires?: boolean | 'boundary';
+  /**
+  	 * The filename where you plan to write the sourcemap.
+  	 */
+  file?: string;
+  /**
+  	 * The filename of the file containing the original source.
+  	 */
+  source?: string;
+  /**
+  	 * Whether to include the original content in the map's sourcesContent array.
+  	 */
+  includeContent?: boolean;
+}
+type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number];
+interface DecodedSourceMap {
+  file: string;
+  sources: string[];
+  sourcesContent?: string[];
+  names: string[];
+  mappings: SourceMapSegment[][];
+  x_google_ignoreList?: number[];
+}
+declare class SourceMap {
+  constructor(properties: DecodedSourceMap);
+  version: number;
+  file: string;
+  sources: string[];
+  sourcesContent?: string[];
+  names: string[];
+  mappings: string;
+  x_google_ignoreList?: number[];
+  debugId?: string;
+  /**
+  	 * Returns the equivalent of `JSON.stringify(map)`
+  	 */
+  toString(): string;
+  /**
+  	 * Returns a DataURI containing the sourcemap. Useful for doing this sort of thing:
+  	 * `generateMap(options?: SourceMapOptions): SourceMap;`
+  	 */
+  toUrl(): string;
+}
+type ExclusionRange = [number, number];
+interface MagicStringOptions {
+  filename?: string;
+  indentExclusionRanges?: ExclusionRange | Array<ExclusionRange>;
+  offset?: number;
+}
+interface IndentOptions {
+  exclude?: ExclusionRange | Array<ExclusionRange>;
+  indentStart?: boolean;
+}
+interface OverwriteOptions {
+  storeName?: boolean;
+  contentOnly?: boolean;
+}
+interface UpdateOptions {
+  storeName?: boolean;
+  overwrite?: boolean;
+}
+declare class MagicString {
+  constructor(str: string, options?: MagicStringOptions);
+  /**
+  	 * Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false.
+  	 */
+  addSourcemapLocation(char: number): void;
+  /**
+  	 * Appends the specified content to the end of the string.
+  	 */
+  append(content: string): this;
+  /**
+  	 * Appends the specified content at the index in the original string.
+  	 * If a range *ending* with index is subsequently moved, the insert will be moved with it.
+  	 * See also `s.prependLeft(...)`.
+  	 */
+  appendLeft(index: number, content: string): this;
+  /**
+  	 * Appends the specified content at the index in the original string.
+  	 * If a range *starting* with index is subsequently moved, the insert will be moved with it.
+  	 * See also `s.prependRight(...)`.
+  	 */
+  appendRight(index: number, content: string): this;
+  /**
+  	 * Does what you'd expect.
+  	 */
+  clone(): this;
+  /**
+  	 * Generates a version 3 sourcemap.
+  	 */
+  generateMap(options?: SourceMapOptions): SourceMap;
+  /**
+  	 * Generates a sourcemap object with raw mappings in array form, rather than encoded as a string.
+  	 * Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead.
+  	 */
+  generateDecodedMap(options?: SourceMapOptions): DecodedSourceMap;
+  getIndentString(): string;
+  /**
+  	 * Prefixes each line of the string with prefix.
+  	 * If prefix is not supplied, the indentation will be guessed from the original content, falling back to a single tab character.
+  	 */
+  indent(options?: IndentOptions): this;
+  /**
+  	 * Prefixes each line of the string with prefix.
+  	 * If prefix is not supplied, the indentation will be guessed from the original content, falling back to a single tab character.
+  	 *
+  	 * The options argument can have an exclude property, which is an array of [start, end] character ranges.
+  	 * These ranges will be excluded from the indentation - useful for (e.g.) multiline strings.
+  	 */
+  indent(indentStr?: string, options?: IndentOptions): this;
+  indentExclusionRanges: ExclusionRange | Array<ExclusionRange>;
+  /**
+  	 * Moves the characters from `start` and `end` to `index`.
+  	 */
+  move(start: number, end: number, index: number): this;
+  /**
+  	 * Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in
+  	 * that range. The same restrictions as `s.remove()` apply.
+  	 *
+  	 * The fourth argument is optional. It can have a storeName property — if true, the original name will be stored
+  	 * for later inclusion in a sourcemap's names array — and a contentOnly property which determines whether only
+  	 * the content is overwritten, or anything that was appended/prepended to the range as well.
+  	 *
+  	 * It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content.
+  	 */
+  overwrite(start: number, end: number, content: string, options?: boolean | OverwriteOptions): this;
+  /**
+  	 * Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply.
+  	 *
+  	 * The fourth argument is optional. It can have a storeName property — if true, the original name will be stored
+  	 * for later inclusion in a sourcemap's names array — and an overwrite property which determines whether only
+  	 * the content is overwritten, or anything that was appended/prepended to the range as well.
+  	 */
+  update(start: number, end: number, content: string, options?: boolean | UpdateOptions): this;
+  /**
+  	 * Prepends the string with the specified content.
+  	 */
+  prepend(content: string): this;
+  /**
+  	 * Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index
+  	 */
+  prependLeft(index: number, content: string): this;
+  /**
+  	 * Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index`
+  	 */
+  prependRight(index: number, content: string): this;
+  /**
+  	 * Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+  	 * Removing the same content twice, or making removals that partially overlap, will cause an error.
+  	 */
+  remove(start: number, end: number): this;
+  /**
+  	 * Reset the modified characters from `start` to `end` (of the original string, **not** the generated string).
+  	 */
+  reset(start: number, end: number): this;
+  /**
+  	 * Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string.
+  	 * Throws error if the indices are for characters that were already removed.
+  	 */
+  slice(start: number, end: number): string;
+  /**
+  	 * Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed.
+  	 */
+  snip(start: number, end: number): this;
+  /**
+  	 * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end.
+  	 */
+  trim(charType?: string): this;
+  /**
+  	 * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
+  	 */
+  trimStart(charType?: string): this;
+  /**
+  	 * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
+  	 */
+  trimEnd(charType?: string): this;
+  /**
+  	 * Removes empty lines from the start and end.
+  	 */
+  trimLines(): this;
+  /**
+  	 * String replacement with RegExp or string.
+  	 */
+  replace(regex: RegExp | string, replacement: string | ((substring: string, ...args: any[]) => string)): this;
+  /**
+  	 * Same as `s.replace`, but replace all matched strings instead of just one.
+  	 */
+  replaceAll(regex: RegExp | string, replacement: string | ((substring: string, ...args: any[]) => string)): this;
+  lastChar(): string;
+  lastLine(): string;
+  /**
+  	 * Returns true if the resulting source is empty (disregarding white space).
+  	 */
+  isEmpty(): boolean;
+  length(): number;
+  /**
+  	 * Indicates if the string has been changed.
+  	 */
+  hasChanged(): boolean;
+  original: string;
+  /**
+  	 * Returns the generated string.
+  	 */
+  toString(): string;
+  offset: number;
+}
+//#endregion
+export { MagicString as t };

package/dist/_libs/mlly.d.mts

@@ -0,0 +1,57 @@
+//#region node_modules/.pnpm/mlly@1.8.0/node_modules/mlly/dist/index.d.ts
+/**
+ * Represents a general structure for ECMAScript module exports.
+ */
+interface ESMExport {
+  /**
+       * Optional explicit type for complex scenarios, often used internally.
+       * @optional
+       */
+  _type?: "declaration" | "named" | "default" | "star";
+  /**
+       * The type of export (declaration, named, default or star).
+       */
+  type: "declaration" | "named" | "default" | "star";
+  /**
+       * The specific type of declaration being exported, if applicable.
+       * @optional
+       */
+  declarationType?: "let" | "var" | "const" | "enum" | "const enum" | "class" | "function" | "async function";
+  /**
+       * The full code snippet of the export statement.
+       */
+  code: string;
+  /**
+       * The starting position (index) of the export declaration in the source code.
+       */
+  start: number;
+  /**
+       * The end position (index) of the export declaration in the source code.
+       */
+  end: number;
+  /**
+       * The name of the variable, function or class being exported, if given explicitly.
+       * @optional
+       */
+  name?: string;
+  /**
+       * The name used for default exports when a specific identifier isn't given.
+       * @optional
+       */
+  defaultName?: string;
+  /**
+       * An array of names to export, applicable to named and destructured exports.
+       */
+  names: string[];
+  /**
+       * The module specifier, if any, from which exports are being re-exported.
+       * @optional
+       */
+  specifier?: string;
+}
+/**
+ * Represents a declaration export within an ECMAScript module.
+ * Extends {@link ESMExport}.
+ */
+//#endregion
+export { ESMExport 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/rou3.d.mts

@@ -0,0 +1,43 @@
+//#region node_modules/.pnpm/rou3@0.7.12/node_modules/rou3/dist/index.d.mts
+interface RouterContext<T = unknown> {
+  root: Node<T>;
+  static: Record<string, Node<T> | undefined>;
+}
+type ParamsIndexMap = Array<[Index: number, name: string | RegExp, optional: boolean]>;
+type MethodData<T = unknown> = {
+  data: T;
+  paramsMap?: ParamsIndexMap;
+  paramsRegexp: RegExp[];
+};
+interface Node<T = unknown> {
+  key: string;
+  static?: Record<string, Node<T>>;
+  param?: Node<T>;
+  wildcard?: Node<T>;
+  hasRegexParam?: boolean;
+  methods?: Record<string, MethodData<T>[] | undefined>;
+}
+//#endregion
+//#region node_modules/.pnpm/rou3@0.7.12/node_modules/rou3/dist/compiler.d.mts
+interface RouterCompilerOptions<T = any> {
+  matchAll?: boolean;
+  serialize?: (data: T) => string;
+}
+/**
+* Compiles the router instance into a faster route-matching function.
+*
+* **IMPORTANT:** `compileRouter` requires eval support with `new Function()` in the runtime for JIT compilation.
+*
+* @example
+* import { createRouter, addRoute } from "rou3";
+* import { compileRouter } from "rou3/compiler";
+* const router = createRouter();
+* // [add some routes]
+* const findRoute = compileRouter(router);
+* const matchAll = compileRouter(router, { matchAll: true });
+* findRoute("GET", "/path/foo/bar");
+*
+* @param router - The router context to compile.
+*/
+//#endregion
+export { RouterContext as n, RouterCompilerOptions as t };

package/dist/_libs/std-env.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/std-env@3.10.0/node_modules/std-env/dist/index.d.ts
+type ProviderName = "" | "appveyor" | "aws_amplify" | "azure_pipelines" | "azure_static" | "appcircle" | "bamboo" | "bitbucket" | "bitrise" | "buddy" | "buildkite" | "circle" | "cirrus" | "cloudflare_pages" | "cloudflare_workers" | "codebuild" | "codefresh" | "drone" | "drone" | "dsari" | "github_actions" | "gitlab" | "gocd" | "layerci" | "hudson" | "jenkins" | "magnum" | "netlify" | "nevercode" | "render" | "sail" | "semaphore" | "screwdriver" | "shippable" | "solano" | "strider" | "teamcity" | "travis" | "vercel" | "appcenter" | "codesandbox" | "stackblitz" | "stormkit" | "cleavr" | "zeabur" | "codesphere" | "railway" | "deno-deploy" | "firebase_app_hosting";
+//#endregion
+export { ProviderName as t };