@varlet/shared 3.14.2 → 3.15.0-alpha.1776606769606

package/lib/index.cjs

@@ -1,54 +1,1729 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_crypto = require("node:crypto");
+//#region ../../node_modules/.pnpm/rattail@2.0.5_@voidzero-dev+vite-plus-core@0.1.18_@types+node@20.19.39_esbuild@0.27.7_jiti@2._oaa5dabgz63tacyacthirbl23y/node_modules/rattail/dist/chunk-D1SwGrFN.mjs
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  assert: () => assert,
-  error: () => error,
-  isURL: () => isURL,
-  warn: () => warn
+//#endregion
+//#region ../../node_modules/.pnpm/rattail@2.0.5_@voidzero-dev+vite-plus-core@0.1.18_@types+node@20.19.39_esbuild@0.27.7_jiti@2._oaa5dabgz63tacyacthirbl23y/node_modules/rattail/dist/isString-eoLxw4CX.mjs
+function isArray(val) {
+	return Array.isArray(val);
+}
+function isString(val) {
+	return typeof val === "string";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rattail@2.0.5_@voidzero-dev+vite-plus-core@0.1.18_@types+node@20.19.39_esbuild@0.27.7_jiti@2._oaa5dabgz63tacyacthirbl23y/node_modules/rattail/dist/callOrReturn-MpTzoGlG.mjs
+function isFunction(val) {
+	return typeof val === "function";
+}
+function callOrReturn(fnOrValue, ...args) {
+	if (isFunction(fnOrValue)) return fnOrValue(...args);
+	return fnOrValue;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/regex.js
+var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/validate.js
+function validate(uuid) {
+	return typeof uuid === "string" && regex_default.test(uuid);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/parse.js
+function parse(uuid) {
+	if (!validate(uuid)) throw TypeError("Invalid UUID");
+	let v;
+	return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/stringify.js
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
+function unsafeStringify(arr, offset = 0) {
+	return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/rng.js
+const rnds8Pool = new Uint8Array(256);
+let poolPtr = rnds8Pool.length;
+function rng() {
+	if (poolPtr > rnds8Pool.length - 16) {
+		(0, node_crypto.randomFillSync)(rnds8Pool);
+		poolPtr = 0;
+	}
+	return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/v1.js
+const _state = {};
+function v1(options, buf, offset) {
+	let bytes;
+	const isV6 = options?._v6 ?? false;
+	if (options) {
+		const optionsKeys = Object.keys(options);
+		if (optionsKeys.length === 1 && optionsKeys[0] === "_v6") options = void 0;
+	}
+	if (options) bytes = v1Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.nsecs, options.clockseq, options.node, buf, offset);
+	else {
+		const now = Date.now();
+		const rnds = rng();
+		updateV1State(_state, now, rnds);
+		bytes = v1Bytes(rnds, _state.msecs, _state.nsecs, isV6 ? void 0 : _state.clockseq, isV6 ? void 0 : _state.node, buf, offset);
+	}
+	return buf ?? unsafeStringify(bytes);
+}
+function updateV1State(state, now, rnds) {
+	state.msecs ??= -Infinity;
+	state.nsecs ??= 0;
+	if (now === state.msecs) {
+		state.nsecs++;
+		if (state.nsecs >= 1e4) {
+			state.node = void 0;
+			state.nsecs = 0;
+		}
+	} else if (now > state.msecs) state.nsecs = 0;
+	else if (now < state.msecs) state.node = void 0;
+	if (!state.node) {
+		state.node = rnds.slice(10, 16);
+		state.node[0] |= 1;
+		state.clockseq = (rnds[8] << 8 | rnds[9]) & 16383;
+	}
+	state.msecs = now;
+	return state;
+}
+function v1Bytes(rnds, msecs, nsecs, clockseq, node, buf, offset = 0) {
+	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
+	if (!buf) {
+		buf = new Uint8Array(16);
+		offset = 0;
+	} else if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+	msecs ??= Date.now();
+	nsecs ??= 0;
+	clockseq ??= (rnds[8] << 8 | rnds[9]) & 16383;
+	node ??= rnds.slice(10, 16);
+	msecs += 0xb1d069b5400;
+	const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
+	buf[offset++] = tl >>> 24 & 255;
+	buf[offset++] = tl >>> 16 & 255;
+	buf[offset++] = tl >>> 8 & 255;
+	buf[offset++] = tl & 255;
+	const tmh = msecs / 4294967296 * 1e4 & 268435455;
+	buf[offset++] = tmh >>> 8 & 255;
+	buf[offset++] = tmh & 255;
+	buf[offset++] = tmh >>> 24 & 15 | 16;
+	buf[offset++] = tmh >>> 16 & 255;
+	buf[offset++] = clockseq >>> 8 | 128;
+	buf[offset++] = clockseq & 255;
+	for (let n = 0; n < 6; ++n) buf[offset++] = node[n];
+	return buf;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/v1ToV6.js
+function v1ToV6(uuid) {
+	const v6Bytes = _v1ToV6(typeof uuid === "string" ? parse(uuid) : uuid);
+	return typeof uuid === "string" ? unsafeStringify(v6Bytes) : v6Bytes;
+}
+function _v1ToV6(v1Bytes) {
+	return Uint8Array.of((v1Bytes[6] & 15) << 4 | v1Bytes[7] >> 4 & 15, (v1Bytes[7] & 15) << 4 | (v1Bytes[4] & 240) >> 4, (v1Bytes[4] & 15) << 4 | (v1Bytes[5] & 240) >> 4, (v1Bytes[5] & 15) << 4 | (v1Bytes[0] & 240) >> 4, (v1Bytes[0] & 15) << 4 | (v1Bytes[1] & 240) >> 4, (v1Bytes[1] & 15) << 4 | (v1Bytes[2] & 240) >> 4, 96 | v1Bytes[2] & 15, v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/native.js
+var native_default = { randomUUID: node_crypto.randomUUID };
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/v4.js
+function _v4(options, buf, offset) {
+	options = options || {};
+	const rnds = options.random ?? options.rng?.() ?? rng();
+	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
+	rnds[6] = rnds[6] & 15 | 64;
+	rnds[8] = rnds[8] & 63 | 128;
+	if (buf) {
+		offset = offset || 0;
+		if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+		for (let i = 0; i < 16; ++i) buf[offset + i] = rnds[i];
+		return buf;
+	}
+	return unsafeStringify(rnds);
+}
+function v4(options, buf, offset) {
+	if (native_default.randomUUID && !buf && !options) return native_default.randomUUID();
+	return _v4(options, buf, offset);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/v6.js
+function v6(options, buf, offset) {
+	options ??= {};
+	offset ??= 0;
+	let bytes = v1({
+		...options,
+		_v6: true
+	}, new Uint8Array(16));
+	bytes = v1ToV6(bytes);
+	if (buf) {
+		for (let i = 0; i < 16; i++) buf[offset + i] = bytes[i];
+		return buf;
+	}
+	return unsafeStringify(bytes);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
+function mitt_default(n) {
+	return {
+		all: n = n || /* @__PURE__ */ new Map(),
+		on: function(t, e) {
+			var i = n.get(t);
+			i ? i.push(e) : n.set(t, [e]);
+		},
+		off: function(t, e) {
+			var i = n.get(t);
+			i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+		},
+		emit: function(t, e) {
+			var i = n.get(t);
+			i && i.slice().map(function(n) {
+				n(e);
+			}), (i = n.get("*")) && i.slice().map(function(n) {
+				n(t, e);
+			});
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/js-cookie@3.0.5/node_modules/js-cookie/dist/js.cookie.mjs
+/*! js-cookie v3.0.5 | MIT */
+function assign(target) {
+	for (var i = 1; i < arguments.length; i++) {
+		var source = arguments[i];
+		for (var key in source) target[key] = source[key];
+	}
+	return target;
+}
+var defaultConverter = {
+	read: function(value) {
+		if (value[0] === "\"") value = value.slice(1, -1);
+		return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+	},
+	write: function(value) {
+		return encodeURIComponent(value).replace(/%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g, decodeURIComponent);
+	}
+};
+function init(converter, defaultAttributes) {
+	function set(name, value, attributes) {
+		if (typeof document === "undefined") return;
+		attributes = assign({}, defaultAttributes, attributes);
+		if (typeof attributes.expires === "number") attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+		if (attributes.expires) attributes.expires = attributes.expires.toUTCString();
+		name = encodeURIComponent(name).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+		var stringifiedAttributes = "";
+		for (var attributeName in attributes) {
+			if (!attributes[attributeName]) continue;
+			stringifiedAttributes += "; " + attributeName;
+			if (attributes[attributeName] === true) continue;
+			stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
+		}
+		return document.cookie = name + "=" + converter.write(value, name) + stringifiedAttributes;
+	}
+	function get(name) {
+		if (typeof document === "undefined" || arguments.length && !name) return;
+		var cookies = document.cookie ? document.cookie.split("; ") : [];
+		var jar = {};
+		for (var i = 0; i < cookies.length; i++) {
+			var parts = cookies[i].split("=");
+			var value = parts.slice(1).join("=");
+			try {
+				var found = decodeURIComponent(parts[0]);
+				jar[found] = converter.read(value, found);
+				if (name === found) break;
+			} catch (e) {}
+		}
+		return name ? jar[name] : jar;
+	}
+	return Object.create({
+		set,
+		get,
+		remove: function(name, attributes) {
+			set(name, "", assign({}, attributes, { expires: -1 }));
+		},
+		withAttributes: function(attributes) {
+			return init(this.converter, assign({}, this.attributes, attributes));
+		},
+		withConverter: function(converter) {
+			return init(assign({}, this.converter, converter), this.attributes);
+		}
+	}, {
+		attributes: { value: Object.freeze(defaultAttributes) },
+		converter: { value: Object.freeze(converter) }
+	});
+}
+var api = init(defaultConverter, { path: "/" });
+//#endregion
+//#region ../../node_modules/.pnpm/rattail@2.0.5_@voidzero-dev+vite-plus-core@0.1.18_@types+node@20.19.39_esbuild@0.27.7_jiti@2._oaa5dabgz63tacyacthirbl23y/node_modules/rattail/dist/index.mjs
+function at(arr, index) {
+	if (!arr.length) return;
+	if (index < 0) index += arr.length;
+	return arr[index];
+}
+function clamp(num, min, max) {
+	return Math.min(max, Math.max(min, num));
+}
+function clampArrayRange(index, arr) {
+	return clamp(index, 0, arr.length - 1);
+}
+function delay(time) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, time);
+	});
+}
+function randomNumber(min = 0, max = 100) {
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function times(num, fn) {
+	return Array.from({ length: num }, (_, index) => fn(index));
+}
+function inBrowser() {
+	return typeof window !== "undefined";
+}
+function getGlobalThis() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (inBrowser()) return window;
+	return typeof global !== "undefined" ? global : self;
+}
+const { hasOwnProperty } = Object.prototype;
+function hasOwn(val, key) {
+	return hasOwnProperty.call(val, key);
+}
+function inMobile() {
+	return inBrowser() && /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+const objectToString = Object.prototype.toString;
+function toTypeString(value) {
+	return objectToString.call(value);
+}
+function toRawType(value) {
+	return toTypeString(value).slice(8, -1);
+}
+function isArrayBuffer(val) {
+	return toRawType(val) === "ArrayBuffer";
+}
+function isBoolean(val) {
+	return typeof val === "boolean";
+}
+function isDataView(val) {
+	return toRawType(val) === "DataView";
+}
+function isDate(val) {
+	return toRawType(val) === "Date";
+}
+function isDOMException(val) {
+	return toRawType(val) === "DOMException";
+}
+function isEmpty(val) {
+	return val === void 0 || val === null || val === "" || isArray(val) && !val.length;
+}
+function isError(val) {
+	return toRawType(val) === "Error";
+}
+function isMap(val) {
+	return toRawType(val) === "Map";
+}
+function isObject(val) {
+	return typeof val === "object" && val !== null;
+}
+function isPlainObject(val) {
+	return toRawType(val) === "Object";
+}
+function isRegExp(val) {
+	return toRawType(val) === "RegExp";
+}
+function isSet(val) {
+	return toRawType(val) === "Set";
+}
+function isTypedArray(val) {
+	return [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array",
+		"BigInt64Array",
+		"BigUint64Array"
+	].includes(toRawType(val));
+}
+function isEqualWith(value, other, fn) {
+	const valueStack = /* @__PURE__ */ new WeakMap();
+	const otherStack = /* @__PURE__ */ new WeakMap();
+	function baseIsEqual(value, other, valueStack, otherStack) {
+		if (fn(value, other) === true) return true;
+		if (value === other) return true;
+		if (value !== value && other !== other) return true;
+		if (!isObject(value) || !isObject(other)) return value === other;
+		if (value.constructor !== other.constructor) return false;
+		if (toRawType(value) === "String" && toRawType(other) === "String" || toRawType(value) === "Number" && toRawType(other) === "Number" || toRawType(value) === "Boolean" && toRawType(other) === "Boolean" || toRawType(value) === "BigInt" && toRawType(other) === "BigInt" || toRawType(value) === "Symbol" && toRawType(other) === "Symbol") return value.valueOf() === other.valueOf();
+		if (isDate(value) && isDate(other)) return value.getTime() === other.getTime();
+		if (isRegExp(value) && isRegExp(other)) return value.source === other.source && value.flags === other.flags;
+		if (isError(value) && isError(other)) return value.name === other.name && value.message === other.message && value.cause === other.cause;
+		if (isDOMException(value) && isDOMException(other)) return value.name === other.name && value.message === other.message;
+		if (isTypedArray(value) && isTypedArray(other) || isDataView(value) && isDataView(other)) {
+			if (value.byteLength !== other.byteLength) return false;
+			const valueTypedArray = new Uint8Array(value.buffer);
+			const otherTypedArray = new Uint8Array(other.buffer);
+			return valueTypedArray.every((v, i) => v === otherTypedArray[i]);
+		}
+		if (isArrayBuffer(value) && isArrayBuffer(other)) {
+			if (value.byteLength !== other.byteLength) return false;
+			const valueTypedArray = new Uint8Array(value);
+			const otherTypedArray = new Uint8Array(other);
+			return valueTypedArray.every((v, i) => v === otherTypedArray[i]);
+		}
+		if (valueStack.get(value) === other && otherStack.get(other) === value) return true;
+		valueStack.set(value, other);
+		otherStack.set(other, value);
+		if (isMap(value) && isMap(other) || isSet(value) && isSet(other)) {
+			if (value.size !== other.size) return false;
+			const valueArray = [...value];
+			const otherArray = [...other];
+			const result = valueArray.every((v, i) => baseIsEqual(v, otherArray[i], valueStack, otherStack));
+			valueStack.delete(value);
+			otherStack.delete(other);
+			return result;
+		}
+		if (isArray(value) && isArray(other)) {
+			if (value.length !== other.length) return false;
+			const result = value.every((v, i) => baseIsEqual(v, other[i], valueStack, otherStack));
+			valueStack.delete(value);
+			otherStack.delete(other);
+			return result;
+		}
+		if (isPlainObject(value) && isPlainObject(other)) {
+			const valueOwnKeys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
+			const otherOwnKeys = [...Object.keys(other), ...Object.getOwnPropertySymbols(other)];
+			if (valueOwnKeys.length !== otherOwnKeys.length) return false;
+			const result = valueOwnKeys.every((k) => baseIsEqual(value[k], other[k], valueStack, otherStack));
+			valueStack.delete(value);
+			otherStack.delete(other);
+			return result;
+		}
+		return false;
+	}
+	return baseIsEqual(value, other, valueStack, otherStack);
+}
+function isEqual(value, other) {
+	return isEqualWith(value, other, () => void 0);
+}
+function isNonEmptyArray(val) {
+	return isArray(val) && !!val.length;
+}
+function isNullish(val) {
+	return val == null;
+}
+function isNumber(val) {
+	return typeof val === "number";
+}
+function isNumeric(val) {
+	return isNumber(val) || isString(val) && /^[-+]?\d+$/.test(val);
+}
+function isPromise(val) {
+	return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+}
+function isSymbol(val) {
+	return typeof val === "symbol";
+}
+function isTruthy(v) {
+	return Boolean(v);
+}
+function isWeakMap(val) {
+	return toRawType(val) === "WeakMap";
+}
+function isWeakSet(val) {
+	return toRawType(val) === "WeakSet";
+}
+function isWindow(val) {
+	return val === window;
+}
+function supportTouch() {
+	return inBrowser() && "ontouchstart" in window;
+}
+function isFile(val) {
+	return toRawType(val) === "File";
+}
+function isBlob(val) {
+	return toRawType(val) === "Blob";
+}
+function isPrimitive(val) {
+	return val == null || typeof val !== "object" && typeof val !== "function";
+}
+function isEmptyPlainObject(val) {
+	return isPlainObject(val) && Object.keys(val).length === 0 && Object.getOwnPropertySymbols(val).length === 0;
+}
+function assert$1(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function hasDuplicates(arr) {
+	return uniq(arr).length !== arr.length;
+}
+function hasDuplicatesBy(arr, fn) {
+	return uniqBy(arr, fn).length !== arr.length;
+}
+function toNumber(val) {
+	if (val == null) return 0;
+	if (isString(val)) {
+		val = parseFloat(val);
+		val = Number.isNaN(val) ? 0 : val;
+		return val;
+	}
+	if (isBoolean(val)) return Number(val);
+	return val;
+}
+let key$1 = 0;
+function genNumberKey() {
+	return key$1++;
+}
+function chunk(arr, size = 1) {
+	size = clamp(size, 1, arr.length);
+	const result = [];
+	let index = 0;
+	while (index < arr.length) {
+		result.push(arr.slice(index, index + size));
+		index += size;
+	}
+	return result;
+}
+function removeItem(arr, item) {
+	if (arr.length) {
+		const index = arr.indexOf(item);
+		if (index > -1) return arr.splice(index, 1);
+	}
+}
+function removeItemBy(arr, fn) {
+	if (arr.length) {
+		const index = arr.findIndex((v) => fn(v));
+		if (index > -1) return arr.splice(index, 1);
+	}
+}
+function removeItemsBy(arr, fn) {
+	let i = 0;
+	const removedItems = [];
+	while (i < arr.length) if (fn(arr[i])) removedItems.push(...arr.splice(i, 1));
+	else i++;
+	return removedItems;
+}
+function toggleItem(arr, item) {
+	arr.includes(item) ? removeItem(arr, item) : arr.push(item);
+	return arr;
+}
+function uniq(arr) {
+	return [...new Set(arr)];
+}
+function uniqBy(arr, fn) {
+	return arr.reduce((ret, i) => {
+		if (ret.findIndex((j) => fn(i, j)) === -1) ret.push(i);
+		return ret;
+	}, []);
+}
+function find(arr, fn, from = "start") {
+	let i = from === "start" ? 0 : arr.length - 1;
+	while (arr.length > 0 && i >= 0 && i <= arr.length - 1) {
+		if (fn(arr[i], i, arr)) return [arr[i], i];
+		from === "start" ? i++ : i--;
+	}
+	return [null, -1];
+}
+function shuffle(arr) {
+	for (let i = arr.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[arr[i], arr[j]] = [arr[j], arr[i]];
+	}
+	return arr;
+}
+function removeArrayBlank(arr) {
+	return arr.filter((item) => item != null);
+}
+function removeArrayEmpty(arr) {
+	return arr.filter((item) => item != null && item !== "");
+}
+function normalizeToArray(value) {
+	return isArray(value) ? value : [value];
+}
+function differenceWith(arr, ...values) {
+	const fn = at(values, -1);
+	const targets = values.slice(0, -1).reduce((targets, value) => [...targets, ...value], []);
+	return arr.filter((item) => !targets.some((value) => fn(item, value)));
+}
+function difference(arr, ...values) {
+	return differenceWith(arr, ...values, (a, b) => a === b);
+}
+function intersectionWith(...values) {
+	const fn = at(values, -1);
+	const targets = values.slice(0, -1);
+	if (targets.length === 0) return [];
+	if (targets.length === 1) return uniqBy(targets[0], fn);
+	function baseIntersectionWith(arr1, arr2) {
+		return arr1.filter((item) => arr2.some((value) => fn(item, value)));
+	}
+	return uniqBy(targets.reduce((result, target) => baseIntersectionWith(result, target)), fn);
+}
+function intersection(...values) {
+	return intersectionWith(...values, (a, b) => a === b);
+}
+function groupBy(arr, fn) {
+	return arr.reduce((result, item) => {
+		const key = fn(item);
+		(result[key] ??= []).push(item);
+		return result;
+	}, {});
+}
+function xorWith(...values) {
+	const fn = at(values, -1);
+	return uniqBy(values.slice(0, -1).reduce((result, target) => {
+		return [...differenceWith(result, target, fn), ...differenceWith(target, result, fn)];
+	}), fn);
+}
+function xor(...values) {
+	return xorWith(...values, (a, b) => a === b);
+}
+function pick(object, keys) {
+	return keys.reduce((result, key) => {
+		result[key] = object[key];
+		return result;
+	}, {});
+}
+function pickBy(object, fn) {
+	return [...Object.keys(object), ...Object.getOwnPropertySymbols(object)].reduce((result, key) => {
+		const value = object[key];
+		if (fn(value, key)) result[key] = value;
+		return result;
+	}, {});
+}
+function omit(object, keys) {
+	return [...Object.keys(object), ...Object.getOwnPropertySymbols(object)].reduce((result, key) => {
+		if (!keys.includes(key)) result[key] = object[key];
+		return result;
+	}, {});
+}
+function omitBy(object, fn) {
+	return [...Object.keys(object), ...Object.getOwnPropertySymbols(object)].reduce((result, key) => {
+		const value = object[key];
+		if (!fn(value, key)) result[key] = value;
+		return result;
+	}, {});
+}
+function mapObject(object, fn) {
+	return Object.entries(object).reduce((result, [key, value]) => {
+		const entry = fn(key, value);
+		if (isArray(entry)) {
+			const [newKey, newValue] = entry;
+			result[newKey] = newValue;
+		}
+		return result;
+	}, {});
+}
+function promiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((_resolver, _reject) => {
+			resolve = _resolver;
+			reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+function set(object, path, value) {
+	if (!isObject(object)) return;
+	const keys = [...path];
+	if (keys.length === 0) return;
+	let target = object;
+	while (keys.length > 1) {
+		const key = keys.shift();
+		const nextKey = keys[0];
+		if (!isObject(target[key])) target[key] = isNumber(nextKey) ? [] : {};
+		target = target[key];
+	}
+	target[keys[0]] = value;
+}
+function objectKeys(object) {
+	return Object.keys(object);
+}
+function objectEntries(object) {
+	return Object.entries(object);
+}
+var integrated_exports = /* @__PURE__ */ __exportAll({
+	mitt: () => mitt_default,
+	uuid: () => v4,
+	uuidV6: () => v6
 });
-module.exports = __toCommonJS(src_exports);
-var import_rattail = require("rattail");
-__reExport(src_exports, require("rattail"), module.exports);
+function cancelAnimationFrame(handle) {
+	const globalThis = getGlobalThis();
+	globalThis.cancelAnimationFrame ? globalThis.cancelAnimationFrame(handle) : globalThis.clearTimeout(handle);
+}
+function classes(...classes) {
+	return classes.map((className) => {
+		if (isArray(className)) {
+			const [condition, truthy, falsy = null] = className;
+			return condition ? truthy : falsy;
+		}
+		return className;
+	});
+}
+function copyText(value) {
+	if (!value) return;
+	const textArea = document.createElement("textarea");
+	textArea.value = value;
+	textArea.style.position = "fixed";
+	textArea.style.opacity = "0";
+	document.body.appendChild(textArea);
+	textArea.select();
+	document.execCommand("copy");
+	document.body.removeChild(textArea);
+}
+function maskString(text, { prefix = 2, suffix = 2, mask = "*", maskLength } = {}) {
+	if (text.length <= 1) return text;
+	const effectivePrefix = Math.min(prefix, text.length - 1);
+	const effectiveSuffix = Math.min(suffix, Math.max(text.length - effectivePrefix - 1, 0));
+	const count = maskLength ?? text.length - effectivePrefix - effectiveSuffix;
+	const suffixPart = effectiveSuffix > 0 ? text.slice(-effectiveSuffix) : "";
+	return text.slice(0, effectivePrefix) + mask.repeat(count) + suffixPart;
+}
+function camelize(s) {
+	s = s.replace(/[-_](\w)/g, (_, p) => p.toUpperCase());
+	return s.replace(s.charAt(0), s.charAt(0).toLowerCase());
+}
+function ensurePrefix(s, prefix) {
+	return s.startsWith(prefix) ? s : prefix + s;
+}
+function ensureSuffix(s, suffix) {
+	return s.endsWith(suffix) ? s : s + suffix;
+}
+let key = 0;
+function genStringKey() {
+	return `generated-key-${key++}`;
+}
+function kebabCase(s) {
+	return s.replace(/([A-Z])/g, " $1").replace(/[_\s]+/g, "-").trim().replace(/^-/, "").toLowerCase();
+}
+function pascalCase(s) {
+	const ret = camelize(s);
+	return ret.replace(ret.charAt(0), ret.charAt(0).toUpperCase());
+}
+function lowerFirst(s) {
+	return s.charAt(0).toLowerCase() + s.slice(1);
+}
+function upperFirst(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function randomColor() {
+	const letters = "0123456789abcdef";
+	let color = "#";
+	for (let i = 0; i < 6; i++) color += letters[Math.floor(Math.random() * 16)];
+	return color;
+}
+function randomString(length = 10) {
+	let str = baseRandomString();
+	while (str.length < length) str += baseRandomString();
+	function baseRandomString() {
+		return Math.random().toString(36).slice(2);
+	}
+	return str.slice(0, length);
+}
+function slash(path) {
+	if (path.startsWith("\\\\?\\")) return path;
+	return path.replace(/\\/g, "/");
+}
+function createNamespaceFn(namespace) {
+	return (name) => {
+		const componentName = `${namespace}-${name}`;
+		const createBEM = (suffix) => {
+			if (!suffix) return componentName;
+			if (suffix[0] === "$") return suffix.replace("$", namespace);
+			return suffix.startsWith("--") ? `${componentName}${suffix}` : `${componentName}__${suffix}`;
+		};
+		return {
+			name: pascalCase(componentName),
+			n: createBEM,
+			classes
+		};
+	};
+}
+function requestAnimationFrame(fn) {
+	const globalThis = getGlobalThis();
+	return globalThis.requestAnimationFrame ? globalThis.requestAnimationFrame(fn) : globalThis.setTimeout(fn);
+}
+function doubleRaf() {
+	return new Promise((resolve) => {
+		requestAnimationFrame(() => {
+			requestAnimationFrame(resolve);
+		});
+	});
+}
+function getStyle(element) {
+	return window.getComputedStyle(element);
+}
+function getParentScroller(el) {
+	let element = el;
+	while (element) {
+		if (!element.parentNode) break;
+		element = element.parentNode;
+		if (element === document.body || element === document.documentElement) break;
+		const scrollRE = /(scroll|auto)/;
+		const { overflowY, overflow } = getStyle(element);
+		if (scrollRE.test(overflowY) || scrollRE.test(overflow)) return element;
+	}
+	return window;
+}
+function getAllParentScroller(el) {
+	const allParentScroller = [];
+	let element = el;
+	while (!isWindow(element)) {
+		element = getParentScroller(element);
+		allParentScroller.push(element);
+	}
+	return allParentScroller;
+}
+function getRect(element) {
+	if (isWindow(element)) {
+		const width = element.innerWidth;
+		const height = element.innerHeight;
+		const rect = {
+			x: 0,
+			y: 0,
+			top: 0,
+			left: 0,
+			right: width,
+			bottom: height,
+			width,
+			height
+		};
+		return {
+			...rect,
+			toJSON: () => rect
+		};
+	}
+	return element.getBoundingClientRect();
+}
+function getScrollLeft(element) {
+	const left = "scrollLeft" in element ? element.scrollLeft : element.scrollX;
+	return Math.max(left, 0);
+}
+function getScrollTop(element) {
+	const top = "scrollTop" in element ? element.scrollTop : element.scrollY;
+	return Math.max(top, 0);
+}
+function inViewport(element) {
+	const { top, bottom, left, right } = getRect(element);
+	const { width, height } = getRect(window);
+	return left <= width && right >= 0 && top <= height && bottom >= 0;
+}
+function prettyJSONObject(jsonObject) {
+	return JSON.stringify(jsonObject, null, 2);
+}
+function preventDefault(event) {
+	if (event.cancelable === false) return;
+	event.preventDefault();
+}
+function raf() {
+	return new Promise((resolve) => {
+		requestAnimationFrame(resolve);
+	});
+}
+function createStorage(storage) {
+	return {
+		...storage,
+		set(key, value) {
+			if (value == null) return;
+			if (!isString(value)) value = JSON.stringify(value);
+			storage.setItem(key, value);
+		},
+		get(key) {
+			const data = storage.getItem(key);
+			try {
+				return JSON.parse(data);
+			} catch (err) {
+				return data;
+			}
+		},
+		remove(key) {
+			storage.removeItem(key);
+		}
+	};
+}
+function createCookieStorage(options = {}) {
+	const defaultOptions = options;
+	return {
+		set(key, value, options = {}) {
+			if (value == null) return;
+			if (!isString(value)) value = JSON.stringify(value);
+			api.set(key, value, {
+				...defaultOptions,
+				...options
+			});
+		},
+		get(key) {
+			const data = api.get(key);
+			try {
+				return JSON.parse(data);
+			} catch (err) {
+				return data;
+			}
+		},
+		remove(key, options = {}) {
+			api.remove(key, {
+				...defaultOptions,
+				...options
+			});
+		}
+	};
+}
+const sessionStorage = createStorage(getGlobalThis().sessionStorage);
+const localStorage = createStorage(getGlobalThis().localStorage);
+function tryParseJSON(json) {
+	try {
+		return JSON.parse(json);
+	} catch {
+		return;
+	}
+}
+function download(val, filename = "file") {
+	const a = document.createElement("a");
+	a.style.display = "none";
+	a.href = isString(val) ? val : URL.createObjectURL(val);
+	a.download = filename;
+	document.body.appendChild(a);
+	a.click();
+	URL.revokeObjectURL(a.href);
+	document.body.removeChild(a);
+}
+function call(fn, ...args) {
+	if (isArray(fn)) return fn.map((f) => f(...args));
+	if (fn) return fn(...args);
+}
+function tryCall(fn, ...args) {
+	try {
+		return [void 0, fn(...args)];
+	} catch (e) {
+		return [e, void 0];
+	}
+}
+async function tryAsyncCall(fn, ...args) {
+	try {
+		return [void 0, await fn(...args)];
+	} catch (e) {
+		return [e, void 0];
+	}
+}
+function once(fn) {
+	let called = false;
+	let result;
+	return function(...args) {
+		if (called) return result;
+		called = true;
+		result = fn.apply(this, args);
+		return result;
+	};
+}
+function debounce(fn, delay = 0) {
+	let timer;
+	return function(...args) {
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			fn.apply(this, args);
+		}, delay);
+	};
+}
+function throttle(fn, delay = 200) {
+	let timer;
+	let start = 0;
+	return function loop(...args) {
+		const now = performance.now();
+		const elapsed = now - start;
+		if (!start) start = now;
+		if (timer) clearTimeout(timer);
+		if (elapsed >= delay) {
+			fn.apply(this, args);
+			start = now;
+		} else timer = setTimeout(() => {
+			loop.apply(this, args);
+		}, delay - elapsed);
+	};
+}
+function NOOP() {}
+function enumOf(config) {
+	const extractValues = Object.entries(config).reduce((result, [key, value]) => {
+		result[key] = isPlainObject(value) ? value.value : value;
+		return result;
+	}, {});
+	const configValues = Object.values(config);
+	function label(v) {
+		const valueObject = getValueObject(v);
+		return valueObject?.label ? callOrReturn(valueObject.label) : "";
+	}
+	function description(v) {
+		const valueObject = getValueObject(v);
+		return valueObject?.description ? callOrReturn(valueObject.description) : "";
+	}
+	function values() {
+		return configValues.map((option) => isPlainObject(option) ? option.value : option);
+	}
+	function labels() {
+		return configValues.map((option) => {
+			if (isPlainObject(option)) return option.label ? callOrReturn(option.label) : "";
+			return "";
+		});
+	}
+	function descriptions() {
+		return configValues.map((option) => {
+			if (isPlainObject(option)) return option.description ? callOrReturn(option.description) : "";
+			return "";
+		});
+	}
+	function resolveOption(option) {
+		const result = {};
+		for (const key of Object.keys(option)) result[key] = callOrReturn(option[key]);
+		return result;
+	}
+	function option(v) {
+		const valueObject = getValueObject(v);
+		if (valueObject) return resolveOption(valueObject);
+		return {
+			value: v,
+			label: "",
+			description: ""
+		};
+	}
+	function options() {
+		return configValues.map((option) => {
+			if (isPlainObject(option)) return resolveOption(option);
+			return {
+				value: option,
+				label: "",
+				description: ""
+			};
+		});
+	}
+	function getValueObject(v) {
+		return configValues.find((option) => isPlainObject(option) && option.value === v);
+	}
+	return {
+		...extractValues,
+		values,
+		label,
+		description,
+		labels,
+		descriptions,
+		option,
+		options
+	};
+}
+function motion(options) {
+	const { from, to, duration = 300, frame = () => {}, timingFunction = (value) => value, onStateChange = () => {} } = options;
+	let state = "pending";
+	let value = from;
+	const distance = to - from;
+	let ticker = void 0;
+	let startTime = void 0;
+	let pausedTime = void 0;
+	let sleepTime = 0;
+	function start() {
+		if (state === "running" || state === "finished") return;
+		setState("running");
+		const now = performance.now();
+		startTime = startTime != null ? startTime : now;
+		sleepTime += pausedTime != null ? now - pausedTime : 0;
+		pausedTime = void 0;
+		tick();
+		function tick() {
+			ticker = requestAnimationFrame(() => {
+				const progress = clamp((performance.now() - startTime - sleepTime) / duration, 0, 1);
+				value = distance * timingFunction(progress) + from;
+				if (progress >= 1) {
+					setState("finished");
+					frame({
+						value: to,
+						done: true
+					});
+					return;
+				}
+				frame({
+					value,
+					done: false
+				});
+				tick();
+			});
+		}
+	}
+	function pause() {
+		if (state !== "running") return;
+		cancelAnimationFrame(ticker);
+		setState("paused");
+		pausedTime = performance.now();
+	}
+	function reset() {
+		cancelAnimationFrame(ticker);
+		setState("pending");
+		value = from;
+		ticker = void 0;
+		startTime = void 0;
+		pausedTime = void 0;
+		sleepTime = 0;
+	}
+	function getState() {
+		return state;
+	}
+	function setState(_state) {
+		state = _state;
+		onStateChange(_state);
+	}
+	return {
+		start,
+		pause,
+		reset,
+		getState
+	};
+}
+function duration() {
+	const ctx = {
+		value: 0,
+		years,
+		months,
+		weeks,
+		days,
+		hours,
+		minutes,
+		seconds,
+		milliseconds,
+		valueOf
+	};
+	function years(value) {
+		ctx.value += value * 365 * 24 * 60 * 60 * 1e3;
+		return ctx;
+	}
+	function months(value) {
+		ctx.value += value * 30 * 24 * 60 * 60 * 1e3;
+		return ctx;
+	}
+	function weeks(value) {
+		ctx.value += value * 7 * 24 * 60 * 60 * 1e3;
+		return ctx;
+	}
+	function days(value) {
+		ctx.value += value * 24 * 60 * 60 * 1e3;
+		return ctx;
+	}
+	function hours(value) {
+		ctx.value += value * 60 * 60 * 1e3;
+		return ctx;
+	}
+	function minutes(value) {
+		ctx.value += value * 60 * 1e3;
+		return ctx;
+	}
+	function seconds(value) {
+		ctx.value += value * 1e3;
+		return ctx;
+	}
+	function milliseconds(value) {
+		ctx.value += value;
+		return ctx;
+	}
+	function valueOf(options = { milliseconds: true }) {
+		return options.milliseconds ? ctx.value : ctx.value / 1e3;
+	}
+	return ctx;
+}
+function createCacheManager(options = {}) {
+	const cacheManager = /* @__PURE__ */ new Map();
+	const { ttl: defaultTtl = Infinity } = options;
+	function purgeStale() {
+		cacheManager.forEach((value, key) => {
+			if (performance.now() > value.expiredAt) remove(key);
+		});
+	}
+	function has(key) {
+		purgeStale();
+		return cacheManager.has(key);
+	}
+	function get(key) {
+		purgeStale();
+		return cacheManager.get(key)?.value;
+	}
+	function set(key, value, options) {
+		const ttl = options?.ttl ?? defaultTtl;
+		cacheManager.set(key, {
+			expiredAt: performance.now() + ttl,
+			value
+		});
+	}
+	function remove(key) {
+		return cacheManager.delete(key);
+	}
+	function clear() {
+		cacheManager.clear();
+	}
+	return {
+		has,
+		get,
+		set,
+		remove,
+		clear
+	};
+}
+function buildNavigationUrl(target) {
+	if (isString(target)) return target;
+	const { to, query, hash } = target;
+	const hashIndex = to.indexOf("#");
+	const toWithoutHash = hashIndex >= 0 ? to.slice(0, hashIndex) : to;
+	const existingHash = hashIndex >= 0 ? `#${to.slice(hashIndex + 1)}` : "";
+	const queryIndex = toWithoutHash.indexOf("?");
+	const base = queryIndex >= 0 ? toWithoutHash.slice(0, queryIndex) : toWithoutHash;
+	const existingQueryString = queryIndex >= 0 ? toWithoutHash.slice(queryIndex + 1) : "";
+	const params = new URLSearchParams(existingQueryString);
+	if (query) for (const [key, value] of Object.entries(query)) params.append(key, String(value));
+	const queryString = params.toString();
+	const finalHash = hash ?? existingHash;
+	let url = base;
+	if (queryString) url += `?${queryString}`;
+	if (finalHash) url += finalHash;
+	return url;
+}
+const navigation = {
+	push(target) {
+		window.location.assign(buildNavigationUrl(target));
+	},
+	replace(target) {
+		window.location.replace(buildNavigationUrl(target));
+	},
+	open(target) {
+		const url = buildNavigationUrl(target);
+		window.open(url);
+	},
+	back() {
+		window.history.back();
+	},
+	go(delta) {
+		window.history.go(delta);
+	}
+};
+function cloneDeepWith(value, fn) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	function baseCloneDeep(value, cache) {
+		const customResult = fn(value);
+		if (customResult !== void 0) return customResult;
+		if (!isObject(value)) return value;
+		if (cache.has(value)) return cache.get(value);
+		if (isDate(value)) return new Date(value);
+		if (isRegExp(value)) return new RegExp(value);
+		if (isMap(value)) {
+			const result = /* @__PURE__ */ new Map();
+			cache.set(value, result);
+			value.forEach((val, key) => {
+				result.set(baseCloneDeep(key, cache), baseCloneDeep(val, cache));
+			});
+			return result;
+		}
+		if (isSet(value)) {
+			const result = /* @__PURE__ */ new Set();
+			cache.set(value, result);
+			value.forEach((val) => {
+				result.add(baseCloneDeep(val, cache));
+			});
+			return result;
+		}
+		if (toRawType(value) === "String" || toRawType(value) === "Number" || toRawType(value) === "Boolean") return newConstructor(value, value.valueOf());
+		if (isWeakMap(value) || isWeakSet(value) || isError(value) || isDOMException(value)) return {};
+		if (isTypedArray(value)) return newConstructor(value, baseCloneArrayBuffer(value.buffer), value.byteOffset, value.length);
+		if (isDataView(value)) return newConstructor(value, baseCloneArrayBuffer(value.buffer), value.byteOffset, value.byteLength);
+		if (isArrayBuffer(value)) return baseCloneArrayBuffer(value);
+		if (isArray(value)) {
+			const result = [];
+			cache.set(value, result);
+			value.forEach((value, index) => {
+				result[index] = baseCloneDeep(value, cache);
+			});
+			return result;
+		}
+		if (isPlainObject(value)) {
+			const result = Object.create(Reflect.getPrototypeOf(value));
+			cache.set(value, result);
+			[...Object.keys(value), ...Object.getOwnPropertySymbols(value)].forEach((key) => {
+				result[key] = baseCloneDeep(value[key], cache);
+			});
+			return result;
+		}
+		return value;
+	}
+	function baseCloneArrayBuffer(value) {
+		const result = new ArrayBuffer(value.byteLength);
+		new Uint8Array(result).set(new Uint8Array(value));
+		return result;
+	}
+	function newConstructor(value, ...args) {
+		return new value.constructor(...args);
+	}
+	return baseCloneDeep(value, cache);
+}
+function cloneDeep(value) {
+	return cloneDeepWith(value, () => void 0);
+}
+function mergeWith(object, ...sources) {
+	const fn = at(sources, -1);
+	const targets = [object, ...sources.slice(0, -1)];
+	let len = targets.length - 1;
+	let result = targets[len];
+	while (len) {
+		result = baseMergeWith(targets[len - 1], result, fn);
+		len--;
+	}
+	function baseMergeWith(object, source, fn) {
+		function baseMerge(target, src) {
+			for (const key in src) if (hasOwn(src, key)) {
+				const srcValue = src[key];
+				const targetValue = target[key];
+				const customResult = fn(targetValue, srcValue, key, object, source);
+				if (customResult !== void 0) target[key] = customResult;
+				else if (isObject(srcValue)) if (isObject(targetValue)) target[key] = baseMerge(targetValue, srcValue);
+				else target[key] = baseMerge(isArray(srcValue) ? [] : {}, srcValue);
+				else target[key] = srcValue;
+			}
+			return target;
+		}
+		return baseMerge(object, source);
+	}
+	return result;
+}
+function merge(object, ...sources) {
+	return mergeWith(object, ...sources, () => void 0);
+}
+function toArrayBuffer(file) {
+	return new Promise((resolve) => {
+		const fileReader = new FileReader();
+		fileReader.onload = () => {
+			resolve(fileReader.result);
+		};
+		fileReader.readAsArrayBuffer(file);
+	});
+}
+function toDataURL(file) {
+	return new Promise((resolve) => {
+		const fileReader = new FileReader();
+		fileReader.onload = () => {
+			resolve(fileReader.result);
+		};
+		fileReader.readAsDataURL(file);
+	});
+}
+function toText(file) {
+	return new Promise((resolve) => {
+		const fileReader = new FileReader();
+		fileReader.onload = () => {
+			resolve(fileReader.result);
+		};
+		fileReader.readAsText(file);
+	});
+}
+function maxBy(arr, fn) {
+	return arr.reduce((result, item) => fn(result) > fn(item) ? result : item, arr[0]);
+}
+function minBy(arr, fn) {
+	return arr.reduce((result, item) => fn(result) < fn(item) ? result : item, arr[0]);
+}
+function sum(arr) {
+	return arr.reduce((ret, val) => ret + val, 0);
+}
+function sumBy(arr, fn) {
+	return arr.reduce((ret, val) => ret + fn(val), 0);
+}
+function sumHash(value) {
+	function sum(hash, value) {
+		for (let i = 0; i < value.length; i++) {
+			const chr = value.charCodeAt(i);
+			hash = (hash << 5) - hash + chr;
+			hash |= 0;
+		}
+		return hash < 0 ? hash * -2 : hash;
+	}
+	function baseSumHash(hash, value, key, seen) {
+		hash = sum(hash, key);
+		hash = sum(hash, toTypeString(value));
+		hash = sum(hash, typeof value);
+		if (value === null) return sum(hash, "null");
+		if (value === void 0) return sum(hash, "undefined");
+		if (isObject(value) || isFunction(value)) {
+			if (seen.includes(value)) return sum(hash, `[Circular]${key}`);
+			seen.push(value);
+			hash = Object.keys(value).sort().reduce((hash, key) => baseSumHash(hash, value[key], key, seen), hash);
+			if (isFunction(value.valueOf)) return sum(hash, String(value.valueOf()));
+			return hash;
+		}
+		return sum(hash, value.toString());
+	}
+	return baseSumHash(0, value, "", []).toString(16).padStart(8, "0");
+}
+function mean(arr) {
+	return sum(arr) / arr.length;
+}
+function meanBy(arr, fn) {
+	return sumBy(arr, fn) / arr.length;
+}
+function sample(arr) {
+	if (!arr.length) return;
+	return arr[randomNumber(0, arr.length - 1)];
+}
+function round(val, precision = 0) {
+	return baseRound(val, precision, Math.round);
+}
+function baseRound(val, precision, fn) {
+	precision = clamp(precision ?? 0, -292, 292);
+	if (!precision) return fn(val);
+	return +`${fn(`${val}e${precision}`)}e${-precision}`;
+}
+function floor(val, precision = 0) {
+	return baseRound(val, precision, Math.floor);
+}
+function ceil(val, precision = 0) {
+	return baseRound(val, precision, Math.ceil);
+}
+__reExport(/* @__PURE__ */ __exportAll({
+	NOOP: () => NOOP,
+	assert: () => assert$1,
+	at: () => at,
+	baseRound: () => baseRound,
+	buildNavigationUrl: () => buildNavigationUrl,
+	call: () => call,
+	callOrReturn: () => callOrReturn,
+	camelize: () => camelize,
+	cancelAnimationFrame: () => cancelAnimationFrame,
+	ceil: () => ceil,
+	chunk: () => chunk,
+	clamp: () => clamp,
+	clampArrayRange: () => clampArrayRange,
+	classes: () => classes,
+	cloneDeep: () => cloneDeep,
+	cloneDeepWith: () => cloneDeepWith,
+	copyText: () => copyText,
+	createCacheManager: () => createCacheManager,
+	createCookieStorage: () => createCookieStorage,
+	createNamespaceFn: () => createNamespaceFn,
+	createStorage: () => createStorage,
+	debounce: () => debounce,
+	delay: () => delay,
+	difference: () => difference,
+	differenceWith: () => differenceWith,
+	doubleRaf: () => doubleRaf,
+	download: () => download,
+	duration: () => duration,
+	ensurePrefix: () => ensurePrefix,
+	ensureSuffix: () => ensureSuffix,
+	enumOf: () => enumOf,
+	find: () => find,
+	floor: () => floor,
+	genNumberKey: () => genNumberKey,
+	genStringKey: () => genStringKey,
+	getAllParentScroller: () => getAllParentScroller,
+	getGlobalThis: () => getGlobalThis,
+	getParentScroller: () => getParentScroller,
+	getRect: () => getRect,
+	getScrollLeft: () => getScrollLeft,
+	getScrollTop: () => getScrollTop,
+	getStyle: () => getStyle,
+	groupBy: () => groupBy,
+	hasDuplicates: () => hasDuplicates,
+	hasDuplicatesBy: () => hasDuplicatesBy,
+	hasOwn: () => hasOwn,
+	inBrowser: () => inBrowser,
+	inMobile: () => inMobile,
+	inViewport: () => inViewport,
+	intersection: () => intersection,
+	intersectionWith: () => intersectionWith,
+	isArray: () => isArray,
+	isArrayBuffer: () => isArrayBuffer,
+	isBlob: () => isBlob,
+	isBoolean: () => isBoolean,
+	isDOMException: () => isDOMException,
+	isDataView: () => isDataView,
+	isDate: () => isDate,
+	isEmpty: () => isEmpty,
+	isEmptyPlainObject: () => isEmptyPlainObject,
+	isEqual: () => isEqual,
+	isEqualWith: () => isEqualWith,
+	isError: () => isError,
+	isFile: () => isFile,
+	isFunction: () => isFunction,
+	isMap: () => isMap,
+	isNonEmptyArray: () => isNonEmptyArray,
+	isNullish: () => isNullish,
+	isNumber: () => isNumber,
+	isNumeric: () => isNumeric,
+	isObject: () => isObject,
+	isPlainObject: () => isPlainObject,
+	isPrimitive: () => isPrimitive,
+	isPromise: () => isPromise,
+	isRegExp: () => isRegExp,
+	isSet: () => isSet,
+	isString: () => isString,
+	isSymbol: () => isSymbol,
+	isTruthy: () => isTruthy,
+	isTypedArray: () => isTypedArray,
+	isWeakMap: () => isWeakMap,
+	isWeakSet: () => isWeakSet,
+	isWindow: () => isWindow,
+	kebabCase: () => kebabCase,
+	localStorage: () => localStorage,
+	lowerFirst: () => lowerFirst,
+	mapObject: () => mapObject,
+	maskString: () => maskString,
+	maxBy: () => maxBy,
+	mean: () => mean,
+	meanBy: () => meanBy,
+	merge: () => merge,
+	mergeWith: () => mergeWith,
+	minBy: () => minBy,
+	mitt: () => mitt_default,
+	motion: () => motion,
+	navigation: () => navigation,
+	normalizeToArray: () => normalizeToArray,
+	objectEntries: () => objectEntries,
+	objectKeys: () => objectKeys,
+	objectToString: () => objectToString,
+	omit: () => omit,
+	omitBy: () => omitBy,
+	once: () => once,
+	pascalCase: () => pascalCase,
+	pick: () => pick,
+	pickBy: () => pickBy,
+	prettyJSONObject: () => prettyJSONObject,
+	preventDefault: () => preventDefault,
+	promiseWithResolvers: () => promiseWithResolvers,
+	raf: () => raf,
+	randomColor: () => randomColor,
+	randomNumber: () => randomNumber,
+	randomString: () => randomString,
+	removeArrayBlank: () => removeArrayBlank,
+	removeArrayEmpty: () => removeArrayEmpty,
+	removeItem: () => removeItem,
+	removeItemBy: () => removeItemBy,
+	removeItemsBy: () => removeItemsBy,
+	requestAnimationFrame: () => requestAnimationFrame,
+	round: () => round,
+	sample: () => sample,
+	sessionStorage: () => sessionStorage,
+	set: () => set,
+	shuffle: () => shuffle,
+	slash: () => slash,
+	sum: () => sum,
+	sumBy: () => sumBy,
+	sumHash: () => sumHash,
+	supportTouch: () => supportTouch,
+	throttle: () => throttle,
+	times: () => times,
+	toArrayBuffer: () => toArrayBuffer,
+	toDataURL: () => toDataURL,
+	toNumber: () => toNumber,
+	toRawType: () => toRawType,
+	toText: () => toText,
+	toTypeString: () => toTypeString,
+	toggleItem: () => toggleItem,
+	tryAsyncCall: () => tryAsyncCall,
+	tryCall: () => tryCall,
+	tryParseJSON: () => tryParseJSON,
+	uniq: () => uniq,
+	uniqBy: () => uniqBy,
+	upperFirst: () => upperFirst,
+	uuid: () => v4,
+	uuidV6: () => v6,
+	xor: () => xor,
+	xorWith: () => xorWith
+}), integrated_exports);
+//#endregion
+//#region src/index.ts
 function assert(condition, source, message) {
-  return (0, import_rattail.assert)(condition, `Varlet [${source}]: ${message}`);
+	return assert$1(condition, `Varlet [${source}]: ${message}`);
 }
 function warn(source, message) {
-  console.warn(`Varlet [${source}]: ${message}`);
+	console.warn(`Varlet [${source}]: ${message}`);
 }
 function error(source, message) {
-  console.error(`Varlet [${source}]: ${message}`);
+	console.error(`Varlet [${source}]: ${message}`);
 }
-var isURL = (val) => {
-  if (!val) {
-    return false;
-  }
-  return /^(http)|(\.*\/)/.test(val);
+const isURL = (val) => {
+	if (!val) return false;
+	return /^(http)|(\.*\/)/.test(val);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  assert,
-  error,
-  isURL,
-  warn,
-  ...require("rattail")
-});
+//#endregion
+exports.NOOP = NOOP;
+exports.assert = assert;
+exports.at = at;
+exports.baseRound = baseRound;
+exports.buildNavigationUrl = buildNavigationUrl;
+exports.call = call;
+exports.callOrReturn = callOrReturn;
+exports.camelize = camelize;
+exports.cancelAnimationFrame = cancelAnimationFrame;
+exports.ceil = ceil;
+exports.chunk = chunk;
+exports.clamp = clamp;
+exports.clampArrayRange = clampArrayRange;
+exports.classes = classes;
+exports.cloneDeep = cloneDeep;
+exports.cloneDeepWith = cloneDeepWith;
+exports.copyText = copyText;
+exports.createCacheManager = createCacheManager;
+exports.createCookieStorage = createCookieStorage;
+exports.createNamespaceFn = createNamespaceFn;
+exports.createStorage = createStorage;
+exports.debounce = debounce;
+exports.delay = delay;
+exports.difference = difference;
+exports.differenceWith = differenceWith;
+exports.doubleRaf = doubleRaf;
+exports.download = download;
+exports.duration = duration;
+exports.ensurePrefix = ensurePrefix;
+exports.ensureSuffix = ensureSuffix;
+exports.enumOf = enumOf;
+exports.error = error;
+exports.find = find;
+exports.floor = floor;
+exports.genNumberKey = genNumberKey;
+exports.genStringKey = genStringKey;
+exports.getAllParentScroller = getAllParentScroller;
+exports.getGlobalThis = getGlobalThis;
+exports.getParentScroller = getParentScroller;
+exports.getRect = getRect;
+exports.getScrollLeft = getScrollLeft;
+exports.getScrollTop = getScrollTop;
+exports.getStyle = getStyle;
+exports.groupBy = groupBy;
+exports.hasDuplicates = hasDuplicates;
+exports.hasDuplicatesBy = hasDuplicatesBy;
+exports.hasOwn = hasOwn;
+exports.inBrowser = inBrowser;
+exports.inMobile = inMobile;
+exports.inViewport = inViewport;
+exports.intersection = intersection;
+exports.intersectionWith = intersectionWith;
+exports.isArray = isArray;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isBlob = isBlob;
+exports.isBoolean = isBoolean;
+exports.isDOMException = isDOMException;
+exports.isDataView = isDataView;
+exports.isDate = isDate;
+exports.isEmpty = isEmpty;
+exports.isEmptyPlainObject = isEmptyPlainObject;
+exports.isEqual = isEqual;
+exports.isEqualWith = isEqualWith;
+exports.isError = isError;
+exports.isFile = isFile;
+exports.isFunction = isFunction;
+exports.isMap = isMap;
+exports.isNonEmptyArray = isNonEmptyArray;
+exports.isNullish = isNullish;
+exports.isNumber = isNumber;
+exports.isNumeric = isNumeric;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPrimitive = isPrimitive;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isTruthy = isTruthy;
+exports.isTypedArray = isTypedArray;
+exports.isURL = isURL;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;
+exports.isWindow = isWindow;
+exports.kebabCase = kebabCase;
+exports.localStorage = localStorage;
+exports.lowerFirst = lowerFirst;
+exports.mapObject = mapObject;
+exports.maskString = maskString;
+exports.maxBy = maxBy;
+exports.mean = mean;
+exports.meanBy = meanBy;
+exports.merge = merge;
+exports.mergeWith = mergeWith;
+exports.minBy = minBy;
+exports.mitt = mitt_default;
+exports.motion = motion;
+exports.navigation = navigation;
+exports.normalizeToArray = normalizeToArray;
+exports.objectEntries = objectEntries;
+exports.objectKeys = objectKeys;
+exports.objectToString = objectToString;
+exports.omit = omit;
+exports.omitBy = omitBy;
+exports.once = once;
+exports.pascalCase = pascalCase;
+exports.pick = pick;
+exports.pickBy = pickBy;
+exports.prettyJSONObject = prettyJSONObject;
+exports.preventDefault = preventDefault;
+exports.promiseWithResolvers = promiseWithResolvers;
+exports.raf = raf;
+exports.randomColor = randomColor;
+exports.randomNumber = randomNumber;
+exports.randomString = randomString;
+exports.removeArrayBlank = removeArrayBlank;
+exports.removeArrayEmpty = removeArrayEmpty;
+exports.removeItem = removeItem;
+exports.removeItemBy = removeItemBy;
+exports.removeItemsBy = removeItemsBy;
+exports.requestAnimationFrame = requestAnimationFrame;
+exports.round = round;
+exports.sample = sample;
+exports.sessionStorage = sessionStorage;
+exports.set = set;
+exports.shuffle = shuffle;
+exports.slash = slash;
+exports.sum = sum;
+exports.sumBy = sumBy;
+exports.sumHash = sumHash;
+exports.supportTouch = supportTouch;
+exports.throttle = throttle;
+exports.times = times;
+exports.toArrayBuffer = toArrayBuffer;
+exports.toDataURL = toDataURL;
+exports.toNumber = toNumber;
+exports.toRawType = toRawType;
+exports.toText = toText;
+exports.toTypeString = toTypeString;
+exports.toggleItem = toggleItem;
+exports.tryAsyncCall = tryAsyncCall;
+exports.tryCall = tryCall;
+exports.tryParseJSON = tryParseJSON;
+exports.uniq = uniq;
+exports.uniqBy = uniqBy;
+exports.upperFirst = upperFirst;
+exports.uuid = v4;
+exports.uuidV6 = v6;
+exports.warn = warn;
+exports.xor = xor;
+exports.xorWith = xorWith;