@unicom-cloud/utils 0.1.30 → 0.1.32

package/tree/index.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import a from "lodash/castArray";
 import c from "lodash/isArray.js";
 import g from "lodash/isObject.js";

package/tree/search/index.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import E from "lodash/isArray";
 import B from "lodash/isFunction";
 import C from "lodash/isNil";

package/tree.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import "lodash/castArray";
 import "lodash/isArray.js";
 import "lodash/isObject.js";

package/tween/index.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import * as e from "./src/easing.js";
 import { default as r, default as t } from "./src/tween.js";
 export {

package/tween/src/easing.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 function u(n) {
   return function(t) {
     return Math.pow(t, n);

package/tween/src/tween.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import n from "lodash/isFunction.js";
 import d from "lodash/isString.js";
 import * as l from "./easing.js";

package/tween.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import * as e from "./tween/src/easing.js";
 import { default as r, default as t } from "./tween/src/tween.js";
 export {

package/types/constant/isMobile.d.ts

@@ -0,0 +1,3 @@
+export default isMobile;
+export const isMobile: boolean;
+export const isTablet: boolean;

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

@@ -1,3 +1,10 @@
+export function plugins(...defs: any[]): typeof main & {
+    plugins: typeof plugins;
+};
+export const snapdom: typeof main & {
+    plugins: typeof plugins;
+};
+export default snapdom;
 /**
  * Main function that captures a DOM element and returns export utilities.
  * Local-first plugins: `options.plugins` override globals for this capture.
@@ -5,11 +12,10 @@
  * @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
+ *   - toImg(): Converts to Image element
+ *   - toSvg(): Converts to SVG Image element
  *   - toCanvas(): Converts to HTMLCanvasElement
  *   - toBlob(): Converts to Blob
  *   - toPng(): Converts to PNG format
@@ -17,79 +23,4 @@
  *   - toWebp(): Converts to WebP format
  *   - download(): Triggers file download
  */
-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.
-     * @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>;
-}
+declare function main(element: HTMLElement, userOptions: object): Promise<object>;

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

@@ -1,8 +1,15 @@
 /**
- * Rasterize SVG into a canvas honoring width/height + scale.
- * Uses options.meta for natural sizes (from captureDOM).
+ * Rasterize SVG (o data URL) en un canvas respetando width/height + scale.
+ * Soporta aplanar un background color sin canvas intermedio.
  * @param {string} url
- * @param {{width?:number,height?:number,scale?:number,dpr?:number,meta?:object}} options
+ * @param {{
+ *   width?:number,
+ *   height?:number,
+ *   scale?:number,
+ *   dpr?:number,
+ *   meta?:object,
+ *   backgroundColor?: string // <- NUEVO: color opcional para aplanar fondo
+ * }} options
  * @returns {Promise<HTMLCanvasElement>}
  */
 export function toCanvas(url: string, options: {
@@ -11,4 +18,5 @@ export function toCanvas(url: string, options: {
     scale?: number;
     dpr?: number;
     meta?: object;
+    backgroundColor?: string;
 }): Promise<HTMLCanvasElement>;

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

@@ -0,0 +1 @@
+export function toJpg(elOrUrl: any, opts?: {}): Promise<HTMLImageElement>;

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

@@ -0,0 +1,6 @@
+/**
+ * @param {HTMLElement|string} elOrUrl
+ * @param {object} opts
+ * @returns {Promise<HTMLImageElement|string|HTMLCanvasElement|Blob>} según tu contrato de `rasterize`
+ */
+export function toPng(elOrUrl: HTMLElement | string, opts?: object): Promise<HTMLImageElement | string | HTMLCanvasElement | Blob>;

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

@@ -0,0 +1 @@
+export { toSvg } from "./toImg.js";

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

@@ -0,0 +1 @@
+export function toWebp(elOrUrl: any, opts?: {}): Promise<HTMLImageElement>;

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

@@ -1,36 +1,23 @@
 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, }?: {
+export function materialIconToImage(ligatureText: any, { family, weight, fontSize, color, variation, className, }?: {
     family?: string | undefined;
     weight?: string | undefined;
     fontSize?: number | undefined;
     color?: string | undefined;
     variation?: string | undefined;
+    className?: 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>}
+ * Replace Material ligature nodes in the CLONE by <img>.
+ * Reads styles from SOURCE for accurate size/color/variation/class.
  */
-export function ligatureIconToImage(cloneRoot: Element, sourceRoot: Element): Promise<number>;
+export function ligatureIconToImage(cloneRoot: any, sourceRoot: any): Promise<number>;
+export const defaultIconFonts: RegExp[];
+export const ICON_FONT_URLS: any;

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

@@ -1,3 +1,21 @@
+/**
+ * Fast preflight to decide whether pseudo/counter inlining is needed at all.
+ * Triggers true if detects any:
+ *  - ::before / ::after / ::first-letter (and single-colon variants)
+ *  - counter( / counters( / counter-increment / counter-reset
+ *
+ * Strategy (fast → slower):
+ *  1) Scan inline <style> textContent
+ *  2) Scan adoptedStyleSheets (cssRules) if available
+ *  3) Scan a small budget of cssRules in <style>/<link> same-origin
+ *  4) Cheap DOM hint for inline styles with counter(
+ *
+ * Memoized by document + style fingerprint.
+ *
+ * @param {Document} doc
+ * @returns {boolean}
+ */
+export function shouldProcessPseudos(doc?: Document): boolean;
 /**
  * Creates elements to represent ::before, ::after, and ::first-letter pseudo-elements, inlining their styles and content.
  *

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

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

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

@@ -6,7 +6,4 @@
 export function idle(fn: any, { fast }?: {
     fast?: boolean | undefined;
 }): Promise<void>;
-/**
- * Detecta Safari real + Safari en iOS WebView (UIWebView/WKWebView) + variantes WeChat.
- */
 export function isSafari(): boolean;

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

@@ -0,0 +1,45 @@
+/**
+ * Helper utilities for DOM capture operations
+ * @module utils/capture.helpers
+ */
+/**
+ * Strip shadow-like visuals on the CLONE ROOT ONLY (box/text-shadow, outline, blur()/drop-shadow()).
+ * Children remain intact.
+ * @param {Element} originalEl
+ * @param {HTMLElement} cloneRoot
+ */
+export function stripRootShadows(originalEl: Element, cloneRoot: HTMLElement): void;
+/** Remove all HTML comments (prevents invalid XML like "--") */
+export function removeAllComments(root: any): void;
+/**
+ * Sanitize attributes to produce valid XHTML inside foreignObject.
+ * - Drop "@", unknown ":" prefixes
+ * - Drop common framework directives (x-*, v-*, :*, on:*, bind:*, let:*, class:*)
+ */
+export function sanitizeAttributesForXHTML(root: any, opts?: {}): void;
+export function sanitizeCloneForXHTML(root: any, opts?: {}): void;
+/**
+ * Post-clone "shrink pass": for parents that lost children due to excludeMode:"remove",
+ * override snapshot sizes so they can collapse naturally.
+ *
+ * It writes inline overrides on the CLONE (never the real DOM):
+ *   - height/width: auto
+ *   - remove logical sizes (block-size/inline-size)
+ *   - relax min/max to allow collapse
+ *
+ * @param {Element} sourceRoot - original subtree root (for reading computed styles)
+ * @param {HTMLElement} cloneRoot - cloned subtree root (to write overrides)
+ * @param {Map<Element, CSSStyleDeclaration>} styleCache - optional cache you already build
+ */
+export function shrinkAutoSizeBoxes(sourceRoot: Element, cloneRoot: HTMLElement, styleCache?: Map<Element, CSSStyleDeclaration>): void;
+/**
+ * Compute the kept-children vertical span inside container's content box.
+ * We take the min(top) and max(bottom) of included, in-flow children,
+ * then add container paddings and borders to rebuild total height.
+ * This avoids double-counting collapsed margins.
+ * @param {Element} container
+ * @param {any} options
+ * @returns {number} estimated outerHeight (border+padding+content)
+ */
+export function estimateKeptHeight(container: Element, options: any): number;
+export function limitDecimals(v: any, n?: number): any;

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

@@ -0,0 +1,97 @@
+/**
+ * Schedule work across idle slices without relying on IdleDeadline constructor.
+ * Falls back to setTimeout on browsers without requestIdleCallback.
+ * @param {Node[]} childList
+ * @param {(child: Node, done: () => void) => void} callback
+ * @param {boolean} fast
+ * @returns {Promise<(Node|null)[]>}
+ */
+export function idleCallback(childList: Node[], callback: (child: Node, done: () => void) => void, fast: boolean): Promise<(Node | null)[]>;
+/**
+ * Rewrite Shadow DOM selectors to a flat, host-scoped form with specificity 0.
+ * - :host(.foo)           => :where([data-sd="sN"]:is(.foo))
+ * - :host                 => :where([data-sd="sN"])
+ * - ::slotted(X)          => :where([data-sd="sN"] X)              (no excluye sloteados)
+ * - (resto, p.ej. .button)=> :where([data-sd="sN"] .button:not([data-sd-slotted]))
+ * - :host-context(Y)      => :where(:where(Y) [data-sd="sN"])      (aprox)
+ */
+export function rewriteShadowCSS(cssText: any, scopeSelector: any): any;
+/**
+ * Generate a unique shadow scope id for this session.
+ * @param {{shadowScopeSeq?: number}} sessionCache
+ * @returns {string} like "s1", "s2", ...
+ */
+export function nextShadowScopeId(sessionCache: {
+    shadowScopeSeq?: number;
+}): string;
+/**
+ * Extract CSS text from a ShadowRoot: inline <style> plus adoptedStyleSheets (if readable).
+ * @param {ShadowRoot} sr
+ * @returns {string}
+ */
+export function extractShadowCSS(sr: ShadowRoot): string;
+/**
+ * Inject a <style> as the first child of `hostClone` with rewritten CSS.
+ * @param {Element} hostClone
+ * @param {string} cssText
+ * @param {string} scopeId like s1
+ */
+export function injectScopedStyle(hostClone: Element, cssText: string, scopeId: string): void;
+/**
+ * Freeze the responsive selection of an <img> that has srcset/sizes.
+ * Copies a concrete URL into `src` and removes `srcset`/`sizes` so the clone
+ * doesn't need layout to resolve a candidate.
+ * Works with <picture> because currentSrc reflects the chosen source.
+ * @param {HTMLImageElement} original - Image in the live DOM.
+ * @param {HTMLImageElement} cloned - Just-created cloned <img>.
+ */
+export function freezeImgSrcset(original: HTMLImageElement, cloned: HTMLImageElement): void;
+/**
+ * Collect all custom properties referenced via var(--foo) in a CSS string.
+ * @param {string} cssText
+ * @returns {Set<string>} e.g. new Set(['--o-fill','--o-gray-light'])
+ */
+export function collectCustomPropsFromCSS(cssText: string): Set<string>;
+/**
+ * Build a seed rule that initializes given custom props on the scope.
+ * Placed before the rewritten shadow CSS so later rules (e.g. :hover) can override.
+ * @param {Element} hostEl
+ * @param {Iterable<string>} names
+ * @param {string} scopeSelector e.g. [data-sd="s3"]
+ * @returns {string} CSS rule text (or "" if nothing to seed)
+ */
+export function buildSeedCustomPropsRule(hostEl: Element, names: Iterable<string>, scopeSelector: string): string;
+/**
+ * Mark slotted subtree with data-sd-slotted attribute
+ * @param {Node} root
+ */
+export function markSlottedSubtree(root: Node): void;
+/**
+ * Wait for an accessible same-origin Document for a given <iframe>.
+ * @param {HTMLIFrameElement} iframe
+ * @param {number} [attempts=3]
+ * @returns {Promise<Document|null>}
+ */
+export function getAccessibleIframeDocument(iframe: HTMLIFrameElement, attempts?: number): Promise<Document | null>;
+/**
+ * Rasterize a same-origin iframe exactly at its content-box size, as the user requested:
+ * - Capture iframe.contentDocument.documentElement
+ * - Force a bitmap (toPng) sized to the iframe viewport (not the content height)
+ * - Wrap with a styled container that mimics the <iframe> box (borders, radius, etc.)
+ *
+ * @param {HTMLIFrameElement} iframe
+ * @param {object} sessionCache
+ * @param {object} options
+ * @returns {Promise<HTMLElement>}
+ */
+export function rasterizeIframe(iframe: HTMLIFrameElement, sessionCache: object, options: object): Promise<HTMLElement>;
+/**
+ * Read a blob: URL and return its data URL, with memoization + shared cache.
+ * - Usa snapFetch(as:'dataURL') para convertir directo.
+ * - Dedupea inflight guardando la promesa en el Map.
+ * - Escribe también en cache.resource para reuso cross-módulo.
+ * @param {string} blobUrl
+ * @returns {Promise<string>} data URL
+ */
+export function blobUrlToDataUrl(blobUrl: string): Promise<string>;
+export function resolveBlobUrlsInTree(root: any): Promise<void>;

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

@@ -1,11 +1,3 @@
-/**
- * Adds a background color to the canvas if specified.
- * @param {HTMLCanvasElement} baseCanvas - Source canvas element.
- * @param {string} backgroundColor - CSS color string for the background.
- * @returns {HTMLCanvasElement} Returns the original canvas if no background needed,
- * or a new canvas with the background applied.
- */
-export function createBackground(baseCanvas: HTMLCanvasElement, backgroundColor: string): HTMLCanvasElement;
 /**
  * Inline a single background-image entry (one layer) robustly.
  * - If it's a URL() and fetching fails, degrade to "none" instead of throwing.

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Helper utilities for preparing DOM clones
+ * @module utils/prepare.helpers
+ */
+/**
+ * Stabilize layout by adding transparent border if element has outline but no border
+ * @param {Element} element
+ */
+export function stabilizeLayout(element: Element): void;

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

@@ -0,0 +1,118 @@
+/**
+ * Parse box-shadow and calculate bleed dimensions
+ * @param {CSSStyleDeclaration} cs
+ * @returns {{top: number, right: number, bottom: number, left: number}}
+ */
+export function parseBoxShadow(cs: CSSStyleDeclaration): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+/**
+ * Parse filter blur and calculate bleed
+ * @param {CSSStyleDeclaration} cs
+ * @returns {{top: number, right: number, bottom: number, left: number}}
+ */
+export function parseFilterBlur(cs: CSSStyleDeclaration): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+/**
+ * Parse outline and calculate bleed
+ * @param {CSSStyleDeclaration} cs
+ * @returns {{top: number, right: number, bottom: number, left: number}}
+ */
+export function parseOutline(cs: CSSStyleDeclaration): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+/**
+ * Parse filter drop-shadow and calculate bleed
+ * @param {CSSStyleDeclaration} cs
+ * @returns {{bleed: {top: number, right: number, bottom: number, left: number}, has: boolean}}
+ */
+export function parseFilterDropShadows(cs: CSSStyleDeclaration): {
+    bleed: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    has: boolean;
+};
+/**
+ * Remove only translate/rotate from CLONE ROOT transform, keeping scale/skew.
+ * Also forces transformOrigin to 0 0 to avoid negative offsets.
+ * Returns the applied 2D matrix components so the caller can expand the viewBox accordingly.
+ *
+ * @param {Element} originalEl
+ * @param {HTMLElement} cloneRoot
+ * @returns {{a:number,b:number,c:number,d:number}|null} The 2D matrix (without translation) or null if not applicable.
+ */
+export function normalizeRootTransforms(originalEl: Element, cloneRoot: HTMLElement): {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+} | null;
+/**
+ * Calculate bounding box with transform origin
+ * @param {number} w2
+ * @param {number} h2
+ * @param {DOMMatrix} M
+ * @param {number} ox2
+ * @param {number} oy2
+ * @returns {{minX: number, minY: number, maxX: number, maxY: number, width: number, height: number}}
+ */
+export function bboxWithOriginFull(w2: number, h2: number, M: DOMMatrix, ox2: number, oy2: number): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    width: number;
+    height: number;
+};
+/**
+ * Parses transform-origin supporting keywords (left/center/right, top/center/bottom).
+ * Returns pixel offsets.
+ * @param {CSSStyleDeclaration} cs
+ * @param {number} w
+ * @param {number} h
+ */
+export function parseTransformOriginPx(cs: CSSStyleDeclaration, w: number, h: number): {
+    ox: any;
+    oy: any;
+};
+/**
+ * Returns a robust snapshot of individual transform-like properties.
+ * Supports CSS Typed OM (CSSScale/CSSRotate/CSSTranslate) and legacy strings.
+ * @param {Element} el
+ * @returns {{ rotate:string, scale:string|null, translate:string|null }}
+ */
+export function readIndividualTransforms(el: Element): {
+    rotate: string;
+    scale: string | null;
+    translate: string | null;
+};
+/**
+ * Read total transform matrix from combined transform properties
+ * @param {object} t - Transform properties
+ * @returns {DOMMatrix}
+ */
+export function readTotalTransformMatrix(t: object): DOMMatrix;
+/**
+ * True if any transform (matrix or individual) can affect layout/bbox.
+ * @param {Element} el
+ */
+export function hasBBoxAffectingTransform(el: Element): boolean;
+/**
+ * Get matrix from computed style
+ * @param {Element} el
+ * @returns {DOMMatrix}
+ */
+export function matrixFromComputed(el: Element): DOMMatrix;

package/ui-color/compareColorByRange.js

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

package/ui-color/index.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import { TinyColor as e } from "../tinycolor/src/index.js";
 import { default as Q } from "./compareColorByRange.js";
 const c = 10, f = {

package/uiColor.js

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

package/url-toolkit/index.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import { buildAbsoluteURL as e, buildURLFromParts as l, default as o, normalizePath as t, parseURL as u } from "./src/url-toolkit.js";
 export {
   e as buildAbsoluteURL,

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

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

package/urlToolkit.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import { buildAbsoluteURL as e, buildURLFromParts as l, default as o, normalizePath as t, parseURL as u } from "./url-toolkit/src/url-toolkit.js";
 export {
   e as buildAbsoluteURL,

package/validate/index.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import { Schema as t, default as o } from "./src/index.js";
 import { default as l } from "./src/rules/array.js";
 import { default as d } from "./src/rules/boolean.js";

package/validate/src/index.js

@@ -1,4 +1,4 @@
-/* 2025-11-19 09:08:12 */
+/* 2025-11-27 12:11:03 */
 import V from "lodash/defaultsDeep";
 import u from "lodash/isArray.js";
 import E from "lodash/isFunction.js";