@powerlines/plugin-alloy 0.26.179 → 0.26.181

package/dist/node_modules/.pnpm/@vitest_utils@4.1.7/node_modules/@vitest/utils/dist/display.cjs

@@ -0,0 +1,561 @@
+const require_index = require('../../../../../@vitest_pretty-format@4.1.7/node_modules/@vitest/pretty-format/dist/index.cjs');
+
+//#region ../../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/display.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}`;
+}
+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}` : ""} ]`;
+}
+const getArrayName = (array) => {
+	if (typeof Buffer === "function" && array instanceof Buffer) return "Buffer";
+	if (array[Symbol.toStringTag]) return array[Symbol.toStringTag];
+	return array.constructor.name;
+};
+function inspectTypedArray(array, options) {
+	const name = getArrayName(array);
+	options.truncate -= name.length + 4;
+	const nonIndexProperties = Object.keys(array).slice(array.length);
+	if (!array.length && !nonIndexProperties.length) return `${name}[]`;
+	let output = "";
+	for (let i = 0; i < array.length; i++) {
+		const string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;
+		options.truncate -= string.length;
+		if (array[i] !== array.length && options.truncate <= 3) {
+			output += `${truncator}(${array.length - array[i] + 1})`;
+			break;
+		}
+		output += string;
+	}
+	let propertyContents = "";
+	if (nonIndexProperties.length) propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
+	return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+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");
+}
+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");
+}
+function inspectMapEntry([key, value], options) {
+	options.truncate -= 4;
+	key = options.inspect(key, options);
+	options.truncate -= key.length;
+	value = options.inspect(value, options);
+	return `${key} => ${value}`;
+}
+function mapToEntries(map) {
+	const entries = [];
+	map.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+}
+function inspectMap(map, options) {
+	if (map.size === 0) return "Map{}";
+	options.truncate -= 7;
+	return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+}
+const isNaN = Number.isNaN || ((i) => i !== i);
+function inspectNumber(number, options) {
+	if (isNaN(number)) return options.stylize("NaN", "number");
+	if (number === Infinity) return options.stylize("Infinity", "number");
+	if (number === -Infinity) return options.stylize("-Infinity", "number");
+	if (number === 0) return options.stylize(1 / number === Infinity ? "+0" : "-0", "number");
+	return options.stylize(truncate(String(number), options.truncate), "number");
+}
+function inspectBigInt(number, options) {
+	let nums = truncate(number.toString(), options.truncate - 1);
+	if (nums !== truncator) nums += "n";
+	return options.stylize(nums, "bigint");
+}
+function inspectRegExp(value, options) {
+	const flags = value.toString().split("/")[2];
+	const sourceLength = options.truncate - (2 + flags.length);
+	const source = value.source;
+	return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
+}
+function arrayFromSet(set) {
+	const values = [];
+	set.forEach((value) => {
+		values.push(value);
+	});
+	return values;
+}
+function inspectSet(set, options) {
+	if (set.size === 0) return "Set{}";
+	options.truncate -= 7;
+	return `Set{ ${inspectList(arrayFromSet(set), options)} }`;
+}
+const stringEscapeChars = /* @__PURE__ */ new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
+const escapeCharacters = {
+	"\b": "\\b",
+	"	": "\\t",
+	"\n": "\\n",
+	"\f": "\\f",
+	"\r": "\\r",
+	"'": "\\'",
+	"\\": "\\\\"
+};
+const hex = 16;
+function escape(char) {
+	return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-4)}`;
+}
+function inspectString(string, options) {
+	if (stringEscapeChars.test(string)) string = string.replace(stringEscapeChars, escape);
+	return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
+}
+function inspectSymbol(value) {
+	if ("description" in Symbol.prototype) return value.description ? `Symbol(${value.description})` : "Symbol()";
+	return value.toString();
+}
+const getPromiseValue = () => "Promise{…}";
+function inspectObject$1(object, options) {
+	const properties = Object.getOwnPropertyNames(object);
+	const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+	if (properties.length === 0 && symbols.length === 0) return "{}";
+	options.truncate -= 4;
+	options.seen = options.seen || [];
+	if (options.seen.includes(object)) return "[Circular]";
+	options.seen.push(object);
+	const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty);
+	const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);
+	options.seen.pop();
+	let sep = "";
+	if (propertyContents && symbolContents) sep = ", ";
+	return `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+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$1(value, options)}`;
+}
+function inspectArguments(args, options) {
+	if (args.length === 0) return "Arguments[]";
+	options.truncate -= 13;
+	return `Arguments[ ${inspectList(args, options)} ]`;
+}
+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} }` : ""}`;
+}
+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}`;
+}
+const chaiInspect = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("chai/inspect") : "@@chai/inspect";
+const nodeInspect = Symbol.for("nodejs.util.inspect.custom");
+const constructorMap = /* @__PURE__ */ new WeakMap();
+const stringTagMap = {};
+const baseTypesMap = {
+	undefined: (value, options) => options.stylize("undefined", "undefined"),
+	null: (value, options) => options.stylize("null", "null"),
+	boolean: (value, options) => options.stylize(String(value), "boolean"),
+	Boolean: (value, options) => options.stylize(String(value), "boolean"),
+	number: inspectNumber,
+	Number: inspectNumber,
+	bigint: inspectBigInt,
+	BigInt: inspectBigInt,
+	string: inspectString,
+	String: inspectString,
+	function: inspectFunction,
+	Function: inspectFunction,
+	symbol: inspectSymbol,
+	Symbol: inspectSymbol,
+	Array: inspectArray,
+	Date: inspectDate,
+	Map: inspectMap,
+	Set: inspectSet,
+	RegExp: inspectRegExp,
+	Promise: getPromiseValue,
+	WeakSet: (value, options) => options.stylize("WeakSet{…}", "special"),
+	WeakMap: (value, options) => options.stylize("WeakMap{…}", "special"),
+	Arguments: inspectArguments,
+	Int8Array: inspectTypedArray,
+	Uint8Array: inspectTypedArray,
+	Uint8ClampedArray: inspectTypedArray,
+	Int16Array: inspectTypedArray,
+	Uint16Array: inspectTypedArray,
+	Int32Array: inspectTypedArray,
+	Uint32Array: inspectTypedArray,
+	Float32Array: inspectTypedArray,
+	Float64Array: inspectTypedArray,
+	Generator: () => "",
+	DataView: () => "",
+	ArrayBuffer: () => "",
+	Error: inspectObject,
+	HTMLCollection: inspectNodeCollection,
+	NodeList: inspectNodeCollection
+};
+const inspectCustom = (value, options, type, inspectFn) => {
+	if (chaiInspect in value && typeof value[chaiInspect] === "function") return value[chaiInspect](options);
+	if (nodeInspect in value && typeof value[nodeInspect] === "function") return value[nodeInspect](options.depth, options, inspectFn);
+	if ("inspect" in value && typeof value.inspect === "function") return value.inspect(options.depth, options);
+	if ("constructor" in value && constructorMap.has(value.constructor)) return constructorMap.get(value.constructor)(value, options);
+	if (stringTagMap[type]) return stringTagMap[type](value, options);
+	return "";
+};
+const toString = Object.prototype.toString;
+function inspect$1(value, opts = {}) {
+	const options = normaliseOptions(opts, inspect$1);
+	const { customInspect } = options;
+	let type = value === null ? "null" : typeof value;
+	if (type === "object") type = toString.call(value).slice(8, -1);
+	if (type in baseTypesMap) return baseTypesMap[type](value, options);
+	if (customInspect && value) {
+		const output = inspectCustom(value, options, type, inspect$1);
+		if (output) {
+			if (typeof output === "string") return output;
+			return inspect$1(output, options);
+		}
+	}
+	const proto = value ? Object.getPrototypeOf(value) : false;
+	if (proto === Object.prototype || proto === null) return inspectObject$1(value, options);
+	if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) return inspectHTML(value, options);
+	if ("constructor" in value) {
+		if (value.constructor !== Object) return inspectClass(value, options);
+		return inspectObject$1(value, options);
+	}
+	if (value === Object(value)) return inspectObject$1(value, options);
+	return options.stylize(String(value), type);
+}
+const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = require_index.plugins;
+const PLUGINS = [
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options } = {}) {
+	const MAX_LENGTH = maxLength ?? 1e4;
+	let result;
+	const filterFn = typeof filterNode === "string" ? createNodeFilterFromSelector(filterNode) : filterNode;
+	const plugins = filterFn ? [
+		ReactTestComponent,
+		ReactElement,
+		require_index.createDOMElementFilter(filterFn),
+		DOMCollection,
+		Immutable,
+		AsymmetricMatcher
+	] : PLUGINS;
+	try {
+		result = require_index.format(object, {
+			maxDepth,
+			escapeString: false,
+			plugins,
+			...options
+		});
+	} catch {
+		result = require_index.format(object, {
+			callToJSON: false,
+			maxDepth,
+			escapeString: false,
+			plugins,
+			...options
+		});
+	}
+	return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+		maxLength,
+		filterNode,
+		...options
+	}) : result;
+}
+function createNodeFilterFromSelector(selector) {
+	const ELEMENT_NODE = 1;
+	const COMMENT_NODE = 8;
+	return (node) => {
+		if (node.nodeType === COMMENT_NODE) return false;
+		if (node.nodeType === ELEMENT_NODE && node.matches) try {
+			return !node.matches(selector);
+		} catch {
+			return true;
+		}
+		return true;
+	};
+}
+const formatRegExp = /%[sdjifoOc%]/g;
+function baseFormat(args, options = {}) {
+	const formatArg = (item, inspecOptions) => {
+		if (options.prettifyObject) return stringify(item, void 0, {
+			printBasicPrototype: false,
+			escapeString: false
+		});
+		return inspect(item, inspecOptions);
+	};
+	if (typeof args[0] !== "string") {
+		const objects = [];
+		for (let i = 0; i < args.length; i++) objects.push(formatArg(args[i], {
+			depth: 0,
+			colors: false
+		}));
+		return objects.join(" ");
+	}
+	const len = args.length;
+	let i = 1;
+	const template = args[0];
+	let str = String(template).replace(formatRegExp, (x) => {
+		if (x === "%%") return "%";
+		if (i >= len) return x;
+		switch (x) {
+			case "%s": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				if (typeof value === "number" && value === 0 && 1 / value < 0) return "-0";
+				if (typeof value === "object" && value !== null) {
+					if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) return value.toString();
+					return formatArg(value, {
+						depth: 0,
+						colors: false
+					});
+				}
+				return String(value);
+			}
+			case "%d": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				if (typeof value === "symbol") return "NaN";
+				return Number(value).toString();
+			}
+			case "%i": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				return Number.parseInt(String(value)).toString();
+			}
+			case "%f": return Number.parseFloat(String(args[i++])).toString();
+			case "%o": return formatArg(args[i++], {
+				showHidden: true,
+				showProxy: true
+			});
+			case "%O": return formatArg(args[i++]);
+			case "%c":
+				i++;
+				return "";
+			case "%j": try {
+				return JSON.stringify(args[i++]);
+			} catch (err) {
+				const m = err.message;
+				if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) return "[Circular]";
+				throw err;
+			}
+			default: return x;
+		}
+	});
+	for (let x = args[i]; i < len; x = args[++i]) if (x === null || typeof x !== "object") str += ` ${typeof x === "symbol" ? x.toString() : x}`;
+	else str += ` ${formatArg(x)}`;
+	return str;
+}
+function format(...args) {
+	return baseFormat(args);
+}
+function inspect(obj, options = {}) {
+	if (options.truncate === 0) options.truncate = Number.POSITIVE_INFINITY;
+	return inspect$1(obj, options);
+}
+function objDisplay(obj, options = {}) {
+	if (typeof options.truncate === "undefined") options.truncate = 40;
+	const str = inspect(obj, options);
+	const type = Object.prototype.toString.call(obj);
+	if (options.truncate && str.length >= options.truncate) if (type === "[object Function]") {
+		const fn = obj;
+		return !fn.name ? "[Function]" : `[Function: ${fn.name}]`;
+	} else if (type === "[object Array]") return `[ Array(${obj.length}) ]`;
+	else if (type === "[object Object]") {
+		const keys = Object.keys(obj);
+		return `{ Object (${keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ")}) }`;
+	} else return str;
+	return str;
+}
+
+//#endregion
+exports.format = format;
+exports.formatRegExp = formatRegExp;
+exports.objDisplay = objDisplay;
+exports.stringify = stringify;