@unicom-cloud/utils 0.1.5 → 0.1.11

package/types/normalize-wheel/index.d.ts

@@ -0,0 +1,115 @@
+export default normalizeWheel;
+/**
+ * Mouse wheel (and 2-finger trackpad) support on the web sucks.  It is
+ * complicated, thus this doc is long and (hopefully) detailed enough to answer
+ * your questions.
+ *
+ * If you need to react to the mouse wheel in a predictable way, this code is
+ * like your bestest friend. * hugs *
+ *
+ * As of today, there are 4 DOM event types you can listen to:
+ *
+ *   'wheel'                -- Chrome(31+), FF(17+), IE(9+)
+ *   'mousewheel'           -- Chrome, IE(6+), Opera, Safari
+ *   'MozMousePixelScroll'  -- FF(3.5 only!) (2010-2013) -- don't bother!
+ *   'DOMMouseScroll'       -- FF(0.9.7+) since 2003
+ *
+ * So what to do?  The is the best:
+ *
+ *   normalizeWheel.getEventType();
+ *
+ * In your event callback, use this code to get sane interpretation of the
+ * deltas.  This code will return an object with properties:
+ *
+ *   spinX   -- normalized spin speed (use for zoom) - x plane
+ *   spinY   -- " - y plane
+ *   pixelX  -- normalized distance (to pixels) - x plane
+ *   pixelY  -- " - y plane
+ *
+ * Wheel values are provided by the browser assuming you are using the wheel to
+ * scroll a web page by a number of lines or pixels (or pages).  Values can vary
+ * significantly on different platforms and browsers, forgetting that you can
+ * scroll at different speeds.  Some devices (like trackpads) emit more events
+ * at smaller increments with fine granularity, and some emit massive jumps with
+ * linear speed or acceleration.
+ *
+ * This code does its best to normalize the deltas for you:
+ *
+ *   - spin is trying to normalize how far the wheel was spun (or trackpad
+ *     dragged).  This is super useful for zoom support where you want to
+ *     throw away the chunky scroll steps on the PC and make those equal to
+ *     the slow and smooth tiny steps on the Mac. Key data: This code tries to
+ *     resolve a single slow step on a wheel to 1.
+ *
+ *   - pixel is normalizing the desired scroll delta in pixel units.  You'll
+ *     get the crazy differences between browsers, but at least it'll be in
+ *     pixels!
+ *
+ *   - positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT.  This
+ *     should translate to positive value zooming IN, negative zooming OUT.
+ *     This matches the newer 'wheel' event.
+ *
+ * Why are there spinX, spinY (or pixels)?
+ *
+ *   - spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn
+ *     with a mouse.  It results in side-scrolling in the browser by default.
+ *
+ *   - spinY is what you expect -- it's the classic axis of a mouse wheel.
+ *
+ *   - I dropped spinZ/pixelZ.  It is supported by the DOM 3 'wheel' event and
+ *     probably is by browsers in conjunction with fancy 3D controllers .. but
+ *     you know.
+ *
+ * Implementation info:
+ *
+ * Examples of 'wheel' event if you scroll slowly (down) by one step with an
+ * average mouse:
+ *
+ *   OS X + Chrome  (mouse)     -    4   pixel delta  (wheelDelta -120)
+ *   OS X + Safari  (mouse)     -  N/A   pixel delta  (wheelDelta  -12)
+ *   OS X + Firefox (mouse)     -    0.1 line  delta  (wheelDelta  N/A)
+ *   Win8 + Chrome  (mouse)     -  100   pixel delta  (wheelDelta -120)
+ *   Win8 + Firefox (mouse)     -    3   line  delta  (wheelDelta -120)
+ *
+ * On the trackpad:
+ *
+ *   OS X + Chrome  (trackpad)  -    2   pixel delta  (wheelDelta   -6)
+ *   OS X + Firefox (trackpad)  -    1   pixel delta  (wheelDelta  N/A)
+ *
+ * On other/older browsers.. it's more complicated as there can be multiple and
+ * also missing delta values.
+ *
+ * The 'wheel' event is more standard:
+ *
+ * http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
+ *
+ * The basics is that it includes a unit, deltaMode (pixels, lines, pages), and
+ * deltaX, deltaY and deltaZ.  Some browsers provide other values to maintain
+ * backward compatibility with older events.  Those other values help us
+ * better normalize spin speed.  Example of what the browsers provide:
+ *
+ *                          | event.wheelDelta | event.detail
+ *        ------------------+------------------+--------------
+ *          Safari v5/OS X  |       -120       |       0
+ *          Safari v5/Win7  |       -120       |       0
+ *         Chrome v17/OS X  |       -120       |       0
+ *         Chrome v17/Win7  |       -120       |       0
+ *                IE9/Win7  |       -120       |   undefined
+ *         Firefox v4/OS X  |     undefined    |       1
+ *         Firefox v4/Win7  |     undefined    |       3
+ *
+ */
+declare function normalizeWheel(event: any): {
+    spinX: number;
+    spinY: number;
+    pixelX: number;
+    pixelY: number;
+};
+declare namespace normalizeWheel {
+    /**
+     * The best combination if you prefer spinX + spinY normalization.  It favors
+     * the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with
+     * 'wheel' event, making spin speed determination impossible.
+     */
+    function getEventType(): "wheel" | "DOMMouseScroll" | "mousewheel";
+}

