@ui0/util 0.0.0-stage → 0.0.1

package/dist/index.js

@@ -0,0 +1,2164 @@
+// src/array/array.ts
+/**
+* Omit values from arr based on values list and return new array with this values
+* @param {T[]} arr
+* @param {T[]} omitted
+* @return {T[]}
+*/
+function arrayOmit(arr, omitted) {
+	const _omitted = omitted || [];
+	const copy = arr ? [...arr] : [];
+	const out = copy || [];
+	_omitted.forEach((o) => {
+		const pos = copy.indexOf(o);
+		if (pos > -1) copy.splice(pos, 1);
+	});
+	return out;
+}
+/**
+* Omit values from arr based on values list
+* Mutable version of arrayOmit
+* @param {T[]} arr
+* @param {T[]} omitted
+
+*/
+function arrayOmitArray(arr = [], omitted) {
+	const _omitted = omitted || [];
+	const copy = [...arr];
+	_omitted.forEach((o) => {
+		const pos = copy.indexOf(o);
+		if (pos > -1) copy.splice(pos, 1);
+	});
+}
+/**
+* Make this array items unique
+* [1,2,3,3,2,5] => [1,2,3,5]
+* @param {T[]} arr
+* @return {T[]}
+*/
+function toUnique(arr) {
+	return [...new Set(arr)];
+}
+/**
+* Return the last element of an array.
+*
+* @param arr - the array to read
+* @returns the last item, or `undefined` for an empty array
+*/
+function getLastItemFromArray(arr) {
+	return arr[arr.length - 1];
+}
+/**
+* Pick element with offset from item's position in arr
+* Next item - +1
+* Prev item - -1
+* returns same item if not found
+* @param {T[]} arr
+* @param {T} item
+* @param {number} offset
+* @return {T}
+*/
+function arrayPickFromItemOffset(arr, item, offset) {
+	if (arr.length < 2) return item;
+	if (offset < 0 && arr[0] === item) return item;
+	if (offset > 0 && arr[arr.length - offset] === item) return item;
+	for (let i = 1; i < arr.length; i++) if (arr[i] === item) return arr[i + offset];
+	return item;
+}
+/**
+* Pick the element `offset` positions after `item`.
+*
+* Thin wrapper over {@link arrayPickFromItemOffset} with a positive offset;
+* out-of-range offsets and unknown items return `item` itself.
+*
+* @param arr - the array to walk
+* @param item - the anchor element
+* @param offset - how many positions to move forward, defaults to `1`
+* @returns the neighbor element, or `item`
+*/
+function arrayPickNext(arr, item, offset = 1) {
+	return arrayPickFromItemOffset(arr, item, offset);
+}
+/**
+* Pick the element `offset` positions before `item`.
+*
+* Thin wrapper over {@link arrayPickFromItemOffset} with a negative offset;
+* out-of-range offsets and unknown items return `item` itself.
+*
+* @param arr - the array to walk
+* @param item - the anchor element
+* @param offset - how many positions to move back, defaults to `1`
+* @returns the neighbor element, or `item`
+*/
+function arrayPickPrev(arr, item, offset = 1) {
+	return arrayPickFromItemOffset(arr, item, -offset);
+}
+/**
+* get item from array when iterating over length
+* getItemByOverflowIndex([0,1,2,3], 8) // => 1 ([0,1,2,3], 6) => 3
+*
+* @param {T[]} arr
+* @param {number} index
+* @param offset takes inc/dec by offset value,
+* @default 1
+* @return {T}
+*/
+function getItemByOverflowIndex(arr, index, offset = 1) {
+	if (index > arr.length - offset) return arr[index % arr.length];
+	return arr[Math.abs(index)];
+}
+/**
+* Coerce every element of an array to a number.
+*
+* Nullish entries become `0`; non-numeric strings coerce to `NaN`.
+*
+* @param arr - the source array
+* @returns a parallel array of numbers
+*/
+function arrayToNumberArray(arr) {
+	return arr.reduce((prev, next) => [...prev, +(next ?? 0)], []);
+}
+/**
+* Compare two arrays item by item, recursing into nested arrays.
+*
+* @param a - the first array
+* @param b - the second array
+* @returns `true` when the lengths match and every pair is `===` (nested
+*   arrays compared recursively)
+*/
+function arrayIsEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	return a.every((item, index) => {
+		const other = b[index];
+		return Array.isArray(item) && Array.isArray(other) ? arrayIsEqual(item, other) : item === other;
+	});
+}
+/**
+* insert `items` to array at specific `index`
+* delete `deleteCount` items from `index`
+* @param arr
+* @param index
+* @param items
+* @param deleteCount
+*/
+function arrayInsertAtIndex(arr, index, items, deleteCount = 0) {
+	const safeIndex = Math.max(0, Math.min(index, arr.length));
+	arr.splice(safeIndex, deleteCount, ...items);
+}
+/**
+* Type guard: value is an array.
+*
+* @param value - the value to check
+* @returns `true` when `value` is an array
+*/
+function isArray(value) {
+	return Array.isArray(value);
+}
+// src/object/objectPickKeys.ts
+/**
+* Pick keys from object to new object with key-value
+*
+* @param {T} obj
+* @param keys
+* @example objectPickKeys({key1: true, key2: 0, key3: 'str'}, 'key2', 'key3') // {key2: 0, key3: 'str'}
+* @return {{[P in keyof T]?: any}}
+*/
+function objectPickKeys(obj, ...keys) {
+	return keys.reduce((acc, key) => {
+		if (obj.hasOwnProperty(key)) acc[key] = obj[key];
+		return acc;
+	}, {});
+}
+// src/object/objectOmitKeys.ts
+/**
+* Opposite to objectPickKeys
+* Return new object without selected keys
+* @param {T} obj
+* @param {P} args
+* @example objectOmitKeys({key1: true, key2: 0, key3: 'str'}, 'key2', 'key3') // {key1: true}
+* @return {{[P in keyof T]?: any}}
+*/
+function objectOmitKeys(obj, ...args) {
+	const out = Object.assign({}, obj);
+	args.forEach((arg) => {
+		delete out[arg];
+	});
+	return out;
+}
+// src/primitives.ts
+/**
+* Replace `undefined` with `false`, keeping any other value as-is.
+*
+* @param x - the value to guard
+* @returns `x`, or `false` when `x` is `undefined`
+*/
+function notUndefined(x) {
+	return x !== void 0 ? x : false;
+}
+/**
+* Type guard: value is a function (anything callable).
+*
+* @param fn - the value to check
+* @returns `true` when `fn` is callable
+*/
+const isFunction = (fn) => typeof fn === "function";
+/**
+* Type guard: value is a symbol.
+*
+* @param s - the value to check
+* @returns `true` when `s` is a symbol
+*/
+const isSymbol = (s) => typeof s === "symbol";
+// src/object/isObject.ts
+/**
+* Type guard: value is an object (not `null`, not an array).
+*
+* @param v - the value to check
+* @returns `true` for non-null, non-array objects
+*/
+function isObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+// src/object/objectMerge.ts
+/**
+* Objects customizable deep merging
+* @param {Record<string, any>} to
+* @param {Record<string, any>} from
+* @param {{replaceNonObjectIfObject: boolean}} options
+* @return {Record<string, any>}
+*/
+function objectMerge(to, from, options = {}) {
+	const result = { ...to };
+	const { overwrite = true, replaceNonObjectIfObject = false, mergeFunctions = false } = options;
+	if (!isObject(to) || !isObject(from)) return overwrite ? {
+		...result,
+		...from
+	} : result;
+	for (const key in from) if (key in to) {
+		if (mergeFunctions && isFunction(from[key])) result[key] = isFunction(to[key]) ? (...arg) => {
+			to[key](...arg);
+			return from[key](...arg);
+		} : overwrite ? from[key] : to[key];
+		else if (isObject(from[key]) && isObject(to[key])) result[key] = objectMerge(to[key], from[key], options);
+		else if (replaceNonObjectIfObject && isObject(from[key])) result[key] = from[key];
+		else result[key] = overwrite ? from[key] : to[key];
+	} else result[key] = from[key];
+	return result;
+}
+// src/string/string.ts
+const hyphenateExpr = /\B([A-Z])/g;
+/**
+* Convert CaseWordAAA to 'case-word-a-a-a'
+* @param {string} str
+* @return {string}
+*/
+function hyphenate(str) {
+	return str.replace(hyphenateExpr, "-$1").toLowerCase();
+}
+/**
+* Converts `is-name` to 'isName'
+* @param s
+*/
+function toCamelCase(s = "") {
+	return s.replace(/-./g, (x) => x[1].toUpperCase());
+}
+/**
+* Converts string to kebab-case (including spaces).
+* @example
+* toKebabCase('Hello World') => 'hello-world'
+* toKebabCase('camelCase') => 'camel-case'
+*/
+function toKebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase().replace(/^-+|-+$/g, "");
+}
+/**
+* Convert a kebab-case string to PascalCase (`'is-name'` → `'IsName'`).
+*
+* @param s - the kebab-case input
+* @returns the PascalCase string
+*/
+function toPascalCase(s = "") {
+	const r = s.replace(/-./g, (x) => x[1].toUpperCase());
+	return r ? r[0].toUpperCase() + r.substring(1) : r;
+}
+/**
+* Kebab-case a string, collapsing uppercase runs as whole words.
+*
+* Unlike {@link toKebabCase} (which only splits on lower→upper edges),
+* consecutive capitals collapse together: `'FOOBar'` → `'foo-bar'`,
+* `'XMLHttpRequest'` → `'xml-http-request'`.
+*
+* @param str - the string to kebab-case
+* @returns the kebab-cased string
+*/
+function kebabize(str) {
+	return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (s, ofs) => (ofs ? "-" : "") + s.toLowerCase());
+}
+/**
+* Remove vowels form word
+* @param {string} str
+* @example  removeVowels('hello world') // hll wrld
+* @return {string}
+*/
+function removeVowels(str) {
+	return str.replace(/[aoeyui]/g, "");
+}
+/**
+* returns filename from a path
+* @param {string} name
+* @example  extractFileName('/some/path/to/file.txt') // file.txt
+* @return {string | undefined}
+*/
+function extractFileName(name) {
+	return name.split(/(\\|\/)/g).pop();
+}
+/**
+* Return the directory part of a path — everything before the file name.
+*
+* @param file - the path to split
+* @returns the trailing-slash directory, or `''` when the path has none
+*/
+function extractFileDir(file) {
+	return file.replace(extractFileName(file) || "", "");
+}
+/**
+* process pack/icon?value=123 to {params: {value: 123}, res: ['pack', 'icon']}
+* @param query
+*/
+function parseQueryString(query) {
+	if (!query) return {
+		params: {},
+		res: [""]
+	};
+	const paramsOut = {};
+	const [res, params] = query.split("?");
+	const resources = res.split("/").toReversed();
+	if (params) params.split("&").forEach((item) => {
+		const [param, value] = item.split("=");
+		paramsOut[param] = value;
+		if (value === void 0) paramsOut[param] = true;
+		else if (value.indexOf(",") > 1) paramsOut[param] = value.split(",");
+		if (value === "false") paramsOut[param] = false;
+		else if (!isNaN(+value)) paramsOut[param] = +value;
+	});
+	return {
+		params: paramsOut,
+		res: resources
+	};
+}
+/**
+* convert 'some content here' to 'sch'
+* @param {string} str
+* @return {string}
+*/
+function stringToFirstLetters(str) {
+	return str.split(" ").reduce((x, i) => x ? x + (i.length && i[0] || "") : i[0], "");
+}
+/**
+* Generate random  string (a-z 0-9) with specific len
+*
+* @param {number} len  6 by default
+* @default 6
+* @return {string}
+*/
+function genRandomString(len = 6) {
+	let out = "";
+	while (out.length < len) out += Math.random().toString(36).replace("0.", "");
+	return out.substring(0, len);
+}
+/**
+* Typed String.split() wrapper
+* @param input
+* @param separator
+*/
+function splitString(input, separator) {
+	if (Array.isArray(input)) return input;
+	return input.split(separator).map((item) => item.trim());
+}
+/**
+* typeof guard
+*/
+function isString(v) {
+	return typeof v === "string";
+}
+// src/vue/findFrameworkInstance.ts
+/**
+* retrieve instance of a any framework plugin from vue instance if exists
+* @param app
+* @param name
+*/
+function findFrameworkInstance(app, name) {
+	if (name in app.config.globalProperties) {
+		const instance = app.config.globalProperties[name];
+		if (instance) return instance;
+	}
+}
+// src/vue/mergeCssModulesStyles.ts
+/**
+* Merge two CSS-module class maps, the second winning on key conflicts.
+*
+* Mirrors how a component's own local `$style` overrides the class map
+* shipped by a contract.
+*
+* @param $from - the base map (e.g. the contract's shipped classes)
+* @param $to - the overriding map (e.g. the component's local `$style`)
+* @returns the merged class map
+*/
+function mergeCssModulesStyles($from = {}, $to = {}) {
+	return {
+		...$from,
+		...$to
+	};
+}
+// src/number/number.ts
+/**
+* Floor the mantissa of a number's scientific notation after shifting its
+* exponent by `-exp`, then shift the exponent back.
+*
+* Operates on the printed `toString()` digits rather than on decimal
+* places: `decimalAdjust(0, 2.7)` → `2`, `decimalAdjust(2, 123.456)` →
+* `100`. A non-integer `exp` or a non-numeric `value` yields `NaN`.
+*
+* @param exp - the decimal exponent shift (integer)
+* @param value - the number to adjust
+* @returns the adjusted number
+*/
+function decimalAdjust(exp, value) {
+	value = Number(value);
+	if (exp % 1 !== 0 || Number.isNaN(value)) return NaN;
+	else if (exp === 0) return Math.floor(value);
+	const [magnitude, exponent = 0] = value.toString().split("e");
+	const [newMagnitude, newExponent = 0] = Math.floor(+`${magnitude}e${+exponent - exp}`).toString().split("e");
+	return Number(`${newMagnitude}e${+newExponent + exp}`);
+}
+/**
+* Extract the exponent of a number's scientific-notation form.
+*
+* `123.456` → `2` (`1.23456e+2`), `0.00123` → `-3` (`1.23e-3`).
+*
+* @param num - the number to inspect
+* @returns the decimal exponent as a signed number
+*/
+function exponentialToNumber(num) {
+	const x = (+num).toExponential();
+	const minus = x.split("e-");
+	const plus = x.split("e+");
+	if (minus[1] !== void 0) return -minus[1];
+	if (plus[1] !== void 0) return +plus[1];
+	return 0;
+}
+/**
+* Tell floats from integers.
+*
+* @param n - the number to check
+* @returns `true` when `n` has a non-zero fractional part
+*/
+function isFloat(n) {
+	return n % 1 !== 0;
+}
+/**
+* Count the digits after the decimal point.
+*
+* @param int - the (float) number to inspect
+* @returns the number of fractional digits; `0` for integers
+*/
+function getFloatDigitsCount(int) {
+	if (int % 1 !== 0) return int.toString().split(".")[1].length;
+	return 0;
+}
+/**
+* Type guard: value is a number or a string coercible to one.
+*
+* Coercion follows `+v` — numeric strings pass, non-numeric ones don't.
+*
+* @param v - the value to check
+* @returns `true` when `v` is a string/number and `+v` is not `NaN`
+*/
+function isNumberish(v) {
+	return (typeof v === "string" || typeof v === "number") && !Number.isNaN(+v);
+}
+/**
+* Strict numeric-validity check: real, finite, non-`NaN` numbers — and
+* numeric strings that aren't blank.
+*
+* @param val - the value to check
+* @returns `true` only for genuine numeric values
+*/
+function isValidNumber(val) {
+	return typeof val === "number" && val - val === 0 || typeof val === "string" && Number.isFinite(+val) && val.trim() !== "";
+}
+/**
+* Coerce a number-ish value with `+val`.
+*
+* @param val - the value to coerce; `undefined` falls back to `def`
+* @param def - the default for `undefined`, defaults to `0`
+* @returns the coerced number, `def` for `undefined`, or `NaN` when `val`
+*   coerces to `NaN` (no validation is applied)
+*/
+function numberCast(val, def = 0) {
+	return +(val ?? def);
+}
+/**
+* Clamp a number into the inclusive `[min, max]` range.
+*
+* @param value - the number to clamp
+* @param min - the lower bound
+* @param max - the upper bound
+* @returns the bounded value
+*/
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+// src/css/parseCssTime.ts
+/**
+* Parse a CSS time literal into milliseconds.
+*
+* Accepts the two CSS time units: `<number>s` and `<number>ms`. Anything
+* that doesn't match the `value + unit` shape — unitless numbers, other
+* units, arbitrary strings — returns `0`, mirroring an unset duration.
+*
+* @param cssTime - a CSS time literal, e.g. `'300ms'`, `'2.5s'`
+* @returns the time in milliseconds (`'2.5s'` → `2500`), or `0` when invalid
+*/
+function parseCssTime(cssTime) {
+	const match = cssTime.match(/^([\d.]+)(s|ms)$/);
+	if (!match) return 0;
+	const value = parseFloat(match[1]);
+	return match[2] === "s" ? value * 1e3 : value;
+}
+// src/css/toUnits.ts
+/**
+* Append a CSS unit to a unitless value.
+*
+* Numbers and numeric strings get `units` appended (`20` → `'20px'`,
+* `'2.5'` → `'2.5px'`). Anything else — strings that already carry a unit
+* or a keyword (`'20em'`, `'auto'`), `undefined` — returns an empty string;
+* use {@link tryToUnits} when the original value should survive.
+*
+* @param val - a number or a numeric string
+* @param units - the unit to append, defaults to `'px'`
+* @returns the value with the unit attached, or `''` when `val` is not
+*   unitless-numeric
+*/
+function toUnits(val, units = "px") {
+	if (typeof val === "number") return val + units;
+	else if (typeof val === "string") {
+		if (val === +val + "") return val + units;
+	}
+	return "";
+}
+// src/css/tryToUnits.ts
+/**
+* Like {@link toUnits}, but passes non-numeric values through untouched.
+*
+* Numberish input gets the unit appended (`20` → `'20px'`); strings that
+* already read as CSS (`'20em'`, `'auto'`) are returned as-is; `undefined`
+* collapses to `'0'` so an omitted value never leaks into a style
+* declaration.
+*
+* @param val - a number, a numeric string, or any other CSS value
+* @param units - the unit for numberish input, defaults to `'px'`
+* @returns the unit-bearing value, the original string, or `'0'`
+*/
+function tryToUnits(val, units = "px") {
+	return isNumberish(val) ? toUnits(val, units) : val ?? "0";
+}
+// src/css/objectToCss.ts
+/**
+* Serialize a style object into an inline CSS declaration string.
+*
+* camelCase keys are kebab-cased (`zIndex` → `z-index`, an initial capital
+* becomes a vendor prefix: `WebkitBackdropFilter` → `-webkit-backdrop-filter`),
+* each pair becomes `key:value;` and pairs are concatenated without
+* separators — the result targets a single `style` attribute or a css-in-js
+* template, not pretty printing.
+*
+* @param obj - the style object (`StyleList` / any plain record)
+* @returns the declaration string, e.g. `'width:20px;z-index:2;'`
+*/
+function objectToCss(obj) {
+	return Object.entries(obj).map(([k, v]) => `${k.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase())}:${v};`).join("");
+}
+// src/css/parseUnits.ts
+/**
+* convert 123px to {value:  123, units: 'px'}
+* @param {string} str
+* @return {{units: string, value: number}}
+*/
+function parseUnits(str = "") {
+	const result = /-?\d*\.?\d+/.exec(str);
+	if (result && result[0]) {
+		const value = +result[0];
+		const units = str.replace(result[0], "");
+		return {
+			value,
+			units,
+			calc: value + units
+		};
+	} else return {
+		value: 0,
+		units: "px",
+		calc: ""
+	};
+}
+// src/console.ts
+/**
+* Build the error a composable throws when it is called outside of a
+* component's setup or lifecycle hooks.
+*
+* @param funcName - the composable's name for the message
+* @returns the ready `Error` instance
+*/
+function newErrorForSetupCall(funcName) {
+	return /* @__PURE__ */ new Error(`${funcName} must be called from the setup or lifecycle hook methods.`);
+}
+/**
+* Build a core-prefixed framework error (`[core]: <msg>`).
+*
+* @param msg - the error detail
+* @returns the ready `Error` instance
+*/
+function newFrameworkError(msg) {
+	return /* @__PURE__ */ new Error(`[core]: ${msg}`);
+}
+/**
+* Build the error thrown when an app is requested by a name nothing
+* registered under.
+*
+* @param data - the missing app's name
+* @returns the ready `Error` instance
+*/
+function newErrorAppNotFound(data) {
+	return /* @__PURE__ */ new Error(`App ${data} not found.`);
+}
+/**
+* Build the error thrown when an app name is registered twice.
+*
+* @param data - the duplicated app's name
+* @returns the ready `Error` instance
+*/
+function newErrorAppExists(data) {
+	return /* @__PURE__ */ new Error(`App ${data} already exists. Please, provide unique name for each app.`);
+}
+/**
+* Build the error `useApp` throws when no app context is active.
+*
+* @returns the ready `Error` instance
+*/
+function newErrorUseAppCall() {
+	return /* @__PURE__ */ new Error(`useApp must be called inside any app.
+   use data in <app data></app>`);
+}
+// src/hash.ts
+const K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+function rotr(x, n) {
+	return x >>> n | x << 32 - n;
+}
+/**
+* SHA-256 of a string as a lowercase hex digest.
+*
+* Pure JS implementation (FIPS 180-4) — runs identically in the browser
+* and in Node, so generated class-name hashes can be computed at runtime
+* on either side without `node:crypto`.
+*
+* @param message - the string to hash (UTF-8 encoded)
+* @returns the 64-character hex digest
+*/
+function sha256hex(message) {
+	const bytes = new TextEncoder().encode(message);
+	const bitLen = bytes.length * 8;
+	const padded = new Uint8Array((bytes.length + 8 >> 6) + 1 << 6);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+	view.setUint32(padded.length - 4, bitLen >>> 0);
+	let h0 = 1779033703, h1 = 3144134277, h2 = 1013904242, h3 = 2773480762;
+	let h4 = 1359893119, h5 = 2600822924, h6 = 528734635, h7 = 1541459225;
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let block = 0; block < padded.length; block += 64) {
+		for (let t = 0; t < 16; t++) w[t] = view.getUint32(block + t * 4);
+		for (let t = 16; t < 64; t++) {
+			const s0 = rotr(w[t - 15], 7) ^ rotr(w[t - 15], 18) ^ w[t - 15] >>> 3;
+			const s1 = rotr(w[t - 2], 17) ^ rotr(w[t - 2], 19) ^ w[t - 2] >>> 10;
+			w[t] = w[t - 16] + s0 + w[t - 7] + s1 | 0;
+		}
+		let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+		for (let t = 0; t < 64; t++) {
+			const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = h + S1 + ch + K[t] + w[t] | 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		h0 = h0 + a | 0;
+		h1 = h1 + b | 0;
+		h2 = h2 + c | 0;
+		h3 = h3 + d | 0;
+		h4 = h4 + e | 0;
+		h5 = h5 + f | 0;
+		h6 = h6 + g | 0;
+		h7 = h7 + h | 0;
+	}
+	return [
+		h0,
+		h1,
+		h2,
+		h3,
+		h4,
+		h5,
+		h6,
+		h7
+	].map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
+}
+// src/color/hexToRgb.ts
+/**
+* Parse a CSS hex color into an sRGB triple.
+*
+* Accepts the long (`#rrggbb`) and short (`#rgb`) forms, with or without
+* the leading `#`.
+*
+* @param hex - the hex literal, e.g. `'#16e3c5'`, `'f00'`
+* @returns `[r, g, b]` with integer channels 0-255
+*/
+function hexToRgb(hex) {
+	hex = hex.replace("#", "");
+	if (hex.length === 3) hex = hex.split("").map((c) => c + c).join("");
+	const num = parseInt(hex, 16);
+	return [
+		num >> 16 & 255,
+		num >> 8 & 255,
+		num & 255
+	];
+}
+// src/color/parseRgbString.ts
+/**
+* Extract the RGB channels from an `rgb()` / `rgba()` string.
+*
+* Handles the legacy comma syntax (`rgb(1, 2, 3)`) and the modern space
+* syntax with alpha (`rgb(1 2 3 / .5)`); the alpha component is dropped.
+*
+* @param s - the CSS color function string
+* @returns `[r, g, b]` as parsed (fractional for decimals/percentages)
+*/
+function parseRgbString(s) {
+	const parts = s.match(/rgba?\(([^)]+)\)/)[1].replace(/\//g, " ").split(/[\s,]+/).filter(Boolean).map((x) => parseFloat(x));
+	return [
+		parts[0],
+		parts[1],
+		parts[2]
+	];
+}
+// src/color/namedColors.ts
+/**
+* The CSS named colors (CSS Color Module Level 4) as sRGB triples,
+* keyed by lowercase name.
+*/
+const NAMED_COLORS = {
+	aliceblue: [
+		240,
+		248,
+		255
+	],
+	antiquewhite: [
+		250,
+		235,
+		215
+	],
+	aqua: [
+		0,
+		255,
+		255
+	],
+	aquamarine: [
+		127,
+		255,
+		212
+	],
+	azure: [
+		240,
+		255,
+		255
+	],
+	beige: [
+		245,
+		245,
+		220
+	],
+	bisque: [
+		255,
+		228,
+		196
+	],
+	black: [
+		0,
+		0,
+		0
+	],
+	blanchedalmond: [
+		255,
+		235,
+		205
+	],
+	blue: [
+		0,
+		0,
+		255
+	],
+	blueviolet: [
+		138,
+		43,
+		226
+	],
+	brown: [
+		165,
+		42,
+		42
+	],
+	burlywood: [
+		222,
+		184,
+		135
+	],
+	cadetblue: [
+		95,
+		158,
+		160
+	],
+	chartreuse: [
+		127,
+		255,
+		0
+	],
+	chocolate: [
+		210,
+		105,
+		30
+	],
+	coral: [
+		255,
+		127,
+		80
+	],
+	cornflowerblue: [
+		100,
+		149,
+		237
+	],
+	cornsilk: [
+		255,
+		248,
+		220
+	],
+	crimson: [
+		220,
+		20,
+		60
+	],
+	cyan: [
+		0,
+		255,
+		255
+	],
+	darkblue: [
+		0,
+		0,
+		139
+	],
+	darkcyan: [
+		0,
+		139,
+		139
+	],
+	darkgoldenrod: [
+		184,
+		134,
+		11
+	],
+	darkgray: [
+		169,
+		169,
+		169
+	],
+	darkgreen: [
+		0,
+		100,
+		0
+	],
+	darkgrey: [
+		169,
+		169,
+		169
+	],
+	darkkhaki: [
+		189,
+		183,
+		107
+	],
+	darkmagenta: [
+		139,
+		0,
+		139
+	],
+	darkolivegreen: [
+		85,
+		107,
+		47
+	],
+	darkorange: [
+		255,
+		140,
+		0
+	],
+	darkorchid: [
+		153,
+		50,
+		204
+	],
+	darkred: [
+		139,
+		0,
+		0
+	],
+	darksalmon: [
+		233,
+		150,
+		122
+	],
+	darkseagreen: [
+		143,
+		188,
+		143
+	],
+	darkslateblue: [
+		72,
+		61,
+		139
+	],
+	darkslategray: [
+		47,
+		79,
+		79
+	],
+	darkslategrey: [
+		47,
+		79,
+		79
+	],
+	darkturquoise: [
+		0,
+		206,
+		209
+	],
+	darkviolet: [
+		148,
+		0,
+		211
+	],
+	deeppink: [
+		255,
+		20,
+		147
+	],
+	deepskyblue: [
+		0,
+		191,
+		255
+	],
+	dimgray: [
+		105,
+		105,
+		105
+	],
+	dimgrey: [
+		105,
+		105,
+		105
+	],
+	dodgerblue: [
+		30,
+		144,
+		255
+	],
+	firebrick: [
+		178,
+		34,
+		34
+	],
+	floralwhite: [
+		255,
+		250,
+		240
+	],
+	forestgreen: [
+		34,
+		139,
+		34
+	],
+	fuchsia: [
+		255,
+		0,
+		255
+	],
+	gainsboro: [
+		220,
+		220,
+		220
+	],
+	ghostwhite: [
+		248,
+		248,
+		255
+	],
+	gold: [
+		255,
+		215,
+		0
+	],
+	goldenrod: [
+		218,
+		165,
+		32
+	],
+	gray: [
+		128,
+		128,
+		128
+	],
+	green: [
+		0,
+		128,
+		0
+	],
+	greenyellow: [
+		173,
+		255,
+		47
+	],
+	grey: [
+		128,
+		128,
+		128
+	],
+	honeydew: [
+		240,
+		255,
+		240
+	],
+	hotpink: [
+		255,
+		105,
+		180
+	],
+	indianred: [
+		205,
+		92,
+		92
+	],
+	indigo: [
+		75,
+		0,
+		130
+	],
+	ivory: [
+		255,
+		255,
+		240
+	],
+	khaki: [
+		240,
+		230,
+		140
+	],
+	lavender: [
+		230,
+		230,
+		250
+	],
+	lavenderblush: [
+		255,
+		240,
+		245
+	],
+	lawngreen: [
+		124,
+		252,
+		0
+	],
+	lemonchiffon: [
+		255,
+		250,
+		205
+	],
+	lightblue: [
+		173,
+		216,
+		230
+	],
+	lightcoral: [
+		240,
+		128,
+		128
+	],
+	lightcyan: [
+		224,
+		255,
+		255
+	],
+	lightgoldenrodyellow: [
+		250,
+		250,
+		210
+	],
+	lightgray: [
+		211,
+		211,
+		211
+	],
+	lightgreen: [
+		144,
+		238,
+		144
+	],
+	lightgrey: [
+		211,
+		211,
+		211
+	],
+	lightpink: [
+		255,
+		182,
+		193
+	],
+	lightsalmon: [
+		255,
+		160,
+		122
+	],
+	lightseagreen: [
+		32,
+		178,
+		170
+	],
+	lightskyblue: [
+		135,
+		206,
+		250
+	],
+	lightslategray: [
+		119,
+		136,
+		153
+	],
+	lightslategrey: [
+		119,
+		136,
+		153
+	],
+	lightsteelblue: [
+		176,
+		196,
+		222
+	],
+	lightyellow: [
+		255,
+		255,
+		224
+	],
+	lime: [
+		0,
+		255,
+		0
+	],
+	limegreen: [
+		50,
+		205,
+		50
+	],
+	linen: [
+		250,
+		240,
+		230
+	],
+	magenta: [
+		255,
+		0,
+		255
+	],
+	maroon: [
+		128,
+		0,
+		0
+	],
+	mediumaquamarine: [
+		102,
+		205,
+		170
+	],
+	mediumblue: [
+		0,
+		0,
+		205
+	],
+	mediumorchid: [
+		186,
+		85,
+		211
+	],
+	mediumpurple: [
+		147,
+		112,
+		219
+	],
+	mediumseagreen: [
+		60,
+		179,
+		113
+	],
+	mediumslateblue: [
+		123,
+		104,
+		238
+	],
+	mediumspringgreen: [
+		0,
+		250,
+		154
+	],
+	mediumturquoise: [
+		72,
+		209,
+		204
+	],
+	mediumvioletred: [
+		199,
+		21,
+		133
+	],
+	midnightblue: [
+		25,
+		25,
+		112
+	],
+	mintcream: [
+		245,
+		255,
+		250
+	],
+	mistyrose: [
+		255,
+		228,
+		225
+	],
+	moccasin: [
+		255,
+		228,
+		181
+	],
+	navajowhite: [
+		255,
+		222,
+		173
+	],
+	navy: [
+		0,
+		0,
+		128
+	],
+	oldlace: [
+		253,
+		245,
+		230
+	],
+	olive: [
+		128,
+		128,
+		0
+	],
+	olivedrab: [
+		107,
+		142,
+		35
+	],
+	orange: [
+		255,
+		165,
+		0
+	],
+	orangered: [
+		255,
+		69,
+		0
+	],
+	orchid: [
+		218,
+		112,
+		214
+	],
+	palegoldenrod: [
+		238,
+		232,
+		170
+	],
+	palegreen: [
+		152,
+		251,
+		152
+	],
+	paleturquoise: [
+		175,
+		238,
+		238
+	],
+	palevioletred: [
+		219,
+		112,
+		147
+	],
+	papayawhip: [
+		255,
+		239,
+		213
+	],
+	peachpuff: [
+		255,
+		218,
+		185
+	],
+	peru: [
+		205,
+		133,
+		63
+	],
+	pink: [
+		255,
+		192,
+		203
+	],
+	plum: [
+		221,
+		160,
+		221
+	],
+	powderblue: [
+		176,
+		224,
+		230
+	],
+	purple: [
+		128,
+		0,
+		128
+	],
+	rebeccapurple: [
+		102,
+		51,
+		153
+	],
+	red: [
+		255,
+		0,
+		0
+	],
+	rosybrown: [
+		188,
+		143,
+		143
+	],
+	royalblue: [
+		65,
+		105,
+		225
+	],
+	saddlebrown: [
+		139,
+		69,
+		19
+	],
+	salmon: [
+		250,
+		128,
+		114
+	],
+	sandybrown: [
+		244,
+		164,
+		96
+	],
+	seagreen: [
+		46,
+		139,
+		87
+	],
+	seashell: [
+		255,
+		245,
+		238
+	],
+	sienna: [
+		160,
+		82,
+		45
+	],
+	silver: [
+		192,
+		192,
+		192
+	],
+	skyblue: [
+		135,
+		206,
+		235
+	],
+	slateblue: [
+		106,
+		90,
+		205
+	],
+	slategray: [
+		112,
+		128,
+		144
+	],
+	slategrey: [
+		112,
+		128,
+		144
+	],
+	snow: [
+		255,
+		250,
+		250
+	],
+	springgreen: [
+		0,
+		255,
+		127
+	],
+	steelblue: [
+		70,
+		130,
+		180
+	],
+	tan: [
+		210,
+		180,
+		140
+	],
+	teal: [
+		0,
+		128,
+		128
+	],
+	thistle: [
+		216,
+		191,
+		216
+	],
+	tomato: [
+		255,
+		99,
+		71
+	],
+	turquoise: [
+		64,
+		224,
+		208
+	],
+	violet: [
+		238,
+		130,
+		238
+	],
+	wheat: [
+		245,
+		222,
+		179
+	],
+	white: [
+		255,
+		255,
+		255
+	],
+	whitesmoke: [
+		245,
+		245,
+		245
+	],
+	yellow: [
+		255,
+		255,
+		0
+	],
+	yellowgreen: [
+		154,
+		205,
+		50
+	]
+};
+// src/color/isLiteralColor.ts
+/**
+* Tell literal CSS colors from palette references.
+*
+* Literal means the string is a color by itself: `#hex`, `rgb(...)` /
+* `rgba(...)`, or a CSS named color (case-insensitive) — as opposed to
+* theme references like `'brand-l2'`.
+*
+* @param s - the color string to classify
+* @returns `true` when `s` is directly usable as a CSS color value
+*/
+function isLiteralColor(s) {
+	return s.startsWith("#") || s.startsWith("rgb") || s.toLowerCase() in NAMED_COLORS;
+}
+// src/color/toRgb.ts
+/**
+* Resolve any literal CSS color string to an sRGB triple.
+*
+* Dispatches on the format: `#hex` → {@link hexToRgb}, `rgb(...)` →
+* {@link parseRgbString}, anything else is looked up among the CSS named
+* colors (case-insensitive). Theme references are rejected.
+*
+* @param color - a literal color string
+* @returns the sRGB triple
+* @throws when `color` is not a literal color (e.g. a palette reference)
+*/
+function toRgb(color) {
+	if (!isLiteralColor(color)) throw new Error("unknown literal color format: " + color);
+	if (color.startsWith("#")) return hexToRgb(color);
+	if (color.startsWith("rgb")) return parseRgbString(color);
+	return NAMED_COLORS[color.toLowerCase()];
+}
+// src/color/rgbToHsl.ts
+/**
+* Convert an sRGB triple to HSL.
+*
+* @param rgb - the color (channels 0-255)
+* @returns `[hue 0-360, saturation 0-100, lightness 0-100]` (fractional)
+*/
+function rgbToHsl([r, g, b]) {
+	r /= 255;
+	g /= 255;
+	b /= 255;
+	const max = Math.max(r, g, b), min = Math.min(r, g, b);
+	let h = 0, s;
+	const l = (max + min) / 2;
+	if (max === min) h = s = 0;
+	else {
+		const d = max - min;
+		s = l > .5 ? d / (2 - max - min) : d / (max + min);
+		switch (max) {
+			case r:
+				h = (g - b) / d + (g < b ? 6 : 0);
+				break;
+			case g:
+				h = (b - r) / d + 2;
+				break;
+			case b: h = (r - g) / d + 4;
+		}
+		h /= 6;
+	}
+	return [
+		h * 360,
+		s * 100,
+		l * 100
+	];
+}
+// src/color/hslToRgb.ts
+/**
+* Convert an HSL triple to a fractional sRGB triple.
+*
+* @param hsl - `[hue 0-360, saturation 0-100, lightness 0-100]`
+* @returns fractional sRGB channels (0-255, not rounded)
+*/
+function hslToRgb([h, s, l]) {
+	h /= 360;
+	s /= 100;
+	l /= 100;
+	let r, g, b;
+	if (s === 0) r = g = b = l;
+	else {
+		const hue2rgb = (p, q, t) => {
+			if (t < 0) t += 1;
+			if (t > 1) t -= 1;
+			if (t < 1 / 6) return p + (q - p) * 6 * t;
+			if (t < 1 / 2) return q;
+			if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+			return p;
+		};
+		const q = l < .5 ? l * (1 + s) : l + s - l * s;
+		const p = 2 * l - q;
+		r = hue2rgb(p, q, h + 1 / 3);
+		g = hue2rgb(p, q, h);
+		b = hue2rgb(p, q, h - 1 / 3);
+	}
+	return [
+		r * 255,
+		g * 255,
+		b * 255
+	];
+}
+// src/color/withLightnessHsl.ts
+/**
+* Rebuild a color with a new HSL lightness, keeping hue and saturation.
+*
+* @param rgb - the source color (sRGB triple)
+* @param l - the target lightness, percent 0-100
+* @returns the recolored sRGB triple (fractional channels)
+*/
+function withLightnessHsl(rgb, l) {
+	const [h, s] = rgbToHsl(rgb);
+	return hslToRgb([
+		h,
+		s,
+		l
+	]);
+}
+// src/color/lightnessOfHsl.ts
+/**
+* Read the HSL lightness (percent, 0-100) of an sRGB color.
+*
+* @param rgb - the color to measure (sRGB triple)
+* @returns the lightness percentage (fractional)
+*/
+function lightnessOfHsl(rgb) {
+	return rgbToHsl(rgb)[2];
+}
+// src/color/srgbToLinear.ts
+/**
+* Decode one gamma-encoded sRGB channel to linear light.
+*
+* @param v - the sRGB channel, 0-255
+* @returns the linear-light value (0-1)
+*/
+function srgbToLinear(v) {
+	v /= 255;
+	return v <= .04045 ? v / 12.92 : ((v + .055) / 1.055) ** 2.4;
+}
+// src/color/linearToSrgb.ts
+/**
+* Gamma-encode one linear-light channel to sRGB.
+*
+* @param v - the linear channel, nominally 0-1
+* @returns the sRGB channel, 0-255, clamped to the gamut
+*/
+function linearToSrgb(v) {
+	const s = v <= .0031308 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - .055;
+	return Math.min(255, Math.max(0, s * 255));
+}
+// src/color/linearRgbToOklab.ts
+/**
+* Convert a linear-light sRGB triple to OKLab.
+*
+* Björn Ottosson's LMS-based transform; the input must be linear (run
+* {@link srgbToLinear} over gamma-encoded channels first).
+*
+* @param rgb - linear sRGB channels (0-1)
+* @returns `[L, a, b]` OKLab coordinates
+*/
+function linearRgbToOklab([r, g, b]) {
+	const l = .4122214708 * r + .5363325363 * g + .0514459929 * b;
+	const m = .2119034982 * r + .6806995451 * g + .1073969566 * b;
+	const s = .0883024619 * r + .2817188376 * g + .6299787005 * b;
+	const l_ = Math.cbrt(l), m_ = Math.cbrt(m), s_ = Math.cbrt(s);
+	return [
+		.2104542553 * l_ + .793617785 * m_ - .0040720468 * s_,
+		1.9779984951 * l_ - 2.428592205 * m_ + .4505937099 * s_,
+		.0259040371 * l_ + .7827717662 * m_ - .808675766 * s_
+	];
+}
+// src/color/oklabToLinearRgb.ts
+/**
+* Convert OKLab coordinates back to a linear-light sRGB triple.
+*
+* Inverse of {@link linearRgbToOklab}; run {@link linearToSrgb} over the
+* result to get gamma-encoded channels.
+*
+* @param L - OKLab lightness
+* @param a - green-red opponent channel
+* @param b - blue-yellow opponent channel
+* @returns linear sRGB channels (0-1)
+*/
+function oklabToLinearRgb([L, a, b]) {
+	const l_ = L + .3963377774 * a + .2158037573 * b;
+	const m_ = L - .1055613458 * a - .0638541728 * b;
+	const s_ = L - .0894841775 * a - 1.291485548 * b;
+	const l = l_ ** 3, m = m_ ** 3, s = s_ ** 3;
+	return [
+		4.0767416621 * l - 3.3077115913 * m + .2309699292 * s,
+		-1.2684380046 * l + 2.6097574011 * m - .3413193965 * s,
+		-.0041960863 * l - .7034186147 * m + 1.707614701 * s
+	];
+}
+// src/color/rgbToOklch.ts
+/**
+* Convert an sRGB triple to OKLCH (via linear sRGB + OKLab).
+*
+* @param rgb - the color (channels 0-255)
+* @returns `[L 0-100, C, H degrees]` (fractional)
+*/
+function rgbToOklch(rgb) {
+	const [L, a, b] = linearRgbToOklab(rgb.map(srgbToLinear));
+	return [
+		L * 100,
+		Math.sqrt(a * a + b * b),
+		Math.atan2(b, a) * (180 / Math.PI)
+	];
+}
+// src/color/oklchToRgb.ts
+/**
+* Convert OKLCH coordinates to a gamma-encoded sRGB triple.
+*
+* @param L100 - lightness in percent (0-100)
+* @param C - chroma
+* @param H - hue in degrees
+* @returns the sRGB triple (channels 0-255, fractional)
+*/
+function oklchToRgb([L100, C, H]) {
+	const hRad = H * (Math.PI / 180);
+	return oklabToLinearRgb([
+		L100 / 100,
+		C * Math.cos(hRad),
+		C * Math.sin(hRad)
+	]).map(linearToSrgb);
+}
+// src/color/withLightnessOklch.ts
+/**
+* Rebuild a color with a new OKLCH lightness, keeping chroma and hue.
+*
+* @param rgb - the source color (sRGB triple)
+* @param l - the target lightness, percent 0-100
+* @returns the recolored sRGB triple (fractional channels)
+*/
+function withLightnessOklch(rgb, l) {
+	const [, C, H] = rgbToOklch(rgb);
+	return oklchToRgb([
+		l,
+		C,
+		H
+	]);
+}
+// src/color/lightnessOfOklch.ts
+/**
+* Read the OKLCH lightness (percent, 0-100) of an sRGB color.
+*
+* @param rgb - the color to measure (sRGB triple)
+* @returns the OKLCH L dimension (fractional)
+*/
+function lightnessOfOklch(rgb) {
+	return rgbToOklch(rgb)[0];
+}
+// src/color/spaces.ts
+/**
+* The color spaces the ramp math (`lighten` / `darken`) can run in.
+*
+* `oklch` is perceptually uniform — a ramp looks evenly spaced regardless
+* of hue; `hsl` is the legacy (cheaper) path.
+*/
+const SPACES = {
+	hsl: {
+		lightnessOf: lightnessOfHsl,
+		withLightness: withLightnessHsl
+	},
+	oklch: {
+		lightnessOf: lightnessOfOklch,
+		withLightness: withLightnessOklch
+	}
+};
+// src/color/lighten.ts
+/**
+* Lighten a color by `step` steps of a `steps`-step ramp.
+*
+* Scales the color's lightness up toward 100 percent proportionally
+* (`l -> l + (100 - l) * (step / steps)`) in the given color space;
+* `oklch` keeps ramps perceptually even, `hsl` is the legacy path.
+*
+* @param rgb - the color to lighten (sRGB triple)
+* @param step - how many steps up the ramp (1-based)
+* @param steps - the total number of ramp steps
+* @param space - the color space the lightness math runs in
+* @returns the lightened color (fractional channels)
+*/
+function lighten(rgb, step, steps, space = "hsl") {
+	const { lightnessOf, withLightness } = SPACES[space];
+	const l0 = lightnessOf(rgb);
+	return withLightness(rgb, l0 + (100 - l0) * (step / steps));
+}
+// src/color/darken.ts
+/**
+* Darken a color by `step` steps of a `steps`-step ramp.
+*
+* Scales the color's lightness down proportionally
+* (`l -> l * (1 - step / steps)`) in the given color space; `oklch` keeps
+* ramps perceptually even, `hsl` is the legacy path.
+*
+* @param rgb - the color to darken (sRGB triple)
+* @param step - how many steps down the ramp (1-based)
+* @param steps - the total number of ramp steps
+* @param space - the color space the lightness math runs in
+* @returns the darkened color (fractional channels)
+*/
+function darken(rgb, step, steps, space = "hsl") {
+	const { lightnessOf, withLightness } = SPACES[space];
+	return withLightness(rgb, lightnessOf(rgb) * (1 - step / steps));
+}
+// src/color/blend.ts
+/**
+* Mix two sRGB colors by a depth percentage.
+*
+* Linear interpolation per channel: `depthPercent` of 0 returns `rgb1`
+* untouched, 100 returns `rgb2`; the channels stay fractional (not
+* rounded).
+*
+* @param rgb1 - the base color (sRGB triple, channels 0-255)
+* @param rgb2 - the color blended in
+* @param depthPercent - blend weight of `rgb2`, 0-100
+* @returns the mixed color as a fractional sRGB triple
+*/
+function blend(rgb1, rgb2, depthPercent) {
+	const t = depthPercent / 100;
+	return [
+		0,
+		1,
+		2
+	].map((i) => rgb1[i] * (1 - t) + rgb2[i] * t);
+}
+// src/props/castAnyPropToBoolean.ts
+/**
+* Coerces an arbitrary prop value to a boolean the way presence-classes
+* expect it: an empty string means "present" (`true`), an empty array means
+* "absent" (`false`), anything else falls through to the default truthiness
+* rules.
+* @param value - the prop value
+* @returns the boolean presence of the value
+*/
+function castAnyPropToBoolean(value) {
+	if (typeof value === "string" && value === "") return true;
+	if (typeof value === "object" && value instanceof Array && !value.length) return false;
+	return !!value;
+}
+// src/props/namesToClassNames.ts
+/**
+* Builds a `{ [className]: true }` record from a list of state names,
+* keeping only the names whose prop value is "on" (defined, not `false`
+* and not a function).
+* @param names - space-separated string, list, or map of state names
+* @param props - the props to test each name against
+* @param className - prefix joined with `_` to each name; empty = bare name
+* @param debug - log the inputs before computing
+* @returns record of `className_name -> true` for the active names
+*/
+function namesToClassNames(names, props = {}, className = "state", debug = false) {
+	debug && console.log("names to classname", names, props, className);
+	const out = {};
+	let list = [];
+	if (typeof names === "object") list = names instanceof Array ? names : Object.keys(names || []);
+	else list = names.split(" ");
+	list.forEach((item) => {
+		const cn = className ? `${className}_${item}` : item;
+		if (props[item] !== void 0 && props[item] !== false && typeof props[item] !== "function") out[cn] = true;
+	});
+	return out;
+}
+// src/props/propValueToClass.ts
+/**
+* Converts a prop value to a class via a value -> class alias record: the
+* alias may be a single class name or a list of class names.
+* @param propValue - the prop's value token
+* @param values - record of value token -> class alias (string or string[])
+* @returns `{ className: true }` for the aliased class(es), `{}` when the
+* value has no alias or the alias is neither a string nor a list
+*/
+function propValueToClass(propValue, values) {
+	if (!values[propValue]) return {};
+	if (typeof values[propValue] === "string") return { [values[propValue]]: true };
+	if (typeof values[propValue] === "object" && values[propValue] instanceof Array) return values[propValue].reduce((acc, cur) => ({
+		...acc,
+		[cur]: true
+	}), {});
+	return {};
+}
+// src/props/propValueToClasses.ts
+/**
+* Converts a prop value to class names via a value -> class alias record:
+* the alias may be a single class name or a list of class names.
+* @param propValue - the prop's value token
+* @param values - record of value token -> class alias (string or string[])
+* @returns the aliased class name list, `[]` when the value has no alias or
+* the alias is neither a string nor a list
+*/
+function propValueToClasses(propValue, values) {
+	if (!values[propValue]) return [];
+	if (typeof values[propValue] === "string") return [values[propValue]];
+	if (typeof values[propValue] === "object" && values[propValue] instanceof Array) return values[propValue];
+	return [];
+}
+// src/props/propsToCssModuleClass.ts
+/**
+* Converts prop names and values to css-module classes, returned as a
+* `{ [className]: boolean }` record (a `false` entry means the prop is off
+* but the class slot is still reported).
+*
+* A picked entry is either a bare prop name - the prop's own class is keyed
+* by the css module and the value's tokens add their own module classes - or
+* a `[propName, modifiers]` tuple that maps the value's tokens onto modifier
+* classes via {@link propValueToClass}.
+* @param props - the instance props
+* @param picked - the props to map (bare names or `[name, modifiers]` tuples)
+* @param cssModule - the css-module class map
+* @returns record of class name -> on/off flag
+*/
+function propsToCssModuleClass(props, picked, cssModule) {
+	let out = {};
+	function getRootClassBoolean(field) {
+		let out = void 0;
+		if (props[field] !== void 0) out = castAnyPropToBoolean(props[field]);
+		return out;
+	}
+	picked.forEach((pickedProp) => {
+		if (typeof pickedProp === "string") {
+			const cn = cssModule[pickedProp];
+			const value = props[pickedProp];
+			if (value !== void 0 && cn) {
+				if (typeof value === "boolean") out[cn] = value;
+				if (typeof value === "string" || typeof value === "number" || typeof value === "object" && value instanceof Array) {
+					out[cn] = true;
+					let arr = [];
+					if (typeof value === "string" || typeof value === "number") arr = value.toString().split(" ");
+					if (value instanceof Array) arr = value;
+					arr.forEach((val) => {
+						const modifierName = cssModule[val];
+						if (modifierName) out[modifierName] = true;
+					});
+				}
+			}
+		}
+		if (typeof pickedProp === "object" && pickedProp instanceof Array && pickedProp.length === 2) {
+			const _pickedProp = pickedProp[0];
+			const _pickedPropValue = pickedProp[1];
+			const _pickedPropClassName = cssModule[_pickedProp];
+			const value = getRootClassBoolean(_pickedProp);
+			if (typeof props[_pickedProp] === "string" || typeof props[_pickedProp] === "number" || typeof props[_pickedProp] === "boolean" || typeof props[_pickedProp] === "object" && props[_pickedProp] instanceof Array) {
+				let classValues = [];
+				if (props[_pickedProp] instanceof Array && props[_pickedProp].length) classValues = props[_pickedProp];
+				if (typeof props[_pickedProp] === "string" || typeof props[_pickedProp] === "number") classValues = String(props[_pickedProp]).split(" ");
+				if (typeof props[_pickedProp] === "boolean" && props[_pickedProp] || props[_pickedProp] === "") classValues = ["true"];
+				let outClassValues = {};
+				classValues.forEach((val) => {
+					if (val !== void 0 && val.trim()) outClassValues = {
+						...outClassValues,
+						...propValueToClass(val, _pickedPropValue)
+					};
+				});
+				out = {
+					...out,
+					...outClassValues
+				};
+			}
+			if (_pickedPropClassName) out = {
+				...out,
+				[_pickedPropClassName]: value || false
+			};
+		}
+	});
+	return out;
+}
+// src/props/propsToCssModuleClassNext.ts
+/**
+* Converts prop names and values to a flat list of css-module classes -
+* the array form of {@link propsToCssModuleClass}: same mapping rules, but
+* only the "on" classes are collected (no `false` entries) and an extra
+* class can be prepended via `options.extraClass`.
+* @param props - the instance props
+* @param picked - the props to map (bare names or `[name, modifiers]` tuples)
+* @param cssModule - the css-module class map
+* @param options - `extraClass` is prepended to the result when given
+* @returns the resolved class name list
+*/
+function propsToCssModuleClassNext(props, picked, cssModule, options) {
+	let out = [];
+	const { extraClass = void 0 } = options || {};
+	if (extraClass) out.push(extraClass);
+	function getRootClassBoolean(field) {
+		let out = void 0;
+		if (props[field] !== void 0) out = castAnyPropToBoolean(props[field]);
+		return out;
+	}
+	picked.forEach((pickedProp) => {
+		if (typeof pickedProp === "string") {
+			const cn = cssModule[pickedProp];
+			const value = props[pickedProp];
+			if (value !== void 0 && cn) {
+				if (typeof value === "boolean" && value) out.push(cn);
+				if (typeof value === "string" || typeof value === "number" || typeof value === "object" && value instanceof Array) {
+					out.push(cn);
+					let arr = [];
+					if (typeof value === "string" || typeof value === "number") arr = value.toString().split(" ");
+					if (value instanceof Array) arr = value;
+					arr.forEach((val) => {
+						const modifierName = cssModule[val];
+						if (modifierName) out.push(modifierName);
+					});
+				}
+			}
+		}
+		if (typeof pickedProp === "object" && pickedProp instanceof Array && pickedProp.length === 2) {
+			const _pickedProp = pickedProp[0];
+			const _pickedPropValue = pickedProp[1];
+			const _pickedPropClassName = cssModule[_pickedProp];
+			const value = getRootClassBoolean(_pickedProp);
+			if (typeof props[_pickedProp] === "string" || typeof props[_pickedProp] === "number" || typeof props[_pickedProp] === "boolean" || typeof props[_pickedProp] === "object" && props[_pickedProp] instanceof Array) {
+				let classValues = [];
+				if (props[_pickedProp] instanceof Array && props[_pickedProp].length) classValues = props[_pickedProp];
+				if (typeof props[_pickedProp] === "string" || typeof props[_pickedProp] === "number") classValues = String(props[_pickedProp]).split(" ");
+				if (typeof props[_pickedProp] === "boolean" && props[_pickedProp] || props[_pickedProp] === "") classValues = ["true"];
+				let outClassValues = [];
+				classValues.forEach((val) => {
+					if (val !== void 0 && val.trim()) outClassValues = [...outClassValues, ...propValueToClasses(val, _pickedPropValue)];
+				});
+				out = [...out, ...outClassValues];
+			}
+			if (_pickedPropClassName && !!value) out.push(_pickedPropClassName);
+		}
+	});
+	return out;
+}
+// src/browser-check.ts
+const isBrowser = typeof window !== "undefined";
+function safetyWindow() {
+	return window && typeof window !== "undefined" ? window : {};
+}
+function safetyDocument() {
+	return typeof document !== "undefined" ? document : {};
+}
+// src/container/record-container.ts
+var RecordContainer = class {
+	records;
+	counter = 0;
+	options;
+	constructor(options = {}) {
+		this.records = {};
+		this.options = options;
+	}
+	/** Returns the item with the highest remaining ID, or undefined when empty. */
+	get last() {
+		let lastId = -1;
+		for (const key in this.records) if (Object.hasOwn(this.records, key)) lastId = Math.max(lastId, Number(key));
+		if (lastId === -1) return void 0;
+		return this.records[lastId];
+	}
+	/** Returns a shallow snapshot; item objects retain their original references. */
+	get raw() {
+		return { ...this.records };
+	}
+	get items() {
+		return Object.values(this.records);
+	}
+	get length() {
+		return Object.keys(this.records).length;
+	}
+	clear() {
+		for (const i in this.records) delete this.records[i];
+	}
+	/** Validates and transforms an item before allocating its ID; returns -1 on rejection. */
+	add(item) {
+		if (this.options.onBeforeChange) {
+			if (!this.options.onBeforeChange(item)) return -1;
+		}
+		const value = this.options.onChange ? this.options.onChange(item) : item;
+		const id = this.counter++;
+		this.records[id] = value;
+		return id;
+	}
+	remove(id) {
+		delete this.records[id];
+	}
+	getItemById(id) {
+		return this.records[id];
+	}
+};
+// src/dom/getClientHeight.ts
+function getClientHeight() {
+	if (isBrowser) return window.innerHeight;
+	else return 0;
+}
+// src/dom/getClientWidth.ts
+function getClientWidth() {
+	if (isBrowser) return window.innerWidth;
+	else return 0;
+}
+export { NAMED_COLORS, RecordContainer, SPACES, arrayInsertAtIndex, arrayIsEqual, arrayOmit, arrayOmitArray, arrayPickFromItemOffset, arrayPickNext, arrayPickPrev, arrayToNumberArray, blend, castAnyPropToBoolean, clamp, darken, decimalAdjust, exponentialToNumber, extractFileDir, extractFileName, findFrameworkInstance, genRandomString, getClientHeight, getClientWidth, getFloatDigitsCount, getItemByOverflowIndex, getLastItemFromArray, hexToRgb, hslToRgb, hyphenate, isArray, isBrowser, isFloat, isFunction, isLiteralColor, isNumberish, isObject, isString, isSymbol, isValidNumber, kebabize, lighten, lightnessOfHsl, lightnessOfOklch, linearRgbToOklab, linearToSrgb, mergeCssModulesStyles, namesToClassNames, newErrorAppExists, newErrorAppNotFound, newErrorForSetupCall, newErrorUseAppCall, newFrameworkError, notUndefined, numberCast, objectMerge, objectOmitKeys, objectPickKeys, objectToCss, oklabToLinearRgb, oklchToRgb, parseCssTime, parseQueryString, parseRgbString, parseUnits, propValueToClass, propValueToClasses, propsToCssModuleClass, propsToCssModuleClassNext, removeVowels, rgbToHsl, rgbToOklch, safetyDocument, safetyWindow, sha256hex, splitString, srgbToLinear, stringToFirstLetters, toCamelCase, toKebabCase, toPascalCase, toRgb, toUnique, toUnits, tryToUnits, withLightnessHsl, withLightnessOklch };
+
+//# sourceMappingURL=index.js.map