@rebon/cli-linux-arm64 1.18.0 → 1.19.0

package/bin/compose-runtime/payload/vendor/cosmokit/index.mjs

@@ -1,357 +1,418 @@
-// src/misc.ts
-function noop() {
-}
+//#region lib/types/misc.js
+/** No-op callback returning `undefined` at runtime and `any` at type level. */
+function noop() {}
+/** Return true when a value is `null` or `undefined`. */
 function isNullable(value) {
-  return value === null || value === void 0;
+	return value === null || value === void 0;
 }
+/** Return true when a value is neither `null` nor `undefined`. */
 function isNonNullable(value) {
-  return !isNullable(value);
+	return !isNullable(value);
 }
+/** Return true for non-array object values. */
 function isPlainObject(data) {
-  return data && typeof data === "object" && !Array.isArray(data);
+	return data && typeof data === "object" && !Array.isArray(data);
 }
+/** Filter object entries and return a new object. */
 function filterKeys(object, filter) {
-  return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
 }
+/** Map object values while preserving the original key set. */
 function mapValues(object, transform) {
-  return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
 }
+/** Pick selected keys from an object, optionally including `undefined` values. */
 function pick(source, keys, forced) {
-  if (!keys) return { ...source };
-  const result = {};
-  for (const key of keys) {
-    if (forced || source[key] !== void 0) result[key] = source[key];
-  }
-  return result;
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
 }
+/** Omit selected keys from a shallow object copy. */
 function omit(source, keys) {
-  if (!keys) return { ...source };
-  const result = { ...source };
-  for (const key of keys) {
-    Reflect.deleteProperty(result, key);
-  }
-  return result;
+	if (!keys) return { ...source };
+	const result = { ...source };
+	for (const key of keys) Reflect.deleteProperty(result, key);
+	return result;
 }
+/** Define a non-enumerable writable property and return the object. */
 function defineProperty(object, key, value) {
-  return Object.defineProperty(object, key, { writable: true, value, enumerable: false });
+	return Object.defineProperty(object, key, {
+		writable: true,
+		value,
+		enumerable: false
+	});
 }
-
-// src/array.ts
+//#endregion
+//#region lib/types/array.js
+/** Return true when every item in `array2` is present in `array1`. */
 function contain(array1, array2) {
-  return array2.every((item) => array1.includes(item));
+	return array2.every((item) => array1.includes(item));
 }
+/** Return items that appear in both arrays. */
 function intersection(array1, array2) {
-  return array1.filter((item) => array2.includes(item));
+	return array1.filter((item) => array2.includes(item));
 }
+/** Return items from `array1` that do not appear in `array2`. */
 function difference(array1, array2) {
-  return array1.filter((item) => !array2.includes(item));
+	return array1.filter((item) => !array2.includes(item));
 }
+/** Return the set-union of two arrays while preserving first occurrence order. */
 function union(array1, array2) {
-  return Array.from(/* @__PURE__ */ new Set([...array1, ...array2]));
+	return Array.from(new Set([...array1, ...array2]));
 }
+/** Remove duplicate values while preserving first occurrence order. */
 function deduplicate(array) {
-  return [...new Set(array)];
+	return [...new Set(array)];
 }
+/** Remove one item from an array and report whether it was found. */
 function remove(list, item) {
-  const index = list?.indexOf(item);
-  if (index >= 0) {
-    list.splice(index, 1);
-    return true;
-  } else {
-    return false;
-  }
+	const index = list?.indexOf(item);
+	if (index >= 0) {
+		list.splice(index, 1);
+		return true;
+	} else return false;
 }
