@nullix/zod-mongoose-studio 0.0.1

package/.output/server/node_modules/@iconify/utils/lib/css/common.js

@@ -0,0 +1,76 @@
+import { makeViewBoxSquare } from "../icon/square.js";
+import { calculateSize } from "../svg/size.js";
+import { iconToSVG } from "../svg/build.js";
+import { svgToURL } from "../svg/url.js";
+import { iconToHTML } from "../svg/html.js";
+
+/**
+* Generates common CSS rules for multiple icons, rendered as background/mask
+*/
+function getCommonCSSRules(options) {
+	const result = {
+		display: "inline-block",
+		width: "1em",
+		height: "1em"
+	};
+	const varName = options.varName;
+	if (options.pseudoSelector) result["content"] = "''";
+	switch (options.mode) {
+		case "background":
+			if (varName) result["background-image"] = "var(--" + varName + ")";
+			result["background-repeat"] = "no-repeat";
+			result["background-size"] = "100% 100%";
+			break;
+		case "mask":
+			result["background-color"] = "currentColor";
+			if (varName) result["mask-image"] = result["-webkit-mask-image"] = "var(--" + varName + ")";
+			result["mask-repeat"] = result["-webkit-mask-repeat"] = "no-repeat";
+			result["mask-size"] = result["-webkit-mask-size"] = "100% 100%";
+			break;
+	}
+	return result;
+}
+/**
+* Generate CSS rules for one icon, rendered as background/mask
+*
+* This function excludes common rules
+*/
+function generateItemCSSRules(icon, options) {
+	const result = {};
+	const varName = options.varName;
+	const buildResult = iconToSVG(icon);
+	let viewBox = buildResult.viewBox;
+	if (viewBox[2] !== viewBox[3]) if (options.forceSquare) viewBox = makeViewBoxSquare(viewBox);
+	else result["width"] = calculateSize("1em", viewBox[2] / viewBox[3]);
+	const url = svgToURL(iconToHTML(buildResult.body.replace(/currentColor/g, options.color || "black"), {
+		viewBox: `${viewBox[0]} ${viewBox[1]} ${viewBox[2]} ${viewBox[3]}`,
+		width: `${viewBox[2]}`,
+		height: `${viewBox[3]}`
+	}));
+	if (varName) result["--" + varName] = url;
+	else switch (options.mode) {
+		case "background":
+			result["background-image"] = url;
+			break;
+		case "mask":
+			result["mask-image"] = result["-webkit-mask-image"] = url;
+			break;
+	}
+	return result;
+}
+/**
+* Generate content for one icon, rendered as content of pseudo-selector
+*/
+function generateItemContent(icon, options) {
+	const buildResult = iconToSVG(icon);
+	const viewBox = buildResult.viewBox;
+	const height = options.height;
+	const width = options.width ?? calculateSize(height, viewBox[2] / viewBox[3]);
+	return svgToURL(iconToHTML(buildResult.body.replace(/currentColor/g, options.color || "black"), {
+		viewBox: `${viewBox[0]} ${viewBox[1]} ${viewBox[2]} ${viewBox[3]}`,
+		width: width.toString(),
+		height: height.toString()
+	}));
+}
+
+export { generateItemCSSRules, generateItemContent, getCommonCSSRules };

package/.output/server/node_modules/@iconify/utils/lib/css/format.js

@@ -0,0 +1,40 @@
+const format = {
+	selectorStart: {
+		compressed: "{",
+		compact: " {",
+		expanded: " {"
+	},
+	selectorEnd: {
+		compressed: "}",
+		compact: "; }\n",
+		expanded: ";\n}\n"
+	},
+	rule: {
+		compressed: "{key}:",
+		compact: " {key}: ",
+		expanded: "\n  {key}: "
+	}
+};
+/**
+* Format data
+*
+* Key is selector, value is list of rules
+*/
+function formatCSS(data, mode = "expanded") {
+	const results = [];
+	for (let i = 0; i < data.length; i++) {
+		const { selector, rules } = data[i];
+		let entry = (selector instanceof Array ? selector.join(mode === "compressed" ? "," : ", ") : selector) + format.selectorStart[mode];
+		let firstRule = true;
+		for (const key in rules) {
+			if (!firstRule) entry += ";";
+			entry += format.rule[mode].replace("{key}", key) + rules[key];
+			firstRule = false;
+		}
+		entry += format.selectorEnd[mode];
+		results.push(entry);
+	}
+	return results.join(mode === "compressed" ? "" : "\n");
+}
+
+export { formatCSS };

