@unicom-cloud/utils 0.1.23 → 0.1.25

package/dom-helpers/remove.js

@@ -0,0 +1,7 @@
+/* 2025-11-03 10:27:31 */
+function e(r) {
+  return r && r.parentNode ? (r.parentNode.removeChild(r), r) : null;
+}
+export {
+  e as default
+};

package/dom-helpers/removeClass.js

@@ -0,0 +1,19 @@
+/* 2025-11-03 10:27:31 */
+function c(s, a) {
+  return s.replace(new RegExp(`(^|\\s)${a}(?:\\s|$)`, "g"), "$1").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, "");
+}
+function r(s, a) {
+  s.classList ? s.classList.remove(a) : typeof s.className == "string" ? s.className = c(
+    s.className,
+    a
+  ) : s.setAttribute(
+    "class",
+    c(
+      s.className && s.className.baseVal || "",
+      a
+    )
+  );
+}
+export {
+  r as default
+};

package/dom-helpers/removeEventListener.js

@@ -0,0 +1,8 @@
+/* 2025-11-03 10:27:31 */
+function v(r, c, t, e) {
+  const n = e && typeof e != "boolean" ? e.capture : e;
+  r.removeEventListener(c, t, n), t.__once && r.removeEventListener(c, t.__once, n);
+}
+export {
+  v as default
+};

package/dom-helpers/scrollLeft.js

@@ -0,0 +1,6 @@
+/* 2025-11-03 10:27:31 */
+import e from "./getScrollAccessor.js";
+const s = e("pageXOffset");
+export {
+  s as default
+};

package/dom-helpers/scrollParent.js

@@ -0,0 +1,17 @@
+/* 2025-11-03 10:27:31 */
+import t from "./css.js";
+import n from "./height.js";
+import a from "./isDocument.js";
+function h(o, c) {
+  const i = t(o, "position"), s = i === "absolute", r = o.ownerDocument;
+  if (i === "fixed") return r || document;
+  for (; (o = o.parentNode) && !a(o); ) {
+    const u = s && t(o, "position") === "static", f = (t(o, "overflow") || "") + (t(o, "overflow-y") || "") + t(o, "overflow-x");
+    if (!u && /(auto|scroll)/.test(f) && (c || n(o) < o.scrollHeight))
+      return o;
+  }
+  return r || document;
+}
+export {
+  h as default
+};

package/dom-helpers/scrollTo.js

@@ -0,0 +1,27 @@
+/* 2025-11-03 10:27:31 */
+import { request as g, cancel as u } from "./animationFrame.js";
+import a from "./height.js";
+import T from "./isWindow.js";
+import n from "./offset.js";
+import w from "./scrollParent.js";
+import c from "./scrollTop.js";
+function P(e, m) {
+  let t = n(e), r = { top: 0, left: 0 };
+  if (!e) return;
+  const i = m || w(e), l = T(i);
+  let o = c(i);
+  const s = a(i, !0);
+  l || (r = n(i)), t = {
+    top: t.top - r.top,
+    left: t.left - r.left,
+    height: t.height,
+    width: t.width
+  };
+  const h = t.height, f = t.top + (l ? 0 : o), p = f + h;
+  o = o > f ? f : p > o + s ? p - s : o;
+  const d = g(() => c(i, o));
+  return () => u(d);
+}
+export {
+  P as default
+};

package/dom-helpers/scrollTop.js

@@ -0,0 +1,6 @@
+/* 2025-11-03 10:27:31 */
+import o from "./getScrollAccessor.js";
+const e = o("pageYOffset");
+export {
+  e as default
+};

package/dom-helpers/scrollbarSize.js

@@ -0,0 +1,13 @@
+/* 2025-11-03 10:27:31 */
+import l from "./canUseDOM.js";
+let t;
+function s(o) {
+  if ((!t && t !== 0 || o) && l) {
+    const e = document.createElement("div");
+    e.style.position = "absolute", e.style.top = "-9999px", e.style.width = "50px", e.style.height = "50px", e.style.overflow = "scroll", document.body.appendChild(e), t = e.offsetWidth - e.clientWidth, document.body.removeChild(e);
+  }
+  return t;
+}
+export {
+  s as default
+};

package/dom-helpers/siblings.js

@@ -0,0 +1,11 @@
+/* 2025-11-03 10:27:31 */
+import l from "./collectSiblings.js";
+function i(t) {
+  return l(
+    t && t.parentElement ? t.parentElement.firstElementChild : null,
+    t
+  );
+}
+export {
+  i as default
+};

