@ntnyq/utils 0.6.4 → 0.7.0

package/dist/index.js

@@ -1,811 +1,1030 @@
-// src/fn/noop.ts
-function noop() {
-}
-var NOOP = noop;
+//#region src/fn/noop.ts
+/**
+* A function that does nothing.
+*/
+function noop() {}
+/**
+* Alias of {@link noop}.
+*/
+const NOOP = noop;
 
-// src/fn/once.ts
+//#endregion
+//#region src/fn/once.ts
 function once(func) {
-  let called = false;
-  return function(...args) {
-    if (called) {
-      return false;
-    }
-    called = true;
-    func.apply(this, args);
-    return true;
-  };
-}
-
-// src/is/dom.ts
+	let called = false;
+	return function(...args) {
+		if (called) return false;
+		called = true;
+		func.apply(this, args);
+		return true;
+	};
+}
+
+//#endregion
+//#region src/is/dom.ts
+/**
+* @file is/dom.ts
+*/
+/**
+* Check if given value is an HTMLElement
+* @param value - The value to check
+* @returns True if the value is an HTMLElement, false otherwise
+*/
 function isHTMLElement(value) {
-  return typeof value === "object" && value !== null && "nodeType" in value && value.nodeType === Node.ELEMENT_NODE && value instanceof HTMLElement;
+	return typeof value === "object" && value !== null && "nodeType" in value && value.nodeType === Node.ELEMENT_NODE && value instanceof HTMLElement;
 }
 
-// src/is/core.ts
+//#endregion
+//#region src/is/core.ts
 function getObjectType(value) {
-  return Object.prototype.toString.call(value).slice(8, -1);
+	return Object.prototype.toString.call(value).slice(8, -1);
 }
 function isUndefined(value) {
-  return value === void 0;
+	return value === void 0;
 }
 function isNull(value) {
-  return value === null;
+	return value === null;
 }
 function isNil(value) {
-  return isNull(value) || isUndefined(value);
+	return isNull(value) || isUndefined(value);
 }
-var isNullOrUndefined = isNil;
+const isNullOrUndefined = isNil;
 function isString(value) {
-  return typeof value === "string";
+	return typeof value === "string";
 }
 function isEmptyString(value) {
-  return isString(value) && value.length === 0;
+	return isString(value) && value.length === 0;
 }
 function isNonEmptyString(value) {
-  return isString(value) && value.length > 0;
+	return isString(value) && value.length > 0;
 }
 function isWhitespaceString(value) {
-  return isString(value) && /^\s*$/.test(value);
+	return isString(value) && /^\s*$/.test(value);
 }
 function isEmptyStringOrWhitespace(value) {
-  return isEmptyString(value) || isWhitespaceString(value);
+	return isEmptyString(value) || isWhitespaceString(value);
 }
 function isNumbericString(value) {
-  return isString(value) && !isEmptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
+	return isString(value) && !isEmptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
 }
 function isNumber(value) {
-  return typeof value === "number";
+	return typeof value === "number";
 }
 function isZero(value) {
-  return value === 0;
+	return value === 0;
 }
 function isNaN(value) {
-  return Number.isNaN(value);
+	return Number.isNaN(value);
 }
 function isInteger(value) {
-  return Number.isInteger(value);
+	return Number.isInteger(value);
 }
 function isBigInt(value) {
-  return typeof value === "bigint";
+	return typeof value === "bigint";
 }
 function isBoolean(value) {
-  return typeof value === "boolean";
+	return typeof value === "boolean";
 }
 function isTruthy(value) {
-  return Boolean(value);
+	return Boolean(value);
 }
 function isFunction(value) {
-  return typeof value === "function";
+	return typeof value === "function";
 }
 function isArray(value) {
-  return Array.isArray(value);
+	return Array.isArray(value);
 }
 function isEmptyArray(value) {
-  return isArray(value) && value.length === 0;
+	return isArray(value) && value.length === 0;
 }
 function isNonEmptyArray(value) {
-  return isArray(value) && value.length > 0;
+	return isArray(value) && value.length > 0;
 }
 function isObject(value) {
-  return (typeof value === "object" || isFunction(value)) && !isNull(value);
+	return (typeof value === "object" || isFunction(value)) && !isNull(value);
 }
 function isEmptyObject(value) {
-  return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length === 0;
+	return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length === 0;
 }
 function isMap(value) {
-  return getObjectType(value) === "Map";
+	return getObjectType(value) === "Map";
 }
 function isEmptyMap(value) {
-  return isMap(value) && value.size === 0;
+	return isMap(value) && value.size === 0;
 }
 function isSet(value) {
-  return getObjectType(value) === "Set";
+	return getObjectType(value) === "Set";
 }
 function isEmptySet(value) {
-  return isSet(value) && value.size === 0;
+	return isSet(value) && value.size === 0;
 }
 function isRegExp(value) {
-  return getObjectType(value) === "RegExp";
+	return getObjectType(value) === "RegExp";
 }
 function isError(value) {
-  return getObjectType(value) === "Error";
+	return getObjectType(value) === "Error";
 }
+/**
+* @internal
+*/
 function hasPromiseApi(value) {
-  return (
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    isFunction(value?.then) && isFunction(value?.catch)
-  );
+	return isFunction(value?.then) && isFunction(value?.catch);
 }
 function isNativePromise(value) {
-  return getObjectType(value) === "Promise";
+	return getObjectType(value) === "Promise";
 }
 function isPromise(value) {
-  return isNativePromise(value) || hasPromiseApi(value);
+	return isNativePromise(value) || hasPromiseApi(value);
 }
 function isIterable(value) {
-  return isFunction(value?.[Symbol.iterator]);
+	return isFunction(value?.[Symbol.iterator]);
 }
 