package/types/normalize-wheel/isEventSupported.d.ts

@@ -0,0 +1,16 @@
+export default isEventSupported;
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @param {?boolean} capture Check if the capture phase is supported.
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+declare function isEventSupported(eventNameSuffix: string, capture: boolean | null): boolean;

package/types/number-to-chinese/index.d.ts

@@ -0,0 +1,11 @@
+interface NumberToChineseOptions {
+    mode?: 'normal' | 'money';
+    negativeSymbol?: string;
+    decimalDigits?: number;
+    trailingZeros?: boolean;
+}
+/**
+ * 数字转中文主函数
+ */
+declare function numberToChinese(num: number, options?: NumberToChineseOptions): string;
+export default numberToChinese;

package/types/nzh/cn.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    encodeS: (num: any, options: any) => string;
+    encodeB: (num: any, options: any) => string;
+    decodeS: (...args: any[]) => string | number;
+    decodeB: (...args: any[]) => string | number;
+    toMoney: (num: any, options: any) => string;
+};
+export default _default;

package/types/nzh/hk.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    encodeS: (num: any, options: any) => string;
+    encodeB: (num: any, options: any) => string;
+    decodeS: (...args: any[]) => string | number;
+    decodeB: (...args: any[]) => string | number;
+    toMoney: (num: any, options: any) => string;
+};
+export default _default;

package/types/nzh/index.d.ts

@@ -0,0 +1 @@
+export {};

package/types/nzh/nzh.d.ts

@@ -0,0 +1,36 @@
+export default Nzh;
+declare function Nzh(lang: any): void;
+declare class Nzh {
+    constructor(lang: any);
+    lang: any;
+    encode: (...args: any[]) => string;
+    decode: (...args: any[]) => string | number;
+    toMoney: (...args: any[]) => string;
+}
+declare namespace Nzh {
+    export { langs };
+    export let cn: {
+        encodeS: (num: any, options: any) => string;
+        encodeB: (num: any, options: any) => string;
+        decodeS: (...args: any[]) => string | number;
+        decodeB: (...args: any[]) => string | number;
+        toMoney: (num: any, options: any) => string;
+    };
+    export let hk: {
+        encodeS: (num: any, options: any) => string;
+        encodeB: (num: any, options: any) => string;
+        decodeS: (...args: any[]) => string | number;
+        decodeB: (...args: any[]) => string | number;
+        toMoney: (num: any, options: any) => string;
+    };
+}
+declare namespace langs {
+    export { cn_s as s };
+    export { cn_b as b };
+    export { hk_s };
+    export { hk_b };
+}
+import cn_s from './src/langs/cn_s';
+import cn_b from './src/langs/cn_b';
+import hk_s from './src/langs/hk_s';
+import hk_b from './src/langs/hk_b';

package/types/nzh/src/autoGet.d.ts

@@ -0,0 +1,8 @@
+export function getNzhObjByLang(lang_s: any, lang_b: any): {
+    encodeS: (num: any, options: any) => string;
+    encodeB: (num: any, options: any) => string;
+    decodeS: (...args: any[]) => string | number;
+    decodeB: (...args: any[]) => string | number;
+    toMoney: (num: any, options: any) => string;
+};
+export default getNzhObjByLang;

package/types/nzh/src/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 阿拉伯数字转中文数字
+ *
+ * @param {String} num 阿拉伯数字/字符串 , 科学记数法字符串
+ * @param {Object} opration 转换配置
+ *                          {
+ *                              ww: {万万化单位 | false}
+ *                              tenMin: {十的口语化 | false}
+ *                          }
+ * @returns String
+ */
+export function CL(num: string, options: any): string;
+/**
+ * 中文数字转阿拉伯数字
+ *
+ * @param {string} cnnumb 中文数字字符串
+ * @returns Number
+ */
+export function unCL(cnnumb: string, options: any): string | number;
+/**
+ * 阿拉伯数字转金额
+ *
+ * @param {String} num 阿拉伯数字/字符串 , 科学记数法字符串
+ * @param {Object} options 转换配置
+ *                         {
+ *                             ww:{万万化开关 | true},
+ *                             unOmitYuan: {整数为0时不省略元| false},
+ *                             complete:{完整金额格式 | false},
+ *                             outSymbol:{是否输出金额符号 | true}
+ *                             forceZheng:{以转换结果加“整” | false}
+ *                         }
+ * @returns String
+ */
+export function toMoney(num: string, options: Object): string;

