@unicom-cloud/utils 0.1.24 → 0.1.26

package/types/axios/lib/utils.d.ts

@@ -0,0 +1,289 @@
+declare namespace _default {
+    export { isArray };
+    export { isArrayBuffer };
+    export { isBuffer };
+    export { isFormData };
+    export { isArrayBufferView };
+    export { isString };
+    export { isNumber };
+    export { isBoolean };
+    export { isObject };
+    export { isPlainObject };
+    export { isEmptyObject };
+    export { isReadableStream };
+    export { isRequest };
+    export { isResponse };
+    export { isHeaders };
+    export { isUndefined };
+    export { isDate };
+    export { isFile };
+    export { isBlob };
+    export { isRegExp };
+    export { isFunction };
+    export { isStream };
+    export { isURLSearchParams };
+    export { isTypedArray };
+    export { isFileList };
+    export { forEach };
+    export { merge };
+    export { extend };
+    export { trim };
+    export { stripBOM };
+    export { inherits };
+    export { toFlatObject };
+    export { kindOf };
+    export { kindOfTest };
+    export { endsWith };
+    export { toArray };
+    export { forEachEntry };
+    export { matchAll };
+    export { isHTMLForm };
+    export { hasOwnProperty };
+    export { hasOwnProperty as hasOwnProp };
+    export { reduceDescriptors };
+    export { freezeMethods };
+    export { toObjectSet };
+    export { toCamelCase };
+    export { noop };
+    export { toFiniteNumber };
+    export { findKey };
+    export { _global as global };
+    export { isContextDefined };
+    export { isSpecCompliantForm };
+    export { toJSONObject };
+    export { isAsyncFn };
+    export { isThenable };
+    export { _setImmediate as setImmediate };
+    export { asap };
+    export { isIterable };
+}
+export default _default;
+declare const isArray: (arg: any) => arg is any[];
+declare function isArrayBuffer(thing: any): boolean;
+/**
+ * Determine if a value is a Buffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Buffer, otherwise false
+ */
+declare function isBuffer(val: any): boolean;
+/**
+ * Determine if a value is a FormData
+ *
+ * @param {*} thing The value to test
+ *
+ * @returns {boolean} True if value is an FormData, otherwise false
+ */
+declare function isFormData(thing: any): boolean;
+/**
+ * Determine if a value is a view on an ArrayBuffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
+ */
+declare function isArrayBufferView(val: any): boolean;
+declare function isString(thing: any): boolean;
+declare function isNumber(thing: any): boolean;
+/**
+ * Determine if a value is a Boolean
+ *
+ * @param {*} thing The value to test
+ * @returns {boolean} True if value is a Boolean, otherwise false
+ */
+declare function isBoolean(thing: any): boolean;
+/**
+ * Determine if a value is an Object
+ *
+ * @param {*} thing The value to test
+ *
+ * @returns {boolean} True if value is an Object, otherwise false
+ */
+declare function isObject(thing: any): boolean;
+/**
+ * Determine if a value is a plain Object
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a plain Object, otherwise false
+ */
+declare function isPlainObject(val: any): boolean;
+/**
+ * Determine if a value is an empty object (safely handles Buffers)
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is an empty object, otherwise false
+ */
+declare function isEmptyObject(val: any): boolean;
+declare function isReadableStream(thing: any): boolean;
+declare function isRequest(thing: any): boolean;
+declare function isResponse(thing: any): boolean;
+declare function isHeaders(thing: any): boolean;
+declare function isUndefined(thing: any): boolean;
+declare function isDate(thing: any): boolean;
+declare function isFile(thing: any): boolean;
+declare function isBlob(thing: any): boolean;
+declare function isRegExp(thing: any): boolean;
+declare function isFunction(thing: any): boolean;
+/**
+ * Determine if a value is a Stream
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Stream, otherwise false
+ */
+declare function isStream(val: any): boolean;
+declare function isURLSearchParams(thing: any): boolean;
+declare function isTypedArray(thing: any): any;
+declare function isFileList(thing: any): boolean;
+/**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ *
+ * @param {Boolean} [allOwnKeys = false]
+ * @returns {any}
+ */
+declare function forEach(obj: Object | any[], fn: Function, { allOwnKeys }?: boolean): any;
+/**
+ * Accepts varargs expecting each argument to be an object, then
+ * immutably merges the properties of each object and returns result.
+ *
+ * When multiple objects contain the same key the later object in
+ * the arguments list will take precedence.
+ *
+ * Example:
+ *
+ * ```js
+ * var result = merge({foo: 123}, {foo: 456});
+ * console.log(result.foo); // outputs 456
+ * ```
+ *
+ * @param {Object} obj1 Object to merge
+ *
+ * @returns {Object} Result of all merge properties
+ */
+declare function merge(...args: any[]): Object;
+/**
+ * Extends object a by mutably adding to it the properties of object b.
+ *
+ * @param {Object} a The object to be extended
+ * @param {Object} b The object to copy properties from
+ * @param {Object} thisArg The object to bind function to
+ *
+ * @param {Boolean} [allOwnKeys]
+ * @returns {Object} The resulting value of object a
+ */
+declare function extend(a: Object, b: Object, thisArg: Object, { allOwnKeys }?: boolean): Object;
+/**
+ * Trim excess whitespace off the beginning and end of a string
+ *
+ * @param {String} str The String to trim
+ *
+ * @returns {String} The String freed of excess whitespace
+ */
+declare function trim(str: string): string;
+/**
+ * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+ *
+ * @param {string} content with BOM
+ *
+ * @returns {string} content value without BOM
+ */
+declare function stripBOM(content: string): string;
+/**
+ * Inherit the prototype methods from one constructor into another
+ * @param {function} constructor
+ * @param {function} superConstructor
+ * @param {object} [props]
+ * @param {object} [descriptors]
+ *
+ * @returns {void}
+ */
+declare function inherits(constructor: Function, superConstructor: Function, props?: object, descriptors?: object): void;
+/**
+ * Resolve object with deep prototype chain to a flat object
+ * @param {Object} sourceObj source object
+ * @param {Object} [destObj]
+ * @param {Function|Boolean} [filter]
+ * @param {Function} [propFilter]
+ *
+ * @returns {Object}
+ */
+declare function toFlatObject(sourceObj: Object, destObj?: Object, filter?: Function | boolean, propFilter?: Function): Object;
+declare function kindOf(thing: any): any;
+declare function kindOfTest(type: any): (thing: any) => boolean;
+/**
+ * Determines whether a string ends with the characters of a specified string
+ *
+ * @param {String} str
+ * @param {String} searchString
+ * @param {Number} [position= 0]
+ *
+ * @returns {boolean}
+ */
+declare function endsWith(str: string, searchString: string, position?: number): boolean;
+/**
+ * Returns new array from array like object or null if failed
+ *
+ * @param {*} [thing]
+ *
+ * @returns {?Array}
+ */
+declare function toArray(thing?: any): any[] | null;
+/**
+ * For each entry in the object, call the function with the key and value.
+ *
+ * @param {Object<any, any>} obj - The object to iterate over.
+ * @param {Function} fn - The function to call for each entry.
+ *
+ * @returns {void}
+ */
+declare function forEachEntry(obj: any, fn: Function): void;
+/**
+ * It takes a regular expression and a string, and returns an array of all the matches
+ *
+ * @param {string} regExp - The regular expression to match against.
+ * @param {string} str - The string to search.
+ *
+ * @returns {Array<boolean>}
+ */
+declare function matchAll(regExp: string, str: string): Array<boolean>;
+declare function isHTMLForm(thing: any): boolean;
+declare function hasOwnProperty(obj: any, prop: any): boolean;
+declare function reduceDescriptors(obj: any, reducer: any): void;
+/**
+ * Makes all methods read-only
+ * @param {Object} obj
+ */
+declare function freezeMethods(obj: Object): void;
+declare function toObjectSet(arrayOrString: any, delimiter: any): {};
+declare function toCamelCase(str: any): any;
+declare function noop(): void;
+declare function toFiniteNumber(value: any, defaultValue: any): any;
+declare function findKey(obj: any, key: any): string | null;
+declare const _global: any;
+declare function isContextDefined(context: any): boolean;
+/**
+ * If the thing is a FormData object, return true, otherwise return false.
+ *
+ * @param {unknown} thing - The thing to check.
+ *
+ * @returns {boolean}
+ */
+declare function isSpecCompliantForm(thing: unknown): boolean;
+declare function toJSONObject(obj: any): any;
+declare function isAsyncFn(thing: any): boolean;
+declare function isThenable(thing: any): any;
+declare const _setImmediate: any;
+declare const asap: any;
+declare function isIterable(thing: any): boolean;

