nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/_deps/js-tokens.mjs

@@ -0,0 +1,411 @@
+import { a as getDefaultExportFromCjs } from './commondir.mjs';
+
+var jsTokens_1;
+var hasRequiredJsTokens;
+
+function requireJsTokens () {
+	if (hasRequiredJsTokens) return jsTokens_1;
+	hasRequiredJsTokens = 1;
+	// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
+	// License: MIT.
+	var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+	RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
+	Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+	Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
+	StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
+	NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+	Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+	WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/yu;
+	LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+	MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
+	SingleLineComment = /\/\/.*/y;
+	HashbangComment = /^#!.*/;
+	JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+	JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/yu;
+	JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y;
+	JSXText = /[^<>{}]+/y;
+	TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+	TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+	KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+	KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+	Newline = RegExp(LineTerminatorSequence.source);
+	jsTokens_1 = function*(input, {jsx = false} = {}) {
+		var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+		({length} = input);
+		lastIndex = 0;
+		lastSignificantToken = "";
+		stack = [
+			{tag: "JS"}
+		];
+		braces = [];
+		parenNesting = 0;
+		postfixIncDec = false;
+		if (match = HashbangComment.exec(input)) {
+			yield ({
+				type: "HashbangComment",
+				value: match[0]
+			});
+			lastIndex = match[0].length;
+		}
+		while (lastIndex < length) {
+			mode = stack[stack.length - 1];
+			switch (mode.tag) {
+				case "JS":
+				case "JSNonExpressionParen":
+				case "InterpolationInTemplate":
+				case "InterpolationInJSX":
+					if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+						RegularExpressionLiteral.lastIndex = lastIndex;
+						if (match = RegularExpressionLiteral.exec(input)) {
+							lastIndex = RegularExpressionLiteral.lastIndex;
+							lastSignificantToken = match[0];
+							postfixIncDec = true;
+							yield ({
+								type: "RegularExpressionLiteral",
+								value: match[0],
+								closed: match[1] !== void 0 && match[1] !== "\\"
+							});
+							continue;
+						}
+					}
+					Punctuator.lastIndex = lastIndex;
+					if (match = Punctuator.exec(input)) {
+						punctuator = match[0];
+						nextLastIndex = Punctuator.lastIndex;
+						nextLastSignificantToken = punctuator;
+						switch (punctuator) {
+							case "(":
+								if (lastSignificantToken === "?NonExpressionParenKeyword") {
+									stack.push({
+										tag: "JSNonExpressionParen",
+										nesting: parenNesting
+									});
+								}
+								parenNesting++;
+								postfixIncDec = false;
+								break;
+							case ")":
+								parenNesting--;
+								postfixIncDec = true;
+								if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+									stack.pop();
+									nextLastSignificantToken = "?NonExpressionParenEnd";
+									postfixIncDec = false;
+								}
+								break;
+							case "{":
+								Punctuator.lastIndex = 0;
+								isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+								braces.push(isExpression);
+								postfixIncDec = false;
+								break;
+							case "}":
+								switch (mode.tag) {
+									case "InterpolationInTemplate":
+										if (braces.length === mode.nesting) {
+											Template.lastIndex = lastIndex;
+											match = Template.exec(input);
+											lastIndex = Template.lastIndex;
+											lastSignificantToken = match[0];
+											if (match[1] === "${") {
+												lastSignificantToken = "?InterpolationInTemplate";
+												postfixIncDec = false;
+												yield ({
+													type: "TemplateMiddle",
+													value: match[0]
+												});
+											} else {
+												stack.pop();
+												postfixIncDec = true;
+												yield ({
+													type: "TemplateTail",
+													value: match[0],
+													closed: match[1] === "`"
+												});
+											}
+											continue;
+										}
+										break;
+									case "InterpolationInJSX":
+										if (braces.length === mode.nesting) {
+											stack.pop();
+											lastIndex += 1;
+											lastSignificantToken = "}";
+											yield ({
+												type: "JSXPunctuator",
+												value: "}"
+											});
+											continue;
+										}
+								}
+								postfixIncDec = braces.pop();
+								nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+								break;
+							case "]":
+								postfixIncDec = true;
+								break;
+							case "++":
+							case "--":
+								nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+								break;
+							case "<":
+								if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+									stack.push({tag: "JSXTag"});
+									lastIndex += 1;
+									lastSignificantToken = "<";
+									yield ({
+										type: "JSXPunctuator",
+										value: punctuator
+									});
+									continue;
+								}
+								postfixIncDec = false;
+								break;
+							default:
+								postfixIncDec = false;
+						}
+						lastIndex = nextLastIndex;
+						lastSignificantToken = nextLastSignificantToken;
+						yield ({
+							type: "Punctuator",
+							value: punctuator
+						});
+						continue;
+					}
+					Identifier.lastIndex = lastIndex;
+					if (match = Identifier.exec(input)) {
+						lastIndex = Identifier.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "for":
+							case "if":
+							case "while":
+							case "with":
+								if (lastSignificantToken !== "." && lastSignificantToken !== "?.") {
+									nextLastSignificantToken = "?NonExpressionParenKeyword";
+								}
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+						yield ({
+							type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+							value: match[0]
+						});
+						continue;
+					}
+					StringLiteral.lastIndex = lastIndex;
+					if (match = StringLiteral.exec(input)) {
+						lastIndex = StringLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield ({
+							type: "StringLiteral",
+							value: match[0],
+							closed: match[2] !== void 0
+						});
+						continue;
+					}
+					NumericLiteral.lastIndex = lastIndex;
+					if (match = NumericLiteral.exec(input)) {
+						lastIndex = NumericLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield ({
+							type: "NumericLiteral",
+							value: match[0]
+						});
+						continue;
+					}
+					Template.lastIndex = lastIndex;
+					if (match = Template.exec(input)) {
+						lastIndex = Template.lastIndex;
+						lastSignificantToken = match[0];
+						if (match[1] === "${") {
+							lastSignificantToken = "?InterpolationInTemplate";
+							stack.push({
+								tag: "InterpolationInTemplate",
+								nesting: braces.length
+							});
+							postfixIncDec = false;
+							yield ({
+								type: "TemplateHead",
+								value: match[0]
+							});
+						} else {
+							postfixIncDec = true;
+							yield ({
+								type: "NoSubstitutionTemplate",
+								value: match[0],
+								closed: match[1] === "`"
+							});
+						}
+						continue;
+					}
+					break;
+				case "JSXTag":
+				case "JSXTagEnd":
+					JSXPunctuator.lastIndex = lastIndex;
+					if (match = JSXPunctuator.exec(input)) {
+						lastIndex = JSXPunctuator.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "<":
+								stack.push({tag: "JSXTag"});
+								break;
+							case ">":
+								stack.pop();
+								if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+									nextLastSignificantToken = "?JSX";
+									postfixIncDec = true;
+								} else {
+									stack.push({tag: "JSXChildren"});
+								}
+								break;
+							case "{":
+								stack.push({
+									tag: "InterpolationInJSX",
+									nesting: braces.length
+								});
+								nextLastSignificantToken = "?InterpolationInJSX";
+								postfixIncDec = false;
+								break;
+							case "/":
+								if (lastSignificantToken === "<") {
+									stack.pop();
+									if (stack[stack.length - 1].tag === "JSXChildren") {
+										stack.pop();
+									}
+									stack.push({tag: "JSXTagEnd"});
+								}
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						yield ({
+							type: "JSXPunctuator",
+							value: match[0]
+						});
+						continue;
+					}
+					JSXIdentifier.lastIndex = lastIndex;
+					if (match = JSXIdentifier.exec(input)) {
+						lastIndex = JSXIdentifier.lastIndex;
+						lastSignificantToken = match[0];
+						yield ({
+							type: "JSXIdentifier",
+							value: match[0]
+						});
+						continue;
+					}
+					JSXString.lastIndex = lastIndex;
+					if (match = JSXString.exec(input)) {
+						lastIndex = JSXString.lastIndex;
+						lastSignificantToken = match[0];
+						yield ({
+							type: "JSXString",
+							value: match[0],
+							closed: match[2] !== void 0
+						});
+						continue;
+					}
+					break;
+				case "JSXChildren":
+					JSXText.lastIndex = lastIndex;
+					if (match = JSXText.exec(input)) {
+						lastIndex = JSXText.lastIndex;
+						lastSignificantToken = match[0];
+						yield ({
+							type: "JSXText",
+							value: match[0]
+						});
+						continue;
+					}
+					switch (input[lastIndex]) {
+						case "<":
+							stack.push({tag: "JSXTag"});
+							lastIndex++;
+							lastSignificantToken = "<";
+							yield ({
+								type: "JSXPunctuator",
+								value: "<"
+							});
+							continue;
+						case "{":
+							stack.push({
+								tag: "InterpolationInJSX",
+								nesting: braces.length
+							});
+							lastIndex++;
+							lastSignificantToken = "?InterpolationInJSX";
+							postfixIncDec = false;
+							yield ({
+								type: "JSXPunctuator",
+								value: "{"
+							});
+							continue;
+					}
+			}
+			WhiteSpace.lastIndex = lastIndex;
+			if (match = WhiteSpace.exec(input)) {
+				lastIndex = WhiteSpace.lastIndex;
+				yield ({
+					type: "WhiteSpace",
+					value: match[0]
+				});
+				continue;
+			}
+			LineTerminatorSequence.lastIndex = lastIndex;
+			if (match = LineTerminatorSequence.exec(input)) {
+				lastIndex = LineTerminatorSequence.lastIndex;
+				postfixIncDec = false;
+				if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+					lastSignificantToken = "?NoLineTerminatorHere";
+				}
+				yield ({
+					type: "LineTerminatorSequence",
+					value: match[0]
+				});
+				continue;
+			}
+			MultiLineComment.lastIndex = lastIndex;
+			if (match = MultiLineComment.exec(input)) {
+				lastIndex = MultiLineComment.lastIndex;
+				if (Newline.test(match[0])) {
+					postfixIncDec = false;
+					if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+						lastSignificantToken = "?NoLineTerminatorHere";
+					}
+				}
+				yield ({
+					type: "MultiLineComment",
+					value: match[0],
+					closed: match[1] !== void 0
+				});
+				continue;
+			}
+			SingleLineComment.lastIndex = lastIndex;
+			if (match = SingleLineComment.exec(input)) {
+				lastIndex = SingleLineComment.lastIndex;
+				postfixIncDec = false;
+				yield ({
+					type: "SingleLineComment",
+					value: match[0]
+				});
+				continue;
+			}
+			firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+			lastIndex += firstCodePoint.length;
+			lastSignificantToken = firstCodePoint;
+			postfixIncDec = false;
+			yield ({
+				type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+				value: firstCodePoint
+			});
+		}
+		return void 0;
+	};
+	return jsTokens_1;
+}
+
+var jsTokensExports = requireJsTokens();
+const jsTokens = /*@__PURE__*/getDefaultExportFromCjs(jsTokensExports);
+
+export { jsTokens as j };

