@ohos-ports/html2canvas-pro 0.0.0-stage → 2.3.2-beta.0

package/dist/lib/css/grouped/layout-styles.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutStyles = void 0;
+/**
+ * Read-only grouped accessor for layout/display/positioning CSS properties.
+ */
+class LayoutStyles {
+    constructor(styles) {
+        this.styles = styles;
+    }
+    get display() {
+        return this.styles.display;
+    }
+    get position() {
+        return this.styles.position;
+    }
+    get float() {
+        return this.styles.float;
+    }
+    // Explicit return type avoids name clash with z-index descriptor export.
+    get zIndex() {
+        return this.styles.zIndex;
+    }
+    get marginTop() {
+        return this.styles.marginTop;
+    }
+    get marginRight() {
+        return this.styles.marginRight;
+    }
+    get marginBottom() {
+        return this.styles.marginBottom;
+    }
+    get marginLeft() {
+        return this.styles.marginLeft;
+    }
+    get paddingTop() {
+        return this.styles.paddingTop;
+    }
+    get paddingRight() {
+        return this.styles.paddingRight;
+    }
+    get paddingBottom() {
+        return this.styles.paddingBottom;
+    }
+    get paddingLeft() {
+        return this.styles.paddingLeft;
+    }
+    get overflowX() {
+        return this.styles.overflowX;
+    }
+    get overflowY() {
+        return this.styles.overflowY;
+    }
+    get opacity() {
+        return this.styles.opacity;
+    }
+    get visibility() {
+        return this.styles.visibility;
+    }
+    get transform() {
+        return this.styles.transform;
+    }
+    get transformOrigin() {
+        return this.styles.transformOrigin;
+    }
+    get rotate() {
+        return this.styles.rotate;
+    }
+    get zoom() {
+        return this.styles.zoom;
+    }
+    get clipPath() {
+        return this.styles.clipPath;
+    }
+    get mixBlendMode() {
+        return this.styles.mixBlendMode;
+    }
+    get filter() {
+        return this.styles.filter;
+    }
+    get imageRendering() {
+        return this.styles.imageRendering;
+    }
+    get objectFit() {
+        return this.styles.objectFit;
+    }
+    get objectPosition() {
+        return this.styles.objectPosition;
+    }
+    get boxDecorationBreak() {
+        return this.styles.boxDecorationBreak;
+    }
+    get listStyleImage() {
+        return this.styles.listStyleImage;
+    }
+    get listStylePosition() {
+        return this.styles.listStylePosition;
+    }
+    get listStyleType() {
+        return this.styles.listStyleType;
+    }
+    get animationDuration() {
+        return this.styles.animationDuration;
+    }
+    isVisible() {
+        return this.styles.isVisible();
+    }
+    isTransparent() {
+        return this.styles.isTransparent();
+    }
+    isTransformed() {
+        return this.styles.isTransformed();
+    }
+    isPositioned() {
+        return this.styles.isPositioned();
+    }
+    isPositionedWithZIndex() {
+        return this.styles.isPositionedWithZIndex();
+    }
+    isFloating() {
+        return this.styles.isFloating();
+    }
+    isInlineLevel() {
+        return this.styles.isInlineLevel();
+    }
+}
+exports.LayoutStyles = LayoutStyles;

