@farming-labs/theme 0.0.23 → 0.0.25

package/dist/node_modules/.pnpm/js-tokens@9.0.1/node_modules/js-tokens/index.mjs

@@ -0,0 +1,384 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.mjs";
+
+//#region ../../node_modules/.pnpm/js-tokens@9.0.1/node_modules/js-tokens/index.js
+var require_js_tokens = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+	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]+\})+/uy;
+	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}]+/uy;
+	LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+	MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
+	SingleLineComment = /\/\/.*/y;
+	HashbangComment = /^#!.*/;
+	JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+	JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy;
+	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);
+	module.exports = 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
+			};
+		}
+	};
+}));
+
+//#endregion
+export default require_js_tokens();
+
+export { require_js_tokens };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/arguments.mjs

@@ -0,0 +1,11 @@
+import { inspectList } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/arguments.js
+function inspectArguments(args, options) {
+	if (args.length === 0) return "Arguments[]";
+	options.truncate -= 13;
+	return `Arguments[ ${inspectList(args, options)} ]`;
+}
+
+//#endregion
+export { inspectArguments as default };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/array.mjs

@@ -0,0 +1,16 @@
+import { inspectList, inspectProperty } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/array.js
+function inspectArray(array, options) {
+	const nonIndexProperties = Object.keys(array).slice(array.length);
+	if (!array.length && !nonIndexProperties.length) return "[]";
+	options.truncate -= 4;
+	const listContents = inspectList(array, options);
+	options.truncate -= listContents.length;
+	let propertyContents = "";
+	if (nonIndexProperties.length) propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
+	return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+
+//#endregion
+export { inspectArray as default };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/bigint.mjs

@@ -0,0 +1,11 @@
+import { truncate, truncator } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/bigint.js
+function inspectBigInt(number, options) {
+	let nums = truncate(number.toString(), options.truncate - 1);
+	if (nums !== truncator) nums += "n";
+	return options.stylize(nums, "bigint");
+}
+
+//#endregion
+export { inspectBigInt as default };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/class.mjs

@@ -0,0 +1,15 @@
+import inspectObject from "./object.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/class.js
+const toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;
+function inspectClass(value, options) {
+	let name = "";
+	if (toStringTag && toStringTag in value) name = value[toStringTag];
+	name = name || value.constructor.name;
+	if (!name || name === "_class") name = "<Anonymous Class>";
+	options.truncate -= name.length;
+	return `${name}${inspectObject(value, options)}`;
+}
+
+//#endregion
+export { inspectClass as default };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/date.mjs

@@ -0,0 +1,13 @@
+import { truncate } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/date.js
+function inspectDate(dateObject, options) {
+	const stringRepresentation = dateObject.toJSON();
+	if (stringRepresentation === null) return "Invalid Date";
+	const split = stringRepresentation.split("T");
+	const date = split[0];
+	return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
+}
+
+//#endregion
+export { inspectDate as default };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/error.mjs

@@ -0,0 +1,34 @@
+import { inspectList, inspectProperty, truncate } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/error.js
+const errorKeys = [
+	"stack",
+	"line",
+	"column",
+	"name",
+	"message",
+	"fileName",
+	"lineNumber",
+	"columnNumber",
+	"number",
+	"description",
+	"cause"
+];
+function inspectObject(error, options) {
+	const properties = Object.getOwnPropertyNames(error).filter((key) => errorKeys.indexOf(key) === -1);
+	const name = error.name;
+	options.truncate -= name.length;
+	let message = "";
+	if (typeof error.message === "string") message = truncate(error.message, options.truncate);
+	else properties.unshift("message");
+	message = message ? `: ${message}` : "";
+	options.truncate -= message.length + 5;
+	options.seen = options.seen || [];
+	if (options.seen.includes(error)) return "[Circular]";
+	options.seen.push(error);
+	const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);
+	return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
+}
+
+//#endregion
+export { inspectObject as default };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/function.mjs

@@ -0,0 +1,12 @@
+import { truncate } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/function.js
+function inspectFunction(func, options) {
+	const functionType = func[Symbol.toStringTag] || "Function";
+	const name = func.name;
+	if (!name) return options.stylize(`[${functionType}]`, "special");
+	return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
+}
+
+//#endregion
+export { inspectFunction as default };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/helpers.mjs