package/dom-helpers/text.js

@@ -0,0 +1,9 @@
+/* 2025-11-03 10:27:31 */
+const n = / /gi, s = /\xA0/g, x = /\s+([^\s])/gm;
+function c(t, r = !0, p = !0) {
+  let e = "";
+  return t && (e = (t.textContent || "").replace(n, " ").replace(s, " "), r && (e = e.trim()), p && (e = e.replace(x, " $1"))), e;
+}
+export {
+  c as default
+};

package/dom-helpers/toggleClass.js

@@ -0,0 +1,10 @@
+/* 2025-11-03 10:27:31 */
+import i from "./addClass.js";
+import r from "./hasClass.js";
+import f from "./removeClass.js";
+function l(s, o) {
+  s.classList ? s.classList.toggle(o) : r(s, o) ? f(s, o) : i(s, o);
+}
+export {
+  l as default
+};

package/dom-helpers/transitionEnd.js

@@ -0,0 +1,34 @@
+/* 2025-11-03 10:27:31 */
+import a from "./css.js";
+import s from "./listen.js";
+import u from "./triggerEvent.js";
+function c(t) {
+  const r = a(t, "transitionDuration") || "", n = r.indexOf("ms") === -1 ? 1e3 : 1;
+  return parseFloat(r) * n;
+}
+function l(t, r, n = 5) {
+  let o = !1;
+  const e = setTimeout(() => {
+    o || u(t, "transitionend", !0);
+  }, r + n), i = s(
+    t,
+    "transitionend",
+    () => {
+      o = !0;
+    },
+    { once: !0 }
+  );
+  return () => {
+    clearTimeout(e), i();
+  };
+}
+function p(t, r, n, o) {
+  n == null && (n = c(t) || 0);
+  const e = l(t, n, o), i = s(t, "transitionend", r);
+  return () => {
+    e(), i();
+  };
+}
+export {
+  p as default
+};

package/dom-helpers/triggerEvent.js

@@ -0,0 +1,10 @@
+/* 2025-11-03 10:27:31 */
+function a(t, n, i = !1, v = !0) {
+  if (t) {
+    const e = document.createEvent("HTMLEvents");
+    e.initEvent(n, i, v), t.dispatchEvent(e);
+  }
+}
+export {
+  a as default
+};

package/dom-helpers/types.js

@@ -0,0 +1,5 @@
+/* 2025-11-03 10:27:31 */
+const t = {};
+export {
+  t as default
+};

package/dom-helpers/width.js

@@ -0,0 +1,10 @@
+/* 2025-11-03 10:27:31 */
+import n from "./isWindow.js";
+import o from "./offset.js";
+function d(t, r) {
+  const i = n(t);
+  return i ? i.innerWidth : r ? t.clientWidth : o(t).width;
+}
+export {
+  d as default
+};

package/domHelpers.js