package/dist/lib/css/index.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSSParsedCounterDeclaration = exports.CSSParsedPseudoDeclaration = exports.CSSParsedDeclaration = void 0;
+const background_clip_1 = require("./property-descriptors/background-clip");
+const background_color_1 = require("./property-descriptors/background-color");
+const background_image_1 = require("./property-descriptors/background-image");
+const background_origin_1 = require("./property-descriptors/background-origin");
+const background_position_1 = require("./property-descriptors/background-position");
+const background_repeat_1 = require("./property-descriptors/background-repeat");
+const background_size_1 = require("./property-descriptors/background-size");
+const border_color_1 = require("./property-descriptors/border-color");
+const border_radius_1 = require("./property-descriptors/border-radius");
+const border_style_1 = require("./property-descriptors/border-style");
+const border_width_1 = require("./property-descriptors/border-width");
+const clip_path_1 = require("./property-descriptors/clip-path");
+const color_1 = require("./property-descriptors/color");
+const direction_1 = require("./property-descriptors/direction");
+const display_1 = require("./property-descriptors/display");
+const float_1 = require("./property-descriptors/float");
+const letter_spacing_1 = require("./property-descriptors/letter-spacing");
+const line_break_1 = require("./property-descriptors/line-break");
+const line_height_1 = require("./property-descriptors/line-height");
+const list_style_image_1 = require("./property-descriptors/list-style-image");
+const list_style_position_1 = require("./property-descriptors/list-style-position");
+const list_style_type_1 = require("./property-descriptors/list-style-type");
+const margin_1 = require("./property-descriptors/margin");
+const overflow_1 = require("./property-descriptors/overflow");
+const overflow_wrap_1 = require("./property-descriptors/overflow-wrap");
+const padding_1 = require("./property-descriptors/padding");
+const text_align_1 = require("./property-descriptors/text-align");
+const position_1 = require("./property-descriptors/position");
+const text_shadow_1 = require("./property-descriptors/text-shadow");
+const text_transform_1 = require("./property-descriptors/text-transform");
+const transform_1 = require("./property-descriptors/transform");
+const transform_origin_1 = require("./property-descriptors/transform-origin");
+const rotate_1 = require("./property-descriptors/rotate");
+const visibility_1 = require("./property-descriptors/visibility");
+const word_break_1 = require("./property-descriptors/word-break");
+const writing_mode_1 = require("./property-descriptors/writing-mode");
+const z_index_1 = require("./property-descriptors/z-index");
+const parser_1 = require("./syntax/parser");
+const tokenizer_1 = require("./syntax/tokenizer");
+const color_2 = require("./types/color");
+const color_utilities_1 = require("./types/color-utilities");
+const angle_1 = require("./types/angle");
+const image_1 = require("./types/image");
+const time_1 = require("./types/time");
+const opacity_1 = require("./property-descriptors/opacity");
+const text_decoration_color_1 = require("./property-descriptors/text-decoration-color");
+const text_decoration_line_1 = require("./property-descriptors/text-decoration-line");
+const text_decoration_style_1 = require("./property-descriptors/text-decoration-style");
+const text_decoration_thickness_1 = require("./property-descriptors/text-decoration-thickness");
+const text_underline_offset_1 = require("./property-descriptors/text-underline-offset");
+const length_percentage_1 = require("./types/length-percentage");
+const font_family_1 = require("./property-descriptors/font-family");
+const font_size_1 = require("./property-descriptors/font-size");
+const length_1 = require("./types/length");
+const font_weight_1 = require("./property-descriptors/font-weight");
+const font_variant_1 = require("./property-descriptors/font-variant");
+const font_style_1 = require("./property-descriptors/font-style");
+const bitwise_1 = require("../core/bitwise");
+const content_1 = require("./property-descriptors/content");
+const counter_increment_1 = require("./property-descriptors/counter-increment");
+const counter_reset_1 = require("./property-descriptors/counter-reset");
+const duration_1 = require("./property-descriptors/duration");
+const quotes_1 = require("./property-descriptors/quotes");
+const box_shadow_1 = require("./property-descriptors/box-shadow");
+const paint_order_1 = require("./property-descriptors/paint-order");
+const webkit_text_stroke_color_1 = require("./property-descriptors/webkit-text-stroke-color");
+const webkit_text_stroke_width_1 = require("./property-descriptors/webkit-text-stroke-width");
+const webkit_line_clamp_1 = require("./property-descriptors/webkit-line-clamp");
+const object_fit_1 = require("./property-descriptors/object-fit");
+const text_overflow_1 = require("./property-descriptors/text-overflow");
+const image_rendering_1 = require("./property-descriptors/image-rendering");
+const mix_blend_mode_1 = require("./property-descriptors/mix-blend-mode");
+const filter_1 = require("./property-descriptors/filter");
+const font_variant_ligatures_1 = require("./property-descriptors/font-variant-ligatures");
+const zoom_1 = require("./property-descriptors/zoom");
+const object_position_1 = require("./property-descriptors/object-position");
+const background_blend_mode_1 = require("./property-descriptors/background-blend-mode");
+const border_image_source_1 = require("./property-descriptors/border-image-source");
+const border_image_slice_1 = require("./property-descriptors/border-image-slice");
+const border_image_repeat_1 = require("./property-descriptors/border-image-repeat");
+const box_decoration_break_1 = require("./property-descriptors/box-decoration-break");
+const constants_1 = require("../core/constants");
+const border_styles_1 = require("./grouped/border-styles");
+const background_styles_1 = require("./grouped/background-styles");
+const font_styles_1 = require("./grouped/font-styles");
+const layout_styles_1 = require("./grouped/layout-styles");
+class CSSParsedDeclaration {
+    get border() {
+        return this._border ?? (this._border = new border_styles_1.BorderStyles(this));
+    }
+    get background() {
+        return this._background ?? (this._background = new background_styles_1.BackgroundStyles(this));
+    }
+    get font() {
+        return this._font ?? (this._font = new font_styles_1.FontStyles(this));
+    }
+    get layout() {
+        return this._layout ?? (this._layout = new layout_styles_1.LayoutStyles(this));
+    }
+    constructor(context, declaration) {
+        const standardProps = CSSParsedDeclaration.standardProps;
+        // Fast path: display:none elements are invisible and their descendants
+        // are never rendered. Parse only initial values instead of full computed styles.
+        if (declaration.display === 'none') {
+            this.display = 0 /* DISPLAY.NONE */;
+            for (const [key, descriptor] of standardProps) {
+                if (key !== 'display') {
+                    this[key] = parse(context, descriptor, undefined);
+                }
+            }
+            this.float = parse(context, float_1.float, undefined);
+            this.textDecorationColor = parse(context, text_decoration_color_1.textDecorationColor, undefined);
+            this.textDecorationLine = parse(context, text_decoration_line_1.textDecorationLine, undefined);
+            const overflowTuple = parse(context, overflow_1.overflow, undefined);
+            this.overflowX = overflowTuple[0];
+            this.overflowY = overflowTuple[overflowTuple.length > 1 ? 1 : 0];
+            return;
+        }
+        for (const [key, descriptor, cssProp] of standardProps) {
+            this[key] = parse(context, descriptor, declaration[cssProp]);
+        }
+        // Special cases that need different CSS property names or fallback values
+        this.float = parse(context, float_1.float, declaration.cssFloat);
+        this.textDecorationColor = parse(context, text_decoration_color_1.textDecorationColor, declaration.textDecorationColor ?? declaration.color);
+        this.textDecorationLine = parse(context, text_decoration_line_1.textDecorationLine, declaration.textDecorationLine ?? declaration.textDecoration);
+        // overflow returns a tuple that must be split into X/Y
+        const overflowTuple = parse(context, overflow_1.overflow, declaration.overflow);
+        this.overflowX = overflowTuple[0];
+        this.overflowY = overflowTuple[overflowTuple.length > 1 ? 1 : 0];
+    }
+    isVisible() {
+        return this.display > 0 && this.opacity > 0 && this.visibility === 0 /* VISIBILITY.VISIBLE */;
+    }
+    isTransparent() {
+        return (0, color_utilities_1.isTransparent)(this.backgroundColor);
+    }
+    isTransformed() {
+        return this.transform !== null || this.rotate !== null;
+    }
+    isPositioned() {
+        return this.position !== 0 /* POSITION.STATIC */;
+    }
+    isPositionedWithZIndex() {
+        return this.isPositioned() && !this.zIndex.auto;
+    }
+    isFloating() {
+        return this.float !== 0 /* FLOAT.NONE */;
+    }
+    isInlineLevel() {
+        return ((0, bitwise_1.contains)(this.display, 4 /* DISPLAY.INLINE */) ||
+            (0, bitwise_1.contains)(this.display, 33554432 /* DISPLAY.INLINE_BLOCK */) ||
+            (0, bitwise_1.contains)(this.display, 268435456 /* DISPLAY.INLINE_FLEX */) ||
+            (0, bitwise_1.contains)(this.display, 536870912 /* DISPLAY.INLINE_GRID */) ||
+            (0, bitwise_1.contains)(this.display, 67108864 /* DISPLAY.INLINE_LIST_ITEM */) ||
+            (0, bitwise_1.contains)(this.display, 134217728 /* DISPLAY.INLINE_TABLE */));
+    }
+}
+exports.CSSParsedDeclaration = CSSParsedDeclaration;
+CSSParsedDeclaration.standardProps = [
+    ['animationDuration', duration_1.duration, 'animationDuration'],
+    ['backgroundClip', background_clip_1.backgroundClip, 'backgroundClip'],
+    ['backgroundColor', background_color_1.backgroundColor, 'backgroundColor'],
+    ['backgroundImage', background_image_1.backgroundImage, 'backgroundImage'],
+    ['backgroundOrigin', background_origin_1.backgroundOrigin, 'backgroundOrigin'],
+    ['backgroundPosition', background_position_1.backgroundPosition, 'backgroundPosition'],
+    ['backgroundRepeat', background_repeat_1.backgroundRepeat, 'backgroundRepeat'],
+    ['backgroundSize', background_size_1.backgroundSize, 'backgroundSize'],
+    ['borderTopColor', border_color_1.borderTopColor, 'borderTopColor'],
+    ['borderRightColor', border_color_1.borderRightColor, 'borderRightColor'],
+    ['borderBottomColor', border_color_1.borderBottomColor, 'borderBottomColor'],
+    ['borderLeftColor', border_color_1.borderLeftColor, 'borderLeftColor'],
+    ['borderTopLeftRadius', border_radius_1.borderTopLeftRadius, 'borderTopLeftRadius'],
+    ['borderTopRightRadius', border_radius_1.borderTopRightRadius, 'borderTopRightRadius'],
+    ['borderBottomRightRadius', border_radius_1.borderBottomRightRadius, 'borderBottomRightRadius'],
+    ['borderBottomLeftRadius', border_radius_1.borderBottomLeftRadius, 'borderBottomLeftRadius'],
+    ['borderTopStyle', border_style_1.borderTopStyle, 'borderTopStyle'],
+    ['borderRightStyle', border_style_1.borderRightStyle, 'borderRightStyle'],
+    ['borderBottomStyle', border_style_1.borderBottomStyle, 'borderBottomStyle'],
+    ['borderLeftStyle', border_style_1.borderLeftStyle, 'borderLeftStyle'],
+    ['borderTopWidth', border_width_1.borderTopWidth, 'borderTopWidth'],
+    ['borderRightWidth', border_width_1.borderRightWidth, 'borderRightWidth'],
+    ['borderBottomWidth', border_width_1.borderBottomWidth, 'borderBottomWidth'],
+    ['borderLeftWidth', border_width_1.borderLeftWidth, 'borderLeftWidth'],
+    ['boxShadow', box_shadow_1.boxShadow, 'boxShadow'],
+    ['clipPath', clip_path_1.clipPath, 'clipPath'],
+    ['color', color_1.color, 'color'],
+    ['direction', direction_1.direction, 'direction'],
+    ['display', display_1.display, 'display'],
+    ['fontFamily', font_family_1.fontFamily, 'fontFamily'],
+    ['fontSize', font_size_1.fontSize, 'fontSize'],
+    ['fontStyle', font_style_1.fontStyle, 'fontStyle'],
+    ['fontVariant', font_variant_1.fontVariant, 'fontVariant'],
+    ['fontWeight', font_weight_1.fontWeight, 'fontWeight'],
+    ['letterSpacing', letter_spacing_1.letterSpacing, 'letterSpacing'],
+    ['lineBreak', line_break_1.lineBreak, 'lineBreak'],
+    ['lineHeight', line_height_1.lineHeight, 'lineHeight'],
+    ['listStyleImage', list_style_image_1.listStyleImage, 'listStyleImage'],
+    ['listStylePosition', list_style_position_1.listStylePosition, 'listStylePosition'],
+    ['listStyleType', list_style_type_1.listStyleType, 'listStyleType'],
+    ['marginTop', margin_1.marginTop, 'marginTop'],
+    ['marginRight', margin_1.marginRight, 'marginRight'],
+    ['marginBottom', margin_1.marginBottom, 'marginBottom'],
+    ['marginLeft', margin_1.marginLeft, 'marginLeft'],
+    ['opacity', opacity_1.opacity, 'opacity'],
+    ['overflowWrap', overflow_wrap_1.overflowWrap, 'overflowWrap'],
+    ['paddingTop', padding_1.paddingTop, 'paddingTop'],
+    ['paddingRight', padding_1.paddingRight, 'paddingRight'],
+    ['paddingBottom', padding_1.paddingBottom, 'paddingBottom'],
+    ['paddingLeft', padding_1.paddingLeft, 'paddingLeft'],
+    ['paintOrder', paint_order_1.paintOrder, 'paintOrder'],
+    ['position', position_1.position, 'position'],
+    ['textAlign', text_align_1.textAlign, 'textAlign'],
+    ['textDecorationStyle', text_decoration_style_1.textDecorationStyle, 'textDecorationStyle'],
+    ['textDecorationThickness', text_decoration_thickness_1.textDecorationThickness, 'textDecorationThickness'],
+    ['textUnderlineOffset', text_underline_offset_1.textUnderlineOffset, 'textUnderlineOffset'],
+    ['textShadow', text_shadow_1.textShadow, 'textShadow'],
+    ['textTransform', text_transform_1.textTransform, 'textTransform'],
+    ['textOverflow', text_overflow_1.textOverflow, 'textOverflow'],
+    ['transform', transform_1.transform, 'transform'],
+    ['transformOrigin', transform_origin_1.transformOrigin, 'transformOrigin'],
+    ['rotate', rotate_1.rotate, 'rotate'],
+    ['visibility', visibility_1.visibility, 'visibility'],
+    ['webkitTextStrokeColor', webkit_text_stroke_color_1.webkitTextStrokeColor, 'webkitTextStrokeColor'],
+    ['webkitTextStrokeWidth', webkit_text_stroke_width_1.webkitTextStrokeWidth, 'webkitTextStrokeWidth'],
+    ['webkitLineClamp', webkit_line_clamp_1.webkitLineClamp, 'webkitLineClamp'],
+    ['wordBreak', word_break_1.wordBreak, 'wordBreak'],
+    ['writingMode', writing_mode_1.writingMode, 'writingMode'],
+    ['zIndex', z_index_1.zIndex, 'zIndex'],
+    ['objectFit', object_fit_1.objectFit, 'objectFit'],
+    ['imageRendering', image_rendering_1.imageRendering, 'imageRendering'],
+    ['mixBlendMode', mix_blend_mode_1.mixBlendMode, 'mixBlendMode'],
+    ['filter', filter_1.filter, 'filter'],
+    ['fontVariantLigatures', font_variant_ligatures_1.fontVariantLigatures, 'fontVariantLigatures'],
+    ['zoom', zoom_1.zoom, 'zoom'],
+    ['objectPosition', object_position_1.objectPosition, 'objectPosition'],
+    ['backgroundBlendMode', background_blend_mode_1.backgroundBlendMode, 'backgroundBlendMode'],
+    ['borderImageSource', border_image_source_1.borderImageSource, 'borderImageSource'],
+    ['borderImageSlice', border_image_slice_1.borderImageSlice, 'borderImageSlice'],
+    ['borderImageRepeat', border_image_repeat_1.borderImageRepeat, 'borderImageRepeat'],
+    ['boxDecorationBreak', box_decoration_break_1.boxDecorationBreak, 'boxDecorationBreak']
+];
+class CSSParsedPseudoDeclaration {
+    constructor(context, declaration) {
+        this.content = parse(context, content_1.content, declaration.content);
+        this.quotes = parse(context, quotes_1.quotes, declaration.quotes);
+    }
+}
+exports.CSSParsedPseudoDeclaration = CSSParsedPseudoDeclaration;
+class CSSParsedCounterDeclaration {
+    constructor(context, declaration) {
+        this.counterIncrement = parse(context, counter_increment_1.counterIncrement, declaration.counterIncrement);
+        this.counterReset = parse(context, counter_reset_1.counterReset, declaration.counterReset);
+    }
+}
+exports.CSSParsedCounterDeclaration = CSSParsedCounterDeclaration;
+const parseCache = new Map();
+const parse = (context, descriptor, style) => {
+    const rawValue = style !== null && typeof style !== 'undefined' ? style.toString() : descriptor.initialValue;
+    let valueCache = parseCache.get(descriptor);
+    if (valueCache) {
+        const cached = valueCache.get(rawValue);
+        if (cached !== undefined) {
+            valueCache.delete(rawValue);
+            valueCache.set(rawValue, cached);
+            return cached;
+        }
+    }
+    const tokenizer = tokenizer_1.Tokenizer.get();
+    tokenizer.write(rawValue);
+    const parser = new parser_1.Parser(tokenizer.read());
+    tokenizer_1.Tokenizer.release(tokenizer);
+    // Use IIFE so TS infers the return type of each branch (no `let result: any`)
+    const result = (() => {
+        switch (descriptor.type) {
+            case 2 /* PropertyDescriptorParsingType.IDENT_VALUE */: {
+                const token = parser.parseComponentValue();
+                return descriptor.parse(context, (0, parser_1.isIdentToken)(token) ? token.value : descriptor.initialValue);
+            }
+            case 0 /* PropertyDescriptorParsingType.VALUE */:
+                return descriptor.parse(context, parser.parseComponentValue());
+            case 1 /* PropertyDescriptorParsingType.LIST */:
+                return descriptor.parse(context, parser.parseComponentValues());
+            case 4 /* PropertyDescriptorParsingType.TOKEN_VALUE */:
+                return parser.parseComponentValue();
+            case 3 /* PropertyDescriptorParsingType.TYPE_VALUE */:
+                switch (descriptor.format) {
+                    case 'angle':
+                        return angle_1.angle.parse(context, parser.parseComponentValue());
+                    case 'color':
+                        return color_2.color.parse(context, parser.parseComponentValue());
+                    case 'image':
+                        return image_1.image.parse(context, parser.parseComponentValue());
+                    case 'length': {
+                        const length = parser.parseComponentValue();
+                        return (0, length_1.isLength)(length) ? length : length_percentage_1.ZERO_LENGTH;
+                    }
+                    case 'length-percentage': {
+                        const value = parser.parseComponentValue();
+                        return (0, length_percentage_1.isLengthPercentage)(value) ? value : length_percentage_1.ZERO_LENGTH;
+                    }
+                    case 'time':
+                        return time_1.time.parse(context, parser.parseComponentValue());
+                }
+        }
+    })();
+    if (!valueCache) {
+        valueCache = new Map();
+        parseCache.set(descriptor, valueCache);
+    }
+    // Skip caching for descriptors whose parse() has the critical side effect
+    // of calling context.cache.addImage() which must run on every render pass
+    // (different cache instances per html2canvas call). Two paths:
+    // 1. Per-descriptor skipCache flag (backgroundImage, listStyleImage,
+    //    borderImageSource — all call image.parse() internally).
+    // 2. TYPE_VALUE + format 'image' — the image type descriptor itself,
+    //    which calls addImage() directly.
+    const skipCache = descriptor.skipCache ||
+        (descriptor.type === 3 /* PropertyDescriptorParsingType.TYPE_VALUE */ && descriptor.format === 'image');
+    if (!skipCache) {
+        if (valueCache.size >= constants_1.PARSE_CACHE_MAX_PER_DESCRIPTOR) {
+            const oldestKey = valueCache.keys().next().value;
+            valueCache.delete(oldestKey);
+        }
+        valueCache.set(rawValue, result);
+    }
+    return result;
+};