package/types/nzh/src/langs/cn_b.d.ts

@@ -0,0 +1,10 @@
+export default cn_b;
+declare namespace cn_b {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+    let m_t: string;
+    let m_z: string;
+    let m_u: string;
+}

package/types/nzh/src/langs/cn_s.d.ts

@@ -0,0 +1,7 @@
+export default cn_s;
+declare namespace cn_s {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+}

package/types/nzh/src/langs/hk_b.d.ts

@@ -0,0 +1,10 @@
+export default hk_b;
+declare namespace hk_b {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+    let m_t: string;
+    let m_z: string;
+    let m_u: string;
+}

package/types/nzh/src/langs/hk_s.d.ts

@@ -0,0 +1,7 @@
+export default hk_s;
+declare namespace hk_s {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+}

package/types/nzh/src/utils.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 科学计数法转十进制
+ *
+ * @param {string} num 科学记数法字符串
+ * @returns string
+ */
+export function e2ten(num: string): string;
+/**
+ * 分析数字字符串
+ *
+ * @param {string} num NumberString
+ * @returns object
+ */
+export function getNumbResult(num: string): {
+    int: string;
+    decimal: string;
+    minus: boolean;
+    num: string;
+} | undefined;
+/**
+ * 数组归一 (按索引覆盖合并数组,并清空被合并的数组)
+ *
+ * @param {array} baseArray 基础数组
+ * @param {...array} array1
+ * @returns array
+ */
+export function centerArray(baseArray: array, ...args: array[]): array;
+/**
+ * 检查对像属性 (非原型链)
+ *
+ * @param {object} obj
+ * @param {string} key
+ * @returns
+ */
+export function hasAttr(obj: object, key: string): boolean;
+/**
+ * 扩展对像(浅复制)
+ *
+ * @param {object} obj
+ * @param {object} obj1
+ * @returns
+ */
+export function extend(obj: object, ...args: any[]): any;
+/**
+ * 获取真实数位
+ *
+ * @param {number} index 中文单位的索引
+ */
+export function getDigit(index: number): number;
+/**
+ * 往数组头部插入0
+ *
+ * @param {array} arr
+ * @param {number} n
+ */
+export function unshiftZero(arr: array, n: number): void;
+/**
+ * 清理多余"零"
+ *
+ * @param {any} str
+ * @param {any} zero "零"字符
+ * @param {any} type 清理模式 ^ - 开头, $ - 结尾, nto1 - 多个连续变一个
+ * @returns
+ */
+export function clearZero(str: any, zero: any, type: any): any;

package/types/object-keys-sort/index.d.ts

@@ -0,0 +1,4 @@
+export default objectKeysSort;
+declare function objectKeysSort(params: any): {
+    [k: string]: any;
+};

package/types/random/address.d.ts

@@ -0,0 +1,8 @@
+export default address;
+declare namespace address {
+    function region(): string | undefined;
+    function province(): string;
+    function city(prefix: any): string;
+    function county(prefix: any): string;
+    function zip(len: any): string;
+}

package/types/random/constellation.d.ts

@@ -0,0 +1,2 @@
+export default constellation;
+declare function constellation(): string | undefined;

package/types/random/image.d.ts

@@ -0,0 +1,5 @@
+export function generateImageDataURL(params?: {}): string;
+export default image;
+declare namespace image {
+    export { generateImageDataURL };
+}

package/types/random/index.d.ts

@@ -0,0 +1,40 @@
+declare namespace _default {
+    export { number };
+    export let natural: (min?: number, max?: number) => number;
+    export let integer: (min?: number, max?: number) => number;
+    export let float: (min: any, max: any) => number;
+    export function boolean(): boolean;
+    export function sex(): string;
+    export { sample as pick };
+    export { text };
+    export let ctitle: (min: any, max: any) => string;
+    export let cparagraph: (min: any, max: any) => string;
+    export let csentence: (min: any, max: any) => string;
+    export let cword: (pool: any, min: any, max: any, ...args: any[]) => string;
+    export { name };
+    export let cname: () => string;
+    export { web };
+    export let phone: () => string;
+    export { address };
+    export function county(p: any): string;
+    export function company(): string;
+    export function project(): string;
+    export { time };
+    export { constellation };
+    export { licensePlate };
+    export function uuid(): string;
+    export function id(): number;
+    export function increment(step: any): number;
+    export { image };
+}
+export default _default;
+import number from './number';
+import sample from 'lodash/sample';
+import text from './text';
+import name from './name';
+import web from './web';
+import address from './address';
+import time from './time';
+import constellation from './constellation';
+import licensePlate from './licensePlate';
+import image from './image';