package/types/axios-mock-adapter/index.d.ts

@@ -0,0 +1,19 @@
+export default AxiosMockAdapter;
+declare class AxiosMockAdapter {
+    constructor(axiosInstance: any, options?: {
+        delayResponse: number;
+        onNoMatch: string;
+    });
+    axiosInstance: any;
+    axiosInstanceWithoutInterceptors: any;
+    originalAdapter: any;
+    delayResponse: number | null;
+    onNoMatch: string | null;
+    adapter(): (config: any) => Promise<any>;
+    restore(): void;
+    reset(): void;
+    resetHandlers(): void;
+    handlers: any[] | undefined;
+    resetHistory(): void;
+    history: any[] | undefined;
+}

package/types/axios-mock-adapter/request.d.ts

@@ -0,0 +1,2 @@
+export function request(mockAdapter: any, config: any): Promise<any>;
+export default request;

package/types/axios-mock-adapter/utils.d.ts

@@ -0,0 +1,31 @@
+declare namespace _default {
+    export { createAxiosError };
+    export { createCouldNotFindMockError };
+    export { find };
+    export { findHandler };
+    export { isBlob };
+    export { isBodyOrParametersMatching };
+    export { isBuffer };
+    export { isEqual };
+    export { purgeIfReplyOnce };
+    export { settle };
+}
+export default _default;
+declare function createAxiosError(message: any, config: any, response: any, code: any): Error;
+declare function createCouldNotFindMockError(config: any): Error;
+declare function find(array: any, predicate: any): any;
+declare function findHandler(handlers: any, method: any, url: any, body: any, parameters: any, headers: any, baseURL: any): any;
+declare function isBlob(val: any): any;
+declare function isBodyOrParametersMatching(body: any, parameters: any, required: any): any;
+import isBuffer from 'lodash/isBuffer.js';
+import isEqual from 'lodash/isEqual.js';
+declare function purgeIfReplyOnce(mock: any, handler: any): void;
+declare function settle(config: any, response: any, delay: any): Promise<{
+    status: any;
+    data: any;
+    headers: any;
+    config: any;
+    request: {
+        responseURL: any;
+    };
+}>;

