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

package/dist/lib/css/property-descriptors/content.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.content = void 0;
+exports.content = {
+    name: 'content',
+    initialValue: 'none',
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    prefix: false,
+    parse: (_context, tokens) => {
+        if (tokens.length === 0) {
+            return [];
+        }
+        const first = tokens[0];
+        if (first.type === 20 /* TokenType.IDENT_TOKEN */ && first.value === 'none') {
+            return [];
+        }
+        return tokens;
+    }
+};

package/dist/lib/css/property-descriptors/counter-increment.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.counterIncrement = exports.parseCounterValue = void 0;
+const parser_1 = require("../syntax/parser");
+/** Shared counter-ID parsing: returns next number or a fallback default. */
+const parseCounterValue = (tokens, defaultNumber) => {
+    const entries = [];
+    const filtered = tokens.filter(parser_1.nonWhiteSpace);
+    for (let i = 0; i < filtered.length; i++) {
+        const counter = filtered[i];
+        const next = filtered[i + 1];
+        if (counter.type === 20 /* TokenType.IDENT_TOKEN */) {
+            const num = next && (0, parser_1.isNumberToken)(next) ? next.number : defaultNumber;
+            entries.push([counter.value, num]);
+        }
+    }
+    return entries;
+};
+exports.parseCounterValue = parseCounterValue;
+exports.counterIncrement = {
+    name: 'counter-increment',
+    initialValue: 'none',
+    prefix: true,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        if (tokens.length === 0) {
+            return null;
+        }
+        const first = tokens[0];
+        if (first.type === 20 /* TokenType.IDENT_TOKEN */ && first.value === 'none') {
+            return null;
+        }
+        return (0, exports.parseCounterValue)(tokens, 1).map(([counter, increment]) => ({ counter, increment }));
+    }
+};

package/dist/lib/css/property-descriptors/counter-reset.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.counterReset = void 0;
+const counter_increment_1 = require("./counter-increment");
+exports.counterReset = {
+    name: 'counter-reset',
+    initialValue: 'none',
+    prefix: true,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        if (tokens.length === 0) {
+            return [];
+        }
+        return (0, counter_increment_1.parseCounterValue)(tokens, 0)
+            .filter(([counter]) => counter !== 'none')
+            .map(([counter, reset]) => ({ counter, reset }));
+    }
+};