package/types/random/licensePlate.d.ts

@@ -0,0 +1,2 @@
+export default licensePlate;
+declare function licensePlate(): string;

package/types/random/name.d.ts

@@ -0,0 +1,9 @@
+export default name;
+declare namespace name {
+    function first(): string | undefined;
+    function last(): string | undefined;
+    function name(middle: any): string;
+    function cfirst(): string | undefined;
+    function clast(): string | undefined;
+    function cname(): string;
+}

package/types/random/number.d.ts

@@ -0,0 +1,6 @@
+export default number;
+declare namespace number {
+    function natural(min?: number, max?: number): number;
+    function integer(min?: number, max?: number): number;
+    function float(min: any, max: any): number;
+}

package/types/random/text.d.ts

@@ -0,0 +1,13 @@
+export default text;
+declare namespace text {
+    function paragraph(min: any, max: any): string;
+    function cparagraph(min: any, max: any): string;
+    function sentence(min: any, max: any): string;
+    function csentence(min: any, max: any): string;
+    function word(min: any, max: any): string;
+    function cword(pool: any, min: any, max: any, ...args: any[]): string;
+    function title(min: any, max: any): string;
+    function ctitle(min: any, max: any): string;
+    function character(pool: any): any;
+    function string(pool: any, min: any, max: any, ...args: any[]): string;
+}

package/types/random/time.d.ts

@@ -0,0 +1,2 @@
+export default time;
+declare function time(a: any, b: any): string;

package/types/random/web.d.ts

@@ -0,0 +1,11 @@
+export default web;
+declare namespace web {
+    function url(v: any, host: any): string;
+    function protocol(): string | undefined;
+    function domain(v: any): string;
+    function tld(): string | undefined;
+    function email(domain: any): string;
+    function phone(): string;
+    function ip(): string;
+    function port(): number;
+}

package/types/screenfull/index.d.ts

@@ -0,0 +1,10 @@
+export default screenfull;
+declare namespace screenfull {
+    export function request(element: HTMLElement | undefined, options: any): Promise<any>;
+    export function exit(): Promise<any>;
+    export function toggle(element: any, options: any): any;
+    export function on(event: any, callback: any): void;
+    export function off(event: any, callback: any): void;
+    export { nativeAPI as raw };
+}
+declare const nativeAPI: {};

package/types/search-tree/index.d.ts

@@ -0,0 +1,20 @@
+type Primitive = string | number | boolean | symbol | null | undefined;
+type ConditionValue<T = unknown> = Primitive | ((value: T) => boolean) | RegExp;
+interface SearchOptions {
+    strategy?: 'BFS' | 'DFS';
+    childrenKey?: string;
+    strict?: boolean;
+}
+interface TreeNode {
+    [key: string]: unknown;
+    children?: TreeNode[];
+}
+/**
+ * 非递归树搜索算法
+ * @param {TreeNode[]} treeData - 树数据
+ * @param {Record<string, ConditionValue>} searchCondition - 搜索条件对象
+ * @param {SearchOptions} [options={}] - 配置选项
+ * @returns {TreeNode | null} 找到的节点或null
+ */
+declare function searchTree(treeData: TreeNode[], searchCondition: Record<string, ConditionValue>, options?: SearchOptions): TreeNode | null;
+export default searchTree;

package/types/snapdom/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/types/snapdom/src/api/preCache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Preloads images, background images, and optionally fonts into cache before DOM capture.
+ *
+ * @param {Document|Element} [root=document] - The root node to search for resources
+ * @param {Object} [options={}] - Pre-caching options
+ * @returns {Promise<void>} Resolves when all resources are pre-cached
+ */
+export function preCache(root?: Document | Element, options?: Object): Promise<void>;

