@unicom-cloud/utils 0.1.22 → 0.1.24

package/types/snapdom/src/modules/fonts.d.ts

@@ -7,21 +7,77 @@
  * @param {string|number} fontWeight - The font weight
  * @param {number} [fontSize=32] - The font size in pixels
  * @param {string} [color="#000"] - The color to use
- * @returns {Promise<string>} Data URL of the rendered icon
+ * @returns {Promise<{dataUrl:string,width:number,height:number}>} Data URL and intrinsic size
  */
-export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight: string | number, fontSize?: number, color?: string): Promise<string>;
+export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight: string | number, fontSize?: number, color?: string): Promise<{
+    dataUrl: string;
+    width: number;
+    height: number;
+}>;
 /**
- * Embeds custom fonts found in the document as data URLs in CSS.
+ * Embed only the @font-face rules that match required variants AND intersect used unicode ranges.
+ * Smart by default + simple "exclude" knobs (no regex for end users).
+ *
+ * @typedef {{family:string, weightSpec:string, styleSpec:string, stretchSpec:string, unicodeRange:string, srcRaw:string, srcUrls:string[], href:string}} FontFaceMeta
  *
- * @export
  * @param {Object} options
- * @param {boolean} [options.preCached=false] - Whether to use pre-cached resources
- * @param {Object} [options.localFonts=[]] - Additional local fonts to embed
- * @param {string} [options.useProxy=''] - Optional proxy for font fetching
- * @returns {Promise<string>} The inlined CSS for custom fonts
+ * @param {Set<string>} options.required                     // keys: "family__weight__style__stretchPct"
+ * @param {Set<number>} options.usedCodepoints               // codepoints used in the captured subtree
+ * @param {{families?:string[], domains?:string[], subsets?:string[]}} [options.exclude] // simple exclude
+ * @param {Array<{family:string,src:string,weight?:string|number,style?:string,stretchPct?:number}>} [options.localFonts=[]]
+ * @param {string}  [options.useProxy=""]
+ * @returns {Promise<string>} inlined @font-face CSS
  */
