nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_libs/encodeurl.mjs

@@ -0,0 +1,49 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/encodeurl@2.0.0/node_modules/encodeurl/index.js
+var require_encodeurl = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/encodeurl@2.0.0/node_modules/encodeurl/index.js": ((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = encodeUrl;
+	/**
+	* RegExp to match non-URL code points, *after* encoding (i.e. not including "%")
+	* and including invalid escape sequences.
+	* @private
+	*/
+	var ENCODE_CHARS_REGEXP = /(?:[^\x21\x23-\x3B\x3D\x3F-\x5F\x61-\x7A\x7C\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g;
+	/**
+	* RegExp to match unmatched surrogate pair.
+	* @private
+	*/
+	var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g;
+	/**
+	* String to replace unmatched surrogate pair with.
+	* @private
+	*/
+	var UNMATCHED_SURROGATE_PAIR_REPLACE = "$1�$2";
+	/**
+	* Encode a URL to a percent-encoded form, excluding already-encoded sequences.
+	*
+	* This function will take an already-encoded URL and encode all the non-URL
+	* code points. This function will not encode the "%" character unless it is
+	* not part of a valid sequence (`%20` will be left as-is, but `%foo` will
+	* be encoded as `%25foo`).
+	*
+	* This encode is meant to be "safe" and does not throw errors. It will try as
+	* hard as it can to properly encode the given URL, including replacing any raw,
+	* unpaired surrogate pairs with the Unicode replacement character prior to
+	* encoding.
+	*
+	* @param {string} url
+	* @return {string}
+	* @public
+	*/
+	function encodeUrl(url) {
+		return String(url).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI);
+	}
+}) });
+
+//#endregion
+export { require_encodeurl as t };

package/dist/_libs/escape-html.mjs

@@ -0,0 +1,58 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js
+var require_escape_html = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js": ((exports, module) => {
+	/**
+	* Module variables.
+	* @private
+	*/
+	var matchHtmlRegExp = /["'&<>]/;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = escapeHtml;
+	/**
+	* Escape special characters in the given string of html.
+	*
+	* @param  {string} string The string to escape for inserting into HTML
+	* @return {string}
+	* @public
+	*/
+	function escapeHtml(string) {
+		var str = "" + string;
+		var match = matchHtmlRegExp.exec(str);
+		if (!match) return str;
+		var escape;
+		var html = "";
+		var index = 0;
+		var lastIndex = 0;
+		for (index = match.index; index < str.length; index++) {
+			switch (str.charCodeAt(index)) {
+				case 34:
+					escape = "&quot;";
+					break;
+				case 38:
+					escape = "&amp;";
+					break;
+				case 39:
+					escape = "&#39;";
+					break;
+				case 60:
+					escape = "&lt;";
+					break;
+				case 62:
+					escape = "&gt;";
+					break;
+				default: continue;
+			}
+			if (lastIndex !== index) html += str.substring(lastIndex, index);
+			lastIndex = index + 1;
+			html += escape;
+		}
+		return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+	}
+}) });
+
+//#endregion
+export { require_escape_html as t };

package/dist/_libs/escape-string-regexp.mjs