package/.output/server/node_modules/@iconify/utils/lib/css/icon.js

@@ -0,0 +1,52 @@
+import { defaultIconProps } from "../icon/defaults.js";
+import { generateItemCSSRules, generateItemContent, getCommonCSSRules } from "./common.js";
+import { formatCSS } from "./format.js";
+
+/**
+* Get CSS for icon, rendered as background or mask
+*/
+function getIconCSS(icon, options = {}) {
+	const body = options.customise ? options.customise(icon.body) : icon.body;
+	const mode = options.mode || (options.color || !body.includes("currentColor") ? "background" : "mask");
+	let varName = options.varName;
+	if (varName === void 0 && mode === "mask") varName = "svg";
+	const newOptions = {
+		...options,
+		mode,
+		varName
+	};
+	if (mode === "background") delete newOptions.varName;
+	const rules = {
+		...options.rules,
+		...getCommonCSSRules(newOptions),
+		...generateItemCSSRules({
+			...defaultIconProps,
+			...icon,
+			body
+		}, newOptions)
+	};
+	return formatCSS([{
+		selector: options.iconSelector || ".icon",
+		rules
+	}], newOptions.format);
+}
+/**
+* Get CSS for icon, rendered as content
+*/
+function getIconContentCSS(icon, options) {
+	const body = options.customise ? options.customise(icon.body) : icon.body;
+	const content = generateItemContent({
+		...defaultIconProps,
+		...icon,
+		body
+	}, options);
+	return formatCSS([{
+		selector: options.iconSelector || ".icon::after",
+		rules: {
+			...options.rules,
+			content
+		}
+	}], options.format);
+}
+
+export { getIconCSS, getIconContentCSS };

package/.output/server/node_modules/@iconify/utils/lib/css/icons.js