-export function embedCustomFonts({ preCached, localFonts, useProxy, }?: {
-    preCached?: boolean | undefined;
-    localFonts?: Object | undefined;
+export function embedCustomFonts({ required, usedCodepoints, exclude, localFonts, useProxy, }?: {
+    required: Set<string>;
+    usedCodepoints: Set<number>;
+    exclude?: {
+        families?: string[];
+        domains?: string[];
+        subsets?: string[];
+    } | undefined;
+    localFonts?: {
+        family: string;
+        src: string;
+        weight?: string | number;
+        style?: string;
+        stretchPct?: number;
+    }[] | undefined;
     useProxy?: string | undefined;
 }): Promise<string>;
+/**
+ * Collects used font variants (family, weight, style, stretch) in subtree.
+ * @param {Element} root
+ * @returns {Set<string>} keys "family__weight__style__stretchPct"
+ */
+export function collectUsedFontVariants(root: Element): Set<string>;
+/**
+ * Collects used codepoints in subtree (including ::before/::after content).
+ * @param {Element} root
+ * @returns {Set<number>}
+ */
+export function collectUsedCodepoints(root: Element): Set<number>;
+/**
+ * Ensures web fonts are fully resolved before capture, with a Safari-friendly warm-up.
+ * - Awaits document.fonts.ready
+ * - Forces layout/rasterization for each family by painting hidden spans
+ * - Optionally retries a couple of times if Safari is still lazy
+ *
+ * @param {Set<string>|string[]} families - Plain family names (e.g., "Mansalva", "Unbounded")
+ * @param {number} [warmupRepetitions=2] - How many times to warm-up each family
+ * @returns {Promise<void>}
+ */
+export function ensureFontsReady(families: Set<string> | string[], warmupRepetitions?: number): Promise<void>;
+/**
+ * Embed only the
+ */
+export type FontFaceMeta = {
+    family: string;
+    weightSpec: string;
+    styleSpec: string;
+    stretchSpec: string;
+    unicodeRange: string;
+    srcRaw: string;
+    srcUrls: string[];
+    href: string;
+};

package/types/snapdom/src/modules/images.d.ts

@@ -1,8 +1,14 @@
 /**
- * Converts all <img> elements in the clone to data URLs or replaces them with placeholders if loading fails.
+ * Converts all <img> elements in the clone to data URLs or replaces them with
+ * placeholders if loading fails. Compatible with the new non-throwing snapFetch.
+ *
+ * - Success: result.ok === true && typeof result.data === 'string' (DataURL)
+ * - Failure: any other case → replace <img> with a sized fallback <div>
  *
  * @param {Element} clone - Clone of the original element
- * @param {Object} [options={}] - Options for image processing
- * @returns {Promise<void>} Promise that resolves when all images are processed
+ * @param {{ useProxy?: string }} [options={}] - Options for image processing
+ * @returns {Promise<void>}
  */
-export function inlineImages(clone: Element, options?: Object): Promise<void>;
+export function inlineImages(clone: Element, options?: {
+    useProxy?: string;
+}): Promise<void>;

package/types/snapdom/src/modules/lineClamp.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Apply a multi-line ellipsis ONLY if the target element declares
+ * -webkit-line-clamp/line-clamp. Uses the real layout (scrollHeight) and
+ * mutates the ORIGINAL node briefly (binary search on text + '…'),
+ * then returns an undo() that restores everything right after cloning.
+ *
+ * Scope intentionally minimal: ROOT element only, plain text container
+ * (like your demo). This mirrors the working snippet exactly.
+ *
+ * @param {Element} el
+ * @returns {() => void} undo function (no-op if nothing changed)
+ */
+export function lineClamp(el: Element): () => void;

package/types/snapdom/src/modules/pseudo.d.ts

@@ -3,8 +3,8 @@
  *
  * @param {Element} source - Original element
  * @param {Element} clone - Cloned element
- * @param {boolean} compress - Whether to compress style keys
- * @param {boolean} embedFonts - Whether to embed icon fonts as images
- * @returns {Promise} Promise that resolves when all pseudo-elements are processed
+ * @param {Map} sessionCache - styleMap cache etc.
+ * @param {Object} options - capture options
+ * @returns {Promise<void>}
  */
-export function inlinePseudoElements(source: Element, clone: Element, styleMap: any, styleCache: any, options: any): Promise<any>;
+export function inlinePseudoElements(source: Element, clone: Element, sessionCache: Map<any, any>, options: Object): Promise<void>;

package/types/snapdom/src/modules/rasterize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts to an HTMLImageElement with raster format.
+ * @param {string} url - Image data URL.
+ * @param {object} options - Context including format and dpr.
+ * @param {string} options.format - Output format ('png', 'jpeg', 'webp').
+ * @param {number} options.dpr - Device pixel ratio.
+ * @param {number} [options.quality] - Image quality for lossy formats.
+ * @param {string} [options.backgroundColor] - Optional background color.
+ * @returns {Promise<HTMLImageElement>} Resolves with the rasterized Image element.
+ */
+export function rasterize(url: string, options: {
+    format: string;
+    dpr: number;
+    quality?: number | undefined;
+    backgroundColor?: string | undefined;
+}): Promise<HTMLImageElement>;

package/types/snapdom/src/modules/snapFetch.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Unified, non-throwing fetch with minimal, deduplicated logging.
+ * @param {string} url
+ * @param {SnapFetchOptions} [options]
+ * @returns {Promise<SnapFetchResult>}
+ */
+export function snapFetch(url: string, options?: SnapFetchOptions): Promise<SnapFetchResult>;
+/**
+ * snapFetch — unified fetch for SnapDOM
+ * - Single inflight queue & error cache (with TTL)
+ * - Timeout via AbortController
+ * - Optional proxy handling ("...{url}" or "...?url=")
+ * - Non-throwing: always resolves { ok, data|null, status, url, reason, ... }
+ * - Thin, deduplicated logging: `[snapDOM]` warn/error with TTL + session cap
+ */
+export type FetchAs = "text" | "blob" | "dataURL";
+/**
+ * snapFetch — unified fetch for SnapDOM
+ * - Single inflight queue & error cache (with TTL)
+ * - Timeout via AbortController
+ * - Optional proxy handling ("...{url}" or "...?url=")
+ * - Non-throwing: always resolves { ok, data|null, status, url, reason, ... }
+ * - Thin, deduplicated logging: `[snapDOM]` warn/error with TTL + session cap
+ */
+export type SnapFetchOptions = {
+    /**
+     * Expected result type.
+     */
+    as?: FetchAs | undefined;
+    /**
+     * Timeout in ms.
+     */
+    timeout?: number | undefined;
+    /**
+     * Proxy template or base URL. Supports "{url}" or "?url=" patterns.
+     */
+    useProxy?: string | undefined;
+    /**
+     * ms to cache errors to avoid retry storms.
+     */
+    errorTTL?: number | undefined;
+    /**
+     * Override inferred credentials.
+     */
+    credentials?: RequestCredentials | undefined;
+    /**
+     * Optional headers.
+     */
+    headers?: Record<string, string> | undefined;
+    /**
+     * If true, disables console logging for this call.
+     */
+    silent?: boolean | undefined;
+    /**
+     * Optional hook when a fetch fails (ok=false).
+     */
+    onError?: ((r: SnapFetchResult) => void) | undefined;
+};
+/**
+ * snapFetch — unified fetch for SnapDOM
+ * - Single inflight queue & error cache (with TTL)
+ * - Timeout via AbortController
+ * - Optional proxy handling ("...{url}" or "...?url=")
+ * - Non-throwing: always resolves { ok, data|null, status, url, reason, ... }
+ * - Thin, deduplicated logging: `[snapDOM]` warn/error with TTL + session cap
+ */
+export type SnapFetchResult = {
+    ok: boolean;
+    /**
+     * Text, Blob, or DataURL (depending on `as`).
+     */
+    data: string | Blob | null;
+    /**
+     * HTTP status (0 on network/timeout).
+     */
+    status: number;
+    /**
+     * Final URL (after proxy if applied).
+     */
+    url: string;
+    /**
+     * Served from inflight/error cache.
+     */
+    fromCache: boolean;
+    /**
+     * Best-effort MIME (blob/dataURL modes).
+     */
+    mime?: string | undefined;
+    /**
+     * Failure reason (e.g., 'http_error','timeout','abort','network').
+     */
+    reason?: string | undefined;
+};

package/types/snapdom/src/modules/styles.d.ts

@@ -1 +1,2 @@
-export function inlineAllStyles(source: any, clone: any, styleMap: any, cache: any, compress: any): void;
+export function notifyStyleEpoch(): void;
+export function inlineAllStyles(source: any, clone: any, sessionOrCtx: any, opts: any): Promise<void>;

package/types/snapdom/src/utils/browser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a promise that resolves after the specified delay
+ * @param {number} [ms=0] - Milliseconds to delay
+ * @returns {Promise<void>} Promise that resolves after the delay
+ */
+export function idle(fn: any, { fast }?: {
+    fast?: boolean | undefined;
+}): Promise<void>;
+/**
+ * Detecta Safari real + Safari en iOS WebView (UIWebView/WKWebView) + variantes WeChat.
+ */
+export function isSafari(): boolean;

package/types/snapdom/src/utils/css.d.ts

@@ -0,0 +1,68 @@
+export function precacheCommonTags(): void;
+export function getDefaultStyleForTag(tagName: any): any;
+/**
+ * Returns true if a CSS property should be ignored because it does not affect
+ * the static pixel output of a frame capture.
+ * - Matches prefixes (fast path) and tokens (e.g., “...-animation-...”).
+ * - Skips a curated set of exact property names.
+ * @param {string} prop
+ * @returns {boolean}
+ */
+export function shouldIgnoreProp(prop: string): boolean;
+/**
+ * Builds a style key from a snapshot; returns "" for tags in NO_DEFAULTS_TAGS.
+ * @param {Record<string,string>} snapshot
+ * @param {string} tagName
+ */
+export function getStyleKey(snapshot: Record<string, string>, tagName: string): string;
+/**
+ * Collects all unique tag names used in the DOM tree rooted at the given node.
+ *
+ * @param {Node} root - The root node to search
+ * @returns {string[]} Array of unique tag names
+ */
+export function collectUsedTagNames(root: Node): string[];
+/**
+ * Generates deduplicated base CSS for the given tag names.
+ *
+ * @param {string[]} usedTagNames - Array of tag names
+ * @returns {string} CSS string
+ */
+export function generateDedupedBaseCSS(usedTagNames: string[]): string;
+/**
+ * Generates CSS classes from a style map.
+ *
+ * @returns {Map} Map of style keys to class names
+ */
+export function generateCSSClasses(styleMap: any): Map<any, any>;
+/**
+ * Gets the computed style for an element or pseudo-element, with caching.
+ *
+ * @param {Element} el - The element
+ * @param {string|null} [pseudo=null] - The pseudo-element
+ * @returns {CSSStyleDeclaration} The computed style
+ */
+export function getStyle(el: Element, pseudo?: string | null): CSSStyleDeclaration;
+/**
+ * Parses the CSS content property value, handling unicode escapes.
+ *
+ * @param {string} content - The CSS content value
+ * @returns {string} The parsed content
+ */
+export function parseContent(content: string): string;
+/**
+ * @export
+ * @param {CSSStyleDeclaration} style
+ * @return {Record<string,string>}
+ */
+export function snapshotComputedStyle(style: CSSStyleDeclaration): Record<string, string>;
+/**
+ * @export
+ * @param {string} bg
+ * @return {string[]}
+ */
+export function splitBackgroundImage(bg: string): string[];
+/** Tags that Snapdom must never capture (skip node + subtree). */
+export const NO_CAPTURE_TAGS: Set<string>;
+/** Tags that must not generate default styles nor auto-classes. */
+export const NO_DEFAULTS_TAGS: Set<string>;

package/types/snapdom/src/utils/helpers.d.ts

@@ -1,39 +1,3 @@
-/**
- * Fetches and inlines a single background-image entry to a data URL (with caching).
- * - If entry is a gradient or "none", returns unchanged.
- * - If entry is a url(...), fetches the image as data URL and caches it.
- *
- * @param {string} entry - Single background-image entry (e.g., "url(...)").
- * @param {Object} [options={}] - Options like crossOrigin.
- * @param {boolean} [options.skipInline=false] - If true, only fetches & caches, doesn't return a replacement.
- * @returns {Promise<string|void>} - The processed entry (unless skipInline is true).
- */
-export function inlineSingleBackgroundEntry(entry: string, options?: {
-    skipInline?: boolean | undefined;
-}): Promise<string | void>;
-/**
- * Creates a promise that resolves after the specified delay
- * @param {number} [ms=0] - Milliseconds to delay
- * @returns {Promise<void>} Promise that resolves after the delay
- */
-export function idle(fn: any, { fast }?: {
-    fast?: boolean | undefined;
-}): Promise<void>;
-/**
- * Gets the computed style for an element or pseudo-element, with caching.
- *
- * @param {Element} el - The element
- * @param {string|null} [pseudo=null] - The pseudo-element
- * @returns {CSSStyleDeclaration} The computed style
- */
-export function getStyle(el: Element, pseudo?: string | null): CSSStyleDeclaration;
-/**
- * Parses the CSS content property value, handling unicode escapes.
- *
- * @param {string} content - The CSS content value
- * @returns {string} The parsed content
- */
-export function parseContent(content: string): string;
 /**
  * Extracts a URL from a CSS value like background-image.
  *
@@ -48,30 +12,5 @@ export function extractURL(value: string): string | null;
  * @returns {boolean} True if it is an icon font
  */
 export function isIconFont(familyOrUrl: string): boolean;
-/**
- * Fetch a resource with optional proxy fallback.
- * @param {string} url - Resource URL
- * @param {Object} [options]
- * @param {string} [options.useProxy=''] - Proxy prefix
- * @returns {Promise<Response>} The fetched response
- */
-export function fetchResource(url: string, { useProxy }?: {
-    useProxy?: string | undefined;
-}): Promise<Response>;
-export function fetchImage(src: any, { timeout, useProxy, errorTTL }?: {
-    timeout?: number | undefined;
-    useProxy?: string | undefined;
-    errorTTL?: number | undefined;
-}): any;
-/**
- *
- *
- * @export
- * @param {*} style
- * @return {*}
- */
-export function snapshotComputedStyle(style: any): any;
-export function isSafari(): boolean;
 export function stripTranslate(transform: any): any;
 export function safeEncodeURI(uri: any): any;
-export function splitBackgroundImage(bg: any): any[];

package/types/snapdom/src/utils/image.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Adds a background color to the canvas if specified.
+ * @param {HTMLCanvasElement} baseCanvas - Source canvas element.
+ * @param {string} backgroundColor - CSS color string for the background.
+ * @returns {HTMLCanvasElement} Returns the original canvas if no background needed,
+ * or a new canvas with the background applied.
+ */
+export function createBackground(baseCanvas: HTMLCanvasElement, backgroundColor: string): HTMLCanvasElement;
+/**
+ * Inline a single background-image entry (one layer) robustly.
+ * - If it's a URL() and fetching fails, degrade to "none" instead of throwing.
+ * - Gradients and "none" are returned untouched.
+ * - Uses cache.background to avoid repeated work.
+ *
+ * @param {string} entry - A single background layer (e.g., 'url("...")', 'linear-gradient(...)', 'none')
+ * @param {{ useProxy?: string }} [options]
+ * @returns {Promise<string|undefined>} Inlined CSS value for this layer (e.g., `url("data:...")`), original entry, or "none".
+ */
+export function inlineSingleBackgroundEntry(entry: string, options?: {
+    useProxy?: string;
+}): Promise<string | undefined>;

package/types/snapdom/src/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { idle, isSafari } from "./browser.js";
+export { collectUsedTagNames, generateCSSClasses, generateDedupedBaseCSS, getDefaultStyleForTag, getStyle, getStyleKey, NO_CAPTURE_TAGS, NO_DEFAULTS_TAGS, parseContent, precacheCommonTags, snapshotComputedStyle, splitBackgroundImage } from "./css.js";
+export { extractURL, isIconFont, safeEncodeURI, stripTranslate } from "./helpers.js";
+export { createBackground, inlineSingleBackgroundEntry } from "./image.js";

package/types/tinycolor/src/public_api.d.ts

@@ -7,4 +7,4 @@ export * from './interfaces.js';
 export * from './random.js';
 export * from './readability.js';
 export * from './to-ms-filter.js';
-export * from './util.js';
+export * from './utils.js';

package/types/tree/index.d.ts

@@ -1,9 +1,9 @@
+export default getItemBy;
+export { default as searchTree } from "./search";
 export function findNodeBy(root: any, key: any, value: any, childrenKey?: string): any;
-export function getItemBy(root: any, key: any, value: any, childrenKey?: string): any;
-export function getItemBy3(root: any, key: any, value: any, childrenKey?: string): any;
-export function getItemByID(root: any, value: any): any;
-export function getLabelFromDictionaryByValue(a: any, value: any, 保底?: boolean): any;
 export function getChildWithParentBy(root: any, key: any, value: any, childrenKey?: string): null | undefined;
+export function getItemBy(root: any, key: any, value: any, childrenKey?: string, strict?: boolean): any;
 export function getItemBy2(root: any, key: any, value: any, childrenKey?: string): any;
-export default getItemBy;
-export { default as searchTree } from "./search";
+export function getItemByID(root: any, value: any): any;
+export function getLabelFromDictionaryByValue(a: any, value: any, 保底?: boolean): any;
+export { findNodeBy as getItemBy3 };

package/ui-color/compareColorByRange.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 function i(r = [34797, 15747172]) {
   return (n = 1) => {
     const o = r, t = Math.log(256) / Math.log(2), e = o[0] >>> t * 2 & 255, g = o[0] >>> t * 1 & 255, l = o[0] >>> t * 0 & 255, c = o[1] >>> t * 2 & 255, s = o[1] >>> t * 1 & 255, f = o[1] >>> t * 0 & 255, a = c - (c - e) * n, b = s - (s - g) * n, h = f - (f - l) * n;

package/ui-color/index.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 import { TinyColor as e } from "../tinycolor/src/index.js";
 import { default as Q } from "./compareColorByRange.js";
 const c = 10, f = {

package/uiColor.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 import "./tinycolor/src/index.js";
 import { default as o } from "./ui-color/compareColorByRange.js";
 import { LENGTH as t, PRIMARY_COLOR_KEY_MAPPING as p, blue as g, colorPresets as n, colors as m, cyan as s, generate as y, generateDark as P, gold as c, gray as d, grayPresets as i, green as u, lime as R, magenta as f, orange as k, orangered as _, palette as x, paletteDark as A, pinkpurple as C, primary as D, purple as E, red as G, yellow as I } from "./ui-color/index.js";

package/url-toolkit/index.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 import { buildAbsoluteURL as e, buildURLFromParts as l, default as o, normalizePath as t, parseURL as u } from "./src/url-toolkit.js";
 export {
   e as buildAbsoluteURL,

package/url-toolkit/src/url-toolkit.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 const l = /^(?=((?:[a-zA-Z0-9+\-.]+:)?))\1(?=((?:\/\/[^\/?#]*)?))\2(?=((?:(?:[^?#\/]*\/)*[^;?#\/]*)?))\3((?:;[^?#]*)?)(\?[^#]*)?(#[^]*)?$/, p = /^(?=([^\/?#]*))\1([^]*)$/, f = /(?:\/|^)\.(?=\/)/g, m = /(?:\/|^)\.\.\/(?!\.\.\/)[^\/]*(?=\/)/g;
 function E(r, a, s) {
   if (s = s || {}, r = r.trim(), a = a.trim(), !a) {

package/urlToolkit.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 import { buildAbsoluteURL as e, buildURLFromParts as l, default as o, normalizePath as t, parseURL as u } from "./url-toolkit/src/url-toolkit.js";
 export {
   e as buildAbsoluteURL,

package/version/index.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 const t = "0.0.0";
 export {
   t as VERSION,

package/version.js

@@ -1,3 +1,4 @@
+/* 2025-10-28 09:57:10 */
 import { VERSION as f, VERSION as o } from "./version/index.js";
 export {
   f as VERSION,

package/filesize/index.js

@@ -1,8 +0,0 @@
-import * as s from "./src/constants.js";
-import { filesize as a, filesize as i, partial as o } from "./src/filesize.js";
-export {
-  a as default,
-  i as filesize,
-  s as filesizeConstants,
-  o as partial
-};

package/filesize/src/constants.js

@@ -1,71 +0,0 @@
-const t = "Invalid number", i = "Invalid rounding method", b = "iec", o = "jedec", n = "si", s = "bit", c = "bits", e = "byte", B = "bytes", E = "kbit", I = "kB", T = "array", a = "function", N = "object", S = "string", r = "exponent", R = "round", Y = "", d = ".", y = "s", P = " ", O = "0", g = {
-  symbol: {
-    iec: {
-      bits: [
-        "bit",
-        "Kibit",
-        "Mibit",
-        "Gibit",
-        "Tibit",
-        "Pibit",
-        "Eibit",
-        "Zibit",
-        "Yibit"
-      ],
-      bytes: ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
-    },
-    jedec: {
-      bits: [
-        "bit",
-        "Kbit",
-        "Mbit",
-        "Gbit",
-        "Tbit",
-        "Pbit",
-        "Ebit",
-        "Zbit",
-        "Ybit"
-      ],
-      bytes: ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
-    }
-  },
-  fullform: {
-    iec: ["", "kibi", "mebi", "gibi", "tebi", "pebi", "exbi", "zebi", "yobi"],
-    jedec: [
-      "",
-      "kilo",
-      "mega",
-      "giga",
-      "tera",
-      "peta",
-      "exa",
-      "zetta",
-      "yotta"
-    ]
-  }
-};
-export {
-  T as ARRAY,
-  s as BIT,
-  c as BITS,
-  e as BYTE,
-  B as BYTES,
-  Y as EMPTY,
-  r as EXPONENT,
-  a as FUNCTION,
-  b as IEC,
-  t as INVALID_NUMBER,
-  i as INVALID_ROUND,
-  o as JEDEC,
-  N as OBJECT,
-  d as PERIOD,
-  R as ROUND,
-  y as S,
-  n as SI,
-  E as SI_KBIT,
-  I as SI_KBYTE,
-  P as SPACE,
-  S as STRING,
-  g as STRINGS,
-  O as ZERO
-};