@@ -0,0 +1,122 @@
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/helpers.js
+const ansiColors = {
+	bold: ["1", "22"],
+	dim: ["2", "22"],
+	italic: ["3", "23"],
+	underline: ["4", "24"],
+	inverse: ["7", "27"],
+	hidden: ["8", "28"],
+	strike: ["9", "29"],
+	black: ["30", "39"],
+	red: ["31", "39"],
+	green: ["32", "39"],
+	yellow: ["33", "39"],
+	blue: ["34", "39"],
+	magenta: ["35", "39"],
+	cyan: ["36", "39"],
+	white: ["37", "39"],
+	brightblack: ["30;1", "39"],
+	brightred: ["31;1", "39"],
+	brightgreen: ["32;1", "39"],
+	brightyellow: ["33;1", "39"],
+	brightblue: ["34;1", "39"],
+	brightmagenta: ["35;1", "39"],
+	brightcyan: ["36;1", "39"],
+	brightwhite: ["37;1", "39"],
+	grey: ["90", "39"]
+};
+const styles = {
+	special: "cyan",
+	number: "yellow",
+	bigint: "yellow",
+	boolean: "yellow",
+	undefined: "grey",
+	null: "bold",
+	string: "green",
+	symbol: "green",
+	date: "magenta",
+	regexp: "red"
+};
+const truncator = "…";
+function colorise(value, styleType) {
+	const color = ansiColors[styles[styleType]] || ansiColors[styleType] || "";
+	if (!color) return String(value);
+	return `\u001b[${color[0]}m${String(value)}\u001b[${color[1]}m`;
+}
+function normaliseOptions({ showHidden = false, depth = 2, colors = false, customInspect = true, showProxy = false, maxArrayLength = Infinity, breakLength = Infinity, seen = [], truncate = Infinity, stylize = String } = {}, inspect) {
+	const options = {
+		showHidden: Boolean(showHidden),
+		depth: Number(depth),
+		colors: Boolean(colors),
+		customInspect: Boolean(customInspect),
+		showProxy: Boolean(showProxy),
+		maxArrayLength: Number(maxArrayLength),
+		breakLength: Number(breakLength),
+		truncate: Number(truncate),
+		seen,
+		inspect,
+		stylize
+	};
+	if (options.colors) options.stylize = colorise;
+	return options;
+}
+function isHighSurrogate(char) {
+	return char >= "\ud800" && char <= "\udbff";
+}
+function truncate(string, length, tail = truncator) {
+	string = String(string);
+	const tailLength = tail.length;
+	const stringLength = string.length;
+	if (tailLength > length && stringLength > tailLength) return tail;
+	if (stringLength > length && stringLength > tailLength) {
+		let end = length - tailLength;
+		if (end > 0 && isHighSurrogate(string[end - 1])) end = end - 1;
+		return `${string.slice(0, end)}${tail}`;
+	}
+	return string;
+}
+function inspectList(list, options, inspectItem, separator = ", ") {
+	inspectItem = inspectItem || options.inspect;
+	const size = list.length;
+	if (size === 0) return "";
+	const originalLength = options.truncate;
+	let output = "";
+	let peek = "";
+	let truncated = "";
+	for (let i = 0; i < size; i += 1) {
+		const last = i + 1 === list.length;
+		const secondToLast = i + 2 === list.length;
+		truncated = `${truncator}(${list.length - i})`;
+		const value = list[i];
+		options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+		const string = peek || inspectItem(value, options) + (last ? "" : separator);
+		const nextLength = output.length + string.length;
+		const truncatedLength = nextLength + truncated.length;
+		if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) break;
+		if (!last && !secondToLast && truncatedLength > originalLength) break;
+		peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator);
+		if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) break;
+		output += string;
+		if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+			truncated = `${truncator}(${list.length - i - 1})`;
+			break;
+		}
+		truncated = "";
+	}
+	return `${output}${truncated}`;
+}
+function quoteComplexKey(key) {
+	if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) return key;
+	return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, "\"").replace(/(^"|"$)/g, "'");
+}
+function inspectProperty([key, value], options) {
+	options.truncate -= 2;
+	if (typeof key === "string") key = quoteComplexKey(key);
+	else if (typeof key !== "number") key = `[${options.inspect(key, options)}]`;
+	options.truncate -= key.length;
+	value = options.inspect(value, options);
+	return `${key}: ${value}`;
+}
+
+//#endregion
+export { inspectList, inspectProperty, normaliseOptions, truncate, truncator };

package/dist/node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/html.mjs

@@ -0,0 +1,39 @@
+import { inspectList, truncator } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/html.js
+function inspectAttribute([key, value], options) {
+	options.truncate -= 3;
+	if (!value) return `${options.stylize(String(key), "yellow")}`;
+	return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
+}
+function inspectNodeCollection(collection, options) {
+	return inspectList(collection, options, inspectNode, "\n");
+}
+function inspectNode(node, options) {
+	switch (node.nodeType) {
+		case 1: return inspectHTML(node, options);
+		case 3: return options.inspect(node.data, options);
+		default: return options.inspect(node, options);
+	}
+}
+function inspectHTML(element, options) {
+	const properties = element.getAttributeNames();
+	const name = element.tagName.toLowerCase();
+	const head = options.stylize(`<${name}`, "special");
+	const headClose = options.stylize(`>`, "special");
+	const tail = options.stylize(`</${name}>`, "special");
+	options.truncate -= name.length * 2 + 5;
+	let propertyContents = "";
+	if (properties.length > 0) {
+		propertyContents += " ";
+		propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, " ");
+	}
+	options.truncate -= propertyContents.length;
+	const truncate = options.truncate;
+	let children = inspectNodeCollection(element.children, options);
+	if (children && children.length > truncate) children = `${truncator}(${element.children.length})`;
+	return `${head}${propertyContents}${headClose}${children}${tail}`;
+}
+
+//#endregion
+export { inspectHTML as default, inspectNodeCollection };