@@ -0,0 +1,133 @@
+import { defaultIconProps } from "../icon/defaults.js";
+import { getIconData } from "../icon-set/get-icon.js";
+import { generateItemCSSRules, generateItemContent, getCommonCSSRules } from "./common.js";
+import { formatCSS } from "./format.js";
+
+const commonSelector = ".icon--{prefix}";
+const iconSelector = ".icon--{prefix}--{name}";
+const contentSelector = ".icon--{prefix}--{name}::after";
+const defaultSelectors = {
+	commonSelector,
+	iconSelector,
+	overrideSelector: commonSelector + iconSelector
+};
+/**
+* Get data for getIconsCSS()
+*/
+function getIconsCSSData(iconSet, names, options = {}) {
+	const css = [];
+	const errors = [];
+	const palette = options.color ? true : void 0;
+	let mode = options.mode || typeof palette === "boolean" && (palette ? "background" : "mask");
+	if (!mode) {
+		for (let i = 0; i < names.length; i++) {
+			const name = names[i];
+			const icon = getIconData(iconSet, name);
+			if (icon) {
+				mode = (options.customise ? options.customise(icon.body, name) : icon.body).includes("currentColor") ? "mask" : "background";
+				break;
+			}
+		}
+		if (!mode) {
+			mode = "mask";
+			errors.push("/* cannot detect icon mode: not set in options and icon set is missing info, rendering as " + mode + " */");
+		}
+	}
+	let varName = options.varName;
+	if (varName === void 0 && mode === "mask") varName = "svg";
+	const newOptions = {
+		...options,
+		mode,
+		varName
+	};
+	const { commonSelector: commonSelector$1, iconSelector: iconSelector$1, overrideSelector } = newOptions.iconSelector ? newOptions : defaultSelectors;
+	const iconSelectorWithPrefix = iconSelector$1.replace(/{prefix}/g, iconSet.prefix);
+	const commonRules = {
+		...options.rules,
+		...getCommonCSSRules(newOptions)
+	};
+	const hasCommonRules = commonSelector$1 && commonSelector$1 !== iconSelector$1;
+	const commonSelectors = /* @__PURE__ */ new Set();
+	if (hasCommonRules) css.push({
+		selector: commonSelector$1.replace(/{prefix}/g, iconSet.prefix),
+		rules: commonRules
+	});
+	for (let i = 0; i < names.length; i++) {
+		const name = names[i];
+		const iconData = getIconData(iconSet, name);
+		if (!iconData) {
+			errors.push("/* Could not find icon: " + name + " */");
+			continue;
+		}
+		const body = options.customise ? options.customise(iconData.body, name) : iconData.body;
+		const rules = generateItemCSSRules({
+			...defaultIconProps,
+			...iconData,
+			body
+		}, newOptions);
+		let requiresOverride = false;
+		if (hasCommonRules && overrideSelector) {
+			for (const key in rules) if (key in commonRules) requiresOverride = true;
+		}
+		const selector = (requiresOverride && overrideSelector ? overrideSelector.replace(/{prefix}/g, iconSet.prefix) : iconSelectorWithPrefix).replace(/{name}/g, name);
+		css.push({
+			selector,
+			rules
+		});
+		if (!hasCommonRules) commonSelectors.add(selector);
+	}
+	const result = {
+		css,
+		errors
+	};
+	if (!hasCommonRules && commonSelectors.size) result.common = {
+		selector: Array.from(commonSelectors).join(newOptions.format === "compressed" ? "," : ", "),
+		rules: commonRules
+	};
+	return result;
+}
+/**
+* Get CSS for icons as background/mask
+*/
+function getIconsCSS(iconSet, names, options = {}) {
+	const { css, errors, common } = getIconsCSSData(iconSet, names, options);
+	if (common) if (css.length === 1 && css[0].selector === common.selector) css[0].rules = {
+		...common.rules,
+		...css[0].rules
+	};
+	else css.unshift(common);
+	return formatCSS(css, options.format) + (errors.length ? "\n" + errors.join("\n") + "\n" : "");
+}
+/**
+* Get CSS for icons as content
+*/
+function getIconsContentCSS(iconSet, names, options) {
+	const errors = [];
+	const css = [];
+	const iconSelectorWithPrefix = (options.iconSelector ?? contentSelector).replace(/{prefix}/g, iconSet.prefix);
+	for (let i = 0; i < names.length; i++) {
+		const name = names[i];
+		const iconData = getIconData(iconSet, name);
+		if (!iconData) {
+			errors.push("/* Could not find icon: " + name + " */");
+			continue;
+		}
+		const body = options.customise ? options.customise(iconData.body, name) : iconData.body;
+		const content = generateItemContent({
+			...defaultIconProps,
+			...iconData,
+			body
+		}, options);
+		const selector = iconSelectorWithPrefix.replace(/{name}/g, name);
+		css.push({
+			selector,
+			rules: {
+				...options.rules,
+				content
+			}
+		});
+	}
+	return formatCSS(css, options.format) + (errors.length ? "\n" + errors.join("\n") + "\n" : "");
+}
+
+export { getIconsCSS, getIconsCSSData, getIconsContentCSS };

package/.output/server/node_modules/@iconify/utils/lib/customisations/bool.js

@@ -0,0 +1,20 @@
+/**
+* Get boolean customisation value from attribute
+*/
+function toBoolean(name, value, defaultValue) {
+	switch (typeof value) {
+		case "boolean": return value;
+		case "number": return !!value;
+		case "string": switch (value.toLowerCase()) {
+			case "1":
+			case "true":
+			case name.toLowerCase(): return true;
+			case "0":
+			case "false":
+			case "": return false;
+		}
+	}
+	return defaultValue;
+}
+
+export { toBoolean };

package/.output/server/node_modules/@iconify/utils/lib/customisations/defaults.js

@@ -0,0 +1,15 @@
+import { defaultIconTransformations } from "../icon/defaults.js";
+
+/**
+* Default icon customisations values
+*/
+const defaultIconSizeCustomisations = Object.freeze({
+	width: null,
+	height: null
+});
+const defaultIconCustomisations = Object.freeze({
+	...defaultIconSizeCustomisations,
+	...defaultIconTransformations
+});
+
+export { defaultIconCustomisations, defaultIconSizeCustomisations };

package/.output/server/node_modules/@iconify/utils/lib/customisations/flip.js