-// src/is/isDeepEqual.ts
+//#endregion
+//#region src/is/isDeepEqual.ts
+/**
+* check if two values are deeply equal
+*/
 function isDeepEqual(value1, value2) {
-  const type1 = getObjectType(value1);
-  const type2 = getObjectType(value2);
-  if (type1 !== type2) {
-    return false;
-  }
-  if (isArray(value1) && isArray(value2)) {
-    if (value1.length !== value2.length) {
-      return false;
-    }
-    return value1.every((item, index) => isDeepEqual(item, value2[index]));
-  }
-  if (isObject(value1) && isObject(value2)) {
-    const keys = Object.keys(value1);
-    if (keys.length !== Object.keys(value2).length) {
-      return false;
-    }
-    return keys.every(
-      (key) => isDeepEqual(
-        value1[key],
-        value2[key]
-      )
-    );
-  }
-  return Object.is(value1, value2);
-}
-
-// src/dom/scrollIntoView.ts
+	const type1 = getObjectType(value1);
+	const type2 = getObjectType(value2);
+	if (type1 !== type2) return false;
+	if (isArray(value1) && isArray(value2)) {
+		if (value1.length !== value2.length) return false;
+		return value1.every((item, index) => isDeepEqual(item, value2[index]));
+	}
+	if (isObject(value1) && isObject(value2)) {
+		const keys = Object.keys(value1);
+		if (keys.length !== Object.keys(value2).length) return false;
+		return keys.every((key) => isDeepEqual(value1[key], value2[key]));
+	}
+	return Object.is(value1, value2);
+}
+
+//#endregion
+//#region src/dom/scrollIntoView.ts
+/**
+* Scroll element into view if it is out of view.
+*
+* @param element - element to scroll
+* @param options - scroll options
+*/
 function scrollElementIntoView(element, options = {}) {
-  const body = document.body;
-  const { parent = body, ...scrollIntoViewOptions } = options;
-  if (parent === body) {
-    parent.scrollIntoView(scrollIntoViewOptions);
-    return;
-  }
-  const parentRect = parent.getBoundingClientRect();
-  const elementRect = element.getBoundingClientRect();
-  const isHorizontal = parent.scrollWidth > parent.scrollHeight;
-  const isOutOfView = isHorizontal ? elementRect.left < parentRect.left || elementRect.right > parentRect.right : elementRect.top < parentRect.top || elementRect.bottom > parentRect.bottom;
-  if (isOutOfView) {
-    parent.scrollIntoView(scrollIntoViewOptions);
-  }
-}
-
-// src/dom/openExternalURL.ts
+	const body = document.body;
+	const { parent = body,...scrollIntoViewOptions } = options;
+	if (parent === body) {
+		parent.scrollIntoView(scrollIntoViewOptions);
+		return;
+	}
+	const parentRect = parent.getBoundingClientRect();
+	const elementRect = element.getBoundingClientRect();
+	const isHorizontal = parent.scrollWidth > parent.scrollHeight;
+	const isOutOfView = isHorizontal ? elementRect.left < parentRect.left || elementRect.right > parentRect.right : elementRect.top < parentRect.top || elementRect.bottom > parentRect.bottom;
+	if (isOutOfView) parent.scrollIntoView(scrollIntoViewOptions);
+}
+
+//#endregion
+//#region src/dom/openExternalURL.ts
+/**
+* Open external url
+* @param url - URL to open
+* @param options - open options
+* @returns window proxy
+*/
 function openExternalURL(url, options = {}) {
-  const { target = "_blank" } = options;
-  const proxy = window.open(url, target);
-  return proxy;
+	const { target = "_blank" } = options;
+	const proxy = window.open(url, target);
+	return proxy;
 }
 
-// src/dom/isVisibleInViewport.ts
+//#endregion
+//#region src/dom/isVisibleInViewport.ts
+/**
+* Check if element is in viewport
+* @param element - checked element
+* @param targetWindow - window
+* @returns true if element is in viewport, false otherwise
+*/
 function isElementVisibleInViewport(element, targetWindow = window) {
-  const { top, left, bottom, right } = element.getBoundingClientRect();
-  const { innerWidth, innerHeight } = targetWindow;
-  return (top >= 0 && top <= innerHeight || bottom >= 0 && bottom <= innerHeight) && (left >= 0 && left <= innerWidth || right >= 0 && right <= innerWidth);
+	const { top, left, bottom, right } = element.getBoundingClientRect();
+	const { innerWidth, innerHeight } = targetWindow;
+	return (top >= 0 && top <= innerHeight || bottom >= 0 && bottom <= innerHeight) && (left >= 0 && left <= innerWidth || right >= 0 && right <= innerWidth);
 }
 
-// src/env/isBrowser.ts
-var isBrowser = () => typeof document !== "undefined";
+//#endregion
+//#region src/env/isBrowser.ts
+/**
+* @file env.ts
+*/
+/**
+* Checks if the code is running in a browser
+*
+* @returns boolean - true if the code is running in a browser
+*/
+const isBrowser = () => typeof document !== "undefined";
 
-// src/html/escape.ts
-var htmlEscapeMap = {
-  "&": "&amp;",
-  "<": "&lt;",
-  ">": "&gt;",
-  "'": "&#39;",
-  '"': "&quot;"
+//#endregion
+//#region src/html/escape.ts
+const htmlEscapeMap = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"'": "&#39;",
+	"\"": "&quot;"
 };