package/dist/lib/css/layout/bounds.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDocumentSize = exports.parseBounds = exports.Bounds = void 0;
+class Bounds {
+    constructor(left, top, width, height) {
+        this.left = left;
+        this.top = top;
+        this.width = width;
+        this.height = height;
+    }
+    add(x, y, w, h) {
+        return new Bounds(this.left + x, this.top + y, this.width + w, this.height + h);
+    }
+    static fromClientRect(context, clientRect) {
+        return new Bounds(clientRect.left + context.windowBounds.left, clientRect.top + context.windowBounds.top, clientRect.width, clientRect.height);
+    }
+    static fromDOMRectList(context, domRectList) {
+        const rects = Array.from(domRectList);
+        // First try to find a rect with non-zero width
+        let domRect = rects.find((rect) => rect.width !== 0);
+        // If not found, try to find a rect with non-zero height
+        // This handles cases like inline-flex with single child where width might be 0
+        if (!domRect) {
+            domRect = rects.find((rect) => rect.height !== 0);
+        }
+        // If still not found but rects exist, use the first rect
+        // Position info (left, top) might still be valid even if dimensions are 0
+        if (!domRect && rects.length > 0) {
+            domRect = rects[0];
+        }
+        return domRect
+            ? new Bounds(domRect.left + context.windowBounds.left, domRect.top + context.windowBounds.top, domRect.width, domRect.height)
+            : Bounds.EMPTY;
+    }
+}
+exports.Bounds = Bounds;
+Bounds.EMPTY = new Bounds(0, 0, 0, 0);
+const parseBounds = (context, node) => {
+    return Bounds.fromClientRect(context, node.getBoundingClientRect());
+};
+exports.parseBounds = parseBounds;
+const parseDocumentSize = (document) => {
+    const body = document.body;
+    const documentElement = document.documentElement;
+    if (!body || !documentElement) {
+        throw new Error(`Unable to get document size`);
+    }
+    const width = Math.max(Math.max(body.scrollWidth, documentElement.scrollWidth), Math.max(body.offsetWidth, documentElement.offsetWidth), Math.max(body.clientWidth, documentElement.clientWidth));
+    const height = Math.max(Math.max(body.scrollHeight, documentElement.scrollHeight), Math.max(body.offsetHeight, documentElement.offsetHeight), Math.max(body.clientHeight, documentElement.clientHeight));
+    return new Bounds(0, 0, width, height);
+};
+exports.parseDocumentSize = parseDocumentSize;

