nitro-nightly 3.0.1-alpha.1 → 3.0.1-alpha.2

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

@@ -1,8 +1,13 @@
+import { n as __exportAll } from "../_common.mjs";
 import http from "node:http";
 import https from "node:https";
 import { EventEmitter } from "node:events";
 
 //#region node_modules/.pnpm/httpxy@0.1.7/node_modules/httpxy/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({
+	ProxyServer: () => ProxyServer,
+	createProxyServer: () => createProxyServer
+});
 const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
 const isSSL = /^https|wss/;
 function setupOutgoing(outgoing, options, req, forward) {
@@ -407,4 +412,4 @@ function _createProxyFn(type, server) {
 }
 
 //#endregion
-export { createProxyServer as n, 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 };