+/** Normalize nullish, scalar, or array input to an array. */
 function makeArray(source) {
-  return Array.isArray(source) ? source : isNullable(source) ? [] : [source];
+	return Array.isArray(source) ? source : isNullable(source) ? [] : [source];
+}
+//#endregion
+//#region lib/types/volatile.js
+/** Shared config references used by schema validators and plugin runtimes. */
+const write = Symbol.for("cosmokit.volatile.write");
+function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+	if (value === null || typeof value !== "object") return value;
+	if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("volatile config objects must be plain objects or arrays");
+		return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+/**
+* Create a detached reference containing an immutable copy of the supplied data.
+* @param value - validated config data; class instances and functions are unsupported.
+* @returns a reference whose value is updated only by its owning runtime.
+*/
+function createVolatile(value) {
+	let current = snapshot(value);
+	return Object.freeze({
+		get: () => current,
+		[write]: (value) => {
+			current = value;
+		}
+	});
+}
+/**
+* Identify references across ESM/CJS copies of the shared library.
+* @param value - a parsed config value.
+* @returns whether the value implements the shared reference protocol.
+*/
+function isVolatile(value) {
+	return typeof value === "object" && value !== null && write in value;
 }
-
-// src/types.ts
+/**
+* Collect config references without descending into their snapshots or opaque objects.
+* @internal
+* @param value - parsed config; cyclic ordinary fields are visited once per path.
+* @returns references and their object-key paths, including an empty path for a root reference.
+*/
+function volatileEntries(value) {
+	const ancestors = /* @__PURE__ */ new Set();
+	function visit(value, path) {
+		if (isVolatile(value)) return [{
+			path,
+			ref: value
+		}];
+		if (!value || typeof value !== "object" || ancestors.has(value)) return [];
+		if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return [];
+		ancestors.add(value);
+		try {
+			return Object.entries(value).flatMap(([key, child]) => visit(child, [...path, key]));
+		} finally {
+			ancestors.delete(value);
+		}
+	}
+	return visit(value, []);
+}
+/**
+* Commit an already validated immutable snapshot from another reference.
+* @internal
+* @param target - the owning plugin's stable reference.
+* @param source - a newly parsed candidate reference.
+*/
+function updateVolatile(target, source) {
+	target[write](source.get());
+}
+//#endregion
+//#region lib/types/types.js
+/** Test values using `instanceof` with a `toStringTag` fallback. */
 function is(type, value) {
-  if (arguments.length === 1) return (value2) => is(type, value2);
-  return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
 }
 function isArrayBufferLike(value) {
-  return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
 }
 function isArrayBufferSource(value) {
-  return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
 }
+/** Binary source detection and base64/hex conversion helpers. */
 var Binary;