@@ -0,0 +1,94 @@
+/* 2025-11-03 10:27:31 */
+import { default as r } from "./dom-helpers/activeElement.js";
+import { default as a } from "./dom-helpers/addClass.js";
+import { default as s } from "./dom-helpers/addEventListener.js";
+import { default as m } from "./dom-helpers/animate.js";
+import { cancel as p, request as u } from "./dom-helpers/animationFrame.js";
+import { default as n } from "./dom-helpers/attribute.js";
+import { default as c } from "./dom-helpers/childElements.js";
+import { default as h } from "./dom-helpers/childNodes.js";
+import { default as E } from "./dom-helpers/clear.js";
+import { default as b } from "./dom-helpers/closest.js";
+import { default as A } from "./dom-helpers/contains.js";
+import { default as y } from "./dom-helpers/css.js";
+import { default as S } from "./dom-helpers/filterEventHandler.js";
+import { default as P } from "./dom-helpers/getComputedStyle.js";
+import { default as z } from "./dom-helpers/hasClass.js";
+import { default as I } from "./dom-helpers/height.js";
+import { default as U } from "./dom-helpers/insertAfter.js";
+import { default as W } from "./dom-helpers/isInput.js";
+import { default as k } from "./dom-helpers/isVisible.js";
+import { default as G } from "./dom-helpers/listen.js";
+import { default as J } from "./dom-helpers/matches.js";
+import { default as M } from "./dom-helpers/nextUntil.js";
+import { default as Q } from "./dom-helpers/offset.js";
+import { default as X } from "./dom-helpers/offsetParent.js";
+import { default as Z } from "./dom-helpers/ownerDocument.js";
+import { default as $ } from "./dom-helpers/ownerWindow.js";
+import { default as te } from "./dom-helpers/parents.js";
+import { default as oe } from "./dom-helpers/position.js";
+import { default as fe } from "./dom-helpers/prepend.js";
+import { default as le } from "./dom-helpers/querySelectorAll.js";
+import { default as de } from "./dom-helpers/remove.js";
+import { default as ue } from "./dom-helpers/removeClass.js";
+import { default as ne } from "./dom-helpers/removeEventListener.js";
+import { default as ce } from "./dom-helpers/scrollbarSize.js";
+import { default as he } from "./dom-helpers/scrollLeft.js";
+import { default as Ee } from "./dom-helpers/scrollParent.js";
+import { default as be } from "./dom-helpers/scrollTo.js";
+import { default as Ae } from "./dom-helpers/scrollTop.js";
+import { default as ye } from "./dom-helpers/siblings.js";
+import { default as Se } from "./dom-helpers/text.js";
+import { default as Pe } from "./dom-helpers/toggleClass.js";
+import { default as ze } from "./dom-helpers/transitionEnd.js";
+import { default as Ie } from "./dom-helpers/triggerEvent.js";
+import { default as Ue } from "./dom-helpers/width.js";
+import { default as We } from "./dom-helpers/index.js";
+export {
+  r as activeElement,
+  a as addClass,
+  s as addEventListener,
+  m as animate,
+  n as attribute,
+  p as cancelAnimationFrame,
+  c as childElements,
+  h as childNodes,
+  E as clear,
+  b as closest,
+  A as contains,
+  We as default,
+  S as filter,
+  P as getComputedStyle,
+  z as hasClass,
+  I as height,
+  U as insertAfter,
+  W as isInput,
+  k as isVisible,
+  G as listen,
+  J as matches,
+  M as nextUntil,
+  Q as offset,
+  X as offsetParent,
+  Z as ownerDocument,
+  $ as ownerWindow,
+  te as parents,
+  oe as position,
+  fe as prepend,
+  le as querySelectorAll,
+  de as remove,
+  ue as removeClass,
+  ne as removeEventListener,
+  u as requestAnimationFrame,
+  he as scrollLeft,
+  Ee as scrollParent,
+  be as scrollTo,
+  Ae as scrollTop,
+  ce as scrollbarSize,
+  ye as siblings,
+  y as style,
+  Se as text,
+  Pe as toggleClass,
+  ze as transitionEnd,
+  Ie as triggerEvent,
+  Ue as width
+};