package/dist/_chunks/_deps/klona.mjs

@@ -0,0 +1,137 @@
+function set(obj, key, val) {
+	if (typeof val.value === 'object') val.value = klona$1(val.value);
+	if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {
+		Object.defineProperty(obj, key, val);
+	} else obj[key] = val.value;
+}
+
+function klona$1(x) {
+	if (typeof x !== 'object') return x;
+
+	var i=0, k, list, tmp, str=Object.prototype.toString.call(x);
+
+	if (str === '[object Object]') {
+		tmp = Object.create(x.__proto__ || null);
+	} else if (str === '[object Array]') {
+		tmp = Array(x.length);
+	} else if (str === '[object Set]') {
+		tmp = new Set;
+		x.forEach(function (val) {
+			tmp.add(klona$1(val));
+		});
+	} else if (str === '[object Map]') {
+		tmp = new Map;
+		x.forEach(function (val, key) {
+			tmp.set(klona$1(key), klona$1(val));
+		});
+	} else if (str === '[object Date]') {
+		tmp = new Date(+x);
+	} else if (str === '[object RegExp]') {
+		tmp = new RegExp(x.source, x.flags);
+	} else if (str === '[object DataView]') {
+		tmp = new x.constructor( klona$1(x.buffer) );
+	} else if (str === '[object ArrayBuffer]') {
+		tmp = x.slice(0);
+	} else if (str.slice(-6) === 'Array]') {
+		// ArrayBuffer.isView(x)
+		// ~> `new` bcuz `Buffer.slice` => ref
+		tmp = new x.constructor(x);
+	}
+
+	if (tmp) {
+		for (list=Object.getOwnPropertySymbols(x); i < list.length; i++) {
+			set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
+		}
+
+		for (i=0, list=Object.getOwnPropertyNames(x); i < list.length; i++) {
+			if (Object.hasOwnProperty.call(tmp, k=list[i]) && tmp[k] === x[k]) continue;
+			set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+		}
+	}
+
+	return tmp || x;
+}
+
+function klona(x) {
+	if (typeof x !== 'object') return x;
+
+	var k, tmp, str=Object.prototype.toString.call(x);
+
+	if (str === '[object Object]') {
+		if (x.constructor !== Object && typeof x.constructor === 'function') {
+			tmp = new x.constructor();
+			for (k in x) {
+				if (x.hasOwnProperty(k) && tmp[k] !== x[k]) {
+					tmp[k] = klona(x[k]);
+				}
+			}
+		} else {
+			tmp = {}; // null
+			for (k in x) {
+				if (k === '__proto__') {
+					Object.defineProperty(tmp, k, {
+						value: klona(x[k]),
+						configurable: true,
+						enumerable: true,
+						writable: true,
+					});
+				} else {
+					tmp[k] = klona(x[k]);
+				}
+			}
+		}
+		return tmp;
+	}
+
+	if (str === '[object Array]') {
+		k = x.length;
+		for (tmp=Array(k); k--;) {
+			tmp[k] = klona(x[k]);
+		}
+		return tmp;
+	}
+
+	if (str === '[object Set]') {
+		tmp = new Set;
+		x.forEach(function (val) {
+			tmp.add(klona(val));
+		});
+		return tmp;
+	}
+
+	if (str === '[object Map]') {
+		tmp = new Map;
+		x.forEach(function (val, key) {
+			tmp.set(klona(key), klona(val));
+		});
+		return tmp;
+	}
+
+	if (str === '[object Date]') {
+		return new Date(+x);
+	}
+
+	if (str === '[object RegExp]') {
+		tmp = new RegExp(x.source, x.flags);
+		tmp.lastIndex = x.lastIndex;
+		return tmp;
+	}
+
+	if (str === '[object DataView]') {
+		return new x.constructor( klona(x.buffer) );
+	}
+
+	if (str === '[object ArrayBuffer]') {
+		return x.slice(0);
+	}
+
+	// ArrayBuffer.isView(x)
+	// ~> `new` bcuz `Buffer.slice` => ref
+	if (str.slice(-6) === 'Array]') {
+		return new x.constructor(x);
+	}
+
+	return x;
+}
+
+export { klona as a, klona$1 as k };