-((Binary2) => {
-  Binary2.is = isArrayBufferLike;
-  Binary2.isSource = isArrayBufferSource;
-  function fromSource(source) {
-    if (ArrayBuffer.isView(source)) {
-      return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
-    } else {
-      return source;
-    }
-  }
-  Binary2.fromSource = fromSource;
-  function toBase64(source) {
-    source = fromSource(source);
-    if (typeof Buffer !== "undefined") {
-      return Buffer.from(source).toString("base64");
-    }
-    let binary = "";
-    const bytes = new Uint8Array(source);
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-  Binary2.toBase64 = toBase64;
-  function fromBase64(source) {
-    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
-    return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
-  }
-  Binary2.fromBase64 = fromBase64;
-  function toHex(source) {
-    source = fromSource(source);
-    if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
-    return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
-  }
-  Binary2.toHex = toHex;
-  function fromHex(source) {
-    if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
-    const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
-    const buffer = [];
-    for (let i = 0; i < hex.length; i += 2) {
-      buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
-    }
-    return Uint8Array.from(buffer).buffer;
-  }
-  Binary2.fromHex = fromHex;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
 })(Binary || (Binary = {}));
-var base64ToArrayBuffer = Binary.fromBase64;
-var arrayBufferToBase64 = Binary.toBase64;
-var hexToArrayBuffer = Binary.fromHex;
-var arrayBufferToHex = Binary.toHex;
+/** Decode a base64 string into binary data. */
+const base64ToArrayBuffer = Binary.fromBase64;
+/** Encode binary data as base64. */
+const arrayBufferToBase64 = Binary.toBase64;
+/** Decode a hex string into binary data. */
+const hexToArrayBuffer = Binary.fromHex;
+/** Encode binary data as hex. */
+const arrayBufferToHex = Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
 function clone(source, refs = /* @__PURE__ */ new Map()) {
-  if (!source || typeof source !== "object") return source;
-  if (is("Date", source)) return new Date(source.valueOf());
-  if (is("RegExp", source)) return new RegExp(source.source, source.flags);
-  if (isArrayBufferLike(source)) return source.slice(0);
-  if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
-  const cached = refs.get(source);
-  if (cached) return cached;
-  if (Array.isArray(source)) {
-    const result2 = [];
-    refs.set(source, result2);
-    source.forEach((value, index) => {
-      result2[index] = Reflect.apply(clone, null, [value, refs]);
-    });
-    return result2;
-  }
-  const result = Object.create(Object.getPrototypeOf(source));
-  refs.set(source, result);
-  for (const key of Reflect.ownKeys(source)) {
-    const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
-    if ("value" in descriptor) {
-      descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
-    }
-    Reflect.defineProperty(result, key, descriptor);
-  }
-  return result;
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
 }
+/**
+* Compare values recursively, treating two volatile references as equal regardless of value.
+* Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+* compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+* @param a - first value.
+* @param b - second value.
+* @param strict - whether to require strict data equality outside volatile references.
+* @returns whether the values compare equal.
+*/
 function deepEqual(a, b, strict) {
-  if (a === b) return true;
-  if (!strict && isNullable(a) && isNullable(b)) return true;
-  if (typeof a !== typeof b) return false;
-  if (typeof a !== "object") return false;
-  if (!a || !b) return false;
-  function check(test, then) {
-    return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
-  }
-  return check(Array.isArray, (a2, b2) => a2.length === b2.length && a2.every((item, index) => deepEqual(item, b2[index]))) ?? check(is("Date"), (a2, b2) => a2.valueOf() === b2.valueOf()) ?? check(is("RegExp"), (a2, b2) => a2.source === b2.source && a2.flags === b2.flags) ?? check(isArrayBufferLike, (a2, b2) => {
-    if (a2.byteLength !== b2.byteLength) return false;
-    const viewA = new Uint8Array(a2);
-    const viewB = new Uint8Array(b2);
-    for (let i = 0; i < viewA.length; i++) {
-      if (viewA[i] !== viewB[i]) return false;
-    }
-    return true;
-  }) ?? Object.keys({ ...a, ...b }).every((key) => deepEqual(a[key], b[key], strict));
-}
-
-// src/string.ts
+	const ancestors = /* @__PURE__ */ new Set();
+	function compare(a, b) {
+		if (a === b) return true;
+		if (isVolatile(a) || isVolatile(b)) return isVolatile(a) && isVolatile(b);
+		if (!strict && isNullable(a) && isNullable(b)) return true;
+		if (typeof a !== typeof b || typeof a !== "object" || !a || !b) return false;
+		if (ancestors.has(a)) return false;
+		function check(test, then) {
+			return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+		}
+		ancestors.add(a);
+		try {
+			return check(Array.isArray, (a, b) => {
+				if (a.length !== b.length) return false;
+				for (let index = 0; index < a.length; index++) if (!compare(a[index], b[index])) return false;
+				return true;
+			}) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("URL"), (a, b) => a.href === b.href) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+				if (a.byteLength !== b.byteLength) return false;
+				const viewA = new Uint8Array(a);
+				const viewB = new Uint8Array(b);
+				for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+				return true;
+			}) ?? ((!strict || [a, b].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({
+				...a,
+				...b
+			}).every((key) => compare(a[key], b[key])));
+		} finally {
+			ancestors.delete(a);
+		}
+	}
+	return compare(a, b);
+}
+//#endregion
+//#region lib/types/string.js
+/** Uppercase the first character of a string. */
 function capitalize(source) {
-  return source.charAt(0).toUpperCase() + source.slice(1);
+	return source.charAt(0).toUpperCase() + source.slice(1);
 }
+/** Lowercase the first character of a string. */
 function uncapitalize(source) {
-  return source.charAt(0).toLowerCase() + source.slice(1);
+	return source.charAt(0).toLowerCase() + source.slice(1);
 }