package/types/dom-helpers/types.d.ts

@@ -2,3 +2,5 @@ import * as CSS from 'csstype';
 export type HyphenProperty = keyof CSS.PropertiesHyphen;
 export type CamelProperty = keyof CSS.Properties;
 export type Property = HyphenProperty | CamelProperty;
+declare const _default: {};
+export default _default;

package/types/is/index.d.ts

@@ -35,19 +35,19 @@ import isTypedArray from 'lodash/isTypedArray.js';
 import isUndefined from 'lodash/isUndefined.js';
 import isWeakMap from 'lodash/isWeakMap.js';
 import isWeakSet from 'lodash/isWeakSet.js';
-declare function isPromise(p: any): p is Promise<any>;
-declare function isEmptyArray(o: any): boolean;
-declare function isEmptyObject(o: any): boolean;
-declare function isEmptyValue(o: any): boolean;
-declare function isFile(o: any): boolean;
-declare function isBlob(o: any): boolean;
-declare function isReadableStream(params: any): boolean;
-declare const isReadableStreamSupported: boolean;
-declare const isReadableStreamDefaultControllerSupported: boolean;
-declare const isReadableByteStreamControllerSupported: boolean;
-declare const isReadableStreamSymbolAsyncIteratorSupported: any;
-declare function isJSON(text: any): boolean;
-declare function isColor(color: any): boolean;
-declare function isColor2(color: any): boolean;
-declare function isValidColor(value: any): boolean;
-export { isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBlob, isBoolean, isBuffer, isColor, isColor2, isDate, isElement, isEmpty, isEmptyArray, isEmptyObject, isEmptyValue, isEqual, isEqualWith, isError, isFile, isFinite, isFunction, isInteger, isJSON, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isPromise, isReadableByteStreamControllerSupported, isReadableStream, isReadableStreamDefaultControllerSupported, isReadableStreamSupported, isReadableStreamSymbolAsyncIteratorSupported, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isValidColor, isWeakMap, isWeakSet, };
+export declare function isPromise(value: any): boolean;
+export declare function isFile(params: any): boolean;
+export declare function isBlob(params: any): boolean;
+export declare function isReadableStream(params: any): boolean;
+export declare function isJSON(text: any): boolean;
+export declare function isNullOrUndefined(params: any): boolean;
+export declare function isEmptyArray(params: any): boolean;
+export declare function isEmptyObject(params: any): boolean;
+export declare function isEmptyValue(params: any): boolean;
+export declare function isColorValue(color: any): boolean;
+export declare function isColorValue_(color: any): boolean;
+export declare function is32Bit(s: string): boolean | 0 | undefined;
+export declare function isExist(obj: any): boolean;
+export declare function isWindow(el: any): el is Window;
+export declare function isEventTarget(eventTarget: EventTarget): boolean;
+export { isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, };

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

