@unicom-cloud/utils 0.1.22 → 0.1.24

package/types/lodash/xorWith.d.ts

@@ -0,0 +1,23 @@
+export default xorWith;
+/**
+ * This method is like `_.xor` except that it accepts `comparator` which is
+ * invoked to compare elements of `arrays`. The order of result values is
+ * determined by the order they occur in the arrays. The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.xorWith(objects, others, _.isEqual);
+ * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+ */
+declare var xorWith: Function;

package/types/lodash/zip.d.ts

@@ -0,0 +1,18 @@
+export default zip;
+/**
+ * Creates an array of grouped elements, the first of which contains the
+ * first elements of the given arrays, the second of which contains the
+ * second elements of the given arrays, and so on.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to process.
+ * @returns {Array} Returns the new array of grouped elements.
+ * @example
+ *
+ * _.zip(['a', 'b'], [1, 2], [true, false]);
+ * // => [['a', 1, true], ['b', 2, false]]
+ */
+declare var zip: Function;

package/types/lodash/zipObject.d.ts

@@ -0,0 +1,18 @@
+export default zipObject;
+/**
+ * This method is like `_.fromPairs` except that it accepts two arrays,
+ * one of property identifiers and one of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.4.0
+ * @category Array
+ * @param {Array} [props=[]] The property identifiers.
+ * @param {Array} [values=[]] The property values.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.zipObject(['a', 'b'], [1, 2]);
+ * // => { 'a': 1, 'b': 2 }
+ */
+declare function zipObject(props?: any[], values?: any[]): Object;

package/types/lodash/zipObjectDeep.d.ts

@@ -0,0 +1,17 @@
+export default zipObjectDeep;
+/**
+ * This method is like `_.zipObject` except that it supports property paths.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.1.0
+ * @category Array
+ * @param {Array} [props=[]] The property identifiers.
+ * @param {Array} [values=[]] The property values.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
+ * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
+ */
+declare function zipObjectDeep(props?: any[], values?: any[]): Object;

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/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,91 @@
 /**
- * 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.)
+ * Main function that captures a DOM element and returns export utilities.
+ * @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 {
     /**
-     * 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.
+     * @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,35 @@
  *
  * @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.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)
  * @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;
+    straighten?: boolean | undefined;
+    noShadows?: 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.straighten] // NEW
+ * @param {boolean} [options.noShadows]      // 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;
+    straighten?: boolean | undefined;
+    noShadows?: boolean | undefined;
+}): Object;
+export type CachePolicy = "disabled" | "full" | "auto" | "soft";

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,9 @@
+/**
+ * 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)
+ */
+export function resolveCSSVars(sourceEl: Element, cloneEl: HTMLElement | SVGElement): 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;