package/emitter/index.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 import { Emitter as r } from "./src/index.js";
 export {
   r as default

package/emitter/src/index.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 class a {
   constructor(e = /* @__PURE__ */ new Map()) {
     this.all = e;

package/emitter.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 import { Emitter as r } from "./emitter/src/index.js";
 export {
   r as default

package/file/fileToURL.js

@@ -1,17 +1,17 @@
-import "../is/index.js";
-import s from "lodash/isString";
-function d(r) {
+/* 2025-11-03 10:27:31 */
+import i from "lodash/isString";
+function u(r) {
   return new Promise((n, e) => {
     if (r)
-      if (s(r.url))
+      if (r.url && i(r.url))
         n(r.url);
       else if (r instanceof File) {
-        const i = "文件解析出错", o = new FileReader();
-        o.onload = (t) => {
-          const a = t.target?.result;
-          a ? n(a) : e(new Error(t)), o.abort();
+        const s = "文件解析出错", o = new FileReader();
+        o.onload = (a) => {
+          const t = a.target?.result;
+          t ? n(t) : e(new Error(a)), o.abort();
         }, o.onerror = () => {
-          e(new Error(i));
+          e(new Error(s));
         }, o.readAsDataURL(r);
       } else
         e(new Error("file 不是 File 的实例"));
@@ -20,6 +20,6 @@ function d(r) {
   });
 }
 export {
-  d as default,
-  d as fileToURL
+  u as default,
+  u as fileToURL
 };

package/file/index.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 import { fileToURL as r } from "./fileToURL.js";
 import { saveAs as m } from "./saveAs.js";
 export {

package/file/saveAs.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 import { fileToURL as r } from "./fileToURL.js";
 function o(t) {
   return new XMLHttpRequest();

package/file.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 import { fileToURL as r } from "./file/fileToURL.js";
 import { saveAs as m } from "./file/saveAs.js";
 export {

package/filesize/types/constants.d.ts

@@ -26,6 +26,7 @@ export const EXPONENT: 'exponent';
 export const ROUND: 'round';
 
 // Special Characters and Values
+export const E: 'e';
 export const EMPTY: '';
 export const PERIOD: '.';
 export const S: 's';
@@ -79,3 +80,32 @@ export const STRINGS: {
     ];
   };
 };
+
+// Pre-computed lookup tables for performance optimization
+export const BINARY_POWERS: readonly [
+  1, // 2^0
+  1024, // 2^10
+  1048576, // 2^20
+  1073741824, // 2^30
+  1099511627776, // 2^40
+  1125899906842624, // 2^50
+  1152921504606846976, // 2^60
+  1180591620717411303424, // 2^70
+  1208925819614629174706176, // 2^80
+];
+
+export const DECIMAL_POWERS: readonly [
+  1, // 10^0
+  1000, // 10^3
+  1000000, // 10^6
+  1000000000, // 10^9
+  1000000000000, // 10^12
+  1000000000000000, // 10^15
+  1000000000000000000, // 10^18
+  1000000000000000000000, // 10^21
+  1000000000000000000000000, // 10^24
+];
+
+// Pre-computed log values for faster exponent calculation
+export const LOG_2_1024: number;
+export const LOG_10_1000: number;

package/filesize/types/helpers.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Configuration object returned by getBaseConfiguration
+ */
+export interface BaseConfiguration {
+  /** Whether to use decimal (base 10) calculations */
+  isDecimal: boolean;
+  /** Ceiling value for auto-increment calculations */
+  ceil: number;
+  /** The actual standard to use for formatting */
+  actualStandard: string;
+}
+
+/**
+ * Value calculation result
+ */
+export interface OptimizedValueResult {
+  /** The calculated result value */
+  result: number;
+  /** The adjusted exponent */
+  e: number;
+}
+
+/**
+ * Precision handling result
+ */
+export interface PrecisionHandlingResult {
+  /** The formatted value */
+  value: string | number;
+  /** The adjusted exponent */
+  e: number;
+}
+
+/**
+ * Optimized base configuration lookup
+ * @param standard - Standard type
+ * @param base - Base number
+ * @returns Configuration object
+ */
+export function getBaseConfiguration(
+  standard: string,
+  base: number,
+): BaseConfiguration;
+
+/**
+ * Optimized zero value handling
+ * @param precision - Precision value
+ * @param actualStandard - Standard to use
+ * @param bits - Whether to use bits
+ * @param symbols - Custom symbols
+ * @param full - Whether to use full form
+ * @param fullforms - Custom full forms
+ * @param output - Output format
+ * @param spacer - Spacer character
+ * @returns Formatted result
+ */
+export function handleZeroValue(
+  precision: number,
+  actualStandard: string,
+  bits: boolean,
+  symbols: Record<string, string>,
+  full: boolean,
+  fullforms: string[],
+  output: string,
+  spacer: string,
+):
+  | string
+  | [number | string, string]
+  | { value: number | string; symbol: string; exponent: number; unit: string }
+  | number;
+
+/**
+ * Optimized value calculation with bits handling
+ * @param num - Input number
+ * @param e - Exponent
+ * @param isDecimal - Whether to use decimal powers
+ * @param bits - Whether to calculate bits
+ * @param ceil - Ceiling value for auto-increment
+ * @returns Object with result and e properties
+ */
+export function calculateOptimizedValue(
+  num: number,
+  e: number,
+  isDecimal: boolean,
+  bits: boolean,
+  ceil: number,
+): OptimizedValueResult;
+
+/**
+ * Optimized precision handling with scientific notation correction
+ * @param value - Current value
+ * @param precision - Precision to apply
+ * @param e - Current exponent
+ * @param num - Original number
+ * @param isDecimal - Whether using decimal base
+ * @param bits - Whether calculating bits
+ * @param ceil - Ceiling value
+ * @param roundingFunc - Rounding function
+ * @param round - Round value
+ * @returns Object with value and e properties
+ */
+export function applyPrecisionHandling(
+  value: number,
+  precision: number,
+  e: number,
+  num: number,
+  isDecimal: boolean,
+  bits: boolean,
+  ceil: number,
+  roundingFunc: (x: number) => number,
+  round: number,
+): PrecisionHandlingResult;
+
+/**
+ * Optimized number formatting with locale, separator, and padding
+ * @param value - Value to format
+ * @param locale - Locale setting
+ * @param localeOptions - Locale options
+ * @param separator - Custom separator
+ * @param pad - Whether to pad
+ * @param round - Round value
+ * @returns Formatted value
+ */
+export function applyNumberFormatting(
+  value: number | string,
+  locale: string | boolean,
+  localeOptions: Intl.NumberFormatOptions,
+  separator: string,
+  pad: boolean,
+  round: number,
+): string | number;

package/idb/index.js

@@ -0,0 +1,103 @@
+/* 2025-11-03 10:27:31 */
+function o(n) {
+  return new Promise((t, e) => {
+    (n instanceof IDBOpenDBRequest || n instanceof IDBRequest) && (n.onsuccess = (r) => {
+      t(n.result);
+    }, n.onerror = (r) => {
+      e(n.error);
+    }), n instanceof IDBTransaction && (n.oncomplete = (r) => {
+      t(n);
+    }, n.onabort = n.onerror = (r) => {
+      e(n.error);
+    });
+  });
+}
+const a = "readonly", i = "readwrite";
+class d {
+  constructor(t = "App", e = "app") {
+    this.indexedDBName = t, this.objectStoreName = e;
+    const r = indexedDB.open(
+      this.indexedDBName,
+      1
+    );
+    r.onupgradeneeded = (c) => {
+      const b = c.target.result.createObjectStore(
+        this.objectStoreName,
+        { keyPath: null }
+      );
+      o(b.transaction).then((u) => {
+      }).catch((u) => {
+        console.error(u);
+      }).finally(() => {
+      });
+    }, this.idbOpenDBRequestPromise = o(r);
+  }
+  static deleteDatabase(t) {
+    indexedDB.deleteDatabase(t);
+  }
+  deleteObjectStore(t) {
+    this.idbOpenDBRequestPromise.then((e) => {
+      e.deleteObjectStore(t), e.onclose = () => {
+      };
+    }).catch((e) => {
+      console.error(e);
+    }).finally(() => {
+    });
+  }
+  getObjectStore(t, e) {
+    return this.idbOpenDBRequestPromise.then((r) => {
+      const s = r.transaction(
+        [this.objectStoreName],
+        t
+      ).objectStore(
+        this.objectStoreName
+      );
+      return e(s);
+    }).catch((r) => {
+      console.error(r);
+    }).finally(() => {
+    });
+  }
+  add(t, e) {
+    return this.getObjectStore(i, (r) => (r.add(e, t), o(r.transaction)));
+  }
+  get(t) {
+    return this.getObjectStore(a, (e) => o(e.get(t)));
+  }
+  getAll(t, e) {
+    return this.getObjectStore(a, (r) => o(r.getAll(t, e)));
+  }
+  getKey(t) {
+    return this.getObjectStore(a, (e) => o(e.getKey(t)));
+  }
+  getAllKeys(t, e) {
+    return this.getObjectStore(a, (r) => o(r.getAllKeys(t, e)));
+  }
+  getMany(t) {
+    return this.getObjectStore(a, (e) => Promise.all(
+      t.map((r, c, s) => o(e.get(r)))
+    ));
+  }
+  put(t, e) {
+    return this.getObjectStore(i, (r) => (r.put(e, t), o(r.transaction)));
+  }
+  putMany(t) {
+    return this.getObjectStore(i, (e) => (t.forEach(([r, c], s, l) => {
+      e.put(r, c);
+    }), o(e.transaction)));
+  }
+  delete(t) {
+    return this.getObjectStore(i, (e) => (e.delete(t), o(e.transaction)));
+  }
+  deleteMany(t) {
+    return this.getObjectStore(i, (e) => (t.forEach((r, c, s) => {
+      e.delete(r);
+    }), o(e.transaction)));
+  }
+  clear() {
+    return this.getObjectStore(i, (t) => (t.clear(), o(t.transaction)));
+  }
+}
+export {
+  d as default
+};

package/idb.js

@@ -0,0 +1,5 @@
+/* 2025-11-03 10:27:31 */
+import { default as o } from "./idb/index.js";
+export {
+  o as default
+};

package/index.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 import { VERSION as e } from "./version/index.js";
 export {
   e as version

package/invariant/index.js

@@ -1,3 +1,4 @@
+/* 2025-11-03 10:27:31 */
 function t(n, r, ...i) {
   if (process.env.NODE_ENV !== "production" && r === void 0)
     throw new Error("invariant requires an error message argument");