+/** Convert dash or underscore delimited text to camelCase. */
 function camelCase(source) {
-  return source.replace(/[_-][a-z]/g, (str) => str.slice(1).toUpperCase());
+	return source.replace(/[_-][a-z]/g, (str) => str.slice(1).toUpperCase());
 }
 function tokenize(source, delimiters, delimiter) {
-  const output = [];
-  let state = 0 /* DELIM */;
-  for (let i = 0; i < source.length; i++) {
-    const code = source.charCodeAt(i);
-    if (code >= 65 && code <= 90) {
-      if (state === 1 /* UPPER */) {
-        const next = source.charCodeAt(i + 1);
-        if (next >= 97 && next <= 122) {
-          output.push(delimiter);
-        }
-        output.push(code + 32);
-      } else {
-        if (state !== 0 /* DELIM */) {
-          output.push(delimiter);
-        }
-        output.push(code + 32);
-      }
-      state = 1 /* UPPER */;
-    } else if (code >= 97 && code <= 122) {
-      output.push(code);
-      state = 2 /* LOWER */;
-    } else if (delimiters.includes(code)) {
-      if (state !== 0 /* DELIM */) {
-        output.push(delimiter);
-      }
-      state = 0 /* DELIM */;
-    } else {
-      output.push(code);
-    }
-  }
-  return String.fromCharCode(...output);
+	const output = [];
+	let state = 0;
+	for (let i = 0; i < source.length; i++) {
+		const code = source.charCodeAt(i);
+		if (code >= 65 && code <= 90) {
+			if (state === 1) {
+				const next = source.charCodeAt(i + 1);
+				if (next >= 97 && next <= 122) output.push(delimiter);
+				output.push(code + 32);
+			} else {
+				if (state !== 0) output.push(delimiter);
+				output.push(code + 32);
+			}
+			state = 1;
+		} else if (code >= 97 && code <= 122) {
+			output.push(code);
+			state = 2;
+		} else if (delimiters.includes(code)) {
+			if (state !== 0) output.push(delimiter);
+			state = 0;
+		} else output.push(code);
+	}
+	return String.fromCharCode(...output);
 }
+/** Convert text to dash-delimited parameter case. */
 function paramCase(source) {
-  return tokenize(source, [45, 95], 45);
+	return tokenize(source, [45, 95], 45);
 }
+/** Convert text to underscore-delimited snake case. */
 function snakeCase(source) {
-  return tokenize(source, [45, 95], 95);
+	return tokenize(source, [45, 95], 95);
 }
-var camelize = camelCase;
-var hyphenate = paramCase;
+/** Runtime alias for `camelCase`. */
+const camelize = camelCase;
+/** Runtime alias for `paramCase`. */
+const hyphenate = paramCase;
+/** Format a property key as a JavaScript member access suffix. */
 function formatProperty(key) {
-  if (typeof key !== "string") return `[${key.toString()}]`;
-  return /^[a-z_$][\w$]*$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+	if (typeof key !== "string") return `[${key.toString()}]`;
+	return /^[a-z_$][\w$]*$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
 }
+/** Remove one trailing slash from a path string. */
 function trimSlash(source) {
-  return source.replace(/\/$/, "");
+	return source.replace(/\/$/, "");
 }
+/** Ensure a path starts with `/` and has no trailing slash. */
 function sanitize(source) {
-  if (!source.startsWith("/")) source = "/" + source;
-  return trimSlash(source);
+	if (!source.startsWith("/")) source = "/" + source;
+	return trimSlash(source);
 }
-
-// src/time.ts
+//#endregion
+//#region lib/types/time.js
+/** Time constants plus parsing and formatting helpers. */
 var Time;