-var htmlEscapeRegexp = /[&<>'"]/g;
+const htmlEscapeRegexp = /[&<>'"]/g;
+/**
+* Escape html chars
+*/
 function escapeHTML(str) {
-  return str.replace(
-    htmlEscapeRegexp,
-    (char) => htmlEscapeMap[char]
-  );
-}
-var htmlUnescapeMap = {
-  "&amp;": "&",
-  "&#38;": "&",
-  "&lt;": "<",
-  "&#60;": "<",
-  "&gt;": ">",
-  "&#62;": ">",
-  "&apos;": "'",
-  "&#39;": "'",
-  "&quot;": '"',
-  "&#34;": '"'
+	return str.replace(htmlEscapeRegexp, (char) => htmlEscapeMap[char]);
+}
+const htmlUnescapeMap = {
+	"&amp;": "&",
+	"&#38;": "&",
+	"&lt;": "<",
+	"&#60;": "<",
+	"&gt;": ">",
+	"&#62;": ">",
+	"&apos;": "'",
+	"&#39;": "'",
+	"&quot;": "\"",
+	"&#34;": "\""
 };
-var htmlUnescapeRegexp = /&(amp|#38|lt|#60|gt|#62|apos|#39|quot|#34);/g;
+const htmlUnescapeRegexp = /&(amp|#38|lt|#60|gt|#62|apos|#39|quot|#34);/g;
+/**
+* Unescape html chars
+*/
 function unescapeHTML(str) {
-  return str.replace(
-    htmlUnescapeRegexp,
-    (char) => htmlUnescapeMap[char]
-  );
+	return str.replace(htmlUnescapeRegexp, (char) => htmlUnescapeMap[char]);
 }
 
-// src/misc/raf.ts
-var root = isBrowser() ? window : globalThis;
-var prev = Date.now();
+//#endregion
+//#region src/misc/raf.ts
+const root = isBrowser() ? window : globalThis;
+let prev = Date.now();
 function mockRAF(fn) {
-  const curr = Date.now();
-  const ms = Math.max(0, 16 - (curr - prev));
-  const id = setTimeout(fn, ms);
-  prev = curr + ms;
-  return id;
-}
+	const curr = Date.now();
+	const ms = Math.max(0, 16 - (curr - prev));
+	const id = setTimeout(fn, ms);
+	prev = curr + ms;
+	return id;
+}
+/**
+* Request animation frame
+*
+* @param fn - callback
+* @returns id
+*/
 function rAF(fn) {
-  const raf = root.requestAnimationFrame || mockRAF;
-  return raf.call(root, fn);
-}
+	const raf = root.requestAnimationFrame || mockRAF;
+	return raf.call(root, fn);
+}
+/**
+* Cancel animation frame
+*
+* @param id - id
+* @returns void
+*/
 function cAF(id) {
-  const caf = root.cancelAnimationFrame || root.clearTimeout;
-  return caf.call(root, id);
+	const caf = root.cancelAnimationFrame || root.clearTimeout;
+	return caf.call(root, id);
 }
 
-// src/misc/time.ts
-var ONE_SECOND = 1e3;
-var ONE_MINUTE = 60 * ONE_SECOND;
-var ONE_HOUR = 60 * ONE_MINUTE;
-var ONE_DAY = 24 * ONE_HOUR;
-var ONE_WEEK = 7 * ONE_DAY;
+//#endregion
+//#region src/misc/time.ts
+/**
+* @file time utils
+* @module Time
+*/
+const ONE_SECOND = 1e3;
+const ONE_MINUTE = 60 * ONE_SECOND;
+const ONE_HOUR = 60 * ONE_MINUTE;
+const ONE_DAY = 24 * ONE_HOUR;
+const ONE_WEEK = 7 * ONE_DAY;
 function seconds(count) {
-  return count * ONE_SECOND;
+	return count * ONE_SECOND;
 }
 function minutes(count) {
-  return count * ONE_MINUTE;
+	return count * ONE_MINUTE;
 }
 function hours(count) {
-  return count * ONE_HOUR;
+	return count * ONE_HOUR;
 }
 function days(count) {
-  return count * ONE_DAY;
+	return count * ONE_DAY;
 }
 function weeks(count) {
-  return count * ONE_WEEK;
+	return count * ONE_WEEK;
 }
 
-// src/misc/clamp.ts
+//#endregion
+//#region src/misc/clamp.ts
+/**
+* Clamps a number between a minimum and maximum value
+* @param value - the value to clamp within the given range
+* @param min - the minimum value to clamp
+* @param max - the maximum value to clamp
+* @returns the new value
+*/
 function clamp(value, min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY) {
-  return Math.min(Math.max(value, min), max);
+	return Math.min(Math.max(value, min), max);
 }
 
-// src/misc/waitFor.ts
+//#endregion
+//#region src/misc/waitFor.ts
+/**
+* Wait for a number of milliseconds
+*
+* @param ms - millseconds to wait
+* @returns a promise that resolves after ms milliseconds
+*
+* @example
+* ```
+* import { waitFor } from '@ntnyq/utils'
+* await waitFor(3e3)
+* // do somthing after 3 seconds
+* ```
+*/
 async function waitFor(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/misc/throttle.ts
+//#endregion
+//#region src/misc/throttle.ts
+/**
+* Throttle a function to limit its execution to a maximum of once per a specified time interval.
+*
+* @param delay - Zero or greater delay in milliseconds
+* @param callback - A function to be throttled
+* @param options - throttle options
+* @returns A throttled function
+*/
 function throttle(delay, callback, options = {}) {
-  const { isDebounce } = options;
-  let lastExec = 0;
-  let cancelled = false;
-  let timeoutId;
-  function clearExistingTimeout() {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  }
-  function cancel() {
-    clearExistingTimeout();
-    cancelled = true;
-  }
-  function wrapper(...args) {
-    if (cancelled) return;
-    const _this = this;
-    const now = Date.now();
-    const elapsed = now - lastExec;
-    function clear() {
-      timeoutId = void 0;
-    }
-    function exec(cur) {
-      lastExec = cur || Date.now();
-      callback.apply(_this, args);
-    }
-    if (isDebounce && !timeoutId) {
-      exec(now);
-    }
-    clearExistingTimeout();
-    if (!isDebounce && elapsed > delay) {
-      exec(now);
-    } else {
-      timeoutId = setTimeout(
-        isDebounce ? clear : exec,
-        isDebounce ? delay : delay - elapsed
-      );
-    }
-  }
-  wrapper.cancel = cancel;
-  return wrapper;
+	const { isDebounce } = options;
+	/**
+	* Track the last time `callback` was executed
+	*/
+	let lastExec = 0;
+	let cancelled = false;
+	let timeoutId;
+	function clearExistingTimeout() {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+	function cancel() {
+		clearExistingTimeout();
+		cancelled = true;
+	}
+	function wrapper(...args) {
+		if (cancelled) return;
+		const _this = this;
+		const now = Date.now();
+		const elapsed = now - lastExec;
+		function clear() {
+			timeoutId = void 0;
+		}
+		function exec(cur) {
+			lastExec = cur || Date.now();
+			callback.apply(_this, args);
+		}
+		if (isDebounce && !timeoutId) exec(now);
+		clearExistingTimeout();
+		if (!isDebounce && elapsed > delay) exec(now);
+		else timeoutId = setTimeout(isDebounce ? clear : exec, isDebounce ? delay : delay - elapsed);
+	}
+	wrapper.cancel = cancel;
+	return wrapper;
 }
 function debounce(delay, callback, options = {}) {
-  return throttle(delay, callback, {
-    ...options,
-    isDebounce: true
-  });
+	return throttle(delay, callback, {
+		...options,
+		isDebounce: true
+	});
 }
 
-// src/misc/warnOnce.ts
-var warned = /* @__PURE__ */ new Set();
+//#endregion
+//#region src/misc/warnOnce.ts
+/**
+* Cached warnings
+*/
+const warned = new Set();
+/**
+* Warn message only once
+*
+* @param message - warning message
+*/
 function warnOnce(message) {
-  if (warned.has(message)) {
-    return;
-  }
-  warned.add(message);
-  console.warn(message);
+	if (warned.has(message)) return;
+	warned.add(message);
+	console.warn(message);
 }
 
-// src/array/at.ts
+//#endregion
+//#region src/array/at.ts
+/**
+* Get array item by index, negative for backward
+* @param array - given array
+* @param index - index of item
+* @returns undefined if not match, otherwise matched item
+*/
 function at(array, index) {
-  const length = array.length;
-  if (!length) return void 0;
-  if (index < 0) {
-    index += length;
-  }
-  return array[index];
-}
+	const length = array.length;
+	if (!length) return void 0;
+	if (index < 0) index += length;
+	return array[index];
+}
+/**
+* Get the last item of given array
+* @param array - given array
+* @returns undefined if empty array, otherwise last item
+*/
 function last(array) {
-  return at(array, -1);
+	return at(array, -1);
 }
 
-// src/array/chunk.ts
+//#endregion
+//#region src/array/chunk.ts
+/**
+* Splits an array into smaller chunks of a given size.
+* @param array - The array to split
+* @param size - The size of each chunk
+* @returns An array of arrays, where each sub-array has `size` elements from the original array.
+*/
 function chunk(array, size) {
-  const result = [];
-  for (let i = 0; i < array.length; i += size) {
-    result.push(array.slice(i, i + size));
-  }
-  return result;
+	const result = [];
+	for (let i = 0; i < array.length; i += size) result.push(array.slice(i, i + size));
+	return result;
 }
 
-// src/array/unique.ts
+//#endregion
+//#region src/array/unique.ts
+/**
+* Returns a new array with unique values.
+* @param array - The array to process.
+* @returns The new array.
+*/
 function unique(array) {
-  return Array.from(new Set(array));
-}
+	return Array.from(new Set(array));
+}
+/**
+* Returns a new array with unique values.
+* @param array - The array to process.
+* @param equalFn - The function to compare values.
+* @returns The new array.
+*/
 function uniqueBy(array, equalFn) {
-  return array.reduce((acc, cur) => {
-    const idx = acc.findIndex((item) => equalFn(item, cur));
-    if (idx === -1) {
-      acc.push(cur);
-    }
-    return acc;
-  }, []);
+	return array.reduce((acc, cur) => {
+		const idx = acc.findIndex((item) => equalFn(item, cur));
+		if (idx === -1) acc.push(cur);
+		return acc;
+	}, []);
 }
 
-// src/array/toArray.ts
+//#endregion
+//#region src/array/toArray.ts
+/**
+* Converts a value to an array.
+* @param array - The value to convert.
+* @returns The array.
+*/
 function toArray(array) {
-  array = array ?? [];
-  return Array.isArray(array) ? array : [array];
+	array = array ?? [];
+	return Array.isArray(array) ? array : [array];
 }
 
-// src/array/arrayable.ts
+//#endregion
+//#region src/array/arrayable.ts
+/**
+* Convert `Arrayable<T>` to `Array<T>` and flatten the result
+* @param array - given array
+* @returns Array<T>
+*/
 function flattenArrayable(array) {
-  return toArray(array).flat(1);
+	return toArray(array).flat();
 }
+/**
+* Use rest arguments to merge arrays
+* @param args - rest arguments
+* @returns Array<T>
+*/
 function mergeArrayable(...args) {
-  return args.flatMap((i) => toArray(i));
+	return args.flatMap((i) => toArray(i));
 }
 
-// src/array/intersect.ts
+//#endregion
+//#region src/array/intersect.ts
+/**
+* Get intersect items
+*
+* @returns intersect items
+*/
 function intersect(a, b) {
-  return a.filter((item) => b.includes(item));
+	return a.filter((item) => b.includes(item));
 }
 
-// src/array/isArrayEqual.ts
+//#endregion
+//#region src/array/isArrayEqual.ts
+/**
+* Check if values of two arrays are equal
+* @param array1 - array 1
+* @param array2 - array 2
+* @returns `true` if equal
+*/
 function isArrayEqual(array1, array2) {
-  if (array1.length !== array2.length) {
-    return false;
-  }
-  return array1.every((item, idx) => item === array2[idx]);
+	if (array1.length !== array2.length) return false;
+	return array1.every((item, idx) => item === array2[idx]);
 }
 
-// src/string/pad.ts
+//#endregion
+//#region src/string/pad.ts
 function createPadString(options) {
-  const { length, char } = options;
-  return (value) => (char.repeat(length) + value).slice(-length);
+	const { length, char } = options;
+	return (value) => (char.repeat(length) + value).slice(-length);
 }
 
-// src/string/join.ts
+//#endregion
+//#region src/string/join.ts
+/**
+* Joins an array of strings or numbers into a single string.
+* @param array - An array of strings or numbers.
+* @param options - An object of options.
+* @returns A string.
+*/
 function join(array, options = {}) {
-  const { separator = "" } = options;
-  if (!Array.isArray(array) || !array.length) return "";
-  return array.filter((v) => Boolean(v) || v === 0).join(separator);
+	const { separator = "" } = options;
+	if (!Array.isArray(array) || !array.length) return "";
+	return array.filter((v) => Boolean(v) || v === 0).join(separator);
 }
 
-// src/string/slash.ts
+//#endregion
+//#region src/string/slash.ts
+/**
+* Replace backslash to slash
+*/
 function slash(input) {
-  return input.replace(/\\/g, "/");
+	return input.replace(/\\/g, "/");
 }
 
-// src/number/random.ts
+//#endregion
+//#region src/number/random.ts
+/**
+* random an integer by given range
+*
+* @param min - min value
+* @param max - max value
+* @returns random integer in range
+*/
 function randomNumber(min, max = 0, options = {}) {
-  if (max === 0) {
-    max = min;
-    min = 0;
-  }
-  if (min > max) {
-    ;
-    [min, max] = [max, min];
-  }
-  return Math.trunc(
-    Math.random() * (max - min + (options.includeMax ? 1 : 0)) + min
-  );
-}
-
-// src/string/random.ts
+	if (max === 0) {
+		max = min;
+		min = 0;
+	}
+	if (min > max) [min, max] = [max, min];
+	return Math.trunc(Math.random() * (max - min + (options.includeMax ? 1 : 0)) + min);
+}
+
+//#endregion
+//#region src/number/toInteger.ts
+/**
+* Transforms a value to an integer.
+* @param value - The value to convert to an integer.
+* @param options - Options for the conversion.
+* @returns The converted integer.
+*/
+function toInteger(value, options = {}) {
+	const { defaultValue = 0, allowDecimal = false, allowNaN = false, onError = "useDefault", min, max, outOfRange = "clamp" } = options;
+	let numberValue;
+	let result;
+	if (isNumber(value)) numberValue = value;
+	else if (isString(value)) {
+		const trimmed = value.trim();
+		if (isEmptyString(trimmed)) {
+			if (onError === "throwError") throw new TypeError("Cannot convert empty string to an integer");
+			return onError === "returnOriginal" ? value : defaultValue;
+		}
+		numberValue = Number(trimmed);
+	} else if (isNullOrUndefined(value)) {
+		if (onError === "throwError") throw new TypeError(`Cannot convert ${value} to an integer`);
+		return onError === "useDefault" ? value : defaultValue;
+	} else numberValue = Number(value);
+	if (isNaN(numberValue)) {
+		if (allowNaN) return numberValue;
+		if (onError === "throwError") throw new TypeError(`Cannot convert NaN to an integer`);
+		return onError === "returnOriginal" ? value : defaultValue;
+	}
+	if (allowDecimal) result = Math.floor(numberValue);
+	else {
+		if (numberValue % 1 !== 0) {
+			if (onError === "throwError") throw new Error("Decimal values are not allowed");
+			return onError === "returnOriginal" ? value : defaultValue;
+		}
+		result = numberValue;
+	}
+	if (!isUndefined(min) || !isUndefined(max)) {
+		const minVal = min ?? -Infinity;
+		const maxVal = max ?? Infinity;
+		if (result < minVal || result > maxVal) {
+			if (outOfRange === "throwError") throw new RangeError(`Value ${result} is out of range [${minVal}, ${maxVal}]`);
+			if (outOfRange === "useDefault") return defaultValue;
+			if (outOfRange === "clamp") result = Math.max(minVal, Math.min(maxVal, numberValue));
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/string/random.ts
+/**
+* randome a string useing given chars
+*
+* @param length - string length
+* @param chars - string chars
+* @returns random string
+*/
 function randomString(length = 16, chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
-  const result = [];
-  for (let i = length; i > 0; --i) {
-    result.push(chars[randomNumber(chars.length)]);
-  }
-  return result.join("");
+	const result = [];
+	for (let i = length; i > 0; --i) result.push(chars[randomNumber(chars.length)]);
+	return result.join("");
 }
 
-// src/string/slugify.ts
-var rControl = /[\u0000-\u001F]/g;
-var rSpecial = /[\s~`!@#$%^&*()\-_+=[\]{}|\\;:"'“”‘’<>,.?/]+/g;
-var rCombining = /[\u0300-\u036F]/g;
+//#endregion
+//#region src/string/slugify.ts
+const rControl = /[\u0000-\u001F]/g;
+const rSpecial = /[\s~`!@#$%^&*()\-_+=[\]{}|\\;:"'“”‘’<>,.?/]+/g;
+const rCombining = /[\u0300-\u036F]/g;
+/**
+* Default slugify function
+*/
 function slugify(str) {
-  return str.normalize("NFKD").replace(rCombining, "").replace(rControl, "").replace(rSpecial, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").replace(/^(\d)/, "_$1").toLowerCase();
+	return str.normalize("NFKD").replace(rCombining, "").replace(rControl, "").replace(rSpecial, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").replace(/^(\d)/, "_$1").toLowerCase();
 }
 
-// src/string/unindent.ts
-var _RE_FULL_WS = /^\s*$/;
+//#endregion
+//#region src/string/unindent.ts
+const _RE_FULL_WS = /^\s*$/;
+/**
+* Remove common leading whitespace from a template string
+* Empty lines at the beginning and end of the template string are also removed.
+* @param input - template string
+*
+* @example
+*
+* ```ts
+* const str = unindent`
+*   if (foo) {
+*     bar()
+*   }
+* `
+* ```
+*/
 function unindent(input) {
-  const lines = (typeof input === "string" ? input : input[0]).split("\n");
-  const whitespaceLines = lines.map((line) => _RE_FULL_WS.test(line));
-  const commonIndent = lines.reduce((min, line, idx) => {
-    if (whitespaceLines[idx]) {
-      return min;
-    }
-    const indent = line.match(/^\s*/)?.[0].length;
-    return indent === void 0 ? min : Math.min(min, indent);
-  }, Number.POSITIVE_INFINITY);
-  let emptylinesHead = 0;
-  while (emptylinesHead < lines.length && whitespaceLines[emptylinesHead]) {
-    emptylinesHead++;
-  }
-  let emptylinesTail = 0;
-  while (emptylinesTail < lines.length && whitespaceLines[lines.length - emptylinesTail - 1]) {
-    emptylinesTail++;
-  }
-  return lines.slice(emptylinesHead, lines.length - emptylinesTail).map((line) => line.slice(commonIndent)).join("\n");
-}
-
-// src/string/ensurePrefix.ts
+	const lines = (typeof input === "string" ? input : input[0]).split("\n");
+	const whitespaceLines = lines.map((line) => _RE_FULL_WS.test(line));
+	const commonIndent = lines.reduce((min, line, idx) => {
+		if (whitespaceLines[idx]) return min;
+		const indent = line.match(/^\s*/)?.[0].length;
+		return indent === void 0 ? min : Math.min(min, indent);
+	}, Number.POSITIVE_INFINITY);
+	let emptylinesHead = 0;
+	while (emptylinesHead < lines.length && whitespaceLines[emptylinesHead]) emptylinesHead++;
+	let emptylinesTail = 0;
+	while (emptylinesTail < lines.length && whitespaceLines[lines.length - emptylinesTail - 1]) emptylinesTail++;
+	return lines.slice(emptylinesHead, lines.length - emptylinesTail).map((line) => line.slice(commonIndent)).join("\n");
+}
+
+//#endregion
+//#region src/string/getLength.ts
+let segmenter;
+function isASCII(value) {
+	return /^[\u0020-\u007F]*$/u.test(value);
+}
+/**
+* Counts graphemes in a given string
+* @param value - A string to count graphemes.
+* @returns The number of graphemes in `value`.
+*/
+function getStringLength(value) {
+	if (isASCII(value)) return value.length;
+	segmenter ??= new Intl.Segmenter();
+	return [...segmenter.segment(value)].length;
+}
+
+//#endregion
+//#region src/string/ensurePrefix.ts
 function ensurePrefix(input, prefix) {
-  return input.startsWith(prefix) ? input : `${prefix}${input}`;
+	return input.startsWith(prefix) ? input : `${prefix}${input}`;
 }
 
-// src/string/ensureSuffix.ts
+//#endregion
+//#region src/string/ensureSuffix.ts
 function ensureSuffix(input, suffix) {
-  return input.endsWith(suffix) ? input : `${input}${suffix}`;
+	return input.endsWith(suffix) ? input : `${input}${suffix}`;
 }
 
-// src/color/color.ts
-var pad2 = createPadString({ length: 2, char: "0" });
-var RE_VALID_HEX_COLOR = /^#(?:[0-9a-f]{6}|[0-9a-f]{3})$/i;
+//#endregion
+//#region src/color/color.ts
+const pad2 = createPadString({
+	length: 2,
+	char: "0"
+});
+const RE_VALID_HEX_COLOR = /^#(?:[0-9a-f]{6}|[0-9a-f]{3})$/i;
 function validateHexColor(hex) {
-  if (hex.length !== 4 && hex.length !== 7) return false;
-  if (!hex.startsWith("#")) return false;
-  return RE_VALID_HEX_COLOR.test(hex);
+	if (hex.length !== 4 && hex.length !== 7) return false;
+	if (!hex.startsWith("#")) return false;
+	return RE_VALID_HEX_COLOR.test(hex);
 }
 function normalizeHexString(hex) {
-  return hex.length === 6 ? hex : hex.replace(/./g, "$&$&");
-}
-var Color = class _Color {
-  red = 0;
-  green = 0;
-  blue = 0;
-  alpha = 1;
-  constructor(red = 0, green = 0, blue = 0, alpha = 1) {
-    this.red = red;
-    this.green = green;
-    this.blue = blue;
-    this.alpha = alpha;
-  }
-  static fromRGB(red, green, blue) {
-    return new _Color(red, green, blue);
-  }
-  static fromRGBA(red, green, blue, alpha) {
-    return new _Color(red, green, blue, alpha);
-  }
-  static fromHex(hex) {
-    if (!validateHexColor(hex)) {
-      throw new Error("Invalid hex color");
-    }
-    const [red, green, blue] = normalizeHexString(hex.slice(1)).match(/.{2}/g)?.map((value) => Number.parseInt(value, 16)) ?? [0, 0, 0];
-    return new _Color(red, green, blue);
-  }
-  get brightness() {
-    return (this.red * 299 + this.green * 587 + this.blue * 114) / 1e3;
-  }
-  get isDark() {
-    return this.brightness < 128;
-  }
-  get isLight() {
-    return !this.isDark;
-  }
-  toHexString(isUpperCase = true) {
-    const hexString = `#${pad2(this.red.toString(16))}${pad2(this.green.toString(16))}${pad2(this.blue.toString(16))}`;
-    return isUpperCase ? hexString.toUpperCase() : hexString;
-  }
-  toRGBAString() {
-    return `rgba(${this.red}, ${this.green}, ${this.blue}, ${this.alpha})`;
-  }
-  /**
-   * add alpha value to {@link Color}
-   *
-   * @param alpha - alpha value
-   * @returns instance of {@link Color}
-   */
-  withAlpha(alpha = 1) {
-    return new _Color(this.red, this.green, this.blue, alpha);
-  }
-  /**
-   * lighten the color by percentage
-   *
-   * @param percentage - percentage to lighten
-   */
-  lighten(percentage = 0) {
-    const amount = Math.round(percentage / 100 * 255);
-    return new _Color(
-      Math.min(this.red + amount, 255),
-      Math.min(this.green + amount, 255),
-      Math.min(this.blue + amount, 255),
-      this.alpha
-    );
-  }
-  /**
-   * darken the color by percentage
-   *
-   * @param percentage - percentage to darken
-   */
-  darken(percentage = 0) {
-    const amount = Math.round(percentage / 100 * 255);
-    return new _Color(
-      Math.max(this.red - amount, 0),
-      Math.max(this.green - amount, 0),
-      Math.max(this.blue - amount, 0),
-      this.alpha
-    );
-  }
+	return hex.length === 6 ? hex : hex.replace(/./g, "$&$&");
+}
+var Color = class Color {
+	red = 0;
+	green = 0;
+	blue = 0;
+	alpha = 1;
+	constructor(red = 0, green = 0, blue = 0, alpha = 1) {
+		this.red = red;
+		this.green = green;
+		this.blue = blue;
+		this.alpha = alpha;
+	}
+	static fromRGB(red, green, blue) {
+		return new Color(red, green, blue);
+	}
+	static fromRGBA(red, green, blue, alpha) {
+		return new Color(red, green, blue, alpha);
+	}
+	static fromHex(hex) {
+		if (!validateHexColor(hex)) throw new Error("Invalid hex color");
+		const [red, green, blue] = normalizeHexString(hex.slice(1)).match(/.{2}/g)?.map((value) => Number.parseInt(value, 16)) ?? [
+			0,
+			0,
+			0
+		];
+		return new Color(red, green, blue);
+	}
+	get brightness() {
+		return (this.red * 299 + this.green * 587 + this.blue * 114) / 1e3;
+	}
+	get isDark() {
+		return this.brightness < 128;
+	}
+	get isLight() {
+		return !this.isDark;
+	}
+	toHexString(isUpperCase = true) {
+		const hexString = `#${pad2(this.red.toString(16))}${pad2(this.green.toString(16))}${pad2(this.blue.toString(16))}`;
+		return isUpperCase ? hexString.toUpperCase() : hexString;
+	}
+	toRGBAString() {
+		return `rgba(${this.red}, ${this.green}, ${this.blue}, ${this.alpha})`;
+	}
+	/**
+	* add alpha value to {@link Color}
+	*
+	* @param alpha - alpha value
+	* @returns instance of {@link Color}
+	*/
+	withAlpha(alpha = 1) {
+		return new Color(this.red, this.green, this.blue, alpha);
+	}
+	/**
+	* lighten the color by percentage
+	*
+	* @param percentage - percentage to lighten
+	*/
+	lighten(percentage = 0) {
+		const amount = Math.round(percentage / 100 * 255);
+		return new Color(Math.min(this.red + amount, 255), Math.min(this.green + amount, 255), Math.min(this.blue + amount, 255), this.alpha);
+	}
+	/**
+	* darken the color by percentage
+	*
+	* @param percentage - percentage to darken
+	*/
+	darken(percentage = 0) {
+		const amount = Math.round(percentage / 100 * 255);
+		return new Color(Math.max(this.red - amount, 0), Math.max(this.green - amount, 0), Math.max(this.blue - amount, 0), this.alpha);
+	}
 };
 
-// src/color/random.ts
-var MAX_RGB = 255;
+//#endregion
+//#region src/color/random.ts
+/**
+* the maximum value of RGB
+*/
+const MAX_RGB = 255;
+/**
+* get a random RGB color
+* @returns a random RGB color
+*/
 function randomRGBColor() {
-  return `rgb(${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)})`;
+	return `rgb(${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)})`;
 }
+/**
+* get a random RGBA color
+* @returns a random RGBA color
+*/
 function randomRGBAColor() {
-  return `rgba(${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)}, ${Math.random().toFixed(1)})`;
+	return `rgba(${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)}, ${randomNumber(MAX_RGB)}, ${Math.random().toFixed(1)})`;
 }
+/**
+* get a random hex color
+* @returns a random hex color
+*/
 function randomHexColor() {
-  return `#${Math.random().toString(16).slice(2, 8)}`;
+	return `#${Math.random().toString(16).slice(2, 8)}`;
 }
 
-// src/proxy/enhance.ts
+//#endregion
+//#region src/proxy/enhance.ts
+/**
+* enhance object
+* @module proxy
+*/
 function enhance(module, extra) {
-  return new Proxy(module, {
-    get(target, key, receiver) {
-      if (Reflect.has(extra, key)) {
-        return Reflect.get(extra, key, receiver);
-      }
-      return Reflect.get(target, key, receiver);
-    },
-    has(target, key) {
-      return Reflect.has(extra, key) || Reflect.has(target, key);
-    }
-  });
-}
-
-// src/module/interopDefault.ts
+	return new Proxy(module, {
+		get(target, key, receiver) {
+			if (Reflect.has(extra, key)) return Reflect.get(extra, key, receiver);
+			return Reflect.get(target, key, receiver);
+		},
+		has(target, key) {
+			return Reflect.has(extra, key) || Reflect.has(target, key);
+		}
+	});
+}
+
+//#endregion
+//#region src/module/interopDefault.ts
+/**
+* Interop default export from a module
+*
+* @param mod - The module
+* @returns The default export
+*
+* @example
+*
+* ```ts
+* import { interopDefault } from '@ntnyq/utils'
+*
+* const { unindent } = await interopDefault(import('@ntnyq/utils'))
+* ```
+*/
 async function interopDefault(mod) {
-  const resolved = await mod;
-  return resolved.default || resolved;
+	const resolved = await mod;
+	return resolved.default || resolved;
 }
 
-// src/module/resolveSubOptions.ts
+//#endregion
+//#region src/module/resolveSubOptions.ts
+/**
+* Resolve sub options `boolean | Options` to `Options`
+* @param options - core options
+* @param key - sub options key
+* @returns resolved sub options
+*
+* @example
+*
+* ```ts
+* import { resolveSubOptions } from '@ntnyq/utils'
+*
+* interface Options {
+*   compile?: boolean | {
+*     include?: string[]
+*     exclude?: string[]
+*   }
+* }
+*
+* const options: Options = {
+*   compile: true
+* }
+*
+* console.log(resolveSubOptions(options, 'compile'))
+*
+* // => {}
+* ```
+*/
 function resolveSubOptions(options, key) {
-  return typeof options[key] === "boolean" ? {} : options[key] || {};
+	return typeof options[key] === "boolean" ? {} : options[key] || {};
 }
 
-// src/object/omit.ts
+//#endregion
+//#region src/object/omit.ts
 function omit(object, ...keys) {
-  keys.forEach((key) => delete object[key]);
-  return object;
+	keys.forEach((key) => delete object[key]);
+	return object;
 }
 
-// src/object/hasOwn.ts
+//#endregion
+//#region src/object/hasOwn.ts
+/**
+* check object has a property with given key
+* @param object - the object to check
+* @param key - the key to check
+* @returns true if object has a property with given key, false otherwise
+*/
 function hasOwn(object, key) {
-  if (object === null) {
-    return false;
-  }
-  return Object.prototype.hasOwnProperty.call(object, key);
+	if (object === null) return false;
+	return Object.prototype.hasOwnProperty.call(object, key);
 }
 
-// src/object/pick.ts
+//#endregion
+//#region src/object/pick.ts
 function pick(object, keys) {
-  return Object.assign(
-    {},
-    ...keys.map((key) => {
-      if (object && hasOwn(object, key)) {
-        return { [key]: object[key] };
-      }
-    })
-  );
+	return Object.assign(
+		{},
+		// eslint-disable-next-line array-callback-return
+		...keys.map((key) => {
+			if (object && hasOwn(object, key)) return { [key]: object[key] };
+		})
+);
 }
 
-// src/object/clean.ts
+//#endregion
+//#region src/object/clean.ts
+/**
+* clean undefined, null, zero, empty string, empty array, empty object from object
+* @param obj - object to be cleaned
+* @param options - clean options
+* @returns cleaned object
+*/
 function cleanObject(obj, options = {}) {
-  const {
-    cleanUndefined = true,
-    cleanNull = true,
-    cleanNaN = true,
-    cleanZero = false,
-    cleanEmptyString = false,
-    cleanEmptyArray = false,
-    cleanEmptyObject = false,
-    recursive = true
-  } = options;
-  Object.keys(obj).forEach((key) => {
-    const v = obj[key];
-    if (cleanUndefined && isUndefined(v)) {
-      delete obj[key];
-    }
-    if (cleanNull && isNull(v)) {
-      delete obj[key];
-    }
-    if (cleanZero && isZero(v)) {
-      delete obj[key];
-    }
-    if (cleanNaN && isZero(v)) {
-      delete obj[key];
-    }
-    if (cleanEmptyString && isEmptyString(v)) {
-      delete obj[key];
-    }
-    if (cleanEmptyArray && isEmptyArray(v)) {
-      delete obj[key];
-    }
-    if (cleanEmptyObject && isEmptyObject(v)) {
-      delete obj[key];
-    }
-    if (recursive && isObject(v)) {
-      cleanObject(v, options);
-    }
-  });
-  return obj;
-}
-
-// src/object/isPlainObject.ts
+	const { cleanUndefined = true, cleanNull = true, cleanNaN = true, cleanZero = false, cleanEmptyString = false, cleanEmptyArray = false, cleanEmptyObject = false, recursive = true } = options;
+	Object.keys(obj).forEach((key) => {
+		const v = obj[key];
+		if (cleanUndefined && isUndefined(v)) delete obj[key];
+		if (cleanNull && isNull(v)) delete obj[key];
+		if (cleanZero && isZero(v)) delete obj[key];
+		if (cleanNaN && isZero(v)) delete obj[key];
+		if (cleanEmptyString && isEmptyString(v)) delete obj[key];
+		if (cleanEmptyArray && isEmptyArray(v)) delete obj[key];
+		if (cleanEmptyObject && isEmptyObject(v)) delete obj[key];
+		if (recursive && isObject(v)) cleanObject(v, options);
+	});
+	return obj;
+}
+
+//#endregion
+//#region src/object/isPlainObject.ts
+/**
+* Check if a value is a plain object (not an array, Date, RegExp, Map, Set, etc.)
+*
+* @param value - Checked value
+* @copyright {@link https://github.com/sindresorhus/is/blob/main/source/index.ts}
+*/
 function isPlainObject(value) {
-  if (!isObject(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+	if (!isObject(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
 }
 
-// src/object/sortObject.ts
+//#endregion
+//#region src/object/sortObject.ts
+/**
+* Sort object properties
+*/
 function sortObject(obj, options = {}) {
-  const { compareFn = (a, b) => a.localeCompare(b) } = options;
-  function sortKeys(obj2) {
-    const sortedKeys = Object.keys(obj2).sort(compareFn);
-    const result = {};
-    for (const key of sortedKeys) {
-      const value = obj2[key];
-      let newValue;
-      if (options.deep && isPlainObject(value)) {
-        newValue = sortKeys(value);
-      } else {
-        newValue = value;
-      }
-      Object.defineProperty(result, key, {
-        ...Object.getOwnPropertyDescriptor(obj2, key),
-        value: newValue
-      });
-    }
-    return result;
-  }
-  return sortKeys(obj);
-}
-
-// src/constants/char.ts
-var SPECIAL_CHAR = {
-  newline: "\n"
-};
+	const { compareFn = (a, b) => a.localeCompare(b) } = options;
+	function sortKeys(obj$1) {
+		const sortedKeys = Object.keys(obj$1).sort(compareFn);
+		const result = {};
+		for (const key of sortedKeys) {
+			const value = obj$1[key];
+			let newValue;
+			if (options.deep && isPlainObject(value)) newValue = sortKeys(value);
+			else newValue = value;
+			Object.defineProperty(result, key, {
+				...Object.getOwnPropertyDescriptor(obj$1, key),
+				value: newValue
+			});
+		}
+		return result;
+	}
+	return sortKeys(obj);
+}
 
-// src/constants/regexp.ts
-var RE_COMMENTS = /(?:<!--|\/\*)([\s\S]*?)(?:-->|\*\/)/g;
-var RE_LINE_COMMENT = /\/\/.*/;
-var RE_BLOCK_COMMENT = /\/\*[\s\S]*?\*\//g;
-export {
-  Color,
-  NOOP,
-  RE_BLOCK_COMMENT,
-  RE_COMMENTS,
-  RE_LINE_COMMENT,
-  SPECIAL_CHAR,
-  at,
-  cAF,
-  chunk,
-  clamp,
-  cleanObject,
-  createPadString,
-  days,
-  debounce,
-  enhance,
-  ensurePrefix,
-  ensureSuffix,
-  escapeHTML,
-  flattenArrayable,
-  getObjectType,
-  hasOwn,
-  hours,
-  interopDefault,
-  intersect,
-  isArray,
-  isArrayEqual,
-  isBigInt,
-  isBoolean,
-  isBrowser,
-  isDeepEqual,
-  isElementVisibleInViewport,
-  isEmptyArray,
-  isEmptyMap,
-  isEmptyObject,
-  isEmptySet,
-  isEmptyString,
-  isEmptyStringOrWhitespace,
-  isError,
-  isFunction,
-  isHTMLElement,
-  isInteger,
-  isIterable,
-  isMap,
-  isNaN,
-  isNativePromise,
-  isNil,
-  isNonEmptyArray,
-  isNonEmptyString,
-  isNull,
-  isNullOrUndefined,
-  isNumber,
-  isNumbericString,
-  isObject,
-  isPromise,
-  isRegExp,
-  isSet,
-  isString,
-  isTruthy,
-  isUndefined,
-  isWhitespaceString,
-  isZero,
-  join,
-  last,
-  mergeArrayable,
-  minutes,
-  noop,
-  omit,
-  once,
-  openExternalURL,
-  pick,
-  rAF,
-  randomHexColor,
-  randomNumber,
-  randomRGBAColor,
-  randomRGBColor,
-  randomString,
-  resolveSubOptions,
-  scrollElementIntoView,
-  seconds,
-  slash,
-  slugify,
-  sortObject,
-  throttle,
-  toArray,
-  unescapeHTML,
-  unindent,
-  unique,
-  uniqueBy,
-  waitFor,
-  warnOnce,
-  weeks
-};
+//#endregion
+//#region src/constants/char.ts
+/**
+* Special chars
+*/
+const SPECIAL_CHAR = { newline: "\n" };
+
+//#endregion
+//#region src/constants/regexp.ts
+/**
+* 注释正则
+*
+* 匹配 \<!-- 或 /* 开头的注释，直到 --> 或 *\/ 结尾
+*/
+const RE_COMMENTS = /(?:<!--|\/\*)([\s\S]*?)(?:-->|\*\/)/g;
+/**
+* JavaScript line comment
+*/
+const RE_LINE_COMMENT = /\/\/.*/;
+/**
+* JavaScript block comment
+*/
+const RE_BLOCK_COMMENT = /\/\*[\s\S]*?\*\//g;
+
+//#endregion
+export { Color, NOOP, RE_BLOCK_COMMENT, RE_COMMENTS, RE_LINE_COMMENT, SPECIAL_CHAR, at, cAF, chunk, clamp, cleanObject, createPadString, days, debounce, enhance, ensurePrefix, ensureSuffix, escapeHTML, flattenArrayable, getObjectType, getStringLength, hasOwn, hours, interopDefault, intersect, isArray, isArrayEqual, isBigInt, isBoolean, isBrowser, isDeepEqual, isElementVisibleInViewport, isEmptyArray, isEmptyMap, isEmptyObject, isEmptySet, isEmptyString, isEmptyStringOrWhitespace, isError, isFunction, isHTMLElement, isInteger, isIterable, isMap, isNaN, isNativePromise, isNil, isNonEmptyArray, isNonEmptyString, isNull, isNullOrUndefined, isNumber, isNumbericString, isObject, isPromise, isRegExp, isSet, isString, isTruthy, isUndefined, isWhitespaceString, isZero, join, last, mergeArrayable, minutes, noop, omit, once, openExternalURL, pick, rAF, randomHexColor, randomNumber, randomRGBAColor, randomRGBColor, randomString, resolveSubOptions, scrollElementIntoView, seconds, slash, slugify, sortObject, throttle, toArray, toInteger, unescapeHTML, unindent, unique, uniqueBy, waitFor, warnOnce, weeks };