@@ -0,0 +1,18 @@
+const separator = /[\s,]+/;
+/**
+* Apply "flip" string to icon customisations
+*/
+function flipFromString(custom, flip) {
+	flip.split(separator).forEach((str) => {
+		switch (str.trim()) {
+			case "horizontal":
+				custom.hFlip = true;
+				break;
+			case "vertical":
+				custom.vFlip = true;
+				break;
+		}
+	});
+}
+
+export { flipFromString };

package/.output/server/node_modules/@iconify/utils/lib/customisations/merge.js

@@ -0,0 +1,18 @@
+import { defaultIconSizeCustomisations } from "./defaults.js";
+
+/**
+* Convert IconifyIconCustomisations to FullIconCustomisations, checking value types
+*/
+function mergeCustomisations(defaults, item) {
+	const result = { ...defaults };
+	for (const key in item) {
+		const value = item[key];
+		const valueType = typeof value;
+		if (key in defaultIconSizeCustomisations) {
+			if (value === null || value && (valueType === "string" || valueType === "number")) result[key] = value;
+		} else if (valueType === typeof result[key]) result[key] = key === "rotate" ? value % 4 : value;
+	}
+	return result;
+}
+
+export { mergeCustomisations };

package/.output/server/node_modules/@iconify/utils/lib/customisations/rotate.js

@@ -0,0 +1,31 @@
+/**
+* Get rotation value
+*/
+function rotateFromString(value, defaultValue = 0) {
+	const units = value.replace(/^-?[0-9.]*/, "");
+	function cleanup(value$1) {
+		while (value$1 < 0) value$1 += 4;
+		return value$1 % 4;
+	}
+	if (units === "") {
+		const num = parseInt(value);
+		return isNaN(num) ? 0 : cleanup(num);
+	} else if (units !== value) {
+		let split = 0;
+		switch (units) {
+			case "%":
+				split = 25;
+				break;
+			case "deg": split = 90;
+		}
+		if (split) {
+			let num = parseFloat(value.slice(0, value.length - units.length));
+			if (isNaN(num)) return 0;
+			num = num / split;
+			return num % 1 === 0 ? cleanup(num) : 0;
+		}
+	}
+	return defaultValue;
+}
+
+export { rotateFromString };

package/.output/server/node_modules/@iconify/utils/lib/emoji/cleanup.js

@@ -0,0 +1,80 @@
+import { joinerEmoji, vs16Emoji } from "./data.js";
+import { getEmojiCodePoint } from "./convert.js";
+
+/**
+* Get emoji sequence from string
+*
+* @example
+* // shows same emoji sequence formatted differently
+* - '1F441 FE0F 200D 1F5E8 FE0F' => [0x1f441, 0xfe0f, 0x200d, 0x1f5e8, 0xfe0f]
+* - '1f441-fe0f-200d-1f5e8-fe0f' => [0x1f441, 0xfe0f, 0x200d, 0x1f5e8, 0xfe0f]
+* - '\\uD83D\\uDC41\\uFE0F\\u200D\\uD83D\\uDDE8\\uFE0F' => [0x1f441, 0xfe0f, 0x200d, 0x1f5e8, 0xfe0f]
+*/
+function getEmojiSequenceFromString(value) {
+	return value.trim().split(/[^0-9A-F]+/i).filter((item) => item.length > 0).map(getEmojiCodePoint);
+}
+/**
+* Convert emoji sequence or keyword
+*
+* If sequence is characters list, like '1f441-fe0f', it will be converted to [0x1f441, 0xfe0f]
+* If sequence contains anything other than [0-9A-F-\s], it will be converted character by character
+*
+* This is used to treat keywords, like ':cat:' differently when converting strings to sequences
+*/
+function getSequenceFromEmojiStringOrKeyword(value) {
+	if (!value.match(/^[0-9a-fA-F-\s]+$/)) {
+		const results = [];
+		for (const codePoint of value) {
+			const code = codePoint.codePointAt(0);
+			if (code) results.push(code);
+			else return getEmojiSequenceFromString(value);
+		}
+		return results;
+	}
+	return getEmojiSequenceFromString(value);
+}
+/**
+* Split emoji sequence by joiner
+*
+* Result represents one emoji, split in smaller sequences separated by 0x200D
+*
+* @example
+* [0x1FAF1, 0x1F3FB, 0x200D, 0x1FAF2, 0x1F3FC] => [[0x1FAF1, 0x1F3FB], [0x1FAF2, 0x1F3FC]]
+*/
+function splitEmojiSequences(sequence, separator = joinerEmoji) {
+	const results = [];
+	let queue = [];
+	for (let i = 0; i < sequence.length; i++) {
+		const code = sequence[i];
+		if (code === separator) {
+			results.push(queue);
+			queue = [];
+		} else queue.push(code);
+	}
+	results.push(queue);
+	return results;
+}
+/**
+* Join emoji sequences
+*
+* Parameter represents one emoji, split in smaller sequences
+*
+* @example
+* [[0x1FAF1, 0x1F3FB], [0x1FAF2, 0x1F3FC]] => [0x1FAF1, 0x1F3FB, 0x200D, 0x1FAF2, 0x1F3FC]
+*/
+function joinEmojiSequences(sequences, separator = joinerEmoji) {
+	let results = [];
+	for (let i = 0; i < sequences.length; i++) {
+		if (i > 0) results.push(separator);
+		results = results.concat(sequences[i]);
+	}
+	return results;
+}
+/**
+* Get unqualified sequence
+*/
+function getUnqualifiedEmojiSequence(sequence) {
+	return sequence.filter((num) => num !== vs16Emoji);
+}
+
+export { getEmojiSequenceFromString, getSequenceFromEmojiStringOrKeyword, getUnqualifiedEmojiSequence, joinEmojiSequences, splitEmojiSequences };