@@ -111,5 +111,5 @@ declare namespace normalizeWheel {
      * the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with
      * 'wheel' event, making spin speed determination impossible.
      */
-    function getEventType(): "wheel" | "DOMMouseScroll" | "mousewheel";
+    function getEventType(): "DOMMouseScroll" | "wheel" | "mousewheel";
 }

package/types/object-prototype-to-string-call/index.d.ts

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

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

@@ -1,5 +1,7 @@
 /**
  * Main function that captures a DOM element and returns export utilities.
+ * Local-first plugins: `options.plugins` override globals for this capture.
+ *
  * @param {HTMLElement} element - The DOM element to capture.
  * @param {object} userOptions - Options for rendering/exporting.
  * @returns {Promise<object>} Object with exporter methods:
@@ -17,8 +19,10 @@
  */
 export function snapdom(element: HTMLElement, userOptions: object): Promise<object>;
 export namespace snapdom {
+    function plugins(...defs: any[]): typeof snapdom;
     /**
      * Internal capture method that returns helper methods for transformation/export.
+     * Integrates export hooks: beforeExport → work() → afterExport → afterSnap(once per URL)
      * @private
      * @param {HTMLElement} el - The DOM element to capture.
      * @param {object} context - Normalized context options.

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

@@ -8,22 +8,8 @@
  * @param {number} [options.scale=1] - Output scale multiplier
  * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
  * @param {Function} [options.filter] - Custom filter function
- * @param {boolean} [options.straighten=false] - Normalize root by removing translate*rotate* (keep scale/skew)
- * @param {boolean} [options.noShadows=false] - Do not expand bleed for shadows/blur/outline on root (and strip root shadows visually)
- * @returns {Promise<string>} Promise that resolves to an SVG data URL
- */
-/**
- * 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.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
- * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
- * @param {Function} [options.filter] - Custom filter function
- * @param {boolean} [options.straighten=false] - Normalize root by removing translate/rotate (keep scale/skew)
- * @param {boolean} [options.noShadows=false] - Do not expand bleed for shadows/blur/outline on root (and strip root shadows visually)
+ * @param {boolean} [options.outerTransforms=false] - Normalize root by removing translate/rotate (keep scale/skew)
+ * @param {boolean} [options.outerShadows=false] - Do not expand bleed for shadows/blur/outline on root (and strip root shadows visually)
  * @returns {Promise<string>} Promise that resolves to an SVG data URL
  */
 export function captureDOM(element: Element, options?: {
@@ -32,6 +18,6 @@ export function captureDOM(element: Element, options?: {
     scale?: number | undefined;
     exclude?: string[] | undefined;
     filter?: Function | undefined;
-    straighten?: boolean | undefined;
-    noShadows?: boolean | undefined;
+    outerTransforms?: boolean | undefined;
+    outerShadows?: boolean | undefined;
 }): Promise<string>;

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

@@ -34,8 +34,8 @@ export function normalizeCachePolicy(v: unknown): CachePolicy;
  * @param {string|null} [options.backgroundColor]
  * @param {string}  [options.filename]
  * @param {unknown} [options.cache] // "disabled"|"full"|"auto"|"soft"
- * @param {boolean} [options.straighten] // NEW
- * @param {boolean} [options.noShadows]      // NEW
+ * @param {boolean} [options.outerTransforms] // NEW
+ * @param {boolean} [options.outerShadows]      // NEW
  * @returns {Object}
  */
 export function createContext(options?: {
@@ -55,13 +55,13 @@ export function createContext(options?: {
     width?: number | null | undefined;
     height?: number | null | undefined;
     format?: "svg" | "png" | "jpg" | "jpeg" | "webp" | undefined;
-    type?: "canvas" | "img" | "svg" | "blob" | undefined;
+    type?: "blob" | "canvas" | "img" | "svg" | undefined;
     quality?: number | undefined;
     dpr?: number | undefined;
     backgroundColor?: string | null | undefined;
     filename?: string | undefined;
     cache?: unknown;
-    straighten?: boolean | undefined;
-    noShadows?: boolean | undefined;
+    outerTransforms?: boolean | undefined;
+    outerShadows?: boolean | undefined;
 }): Object;
 export type CachePolicy = "disabled" | "full" | "auto" | "soft";

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

@@ -0,0 +1,33 @@
+/**
+ * Normalize an exporter def: Factory, [Factory, options], { exporter, options }, instance.
+ * @param {any} spec
+ * @returns {any|null}
+ */
+export function normalizeExporter(spec: any): any | null;
+/**
+ * Register one or many exporters.
+ * Last one wins on format collision.
+ * @param  {...any} defs
+ */
+export function registerExporters(...defs: any[]): void;
+/**
+ * Resolve the exporter for a format (case-insensitive).
+ * @param {string} format
+ * @returns {any|null}
+ */
+export function getExporter(format: string): any | null;
+/** Utilities for tests */
+export function _exportersMap(): Map<any, any>;
+export function _clearExporters(): void;
+/**
+ * Runs export-related hooks around a given export task.
+ *
+ * Flow:
+ *   beforeExport → work() → afterExport → afterSnap(once per URL)
+ *
+ * @template T
+ * @param {object} ctx - Capture context extended with { export:{ type, options, url } }
+ * @param {() => Promise<T>} work - Async exporter function
+ * @returns {Promise<T>} - The export result
+ */
+export function runExportHooks<T>(ctx: object, work: () => Promise<T>): Promise<T>;

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

@@ -0,0 +1,59 @@
+/**
+ * Normalize any plugin definition form into an instance.
+ * Supports plain objects, [factory, options], { plugin, options }, or functions.
+ * @param {any} spec
+ * @returns {any|null}
+ */
+export function normalizePlugin(spec: any): any | null;
+/**
+ * Register global plugins (deduped by name, preserves order).
+ * @param  {...any} defs
+ */
+export function registerPlugins(...defs: any[]): void;
+/**
+ * Llama un hook y propaga un acumulador (compat con tu runHook actual).
+ * Usa los plugins locales si existen, o los globales en fallback.
+ * @param {string} name
+ * @param {any} context
+ * @param {any} payload
+ */
+export function runHook(name: string, context: any, payload: any): Promise<any>;
+/**
+ * NUEVO: recolecta los valores devueltos por TODOS los plugins para un hook.
+ * Útil para `defineExports` (cada plugin devuelve un mapa propio).
+ * Usa plugins locales si existen, o los globales en fallback.
+ * @param {string} name
+ * @param {any} context
+ * @param {any} payload
+ */
+export function runAll(name: string, context: any, payload: any): Promise<any[]>;
+/**
+ * Return a shallow copy of currently registered global plugins.
+ * @returns {any[]}
+ */
+export function pluginsList(): any[];
+/** Clear all globally registered plugins (mostly for tests). */
+export function clearPlugins(): void;
+/**
+ * Merge local (per-capture) plugin defs with the global registry (local-first).
+ * - Local plugins override globals by `name`.
+ * - Accepts plain instances, factories ([factory, options]) and {plugin, options}.
+ * - Returns a frozen array for immutability & GC safety.
+ * @param {any[]|undefined} localDefs
+ * @returns {ReadonlyArray<any>}
+ */
+export function mergePlugins(localDefs: any[] | undefined): ReadonlyArray<any>;
+/**
+ * Attach a per-capture plugin list on the given context (local-first).
+ * Idempotent: if `context.plugins` already exists, it remains unless `force` is true.
+ * @param {any} context
+ * @param {any[]|undefined} localDefs
+ * @param {boolean} [force=false]
+ * @returns {any} the same context (for chaining)
+ */
+export function attachSessionPlugins(context: any, localDefs: any[] | undefined, force?: boolean): any;
+/**
+ * Shallow copy of current global plugins (handy for tests or introspection).
+ * @returns {any[]}
+ */
+export function getGlobalPlugins(): any[];

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

@@ -1,9 +1,5 @@
 /**
- * Resolve any author-specified CSS variable usages (var(...)) into computed values
- * on the cloned element. Works for HTML & SVG, inline styles and attributes,
- * without relying on tag/attribute whitelists.
- *
- * @param {Element} sourceEl - Original element in live DOM
- * @param {HTMLElement|SVGElement} cloneEl - Cloned element (detached)
+ * General: resuelve var() en estilos inline/atributos. Además, si no hay var()
+ * pero el valor computado de KEY_PROPS difiere del baseline, inlina ese valor.
  */
-export function resolveCSSVars(sourceEl: Element, cloneEl: HTMLElement | SVGElement): void;
+export function resolveCSSVars(sourceEl: any, cloneEl: any): void;

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

@@ -1,2 +1,36 @@
 export function extendIconFonts(fonts: any): void;
 export function isIconFont(input: any): boolean;
+/**
+ * Rasterization helpers for Google Material Icons / Material Symbols that use ligatures.
+ * Converts elements that render icons via text ligatures into inline <img> (data URL).
+ * This runs on the CLONE tree (never mutates the original).
+ *
+ * @module materialIcons
+ */
+/** True si la familia es Material Icons / Material Symbols */
+export function isMaterialFamily(family?: string): boolean;
+/** Espera a que la fuente esté lista (ligaduras) */
+export function ensureMaterialFontsReady(family?: string, px?: number): Promise<void>;
+/**
+ * Dibuja la ligadura (ej. "face") en canvas → dataURL PNG.
+ */
+export function materialIconToImage(ligatureText: any, { family, weight, fontSize, color, variation, }?: {
+    family?: string | undefined;
+    weight?: string | undefined;
+    fontSize?: number | undefined;
+    color?: string | undefined;
+    variation?: string | undefined;
+}): Promise<{
+    dataUrl: string;
+    width: number;
+    height: number;
+}>;
+/**
+ * Reemplaza nodos de Material (ligaduras) por <img> en el CLONE.
+ * IMPORTANTE: leé estilos del SOURCE para obtener el color correcto.
+ *
+ * @param {Element} cloneRoot - subárbol clonado
+ * @param {Element} sourceRoot - subárbol original (para estilos reales)
+ * @returns {Promise<number>}
+ */
+export function ligatureIconToImage(cloneRoot: Element, sourceRoot: Element): Promise<number>;

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

@@ -1,19 +1,13 @@
 /**
- * Ensures that all external <symbol> or <defs> elements referenced by <use>
- * inside the given root element are inlined into it.
+ * Inline external <defs> and <symbol> dependencies needed by an SVG subtree (or multiple SVGs),
+ * so that serialization does not break. Handles:
+ *  1) <use href="#..."> targets (symbols/defs)
+ *  2) Attributes/inline styles that reference url(#id) (gradients, patterns, filters, clipPath, mask, marker-*)
+ *  3) Recursive chains via href/xlink:href and nested url(#...) inside cloned defs
  *
- * This is necessary when capturing or exporting an SVG fragment that relies on
- * definitions existing elsewhere in the document, ensuring it remains
- * self-contained and renders correctly.
+ * Fast path: no computed styles, no layout reads. Only DOM queries + cloning.
  *
- * Process:
- * 1. Collect all IDs referenced by <use> elements in the root.
- * 2. Look up those IDs in the global document (outside the root).
- * 3. Create or reuse a hidden <svg> container inside the root to hold inlined defs.
- * 4. Only insert missing <symbol>/<defs> elements that are not already present.
- *
- * Existing definitions in the root are never modified or removed.
- *
- * @param {HTMLElement} rootElement - The root element being processed (typically the cloned DOM fragment).
+ * @param {Element} element - SVG root or container holding one/more SVGs.
+ * @param {Document|ParentNode} [lookupRoot] - Where to search for external defs/symbols (defaults to element.ownerDocument).
  */
-export function inlineExternalDefsAndSymbols(rootElement: HTMLElement): void;
+export function inlineExternalDefsAndSymbols(element: Element, lookupRoot?: Document | ParentNode): void;

package/types/tween/index.d.ts

@@ -0,0 +1 @@
+export { default, easing, default as Tween } from "./src";