package/types/snapdom/src/api/snapdom.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Main entry point: captures a DOM element and returns an object with export methods.
+ *
+ * @param {Element} element - DOM element to capture
+ * @param {Object} [options={}] - Capture options
+ * @returns {Promise<Object>} Object with export methods (toRaw, toImg, toCanvas, etc.)
+ */
+export function snapdom(element: Element, options?: Object): Promise<Object>;
+export namespace snapdom {
+    /**
+     * Captures a DOM element and returns an object with export methods (internal use).
+     *
+     * @param {Element} el - DOM element to capture
+     * @param {Object} [options={}] - Capture options
+     * @returns {Promise<Object>} Object with export methods
+     */
+    function capture(el: Element, options?: Object): Promise<Object>;
+    function toRaw(el: any, options: any): Promise<any>;
+    function toImg(el: any, options: any): Promise<any>;
+    function toCanvas(el: any, options: any): Promise<any>;
+    function toBlob(el: any, options: any): Promise<any>;
+    function toPng(el: any, options: any): Promise<any>;
+    function toJpg(el: any, options: any): Promise<any>;
+    function toWebp(el: any, options: any): Promise<any>;
+    function download(el: any, options?: {}): Promise<any>;
+}

package/types/snapdom/src/core/cache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Caches for images, backgrounds, resources, and computed styles used during DOM capture.
+ * @module cache
+ */
+export const imageCache: Map<any, any>;
+export const bgCache: Map<any, any>;
+export const resourceCache: Map<any, any>;
+export const defaultStylesCache: Map<any, any>;
+export const baseCSSCache: Map<any, any>;
+export const computedStyleCache: WeakMap<WeakKey, any>;
+export const processedFontURLs: Set<any>;

package/types/snapdom/src/core/capture.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Captures an HTML element as an SVG data URL, inlining styles, images, backgrounds, and optionally fonts.
+ *
+ * @param {Element} element - DOM element to capture
+ * @param {Object} [options={}] - Capture options
+ * @param {boolean} [options.compress=true] - Whether to compress style keys
+ * @param {boolean} [options.embedFonts=false] - Whether to embed custom fonts
+ * @param {boolean} [options.fast=true] - Whether to skip idle delay for faster results
+ * @param {number} [options.scale=1] - Output scale multiplier
+ * @returns {Promise<string>} Promise that resolves to an SVG data URL
+ */
+export function captureDOM(element: Element, options?: {
+    compress?: boolean | undefined;
+    embedFonts?: boolean | undefined;
+    fast?: boolean | undefined;
+    scale?: number | undefined;
+}): Promise<string>;

package/types/snapdom/src/core/clone.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a deep clone of a DOM node, including styles, shadow DOM, and special handling for excluded/placeholder/canvas nodes.
+ *
+ * @param {Node} node - Node to clone
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {WeakMap} nodeMap - Map to track original-to-clone node relationships
+ * @param {boolean} compress - Whether to compress style keys
+ * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes
+ */
+export function deepClone(node: Node, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, nodeMap: WeakMap<any, any>, compress: boolean): Node | null;

package/types/snapdom/src/core/prepare.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prepares a clone of an element for capture, inlining pseudo-elements and generating CSS classes.
+ *
+ * @param {Element} element - Element to clone
+ * @param {boolean} [compress=false] - Whether to compress style keys
+ * @returns {Promise<Object>} Object containing the clone, generated CSS, and style cache
+ */
+export function prepareClone(element: Element, compress?: boolean, embedFonts?: boolean): Promise<Object>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export { preCache } from "./api/preCache.js";
+export { snapdom } from "./api/snapdom.js";

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

@@ -0,0 +1,10 @@
+/**
+ * Converts all background images in the cloned element tree to data URLs.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {Object} [options={}] - Options for image processing
+ * @returns {Promise<void>} Promise that resolves when all background images are processed
+ */
+export function inlineBackgroundImages(source: Element, clone: Element, styleCache: WeakMap<any, any>, options?: Object): Promise<void>;

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

@@ -0,0 +1,25 @@
+/**
+ * Converts a unicode character from an icon font into a data URL image.
+ *
+ * @export
+ * @param {string} unicodeChar - The unicode character to render
+ * @param {string} fontFamily - The font family name
+ * @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
+ */
+export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight: string | number, fontSize?: number, color?: string): Promise<string>;
+/**
+ * Embeds custom fonts found in the document as data URLs in CSS.
+ *
+ * @export
+ * @param {Object} options
+ * @param {boolean} [options.ignoreIconFonts=true] - Whether to skip icon fonts
+ * @param {boolean} [options.preCached=false] - Whether to use pre-cached resources
+ * @returns {Promise<string>} The inlined CSS for custom fonts
+ */
+export function embedCustomFonts({ ignoreIconFonts, preCached, }?: {
+    ignoreIconFonts?: boolean | undefined;
+    preCached?: boolean | undefined;
+}): Promise<string>;