package/.output/server/node_modules/@iconify/utils/lib/emoji/convert.js

@@ -0,0 +1,102 @@
+import { endUTF32Pair, minUTF32, startUTF32Pair1, startUTF32Pair2 } from "./data.js";
+
+/**
+* Convert string to number
+*/
+function getEmojiCodePoint(code) {
+	return parseInt(code, 16);
+}
+/**
+* First part of UTF-32 to UTF-16
+*/
+function utf32FirstNum(code) {
+	return (code - minUTF32 >> 10 | 0) + startUTF32Pair1;
+}
+/**
+* First part of UTF-32 to UTF-16
+*/
+function utf32SecondNum(code) {
+	return (code - minUTF32 & 1023) + startUTF32Pair2;
+}
+/**
+* Get UTF-32 as UTF-16 sequence
+*/
+function splitUTF32Number(code) {
+	if (code >= minUTF32) return [utf32FirstNum(code), utf32SecondNum(code)];
+}
+/**
+* Check if number is UTF-32 split as UTF-16
+*
+* @returns
+* - 1 if number fits first number in sequence
+* - 2 if number fits second number in sequence
+* - false on failure
+*/
+function isUTF32SplitNumber(value) {
+	if (value >= startUTF32Pair1) {
+		if (value < startUTF32Pair2) return 1;
+		if (value < endUTF32Pair) return 2;
+	}
+	return false;
+}
+/**
+* Get UTF-16 sequence as UTF-32
+*/
+function mergeUTF32Numbers(part1, part2) {
+	if (part1 < startUTF32Pair1 || part1 >= startUTF32Pair2 || part2 < startUTF32Pair2 || part2 >= endUTF32Pair) return;
+	return (part1 - startUTF32Pair1 << 10) + (part2 - startUTF32Pair2) + minUTF32;
+}
+/**
+* Convert hexadecimal string or number to unicode
+*/
+function getEmojiUnicode(code) {
+	return String.fromCodePoint(typeof code === "number" ? code : getEmojiCodePoint(code));
+}
+/**
+* Convert sequence to UTF-16
+*/
+function convertEmojiSequenceToUTF16(numbers) {
+	const results = [];
+	for (let i = 0; i < numbers.length; i++) {
+		const code = numbers[i];
+		if (code >= minUTF32) {
+			results.push(utf32FirstNum(code));
+			results.push(utf32SecondNum(code));
+		} else results.push(code);
+	}
+	return results;
+}
+/**
+* Convert sequence to UTF-32
+*/
+function convertEmojiSequenceToUTF32(numbers, throwOnError = true) {
+	const results = [];
+	for (let i = 0; i < numbers.length; i++) {
+		const code = numbers[i];
+		if (code >= minUTF32) {
+			results.push(code);
+			continue;
+		}
+		const part = isUTF32SplitNumber(code);
+		if (!part) {
+			results.push(code);
+			continue;
+		}
+		if (part === 1 && numbers.length > i + 1) {
+			const merged = mergeUTF32Numbers(code, numbers[i + 1]);
+			if (merged) {
+				i++;
+				results.push(merged);
+				continue;
+			}
+		}
+		if (throwOnError) {
+			const nextCode = numbers[i + 1];
+			throw new Error(`Invalid UTF-16 sequence: ${code.toString(16)}-${nextCode ? nextCode.toString(16) : "undefined"}`);
+		}
+		results.push(code);
+	}
+	return results;
+}
+
+export { convertEmojiSequenceToUTF16, convertEmojiSequenceToUTF32, getEmojiCodePoint, getEmojiUnicode, isUTF32SplitNumber, mergeUTF32Numbers, splitUTF32Number };

