@farming-labs/theme 0.0.24 → 0.0.26

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

@@ -0,0 +1,99 @@
+import { normaliseOptions } from "./helpers.mjs";
+import inspectArray from "./array.mjs";
+import inspectTypedArray from "./typedarray.mjs";
+import inspectDate from "./date.mjs";
+import inspectFunction from "./function.mjs";
+import inspectMap from "./map.mjs";
+import inspectNumber from "./number.mjs";
+import inspectBigInt from "./bigint.mjs";
+import inspectRegExp from "./regexp.mjs";
+import inspectSet from "./set.mjs";
+import inspectString from "./string.mjs";
+import inspectSymbol from "./symbol.mjs";
+import getPromiseValue from "./promise.mjs";
+import inspectObject from "./object.mjs";
+import inspectClass from "./class.mjs";
+import inspectArguments from "./arguments.mjs";
+import inspectObject$1 from "./error.mjs";
+import inspectHTML, { inspectNodeCollection } from "./html.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/index.js
+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$1,
+	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(value, opts = {}) {
+	const options = normaliseOptions(opts, inspect);
+	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);
+		if (output) {
+			if (typeof output === "string") return output;
+			return inspect(output, options);
+		}
+	}
+	const proto = value ? Object.getPrototypeOf(value) : false;
+	if (proto === Object.prototype || proto === null) return inspectObject(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(value, options);
+	}
+	if (value === Object(value)) return inspectObject(value, options);
+	return options.stylize(String(value), type);
+}
+
+//#endregion
+export { inspect as default };

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

@@ -0,0 +1,25 @@
+import { inspectList } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/map.js
+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)} }`;
+}
+
+//#endregion
+export { inspectMap as default };

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

@@ -0,0 +1,14 @@
+import { truncate } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/number.js
+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");
+}
+
+//#endregion
+export { inspectNumber as default };

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

@@ -0,0 +1,21 @@
+import { inspectList, inspectProperty } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/object.js
+function inspectObject(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} }`;
+}
+
+//#endregion
+export { inspectObject as default };

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

@@ -0,0 +1,5 @@
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/promise.js
+const getPromiseValue = () => "Promise{…}";
+
+//#endregion
+export { getPromiseValue as default };

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

@@ -0,0 +1,12 @@
+import { truncate } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/regexp.js
+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");
+}
+
+//#endregion
+export { inspectRegExp as default };

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

@@ -0,0 +1,18 @@
+import { inspectList } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/set.js
+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)} }`;
+}
+
+//#endregion
+export { inspectSet as default };

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

@@ -0,0 +1,25 @@
+import { truncate } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/string.js
+const stringEscapeChars = 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;
+const unicodeLength = 4;
+function escape(char) {
+	return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;
+}
+function inspectString(string, options) {
+	if (stringEscapeChars.test(string)) string = string.replace(stringEscapeChars, escape);
+	return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
+}
+
+//#endregion
+export { inspectString as default };

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

@@ -0,0 +1,8 @@
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/symbol.js
+function inspectSymbol(value) {
+	if ("description" in Symbol.prototype) return value.description ? `Symbol(${value.description})` : "Symbol()";
+	return value.toString();
+}
+
+//#endregion
+export { inspectSymbol as default };

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

@@ -0,0 +1,30 @@
+import { inspectList, inspectProperty, truncate, truncator } from "./helpers.mjs";
+
+//#region ../../node_modules/.pnpm/loupe@3.2.1/node_modules/loupe/lib/typedarray.js
+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}` : ""} ]`;
+}
+
+//#endregion
+export { inspectTypedArray as default };