package/dist/lib/css/property-descriptors/direction.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.direction = void 0;
+exports.direction = {
+    name: 'direction',
+    initialValue: 'ltr',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, direction) => {
+        switch (direction) {
+            case 'rtl':
+                return 1 /* DIRECTION.RTL */;
+            case 'ltr':
+            default:
+                return 0 /* DIRECTION.LTR */;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/display.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.display = void 0;
+const parser_1 = require("../syntax/parser");
+exports.display = {
+    name: 'display',
+    initialValue: 'inline-block',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return tokens.filter(parser_1.isIdentToken).reduce((bit, token) => {
+            return bit | parseDisplayValue(token.value);
+        }, 0 /* DISPLAY.NONE */);
+    }
+};
+const parseDisplayValue = (display) => {
+    switch (display) {
+        case 'block':
+        case '-webkit-box':
+            return 2 /* DISPLAY.BLOCK */;
+        case 'inline':
+            return 4 /* DISPLAY.INLINE */;
+        case 'run-in':
+            return 8 /* DISPLAY.RUN_IN */;
+        case 'flow':
+            return 16 /* DISPLAY.FLOW */;
+        case 'flow-root':
+            return 32 /* DISPLAY.FLOW_ROOT */;
+        case 'table':
+            return 64 /* DISPLAY.TABLE */;
+        case 'flex':
+        case '-webkit-flex':
+            return 128 /* DISPLAY.FLEX */;
+        case 'grid':
+        case '-ms-grid':
+            return 256 /* DISPLAY.GRID */;
+        case 'ruby':
+            return 512 /* DISPLAY.RUBY */;
+        case 'subgrid':
+            return 1024 /* DISPLAY.SUBGRID */;
+        case 'list-item':
+            return 2048 /* DISPLAY.LIST_ITEM */;
+        case 'table-row-group':
+            return 4096 /* DISPLAY.TABLE_ROW_GROUP */;
+        case 'table-header-group':
+            return 8192 /* DISPLAY.TABLE_HEADER_GROUP */;
+        case 'table-footer-group':
+            return 16384 /* DISPLAY.TABLE_FOOTER_GROUP */;
+        case 'table-row':
+            return 32768 /* DISPLAY.TABLE_ROW */;
+        case 'table-cell':
+            return 65536 /* DISPLAY.TABLE_CELL */;
+        case 'table-column-group':
+            return 131072 /* DISPLAY.TABLE_COLUMN_GROUP */;
+        case 'table-column':
+            return 262144 /* DISPLAY.TABLE_COLUMN */;
+        case 'table-caption':
+            return 524288 /* DISPLAY.TABLE_CAPTION */;
+        case 'ruby-base':
+            return 1048576 /* DISPLAY.RUBY_BASE */;
+        case 'ruby-text':
+            return 2097152 /* DISPLAY.RUBY_TEXT */;
+        case 'ruby-base-container':
+            return 4194304 /* DISPLAY.RUBY_BASE_CONTAINER */;
+        case 'ruby-text-container':
+            return 8388608 /* DISPLAY.RUBY_TEXT_CONTAINER */;
+        case 'contents':
+            return 16777216 /* DISPLAY.CONTENTS */;
+        case 'inline-block':
+            return 33554432 /* DISPLAY.INLINE_BLOCK */;
+        case 'inline-list-item':
+            return 67108864 /* DISPLAY.INLINE_LIST_ITEM */;
+        case 'inline-table':
+            return 134217728 /* DISPLAY.INLINE_TABLE */;
+        case 'inline-flex':
+            return 268435456 /* DISPLAY.INLINE_FLEX */;
+        case 'inline-grid':
+            return 536870912 /* DISPLAY.INLINE_GRID */;
+    }
+    return 0 /* DISPLAY.NONE */;
+};

package/dist/lib/css/property-descriptors/duration.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duration = void 0;
+const parser_1 = require("../syntax/parser");
+const time_1 = require("../types/time");
+exports.duration = {
+    name: 'duration',
+    initialValue: '0s',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (context, tokens) => {
+        return tokens.filter(parser_1.isDimensionToken).map((token) => time_1.time.parse(context, token));
+    }
+};

package/dist/lib/css/property-descriptors/filter.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filter = void 0;
+exports.filter = {
+    name: 'filter',
+    initialValue: 'none',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        if (tokens.length === 1 && tokens[0].type === 20 /* TokenType.IDENT_TOKEN */ && tokens[0].value === 'none') {
+            return null;
+        }
+        const parts = [];
+        for (const token of tokens) {
+            if (token.type === 18 /* TokenType.FUNCTION */) {
+                const fn = token;
+                // Reconstruct the function string from its name + values
+                const renderedArgs = renderFilterArgs(fn.values);
+                // Canvas API supports the same CSS filter string format
+                switch (fn.name) {
+                    case 'blur':
+                        parts.push(`blur(${renderedArgs}px)`);
+                        break;
+                    case 'brightness':
+                    case 'contrast':
+                    case 'invert':
+                    case 'opacity':
+                    case 'saturate':
+                    case 'sepia':
+                        parts.push(`${fn.name}(${renderedArgs})`);
+                        break;
+                    case 'grayscale':
+                        parts.push(`grayscale(${renderedArgs})`);
+                        break;
+                    case 'hue-rotate':
+                        parts.push(`hue-rotate(${renderedArgs}deg)`);
+                        break;
+                    case 'drop-shadow':
+                        parts.push(`drop-shadow(${renderedArgs})`);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        return parts.length > 0 ? parts.join(' ') : null;
+    }
+};
+/**
+ * Render filter function arguments back into a CSS string suitable for Canvas API.
+ * Canvas 2D `ctx.filter` accepts the same CSS filter function strings.
+ */
+const renderFilterArgs = (values) => {
+    const parts = [];
+    for (const v of values) {
+        if (v.type === 31 /* TokenType.WHITESPACE_TOKEN */) {
+            continue;
+        }
+        if (v.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+            parts.push(`${v.number}${v.unit}`);
+        }
+        else if (v.type === 17 /* TokenType.NUMBER_TOKEN */) {
+            parts.push(`${v.number}`);
+        }
+        else if (v.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
+            parts.push(`${v.number}%`);
+        }
+        else if (v.type === 20 /* TokenType.IDENT_TOKEN */) {
+            parts.push(v.value);
+        }
+        else if (v.type === 5 /* TokenType.HASH_TOKEN */) {
+            parts.push(`#${v.value}`);
+        }
+    }
+    return parts.join(' ');
+};

package/dist/lib/css/property-descriptors/float.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.float = void 0;
+exports.float = {
+    name: 'float',
+    initialValue: 'none',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, float) => {
+        switch (float) {
+            case 'left':
+                return 1 /* FLOAT.LEFT */;
+            case 'right':
+                return 2 /* FLOAT.RIGHT */;
+            case 'inline-start':
+                return 3 /* FLOAT.INLINE_START */;
+            case 'inline-end':
+                return 4 /* FLOAT.INLINE_END */;
+        }
+        return 0 /* FLOAT.NONE */;
+    }
+};

package/dist/lib/css/property-descriptors/font-family.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontFamily = void 0;
+exports.fontFamily = {
+    name: `font-family`,
+    initialValue: '',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        const accumulator = [];
+        const results = [];
+        tokens.forEach((token) => {
+            switch (token.type) {
+                case 20 /* TokenType.IDENT_TOKEN */:
+                case 0 /* TokenType.STRING_TOKEN */:
+                    accumulator.push(token.value);
+                    break;
+                case 17 /* TokenType.NUMBER_TOKEN */:
+                    accumulator.push(token.number.toString());
+                    break;
+                case 4 /* TokenType.COMMA_TOKEN */:
+                    results.push(accumulator.join(' '));
+                    accumulator.length = 0;
+                    break;
+            }
+        });
+        if (accumulator.length) {
+            results.push(accumulator.join(' '));
+        }
+        return results.map((result) => (result.indexOf(' ') === -1 ? result : `'${result}'`));
+    }
+};

package/dist/lib/css/property-descriptors/font-size.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontSize = void 0;
+exports.fontSize = {
+    name: `font-size`,
+    initialValue: '0',
+    prefix: false,
+    type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
+    format: 'length'
+};

package/dist/lib/css/property-descriptors/font-style.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontStyle = void 0;
+exports.fontStyle = {
+    name: 'font-style',
+    initialValue: 'normal',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, overflow) => {
+        switch (overflow) {
+            case 'oblique':
+                return "oblique" /* FONT_STYLE.OBLIQUE */;
+            case 'italic':
+                return "italic" /* FONT_STYLE.ITALIC */;
+            case 'normal':
+            default:
+                return "normal" /* FONT_STYLE.NORMAL */;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/font-variant-ligatures.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontVariantLigatures = void 0;
+exports.fontVariantLigatures = {
+    name: 'font-variant-ligatures',
+    initialValue: 'normal',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, value) => {
+        switch (value) {
+            case 'none':
+                return 1 /* FONT_VARIANT_LIGATURES.NONE */;
+            case 'common-ligatures':
+                return 2 /* FONT_VARIANT_LIGATURES.COMMON_LIGATURES */;
+            case 'no-common-ligatures':
+                return 3 /* FONT_VARIANT_LIGATURES.NO_COMMON_LIGATURES */;
+            case 'discretionary-ligatures':
+                return 4 /* FONT_VARIANT_LIGATURES.DISCRETIONARY_LIGATURES */;
+            case 'no-discretionary-ligatures':
+                return 5 /* FONT_VARIANT_LIGATURES.NO_DISCRETIONARY_LIGATURES */;
+            case 'historical-ligatures':
+                return 6 /* FONT_VARIANT_LIGATURES.HISTORICAL_LIGATURES */;
+            case 'no-historical-ligatures':
+                return 7 /* FONT_VARIANT_LIGATURES.NO_HISTORICAL_LIGATURES */;
+            case 'contextual':
+                return 8 /* FONT_VARIANT_LIGATURES.CONTEXTUAL */;
+            case 'no-contextual':
+                return 9 /* FONT_VARIANT_LIGATURES.NO_CONTEXTUAL */;
+            case 'normal':
+            default:
+                return 0 /* FONT_VARIANT_LIGATURES.NORMAL */;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/font-variant.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontVariant = void 0;
+const parser_1 = require("../syntax/parser");
+exports.fontVariant = {
+    name: 'font-variant',
+    initialValue: 'none',
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    prefix: false,
+    parse: (_context, tokens) => {
+        return tokens.filter(parser_1.isIdentToken).map((token) => token.value);
+    }
+};

package/dist/lib/css/property-descriptors/font-weight.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontWeight = void 0;
+const parser_1 = require("../syntax/parser");
+exports.fontWeight = {
+    name: 'font-weight',
+    initialValue: 'normal',
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    prefix: false,
+    parse: (_context, token) => {
+        if ((0, parser_1.isNumberToken)(token)) {
+            return token.number;
+        }
+        if ((0, parser_1.isIdentToken)(token)) {
+            switch (token.value) {
+                case 'bold':
+                    return 700;
+                case 'normal':
+                default:
+                    return 400;
+            }
+        }
+        return 400;
+    }
+};

package/dist/lib/css/property-descriptors/image-rendering.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageRendering = exports.IMAGE_RENDERING = void 0;
+var IMAGE_RENDERING;
+(function (IMAGE_RENDERING) {
+    IMAGE_RENDERING[IMAGE_RENDERING["AUTO"] = 0] = "AUTO";
+    IMAGE_RENDERING[IMAGE_RENDERING["CRISP_EDGES"] = 1] = "CRISP_EDGES";
+    IMAGE_RENDERING[IMAGE_RENDERING["PIXELATED"] = 2] = "PIXELATED";
+    IMAGE_RENDERING[IMAGE_RENDERING["SMOOTH"] = 3] = "SMOOTH";
+})(IMAGE_RENDERING || (exports.IMAGE_RENDERING = IMAGE_RENDERING = {}));
+exports.imageRendering = {
+    name: 'image-rendering',
+    initialValue: 'auto',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, value) => {
+        switch (value.toLowerCase()) {
+            case 'crisp-edges':
+            case '-webkit-crisp-edges':
+            case '-moz-crisp-edges':
+                return IMAGE_RENDERING.CRISP_EDGES;
+            case 'pixelated':
+            case '-webkit-optimize-contrast':
+                return IMAGE_RENDERING.PIXELATED;
+            case 'smooth':
+            case 'high-quality':
+                return IMAGE_RENDERING.SMOOTH;
+            case 'auto':
+            default:
+                return IMAGE_RENDERING.AUTO;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/letter-spacing.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.letterSpacing = void 0;
+exports.letterSpacing = {
+    name: 'letter-spacing',
+    initialValue: '0',
+    prefix: false,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'normal') {
+            return 0;
+        }
+        if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
+            return token.number;
+        }
+        if (token.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+            return token.number;
+        }
+        return 0;
+    }
+};

package/dist/lib/css/property-descriptors/line-break.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineBreak = exports.LINE_BREAK = void 0;
+var LINE_BREAK;
+(function (LINE_BREAK) {
+    LINE_BREAK["NORMAL"] = "normal";
+    LINE_BREAK["STRICT"] = "strict";
+})(LINE_BREAK || (exports.LINE_BREAK = LINE_BREAK = {}));
+exports.lineBreak = {
+    name: 'line-break',
+    initialValue: 'normal',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, lineBreak) => {
+        switch (lineBreak) {
+            case 'strict':
+                return LINE_BREAK.STRICT;
+            case 'normal':
+            default:
+                return LINE_BREAK.NORMAL;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/line-height.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeLineHeight = exports.lineHeight = void 0;
+const parser_1 = require("../syntax/parser");
+const length_percentage_1 = require("../types/length-percentage");
+exports.lineHeight = {
+    name: 'line-height',
+    initialValue: 'normal',
+    prefix: false,
+    type: 4 /* PropertyDescriptorParsingType.TOKEN_VALUE */
+};
+const computeLineHeight = (token, fontSize) => {
+    if ((0, parser_1.isIdentToken)(token) && token.value === 'normal') {
+        return 1.2 * fontSize;
+    }
+    else if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
+        return fontSize * token.number;
+    }
+    else if ((0, length_percentage_1.isLengthPercentage)(token)) {
+        return (0, length_percentage_1.getAbsoluteValue)(token, fontSize);
+    }
+    return fontSize;
+};
+exports.computeLineHeight = computeLineHeight;

package/dist/lib/css/property-descriptors/list-style-image.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listStyleImage = void 0;
+const image_1 = require("../types/image");
+exports.listStyleImage = {
+    name: 'list-style-image',
+    initialValue: 'none',
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    prefix: false,
+    skipCache: true,
+    parse: (context, token) => {
+        if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'none') {
+            return null;
+        }
+        return image_1.image.parse(context, token);
+    }
+};

package/dist/lib/css/property-descriptors/list-style-position.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listStylePosition = void 0;
+exports.listStylePosition = {
+    name: 'list-style-position',
+    initialValue: 'outside',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, position) => {
+        switch (position) {
+            case 'inside':
+                return 0 /* LIST_STYLE_POSITION.INSIDE */;
+            case 'outside':
+            default:
+                return 1 /* LIST_STYLE_POSITION.OUTSIDE */;
+        }
+    }
+};