-((Time2) => {
-  Time2.millisecond = 1;
-  Time2.second = 1e3;
-  Time2.minute = Time2.second * 60;
-  Time2.hour = Time2.minute * 60;
-  Time2.day = Time2.hour * 24;
-  Time2.week = Time2.day * 7;
-  let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
-  function setTimezoneOffset(offset) {
-    timezoneOffset = offset;
-  }
-  Time2.setTimezoneOffset = setTimezoneOffset;
-  function getTimezoneOffset() {
-    return timezoneOffset;
-  }
-  Time2.getTimezoneOffset = getTimezoneOffset;
-  function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
-    if (typeof date === "number") date = new Date(date);
-    if (offset === void 0) offset = timezoneOffset;
-    return Math.floor((date.valueOf() / Time2.minute - offset) / 1440);
-  }
-  Time2.getDateNumber = getDateNumber;
-  function fromDateNumber(value, offset) {
-    const date = new Date(value * Time2.day);
-    if (offset === void 0) offset = timezoneOffset;
-    return new Date(+date + offset * Time2.minute);
-  }
-  Time2.fromDateNumber = fromDateNumber;
-  const numeric = /\d+(?:\.\d+)?/.source;
-  const timeRegExp = new RegExp(`^${[
-    "w(?:eek(?:s)?)?",
-    "d(?:ay(?:s)?)?",
-    "h(?:our(?:s)?)?",
-    "m(?:in(?:ute)?(?:s)?)?",
-    "s(?:ec(?:ond)?(?:s)?)?"
-  ].map((unit) => `(${numeric}${unit})?`).join("")}$`);
-  function parseTime(source) {
-    const capture = timeRegExp.exec(source);
-    if (!capture) return 0;
-    return (parseFloat(capture[1]) * Time2.week || 0) + (parseFloat(capture[2]) * Time2.day || 0) + (parseFloat(capture[3]) * Time2.hour || 0) + (parseFloat(capture[4]) * Time2.minute || 0) + (parseFloat(capture[5]) * Time2.second || 0);
-  }
-  Time2.parseTime = parseTime;
-  function parseDate(date) {
-    const parsed = parseTime(date);
-    if (parsed) {
-      date = Date.now() + parsed;
-    } else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
-      date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
-    } else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) {
-      date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
-    }
-    return date ? new Date(date) : /* @__PURE__ */ new Date();
-  }
-  Time2.parseDate = parseDate;
-  function format(ms) {
-    const abs = Math.abs(ms);
-    if (abs >= Time2.day - Time2.hour / 2) {
-      return Math.round(ms / Time2.day) + "d";
-    } else if (abs >= Time2.hour - Time2.minute / 2) {
-      return Math.round(ms / Time2.hour) + "h";
-    } else if (abs >= Time2.minute - Time2.second / 2) {
-      return Math.round(ms / Time2.minute) + "m";
-    } else if (abs >= Time2.second) {
-      return Math.round(ms / Time2.second) + "s";
-    }
-    return ms + "ms";
-  }
-  Time2.format = format;
-  function toDigits(source, length = 2) {
-    return source.toString().padStart(length, "0");
-  }
-  Time2.toDigits = toDigits;
-  function template(template2, time = /* @__PURE__ */ new Date()) {
-    return template2.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
-  }
-  Time2.template = template;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
 })(Time || (Time = {}));
-export {
-  Binary,
-  Time,
-  arrayBufferToBase64,
-  arrayBufferToHex,
-  base64ToArrayBuffer,
-  camelCase,
-  camelize,
-  capitalize,
-  clone,
-  contain,
-  deduplicate,
-  deepEqual,
-  defineProperty,
-  difference,
-  filterKeys,
-  formatProperty,
-  hexToArrayBuffer,
-  hyphenate,
-  intersection,
-  is,
-  isNonNullable,
-  isNullable,
-  isPlainObject,
-  makeArray,
-  mapValues,
-  noop,
-  omit,
-  paramCase,
-  pick,
-  remove,
-  sanitize,
-  snakeCase,
-  trimSlash,
-  uncapitalize,
-  union,
-  mapValues as valueMap
-};
-//# sourceMappingURL=index.mjs.map
+//#endregion
+export { Binary, Time, arrayBufferToBase64, arrayBufferToHex, base64ToArrayBuffer, camelCase, camelize, capitalize, clone, contain, createVolatile, deduplicate, deepEqual, defineProperty, difference, filterKeys, formatProperty, hexToArrayBuffer, hyphenate, intersection, is, isNonNullable, isNullable, isPlainObject, isVolatile, makeArray, mapValues, mapValues as valueMap, noop, omit, paramCase, pick, remove, sanitize, snakeCase, trimSlash, uncapitalize, union, updateVolatile, volatileEntries };