package/.output/server/node_modules/@iconify/utils/lib/emoji/data.js

@@ -0,0 +1,29 @@
+/** Joiner in emoji sequences */
+const joinerEmoji = 8205;
+/** Emoji as icon */
+const vs16Emoji = 65039;
+/** Keycap, preceeded by mandatory VS16 for full emoji */
+const keycapEmoji = 8419;
+const emojiComponents = {
+	"hair-style": [129456, 129460],
+	"skin-tone": [127995, 128e3]
+};
+/**
+* Minimum UTF-32 number
+*/
+const minUTF32 = 65536;
+/**
+* Codes for UTF-32 characters presented as UTF-16
+*
+* startUTF32Pair1 <= code < startUTF32Pair2 -> code for first character in pair
+* startUTF32Pair2 <= code < endUTF32Pair -> code for second character in pair
+*/
+const startUTF32Pair1 = 55296;
+const startUTF32Pair2 = 56320;
+const endUTF32Pair = 57344;
+/**
+* Emoji version as string
+*/
+const emojiVersion = "17.0";
+
+export { emojiComponents, emojiVersion, endUTF32Pair, joinerEmoji, keycapEmoji, minUTF32, startUTF32Pair1, startUTF32Pair2, vs16Emoji };

package/.output/server/node_modules/@iconify/utils/lib/emoji/format.js

@@ -0,0 +1,60 @@
+import { convertEmojiSequenceToUTF16, convertEmojiSequenceToUTF32 } from "./convert.js";
+
+const defaultUnicodeOptions = {
+	prefix: "",
+	separator: "",
+	case: "lower",
+	format: "utf-32",
+	add0: false,
+	throwOnError: true
+};
+/**
+* Convert number to string
+*/
+function convert(sequence, options) {
+	const prefix = options.prefix;
+	const func = options.case === "upper" ? "toUpperCase" : "toLowerCase";
+	return (options.format === "utf-16" ? convertEmojiSequenceToUTF16(sequence) : convertEmojiSequenceToUTF32(sequence, options.throwOnError)).map((code) => {
+		let str = code.toString(16);
+		if (options.add0 && str.length < 4) str = "0".repeat(4 - str.length) + str;
+		return prefix + str[func]();
+	}).join(options.separator);
+}
+/**
+* Convert unicode number to string
+*
+* Example:
+* 	0x1F600 => '1F600'
+*/
+function getEmojiUnicodeString(code, options = {}) {
+	return convert([code], {
+		...defaultUnicodeOptions,
+		...options
+	});
+}
+const defaultSequenceOptions = {
+	...defaultUnicodeOptions,
+	separator: "-"
+};
+/**
+* Convert unicode numbers sequence to string
+*
+* Example:
+* 	[0x1f441, 0xfe0f] => '1f441-fe0f'
+*/
+function getEmojiSequenceString(sequence, options = {}) {
+	return convert(sequence, {
+		...defaultSequenceOptions,
+		...options
+	});
+}
+/**
+* Convert unicode numbers sequence to string
+*
+* Simple version of `getEmojiSequenceString()` without options that otherwise add to bundle
+*/
+function getEmojiSequenceKeyword(sequence) {
+	return sequence.map((code) => code.toString(16)).join("-");
+}
+
+export { getEmojiSequenceKeyword, getEmojiSequenceString, getEmojiUnicodeString };