@@ -0,0 +1,8 @@
+//#region node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
+function escapeStringRegexp(string) {
+	if (typeof string !== "string") throw new TypeError("Expected a string");
+	return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+
+//#endregion
+export { escapeStringRegexp as t };

package/dist/_libs/estree-walker.mjs

@@ -0,0 +1,330 @@
+//#region node_modules/.pnpm/estree-walker@2.0.2/node_modules/estree-walker/dist/esm/estree-walker.js
+/** @typedef { import('estree').BaseNode} BaseNode */
+/** @typedef {{
+skip: () => void;
+remove: () => void;
+replace: (node: BaseNode) => void;
+}} WalkerContext */
+var WalkerBase$1 = class {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {BaseNode | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+	}
+	/**
+	*
+	* @param {any} parent
+	* @param {string} prop
+	* @param {number} index
+	* @param {BaseNode} node
+	*/
+	replace(parent, prop, index, node) {
+		if (parent) if (index !== null) parent[prop][index] = node;
+		else parent[prop] = node;
+	}
+	/**
+	*
+	* @param {any} parent
+	* @param {string} prop
+	* @param {number} index
+	*/
+	remove(parent, prop, index) {
+		if (parent) if (index !== null) parent[prop].splice(index, 1);
+		else delete parent[prop];
+	}
+};
+/** @typedef { import('estree').BaseNode} BaseNode */
+/** @typedef { import('./walker.js').WalkerContext} WalkerContext */
+/** @typedef {(
+*    this: WalkerContext,
+*    node: BaseNode,
+*    parent: BaseNode,
+*    key: string,
+*    index: number
+* ) => void} SyncHandler */
+var SyncWalker$1 = class extends WalkerBase$1 {
+	/**
+	*
+	* @param {SyncHandler} enter
+	* @param {SyncHandler} leave
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {SyncHandler} */
+		this.enter = enter;
+		/** @type {SyncHandler} */
+		this.leave = leave;
+	}
+	/**
+	*
+	* @param {BaseNode} node
+	* @param {BaseNode} parent
+	* @param {string} [prop]
+	* @param {number} [index]
+	* @returns {BaseNode}
+	*/
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			for (const key in node) {
+				const value = node[key];
+				if (typeof value !== "object") continue;
+				else if (Array.isArray(value)) {
+					for (let i = 0; i < value.length; i += 1) if (value[i] !== null && typeof value[i].type === "string") {
+						if (!this.visit(value[i], node, key, i)) i--;
+					}
+				} else if (value !== null && typeof value.type === "string") this.visit(value, node, key, null);
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/** @typedef { import('estree').BaseNode} BaseNode */
+/** @typedef { import('./sync.js').SyncHandler} SyncHandler */
+/** @typedef { import('./async.js').AsyncHandler} AsyncHandler */
+/**
+*
+* @param {BaseNode} ast
+* @param {{
+*   enter?: SyncHandler
+*   leave?: SyncHandler
+* }} walker
+* @returns {BaseNode}
+*/
+function walk$1(ast, { enter, leave }) {
+	return new SyncWalker$1(enter, leave).visit(ast, null);
+}
+
+//#endregion
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef {{
+*   skip: () => void;
+*   remove: () => void;
+*   replace: (node: Node) => void;
+* }} WalkerContext
+*/
+var WalkerBase = class {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	* @param {Node} node
+	*/
+	replace(parent, prop, index, node) {
+		if (parent && prop) if (index != null)
+ /** @type {Array<Node>} */ parent[prop][index] = node;
+		else
+ /** @type {Node} */ parent[prop] = node;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	*/
+	remove(parent, prop, index) {
+		if (parent && prop) if (index !== null && index !== void 0)
+ /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+		else delete parent[prop];
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef { import('./walker.js').WalkerContext} WalkerContext
+* @typedef {(
+*    this: WalkerContext,
+*    node: Node,
+*    parent: Node | null,
+*    key: string | number | symbol | null | undefined,
+*    index: number | null | undefined
+* ) => void} SyncHandler
+*/
+var SyncWalker = class extends WalkerBase {
+	/**
+	*
+	* @param {SyncHandler} [enter]
+	* @param {SyncHandler} [leave]
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+		/** @type {SyncHandler | undefined} */
+		this.enter = enter;
+		/** @type {SyncHandler | undefined} */
+		this.leave = leave;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Node} node
+	* @param {Parent | null} parent
+	* @param {keyof Parent} [prop]
+	* @param {number | null} [index]
+	* @returns {Node | null}
+	*/
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			/** @type {keyof Node} */
+			let key;
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+				if (value && typeof value === "object") {
+					if (Array.isArray(value)) {
+						const nodes = value;
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i)) i--;
+							}
+						}
+					} else if (isNode(value)) this.visit(value, node, key, null);
+				}
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/**
+* Ducktype a node.
+*
+* @param {unknown} value
+* @returns {value is Node}
+*/
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+//#endregion
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+/**
+* @typedef {import('estree').Node} Node
+* @typedef {import('./sync.js').SyncHandler} SyncHandler
+* @typedef {import('./async.js').AsyncHandler} AsyncHandler
+*/
+/**
+* @param {Node} ast
+* @param {{
+*   enter?: SyncHandler
+*   leave?: SyncHandler
+* }} walker
+* @returns {Node | null}
+*/
+function walk(ast, { enter, leave }) {
+	return new SyncWalker(enter, leave).visit(ast, null);
+}
+
+//#endregion
+export { walk$1 as n, walk as t };

package/dist/_libs/etag.mjs

@@ -0,0 +1,75 @@
+import { i as __require, t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js
+var require_etag = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js": ((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = etag;
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var crypto = __require("crypto");
+	var Stats = __require("fs").Stats;
+	/**
+	* Module variables.
+	* @private
+	*/
+	var toString = Object.prototype.toString;
+	/**
+	* Generate an entity tag.
+	*
+	* @param {Buffer|string} entity
+	* @return {string}
+	* @private
+	*/
+	function entitytag(entity) {
+		if (entity.length === 0) return "\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"";
+		var hash = crypto.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
+		return "\"" + (typeof entity === "string" ? Buffer.byteLength(entity, "utf8") : entity.length).toString(16) + "-" + hash + "\"";
+	}
+	/**
+	* Create a simple ETag.
+	*
+	* @param {string|Buffer|Stats} entity
+	* @param {object} [options]
+	* @param {boolean} [options.weak]
+	* @return {String}
+	* @public
+	*/
+	function etag(entity, options) {
+		if (entity == null) throw new TypeError("argument entity is required");
+		var isStats = isstats(entity);
+		var weak = options && typeof options.weak === "boolean" ? options.weak : isStats;
+		if (!isStats && typeof entity !== "string" && !Buffer.isBuffer(entity)) throw new TypeError("argument entity must be string, Buffer, or fs.Stats");
+		var tag = isStats ? stattag(entity) : entitytag(entity);
+		return weak ? "W/" + tag : tag;
+	}
+	/**
+	* Determine if object is a Stats object.
+	*
+	* @param {object} obj
+	* @return {boolean}
+	* @api private
+	*/
+	function isstats(obj) {
+		if (typeof Stats === "function" && obj instanceof Stats) return true;
+		return obj && typeof obj === "object" && "ctime" in obj && toString.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
+	}
+	/**
+	* Generate a tag for a stat.
+	*
+	* @param {object} stat
+	* @return {string}
+	* @private
+	*/
+	function stattag(stat) {
+		var mtime = stat.mtime.getTime().toString(16);
+		return "\"" + stat.size.toString(16) + "-" + mtime + "\"";
+	}
+}) });
+
+//#endregion
+export { require_etag as t };