package/dist/lib/css/layout/text.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segmentGraphemes = exports.parseTextBounds = exports.TextBounds = void 0;
+const css_line_break_1 = require("css-line-break");
+const text_segmentation_1 = require("text-segmentation");
+const bounds_1 = require("./bounds");
+const features_1 = require("../../core/features");
+const writing_mode_1 = require("../property-descriptors/writing-mode");
+class TextBounds {
+    constructor(text, bounds) {
+        this.text = text;
+        this.bounds = bounds;
+    }
+}
+exports.TextBounds = TextBounds;
+const parseTextBounds = (context, value, styles, node) => {
+    const textList = breakText(value, styles);
+    const textBounds = [];
+    let offset = 0;
+    textList.forEach((text) => {
+        if (styles.textDecorationLine.length || text.trim().length > 0) {
+            if (features_1.FEATURES.SUPPORT_RANGE_BOUNDS) {
+                const clientRects = createRange(node, offset, text.length).getClientRects();
+                if (clientRects.length > 1) {
+                    const subSegments = (0, exports.segmentGraphemes)(text);
+                    let subOffset = 0;
+                    subSegments.forEach((subSegment) => {
+                        textBounds.push(new TextBounds(subSegment, bounds_1.Bounds.fromDOMRectList(context, createRange(node, subOffset + offset, subSegment.length).getClientRects())));
+                        subOffset += subSegment.length;
+                    });
+                }
+                else {
+                    textBounds.push(new TextBounds(text, bounds_1.Bounds.fromDOMRectList(context, clientRects)));
+                }
+            }
+            else {
+                const replacementNode = node.splitText(text.length);
+                textBounds.push(new TextBounds(text, getWrapperBounds(context, node)));
+                node = replacementNode;
+            }
+        }
+        else if (!features_1.FEATURES.SUPPORT_RANGE_BOUNDS) {
+            node = node.splitText(text.length);
+        }
+        offset += text.length;
+    });
+    return textBounds;
+};
+exports.parseTextBounds = parseTextBounds;
+const getWrapperBounds = (context, node) => {
+    const ownerDocument = node.ownerDocument;
+    if (ownerDocument) {
+        const wrapper = ownerDocument.createElement('html2canvaswrapper');
+        wrapper.appendChild(node.cloneNode(true));
+        const parentNode = node.parentNode;
+        if (parentNode) {
+            parentNode.replaceChild(wrapper, node);
+            const bounds = (0, bounds_1.parseBounds)(context, wrapper);
+            if (wrapper.firstChild) {
+                parentNode.replaceChild(wrapper.firstChild, wrapper);
+            }
+            return bounds;
+        }
+    }
+    return bounds_1.Bounds.EMPTY;
+};
+const createRange = (node, offset, length) => {
+    const ownerDocument = node.ownerDocument;
+    if (!ownerDocument) {
+        throw new Error('Node has no owner document');
+    }
+    const range = ownerDocument.createRange();
+    range.setStart(node, offset);
+    range.setEnd(node, offset + length);
+    return range;
+};
+const segmentGraphemes = (value) => {
+    if (features_1.FEATURES.SUPPORT_NATIVE_TEXT_SEGMENTATION) {
+        // Intl.Segmenter is TC39 Stage 4 but not yet in TS lib types
+        const Segmenter = Intl;
+        const seg = new Segmenter.Segmenter(void 0, { granularity: 'grapheme' });
+        return Array.from(seg.segment(value)).map((s) => s.segment);
+    }
+    return (0, text_segmentation_1.splitGraphemes)(value);
+};
+exports.segmentGraphemes = segmentGraphemes;
+const segmentWords = (value, styles) => {
+    if (features_1.FEATURES.SUPPORT_NATIVE_TEXT_SEGMENTATION) {
+        const Segmenter = Intl;
+        const seg = new Segmenter.Segmenter(void 0, { granularity: 'word' });
+        return Array.from(seg.segment(value)).map((s) => s.segment);
+    }
+    return breakWords(value, styles);
+};
+const breakText = (value, styles) => {
+    if ((0, writing_mode_1.isVerticalWritingMode)(styles.writingMode)) {
+        return (0, exports.segmentGraphemes)(value);
+    }
+    return styles.letterSpacing !== 0 ? (0, exports.segmentGraphemes)(value) : segmentWords(value, styles);
+};
+// https://drafts.csswg.org/css-text/#word-separator
+const wordSeparators = [0x0020, 0x00a0, 0x1361, 0x10100, 0x10101, 0x1039, 0x1091];
+const breakWords = (str, styles) => {
+    const breaker = (0, css_line_break_1.LineBreaker)(str, {
+        lineBreak: styles.lineBreak,
+        wordBreak: styles.overflowWrap === "break-word" /* OVERFLOW_WRAP.BREAK_WORD */ ? 'break-word' : styles.wordBreak
+    });
+    const words = [];
+    let bk;
+    while (!(bk = breaker.next()).done) {
+        if (bk.value) {
+            const value = bk.value.slice();
+            const codePoints = (0, css_line_break_1.toCodePoints)(value);
+            let word = '';
+            codePoints.forEach((codePoint) => {
+                if (wordSeparators.indexOf(codePoint) === -1) {
+                    word += (0, css_line_break_1.fromCodePoint)(codePoint);
+                }
+                else {
+                    if (word.length) {
+                        words.push(word);
+                    }
+                    words.push((0, css_line_break_1.fromCodePoint)(codePoint));
+                    word = '';
+                }
+            });
+            if (word.length) {
+                words.push(word);
+            }
+        }
+    }
+    return words;
+};

package/dist/lib/css/property-descriptor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });