@unicom-cloud/utils 0.1.23 → 0.1.25

package/types/lodash/zipWith.d.ts

@@ -0,0 +1,22 @@
+export default zipWith;
+/**
+ * This method is like `_.zip` except that it accepts `iteratee` to specify
+ * how grouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.8.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to process.
+ * @param {Function} [iteratee=_.identity] The function to combine
+ *  grouped values.
+ * @returns {Array} Returns the new array of grouped elements.
+ * @example
+ *
+ * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
+ *   return a + b + c;
+ * });
+ * // => [111, 222]
+ */
+declare var zipWith: Function;

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/random/index.d.ts

@@ -1,4 +1,5 @@
 declare namespace _default {
+    export { address };
     export function county(p: any): string;
     export function company(): string;
     export function project(): string;
@@ -9,23 +10,22 @@ declare namespace _default {
     export function id(): number;
     export function increment(step: any): number;
     export { image };
-    export { address };
     export { web };
     export { name };
     export { text };
+    export { number };
     export function boolean(): boolean;
     export function sex(): string;
     export { sample as pick };
-    export { number };
 }
 export default _default;
+import address from './address';
 import time from './time';
 import constellation from './constellation';
 import licensePlate from './licensePlate';
 import image from './image';
-import address from './address';
 import web from './web';
 import name from './name';
 import text from './text';
-import sample from 'lodash/sample';
 import number from './number';
+import sample from 'lodash/sample';

package/types/screenfull/index.d.ts

@@ -1,10 +1,4 @@
 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 };
+    let isEnabled: boolean;
 }
-declare const nativeAPI: {};

package/types/sleep/index.d.ts

@@ -0,0 +1,2 @@
+export default sleep;
+declare function sleep(ms: any): Promise<any>;

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

@@ -1,5 +1,28 @@
 /**
- * Preloads images, background images, and optionally fonts into cache before DOM capture.
- * Nunca deja promesas rechazadas sin manejar (evita unhandled rejections).
+ * Preloads images, background images, and (optionally) fonts into cache before DOM capture.
+ * @param {Element|Document} [root=document]
+ * @param {Object} [options={}]
+ * @param {boolean} [options.embedFonts=true]
+ * @param {'full'|'soft'|'auto'|'disabled'} [options.cache='full']
+ * @param {string}  [options.useProxy=""]
+ * @param {{family:string,src:string,weight?:string|number,style?:string,stretchPct?:number}[]} [options.localFonts=[]]
+ * @param {{families?:string[], domains?:string[], subsets?:string[]}} [options.excludeFonts]
+ * @returns {Promise<void>}
  */
-export function preCache(root?: Document, options?: {}): Promise<void>;
+export function preCache(root?: Element | Document, options?: {
+    embedFonts?: boolean | undefined;
+    cache?: "auto" | "soft" | "full" | "disabled" | undefined;
+    useProxy?: string | undefined;
+    localFonts?: {
+        family: string;
+        src: string;
+        weight?: string | number;
+        style?: string;
+        stretchPct?: number;
+    }[] | undefined;
+    excludeFonts?: {
+        families?: string[];
+        domains?: string[];
+        subsets?: string[];
+    } | undefined;
+}): Promise<void>;

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

@@ -1,26 +1,95 @@
 /**
- * Main entry point: captures a DOM element and returns an object with export methods.
+ * Main function that captures a DOM element and returns export utilities.
+ * Local-first plugins: `options.plugins` override globals for this capture.
  *
- * @param {Element} element - DOM element to capture
- * @param {Object} [options={}] - Capture options
- * @returns {Promise<Object>} Object with export methods (toRaw, toImg, toCanvas, etc.)
+ * @param {HTMLElement} element - The DOM element to capture.
+ * @param {object} userOptions - Options for rendering/exporting.
+ * @returns {Promise<object>} Object with exporter methods:
+ * @deprecated toImg()
+ *   - url: The raw data URL
+ *   - toRaw(): Gets raw data URL
+ *   - toImg(): Converts to Svg format
+ *   - toSvg(): Converts to Svg format
+ *   - toCanvas(): Converts to HTMLCanvasElement
+ *   - toBlob(): Converts to Blob
+ *   - toPng(): Converts to PNG format
+ *   - toJpg(): Converts to JPEG format
+ *   - toWebp(): Converts to WebP format
+ *   - download(): Triggers file download
  */
-export function snapdom(element: Element, options?: Object): Promise<Object>;
+export function snapdom(element: HTMLElement, userOptions: object): Promise<object>;
 export namespace snapdom {
+    function plugins(...defs: any[]): typeof 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>;
+     * 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.
+     * @param {symbol} _token - Internal security token.
+     * @returns {Promise<object>} Exporter functions.
+     */
+    function capture(el: HTMLElement, context: object, _token: symbol): Promise<object>;
+    /**
+     * Returns the raw data URL from a captured element.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} [options] - Rendering options.
+     * @returns {Promise<string>} Raw data URL.
+     */
+    function toRaw(el: HTMLElement, options?: object): Promise<string>;
+    /**
+     * Returns an HTMLImageElement from a captured element.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} [options] - Rendering options.
+     * @returns {Promise<HTMLImageElement>} Loaded image element.
+     */
+    function toImg(el: HTMLElement, options?: object): Promise<HTMLImageElement>;
+    function toSvg(el: any, options: any): Promise<any>;
+    /**
+     * Returns a Canvas element from a captured element.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} [options] - Rendering options.
+     * @returns {Promise<HTMLCanvasElement>} Rendered canvas element.
+     */
+    function toCanvas(el: HTMLElement, options?: object): Promise<HTMLCanvasElement>;
+    /**
+     * Returns a Blob from a captured element.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} [options] - Rendering options.
+     * @returns {Promise<Blob>} Image blob.
+     */
+    function toBlob(el: HTMLElement, options?: object): Promise<Blob>;
+    /**
+     * Returns a PNG image from a captured element.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} [options] - Rendering options.
+     * @returns {Promise<HTMLImageElement>} PNG image element.
+     */
+    function toPng(el: HTMLElement, options?: object): Promise<HTMLImageElement>;
+    /**
+     * Returns a JPEG image from a captured element.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} [options] - Rendering options.
+     * @returns {Promise<HTMLImageElement>} JPEG image element.
+     */
+    function toJpg(el: HTMLElement, options?: object): Promise<HTMLImageElement>;
+    /**
+     * Returns a WebP image from a captured element.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} [options] - Rendering options.
+     * @returns {Promise<HTMLImageElement>} WebP image element.
+     */
+    function toWebp(el: HTMLElement, options?: object): Promise<HTMLImageElement>;
+    /**
+     * Downloads the captured image in the specified format.
+     * @param {HTMLElement} el - DOM element to capture.
+     * @param {object} options - Download options including filename.
+     * @param {string} options.filename - Name for the downloaded file.
+     * @param {string} [options.format='png'] - Image format ('png', 'jpeg', 'webp', 'svg').
+     * @returns {Promise<void>}
+     */
+    function download(el: HTMLElement, options: {
+        filename: string;
+        format?: string | undefined;
+    }): Promise<void>;
 }

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

@@ -1,14 +1,29 @@
+/**
+ * Normalizes shorthand values to canonical cache policies.
+ *  - true  => "soft"
+ *  - false => "disabled"
+ *  - "auto" => "auto"
+ *  - "full" => "full"
+ * @param {unknown} v
+ * @returns {"soft"|"auto"|"full"|"disabled"}
+ */
+export function normalizeCachePolicy(v: unknown): "soft" | "auto" | "full" | "disabled";
+/**
+ * Applies the cache policy.
+ * @param {"soft"|"auto"|"full"|"disabled"} policy
+ */
+export function applyCachePolicy(policy?: "soft" | "auto" | "full" | "disabled"): void;
 export namespace cache {
-    export let image: Map<any, any>;
-    export let background: Map<any, any>;
-    export let resource: Map<any, any>;
-    export let defaultStyle: Map<any, any>;
-    export let baseStyle: Map<any, any>;
-    export let computedStyle: WeakMap<WeakKey, any>;
-    export let font: Set<any>;
-    export let snapshot: WeakMap<WeakKey, any>;
-    export let snapshotKey: Map<any, any>;
-    export { resetCache as reset };
+    let image: Map<any, any>;
+    let background: Map<any, any>;
+    let resource: Map<any, any>;
+    let defaultStyle: Map<any, any>;
+    let baseStyle: Map<any, any>;
+    let computedStyle: WeakMap<WeakKey, any>;
+    let font: Set<any>;
+    namespace session {
+        let styleMap: Map<any, any>;
+        let styleCache: WeakMap<WeakKey, any>;
+        let nodeMap: Map<any, any>;
+    }
 }
-declare function resetCache(): void;
-export {};

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

@@ -3,19 +3,21 @@
  *
  * @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
  * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
  * @param {Function} [options.filter] - Custom filter function
+ * @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?: {
-    compress?: boolean | undefined;
     embedFonts?: boolean | undefined;
     fast?: boolean | undefined;
     scale?: number | undefined;
     exclude?: string[] | undefined;
     filter?: Function | undefined;
+    outerTransforms?: boolean | undefined;
+    outerShadows?: boolean | undefined;
 }): Promise<string>;

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

@@ -1,10 +1 @@
-/**
- * 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 {boolean} compress - Whether to compress style keys
- * @param {Object} [options={}] - Capture options including exclude and filter
- * @param {Node} [originalRoot] - Original root element being captured
- * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes or filtered elements
- */
-export function deepClone(node: Node, styleMap: any, styleCache: any, nodeMap: any, compress: boolean, options?: Object, originalRoot?: Node): Node | null;
+export function deepClone(node: any, sessionCache: any, options: any): Promise<any>;

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

@@ -0,0 +1,67 @@
+/**
+ * @typedef {"disabled"|"full"|"auto"|"soft"} CachePolicy
+ */
+/**
+ * Normalizes `options.cache` into a canonical policy.
+ * Accepted strings: "disabled" | "full" | "auto" | "soft"
+ * Default: "soft"
+ * @param {unknown} v
+ * @returns {CachePolicy}
+ */
+export function normalizeCachePolicy(v: unknown): CachePolicy;
+/**
+ * Creates a normalized capture context for SnapDOM.
+ * @param {Object} [options={}]
+ * @param {boolean} [options.debug]
+ * @param {boolean} [options.fast]
+ * @param {number}  [options.scale]
+ * @param {Array<string|RegExp>} [options.exclude]
+ * @param {string}  [options.excludeMode]
+ * @param {(node: Node)=>boolean} [options.filter]
+ * @param {string}  [options.filterMode]
+ * @param {boolean} [options.embedFonts]
+ * @param {string|string[]} [options.iconFonts]
+ * @param {string[]} [options.localFonts]
+ * @param {string[]|undefined} [options.excludeFonts]
+ * @param {string|function} [options.fallbackURL]
+ * @param {string}  [options.useProxy]
+ * @param {number|null} [options.width]
+ * @param {number|null} [options.height]
+ * @param {"png"|"jpg"|"jpeg"|"webp"|"svg"} [options.format]
+ * @param {"svg"|"img"|"canvas"|"blob"} [options.type]
+ * @param {number}  [options.quality]
+ * @param {number}  [options.dpr]
+ * @param {string|null} [options.backgroundColor]
+ * @param {string}  [options.filename]
+ * @param {unknown} [options.cache] // "disabled"|"full"|"auto"|"soft"
+ * @param {boolean} [options.outerTransforms] // NEW
+ * @param {boolean} [options.outerShadows]      // NEW
+ * @returns {Object}
+ */
+export function createContext(options?: {
+    debug?: boolean | undefined;
+    fast?: boolean | undefined;
+    scale?: number | undefined;
+    exclude?: (string | RegExp)[] | undefined;
+    excludeMode?: string | undefined;
+    filter?: ((node: Node) => boolean) | undefined;
+    filterMode?: string | undefined;
+    embedFonts?: boolean | undefined;
+    iconFonts?: string | string[] | undefined;
+    localFonts?: string[] | undefined;
+    excludeFonts?: string[] | undefined;
+    fallbackURL?: string | Function | undefined;
+    useProxy?: string | undefined;
+    width?: number | null | undefined;
+    height?: number | null | undefined;
+    format?: "svg" | "png" | "jpg" | "jpeg" | "webp" | undefined;
+    type?: "canvas" | "img" | "svg" | "blob" | undefined;
+    quality?: number | undefined;
+    dpr?: number | undefined;
+    backgroundColor?: string | null | undefined;
+    filename?: string | undefined;
+    cache?: unknown;
+    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/core/prepare.d.ts

@@ -2,14 +2,13 @@
  * 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
  * @param {boolean} [embedFonts=false] - Whether to embed custom fonts
  * @param {Object} [options={}] - Capture options
  * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
  * @param {Function} [options.filter] - Custom filter function
  * @returns {Promise<Object>} Object containing the clone, generated CSS, and style cache
  */
-export function prepareClone(element: Element, compress?: boolean, embedFonts?: boolean, options?: {
+export function prepareClone(element: Element, options?: {
     exclude?: string[] | undefined;
     filter?: Function | undefined;
 }): Promise<Object>;

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

@@ -0,0 +1,16 @@
+/**
+ * Triggers download of the generated image.
+ * @param {string} url - Image data URL.
+ * @param {object} options - Context including format, quality, filename.
+ * @param {string} options.format - Output format ('png', 'jpeg', 'webp', 'svg').
+ * @param {string} options.filename - Download filename.
+ * @param {number} [options.quality] - Image quality for lossy formats.
+ * @param {string} [options.backgroundColor] - Optional background color.
+ * @returns {Promise<void>}
+ */
+export function download(url: string, options: {
+    format: string;
+    filename: string;
+    quality?: number | undefined;
+    backgroundColor?: string | undefined;
+}): Promise<void>;

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

@@ -0,0 +1,14 @@
+/**
+ * Converts the rendered output to a Blob.
+ * @param {string} url - Image data URL.
+ * @param {object} options - Context including type and quality.
+ * @param {string} options.type - Image type ('png', 'jpeg', 'webp', 'svg').
+ * @param {number} [options.quality] - Image quality for lossy formats.
+ * @param {string} [options.backgroundColor] - Optional background color.
+ * @returns {Promise<Blob>} Resolves with the image Blob.
+ */
+export function toBlob(url: string, options: {
+    type: string;
+    quality?: number | undefined;
+    backgroundColor?: string | undefined;
+}): Promise<Blob>;

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

@@ -0,0 +1,14 @@
+/**
+ * Rasterize SVG into a canvas honoring width/height + scale.
+ * Uses options.meta for natural sizes (from captureDOM).
+ * @param {string} url
+ * @param {{width?:number,height?:number,scale?:number,dpr?:number,meta?:object}} options
+ * @returns {Promise<HTMLCanvasElement>}
+ */
+export function toCanvas(url: string, options: {
+    width?: number;
+    height?: number;
+    scale?: number;
+    dpr?: number;
+    meta?: object;
+}): Promise<HTMLCanvasElement>;

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

@@ -0,0 +1,11 @@
+/**
+ * Converts a data URL to an HTMLImageElement.
+ * @param {string} url - The data URL of the image.
+ * @param {object} options - Context options including scale.
+ * @param {number} [options.scale=1] - Scale factor for the image dimensions.
+ * @returns {Promise<HTMLImageElement>} Resolves with the loaded Image element.
+ */
+export function toImg(url: string, options: {
+    scale?: number | undefined;
+}): Promise<HTMLImageElement>;
+export { toImg as toSvg };

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

@@ -0,0 +1,5 @@
+/**
+ * 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: any, cloneEl: any): void;

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

@@ -16,4 +16,9 @@
  * @param {Object} [options={}] Optional parameters passed to image inlining functions.
  * @returns {Promise<void>} Resolves when all inlining operations (including async image fetches) complete.
  */
-export function inlineBackgroundImages(source: HTMLElement, clone: HTMLElement, styleCache: any, options?: Object): Promise<void>;
+/**
+ * Inlines URL-bearing properties (background/mask/border-image)
+ * and also preserves mask positioning longhands (position/size/repeat).
+ * This fixes cases like `mask: url(...) center/60% 60% no-repeat`.
+ */
+export function inlineBackgroundImages(source: any, clone: any, styleCache: any, options?: {}): Promise<void>;

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

@@ -0,0 +1,14 @@
+/**
+ * Freeze sticky elements by converting them to absolutely-positioned overlays.
+ * Also creates an invisible absolute placeholder behind each sticky (lower z-index).
+ *
+ * Robust against sibling-index drift:
+ * - Placeholders are marked data-snap-ph="1".
+ * - Path resolution in the clone ignores those placeholders to keep indices aligned.
+ *
+ * Only processes real vertical stickies (numeric top OR bottom).
+ *
+ * @param {HTMLElement} originalRoot
+ * @param {HTMLElement} cloneRoot
+ */
+export function freezeSticky(originalRoot: HTMLElement, cloneRoot: HTMLElement): void;

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

@@ -0,0 +1,72 @@
+/**
+ * Lightweight CSS counter resolver for SnapDOM.
+ * - Supports counter(name[, style]) and counters(name, sep[, style])
+ * - counter-reset push vs replace (push if parent has that counter, replace otherwise)
+ * - Carries state across siblings in document order
+ * - Simple OL/UL indexing (start, li[value]); reversed not handled intentionally
+ *
+ * @module counters
+ */
+/** Detects if a content string uses counter()/counters(). */
+export function hasCounters(input: any): boolean;
+/** Replace every CSS string token "..." with its raw content (keeps single quotes). */
+export function unquoteDoubleStrings(s: any): any;
+/**
+ * Build a counter context by walking the DOM once.
+ * It stores, for each Element, a Map<counterName, number[]> (stack).
+ *
+ * Rules:
+ * - counter-reset on element:
+ *    * if parent had that counter -> push (nest)
+ *    * else -> replace (start a fresh stack with [value])
+ * - counter-increment on element: add to top, creating top=0 if needed
+ * - list-item: sets 'list-item' value for LI in OL/UL (supports start, li[value])
+ *
+ * @param {Document|Element} root
+ * @returns {{ get(node: Element, name: string): number, getStack(node: Element, name: string): number[] }}
+ */
+export function buildCounterContext(root: Document | Element): {
+    get(node: Element, name: string): number;
+    getStack(node: Element, name: string): number[];
+};
+/**
+ * Resolves counter()/counters() calls inside a content string for a specific node,
+ * returning a plain string suitable for textContent. Also strips double-quote tokens.
+ *
+ * @param {string} raw
+ * @param {Element} node
+ * @param {{get(node: Element, name: string): number, getStack(node: Element, name: string): number[]}} ctx
+ */
+export function resolveCountersInContent(raw: string, node: Element, ctx: {
+    get(node: Element, name: string): number;
+    getStack(node: Element, name: string): number[];
+}): any;
+/**
+ * Create a derived counter context that applies a pseudo's counter-reset /
+ * counter-increment *for this node only*, before resolving content.
+ * Works with ::before / ::after (and any pseudo with content).
+ *
+ * @param {Element} node
+ * @param {CSSStyleDeclaration|null} pseudoStyle getComputedStyle(node, '::before' | '::after')
+ * @param {{get(node: Element, name: string): number, getStack(node: Element, name: string): number[]}} baseCtx
+ */
+export function deriveCounterCtxForPseudo(node: Element, pseudoStyle: CSSStyleDeclaration | null, baseCtx: {
+    get(node: Element, name: string): number;
+    getStack(node: Element, name: string): number[];
+}): {
+    get(_node: any, name: any): any;
+    getStack(_node: any, name: any): any;
+};
+/**
+ * Convenience helper: resolve the final text to render for a pseudo's `content`,
+ * correctly applying the pseudo's own counter-reset/increment before evaluation.
+ *
+ * @param {Element} node
+ * @param {'::before'|'::after'} pseudo
+ * @param {{get(node: Element, name: string): number, getStack(node: Element, name: string): number[]}} baseCtx
+ * @returns {string} resolved content (without surrounding double quotes)
+ */
+export function resolvePseudoContent(node: Element, pseudo: "::before" | "::after", baseCtx: {
+    get(node: Element, name: string): number;
+    getStack(node: Element, name: string): number[];
+}): string;