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

package/dist/lib/css/property-descriptors/background-blend-mode.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundBlendMode = exports.MIX_BLEND_MODE = void 0;
+const parser_1 = require("../syntax/parser");
+exports.MIX_BLEND_MODE = {
+    NORMAL: 'normal',
+    MULTIPLY: 'multiply',
+    SCREEN: 'screen',
+    OVERLAY: 'overlay',
+    DARKEN: 'darken',
+    LIGHTEN: 'lighten',
+    COLOR_DODGE: 'color-dodge',
+    COLOR_BURN: 'color-burn',
+    HARD_LIGHT: 'hard-light',
+    SOFT_LIGHT: 'soft-light',
+    DIFFERENCE: 'difference',
+    EXCLUSION: 'exclusion',
+    HUE: 'hue',
+    SATURATION: 'saturation',
+    COLOR: 'color',
+    LUMINOSITY: 'luminosity'
+};
+const VALID_VALUES = new Set(Object.values(exports.MIX_BLEND_MODE));
+exports.backgroundBlendMode = {
+    name: 'background-blend-mode',
+    initialValue: 'normal',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        const modes = [];
+        const filtered = tokens.filter(parser_1.nonFunctionArgSeparator);
+        for (const token of filtered) {
+            if ((0, parser_1.isIdentToken)(token)) {
+                if (VALID_VALUES.has(token.value)) {
+                    modes.push(token.value);
+                }
+            }
+        }
+        return modes.length > 0 ? modes : ['normal'];
+    }
+};

package/dist/lib/css/property-descriptors/background-clip.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundClip = void 0;
+const parser_1 = require("../syntax/parser");
+exports.backgroundClip = {
+    name: 'background-clip',
+    initialValue: 'border-box',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return tokens.map((token) => {
+            if ((0, parser_1.isIdentToken)(token)) {
+                switch (token.value) {
+                    case 'padding-box':
+                        return 1 /* BACKGROUND_CLIP.PADDING_BOX */;
+                    case 'content-box':
+                        return 2 /* BACKGROUND_CLIP.CONTENT_BOX */;
+                }
+            }
+            return 0 /* BACKGROUND_CLIP.BORDER_BOX */;
+        });
+    }
+};

package/dist/lib/css/property-descriptors/background-color.js

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundImage = void 0;
+const image_1 = require("../types/image");
+const parser_1 = require("../syntax/parser");
+exports.backgroundImage = {
+    name: 'background-image',
+    initialValue: 'none',
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    prefix: false,
+    skipCache: true,
+    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
+            .filter((value) => (0, parser_1.nonFunctionArgSeparator)(value) && (0, image_1.isSupportedImage)(value))
+            .map((value) => image_1.image.parse(context, value));
+    }
+};

package/dist/lib/css/property-descriptors/background-origin.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundOrigin = void 0;
+const parser_1 = require("../syntax/parser");
+exports.backgroundOrigin = {
+    name: 'background-origin',
+    initialValue: 'border-box',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return tokens.map((token) => {
+            if ((0, parser_1.isIdentToken)(token)) {
+                switch (token.value) {
+                    case 'padding-box':
+                        return 1 /* BACKGROUND_ORIGIN.PADDING_BOX */;
+                    case 'content-box':
+                        return 2 /* BACKGROUND_ORIGIN.CONTENT_BOX */;
+                }
+            }
+            return 0 /* BACKGROUND_ORIGIN.BORDER_BOX */;
+        });
+    }
+};

package/dist/lib/css/property-descriptors/background-position.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundPosition = void 0;
+const parser_1 = require("../syntax/parser");
+const length_percentage_1 = require("../types/length-percentage");
+exports.backgroundPosition = {
+    name: 'background-position',
+    initialValue: '0% 0%',
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    prefix: false,
+    parse: (_context, tokens) => {
+        return (0, parser_1.parseFunctionArgs)(tokens)
+            .map((values) => {
+            // Convert calc() to length-percentage tokens, keep other length-percentage as is
+            return values.map(length_percentage_1.parseOptionalCalcOrLength).filter((v) => v !== null);
+        })
+            .map(length_percentage_1.parseLengthPercentageTuple);
+    }
+};

package/dist/lib/css/property-descriptors/background-repeat.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundRepeat = void 0;
+const parser_1 = require("../syntax/parser");
+exports.backgroundRepeat = {
+    name: 'background-repeat',
+    initialValue: 'repeat',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return (0, parser_1.parseFunctionArgs)(tokens)
+            .map((values) => values
+            .filter(parser_1.isIdentToken)
+            .map((token) => token.value)
+            .join(' '))
+            .map(parseBackgroundRepeat);
+    }
+};
+const parseBackgroundRepeat = (value) => {
+    switch (value) {
+        case 'no-repeat':
+            return 1 /* BACKGROUND_REPEAT.NO_REPEAT */;
+        case 'repeat-x':
+        case 'repeat no-repeat':
+            return 2 /* BACKGROUND_REPEAT.REPEAT_X */;
+        case 'repeat-y':
+        case 'no-repeat repeat':
+            return 3 /* BACKGROUND_REPEAT.REPEAT_Y */;
+        case 'repeat':
+        default:
+            return 0 /* BACKGROUND_REPEAT.REPEAT */;
+    }
+};

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundSize = exports.BACKGROUND_SIZE = void 0;
+const parser_1 = require("../syntax/parser");
+const length_percentage_1 = require("../types/length-percentage");
+var BACKGROUND_SIZE;
+(function (BACKGROUND_SIZE) {
+    BACKGROUND_SIZE["AUTO"] = "auto";
+    BACKGROUND_SIZE["CONTAIN"] = "contain";
+    BACKGROUND_SIZE["COVER"] = "cover";
+})(BACKGROUND_SIZE || (exports.BACKGROUND_SIZE = BACKGROUND_SIZE = {}));
+exports.backgroundSize = {
+    name: 'background-size',
+    initialValue: '0',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return (0, parser_1.parseFunctionArgs)(tokens).map((values) => values
+            .map((value) => (isBackgroundSizeInfoToken(value) ? value : (0, length_percentage_1.parseOptionalCalcOrLength)(value)))
+            .filter((v) => v !== null));
+    }
+};
+const isBackgroundSizeInfoToken = (value) => (0, parser_1.isIdentToken)(value) || (0, length_percentage_1.isLengthPercentage)(value);

package/dist/lib/css/property-descriptors/border-color.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.borderLeftColor = exports.borderBottomColor = exports.borderRightColor = exports.borderTopColor = void 0;
+const borderColorForSide = (side) => ({
+    name: `border-${side}-color`,
+    initialValue: 'transparent',
+    prefix: false,
+    type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
+    format: 'color'
+});
+exports.borderTopColor = borderColorForSide('top');
+exports.borderRightColor = borderColorForSide('right');
+exports.borderBottomColor = borderColorForSide('bottom');
+exports.borderLeftColor = borderColorForSide('left');

package/dist/lib/css/property-descriptors/border-image-repeat.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.borderImageRepeat = exports.BORDER_IMAGE_REPEAT = void 0;
+const parser_1 = require("../syntax/parser");
+var BORDER_IMAGE_REPEAT;
+(function (BORDER_IMAGE_REPEAT) {
+    BORDER_IMAGE_REPEAT[BORDER_IMAGE_REPEAT["STRETCH"] = 0] = "STRETCH";
+    BORDER_IMAGE_REPEAT[BORDER_IMAGE_REPEAT["REPEAT"] = 1] = "REPEAT";
+    BORDER_IMAGE_REPEAT[BORDER_IMAGE_REPEAT["ROUND"] = 2] = "ROUND";
+    BORDER_IMAGE_REPEAT[BORDER_IMAGE_REPEAT["SPACE"] = 3] = "SPACE";
+})(BORDER_IMAGE_REPEAT || (exports.BORDER_IMAGE_REPEAT = BORDER_IMAGE_REPEAT = {}));
+const parseRepeatValue = (value) => {
+    switch (value) {
+        case 'repeat':
+            return BORDER_IMAGE_REPEAT.REPEAT;
+        case 'round':
+            return BORDER_IMAGE_REPEAT.ROUND;
+        case 'space':
+            return BORDER_IMAGE_REPEAT.SPACE;
+        case 'stretch':
+        default:
+            return BORDER_IMAGE_REPEAT.STRETCH;
+    }
+};
+exports.borderImageRepeat = {
+    name: 'border-image-repeat',
+    initialValue: 'stretch',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        const filtered = tokens.filter(parser_1.nonWhiteSpace);
+        const values = [];
+        for (const token of filtered) {
+            if ((0, parser_1.isIdentToken)(token)) {
+                values.push(parseRepeatValue(token.value));
+            }
+        }
+        const horizontal = values[0] ?? BORDER_IMAGE_REPEAT.STRETCH;
+        const vertical = values[1] ?? horizontal;
+        return { horizontal, vertical };
+    }
+};

package/dist/lib/css/property-descriptors/border-image-slice.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.borderImageSlice = void 0;
+const parser_1 = require("../syntax/parser");
+const fillSides = (sides) => {
+    const result = [...sides];
+    if (result.length === 1) {
+        result.push(result[0], result[0], result[0]);
+    }
+    else if (result.length === 2) {
+        result.push(result[0], result[1]);
+    }
+    else if (result.length === 3) {
+        result.push(result[1]);
+    }
+    return result.slice(0, 4);
+};
+exports.borderImageSlice = {
+    name: 'border-image-slice',
+    initialValue: '100%',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        const filtered = tokens.filter(parser_1.nonWhiteSpace);
+        const values = [];
+        let fill = false;
+        let unit = 'percent';
+        for (const token of filtered) {
+            if ((0, parser_1.isIdentToken)(token) && token.value === 'fill') {
+                fill = true;
+                continue;
+            }
+            if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
+                values.push(token.number);
+                unit = 'number';
+            }
+            else if (token.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
+                values.push(token.number);
+                unit = 'percent';
+            }
+        }
+        const [top, right, bottom, left] = fillSides(values.length > 0 ? values : [100]);
+        return { top, right, bottom, left, fill, unit };
+    }
+};

package/dist/lib/css/property-descriptors/border-image-source.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.borderImageSource = void 0;
+const parser_1 = require("../syntax/parser");
+const image_1 = require("../types/image");
+exports.borderImageSource = {
+    name: 'border-image-source',
+    initialValue: 'none',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    skipCache: true,
+    parse: (context, tokens) => {
+        if (tokens.length === 0) {
+            return null;
+        }
+        const filtered = tokens.filter((t) => (0, parser_1.nonFunctionArgSeparator)(t) && (0, image_1.isSupportedImage)(t));
+        if (filtered.length === 0) {
+            return null;
+        }
+        return image_1.image.parse(context, filtered[0]);
+    }
+};

package/dist/lib/css/property-descriptors/border-radius.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.borderBottomLeftRadius = exports.borderBottomRightRadius = exports.borderTopRightRadius = exports.borderTopLeftRadius = void 0;
+const length_percentage_1 = require("../types/length-percentage");
+const borderRadiusForSide = (side) => ({
+    name: `border-${side}-radius`,
+    initialValue: '0 0',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => (0, length_percentage_1.parseLengthPercentageTuple)(tokens.filter(length_percentage_1.isLengthPercentage))
+});
+exports.borderTopLeftRadius = borderRadiusForSide('top-left');
+exports.borderTopRightRadius = borderRadiusForSide('top-right');
+exports.borderBottomRightRadius = borderRadiusForSide('bottom-right');
+exports.borderBottomLeftRadius = borderRadiusForSide('bottom-left');

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.borderLeftStyle = exports.borderBottomStyle = exports.borderRightStyle = exports.borderTopStyle = void 0;
+const borderStyleForSide = (side) => ({
+    name: `border-${side}-style`,
+    initialValue: 'solid',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, style) => {
+        switch (style) {
+            case 'none':
+                return 0 /* BORDER_STYLE.NONE */;
+            case 'dashed':
+                return 2 /* BORDER_STYLE.DASHED */;
+            case 'dotted':
+                return 3 /* BORDER_STYLE.DOTTED */;
+            case 'double':
+                return 4 /* BORDER_STYLE.DOUBLE */;
+        }
+        return 1 /* BORDER_STYLE.SOLID */;
+    }
+});
+exports.borderTopStyle = borderStyleForSide('top');
+exports.borderRightStyle = borderStyleForSide('right');
+exports.borderBottomStyle = borderStyleForSide('bottom');
+exports.borderLeftStyle = borderStyleForSide('left');

package/dist/lib/css/property-descriptors/border-width.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.borderLeftWidth = exports.borderBottomWidth = exports.borderRightWidth = exports.borderTopWidth = void 0;
+const parser_1 = require("../syntax/parser");
+const borderWidthForSide = (side) => ({
+    name: `border-${side}-width`,
+    initialValue: '0',
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    prefix: false,
+    parse: (_context, token) => {
+        if ((0, parser_1.isDimensionToken)(token)) {
+            return token.number;
+        }
+        return 0;
+    }
+});
+exports.borderTopWidth = borderWidthForSide('top');
+exports.borderRightWidth = borderWidthForSide('right');
+exports.borderBottomWidth = borderWidthForSide('bottom');
+exports.borderLeftWidth = borderWidthForSide('left');

package/dist/lib/css/property-descriptors/box-decoration-break.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boxDecorationBreak = void 0;
+exports.boxDecorationBreak = {
+    name: 'box-decoration-break',
+    initialValue: 'slice',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, token) => {
+        switch (token) {
+            case 'clone':
+                return 1 /* BOX_DECORATION_BREAK.CLONE */;
+            case 'slice':
+            default:
+                return 0 /* BOX_DECORATION_BREAK.SLICE */;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/box-shadow.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boxShadow = void 0;
+const parser_1 = require("../syntax/parser");
+const length_percentage_1 = require("../types/length-percentage");
+const color_1 = require("../types/color");
+const length_1 = require("../types/length");
+exports.boxShadow = {
+    name: 'box-shadow',
+    initialValue: 'none',
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    prefix: false,
+    parse: (context, tokens) => {
+        if (tokens.length === 1 && (0, parser_1.isIdentWithValue)(tokens[0], 'none')) {
+            return [];
+        }
+        return (0, parser_1.parseFunctionArgs)(tokens).map((values) => {
+            const shadow = {
+                color: 0x000000ff,
+                offsetX: length_percentage_1.ZERO_LENGTH,
+                offsetY: length_percentage_1.ZERO_LENGTH,
+                blur: length_percentage_1.ZERO_LENGTH,
+                spread: length_percentage_1.ZERO_LENGTH,
+                inset: false
+            };
+            let c = 0;
+            for (let i = 0; i < values.length; i++) {
+                const token = values[i];
+                if ((0, parser_1.isIdentWithValue)(token, 'inset')) {
+                    shadow.inset = true;
+                }
+                else if ((0, length_1.isLength)(token)) {
+                    if (c === 0) {
+                        shadow.offsetX = token;
+                    }
+                    else if (c === 1) {
+                        shadow.offsetY = token;
+                    }
+                    else if (c === 2) {
+                        shadow.blur = token;
+                    }
+                    else {
+                        shadow.spread = token;
+                    }
+                    c++;
+                }
+                else {
+                    shadow.color = color_1.color.parse(context, token);
+                }
+            }
+            return shadow;
+        });
+    }
+};

package/dist/lib/css/property-descriptors/clip-path.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clipPath = void 0;
+const parser_1 = require("../syntax/parser");
+const length_percentage_1 = require("../types/length-percentage");
+const NONE = { type: 0 /* CLIP_PATH_TYPE.NONE */ };
+/**
+ * Parse a shape-radius token: <length-percentage> | closest-side | farthest-side.
+ * Defaults to 'closest-side' when no tokens are provided.
+ */
+const parseShapeRadius = (tokens) => {
+    const [first] = tokens;
+    if (!first)
+        return 'closest-side';
+    if ((0, parser_1.isIdentToken)(first)) {
+        // Any unrecognised keyword (e.g. 'closest-corner') intentionally falls back to
+        // 'closest-side' as the CSS spec requires unknown values to be treated as invalid
+        // and the initial value of <shape-radius> is 'closest-side'.
+        return first.value === 'farthest-side' ? 'farthest-side' : 'closest-side';
+    }
+    return (0, length_percentage_1.isLengthPercentage)(first) ? first : 'closest-side';
+};
+/**
+ * Parse a CSS <position> as (cx, cy), each as a LengthPercentage.
+ *
+ * Supports the **1–2 value** subset of the CSS `<position>` syntax.
+ * The 4-value form (`at left 10px top 20px`) is not supported and will be
+ * parsed on a best-effort basis.
+ *
+ * Axis assignment rules:
+ *   - `left` / `right`  → x-axis (cx)
+ *   - `top`  / `bottom` → y-axis (cy)
+ *   - `center` or a <length-percentage> → fills the first unset axis, in order
+ *
+ * Examples:
+ *   "at left"        → cx=0,    cy=50%   (left is x; y defaults to center)
+ *   "at top"         → cx=50%,  cy=0     (top is y; x defaults to center)
+ *   "at center 30%"  → cx=50%,  cy=30%
+ *   "at 30% center"  → cx=30%,  cy=50%
+ *   "at left top"    → cx=0,    cy=0
+ *   "at top left"    → cx=0,    cy=0     (keyword order is irrelevant)
+ *
+ * Unset axes fall back to 50%.
+ */
+const parsePosition = (tokens) => {
+    let cx = null;
+    let cy = null;
+    for (const token of tokens) {
+        if ((0, parser_1.isIdentToken)(token)) {
+            switch (token.value) {
+                case 'left':
+                    cx = length_percentage_1.ZERO_LENGTH;
+                    break;
+                case 'right':
+                    cx = length_percentage_1.HUNDRED_PERCENT;
+                    break;
+                case 'top':
+                    cy = length_percentage_1.ZERO_LENGTH;
+                    break;
+                case 'bottom':
+                    cy = length_percentage_1.HUNDRED_PERCENT;
+                    break;
+                case 'center':
+                    // `center` fills whichever axis has not yet been claimed.
+                    if (cx === null)
+                        cx = length_percentage_1.FIFTY_PERCENT;
+                    else if (cy === null)
+                        cy = length_percentage_1.FIFTY_PERCENT;
+                    break;
+            }
+        }
+        else if ((0, length_percentage_1.isLengthPercentage)(token)) {
+            // Length-percentages are assigned in source order.
+            if (cx === null)
+                cx = token;
+            else if (cy === null)
+                cy = token;
+        }
+    }
+    return { cx: cx ?? length_percentage_1.FIFTY_PERCENT, cy: cy ?? length_percentage_1.FIFTY_PERCENT };
+};
+/**
+ * inset( <length-percentage>{1,4} [ round <'border-radius'> ]? )
+ * The 1-4 shorthand follows the same expansion as margin/padding:
+ *   1 value  → all four sides
+ *   2 values → top/bottom | left/right
+ *   3 values → top | left/right | bottom
+ *   4 values → top | right | bottom | left
+ * The optional `round` clause (border-radius) is parsed but ignored.
+ */
+const parseInset = (values) => {
+    const lengths = [];
+    for (const token of values) {
+        if (token.type === 31 /* TokenType.WHITESPACE_TOKEN */)
+            continue;
+        if ((0, parser_1.isIdentToken)(token) && token.value === 'round')
+            break;
+        if ((0, length_percentage_1.isLengthPercentage)(token))
+            lengths.push(token);
+    }
+    const v0 = lengths[0] ?? length_percentage_1.ZERO_LENGTH;
+    const v1 = lengths[1] ?? v0;
+    const v2 = lengths[2] ?? v0;
+    const v3 = lengths[3] ?? v1;
+    return { type: 1 /* CLIP_PATH_TYPE.INSET */, top: v0, right: v1, bottom: v2, left: v3 };
+};
+/**
+ * circle( [ <shape-radius> ]? [ at <position> ]? )
+ */
+const parseCircle = (values) => {
+    const nonWs = values.filter(parser_1.nonWhiteSpace);
+    const atIdx = nonWs.findIndex((t) => (0, parser_1.isIdentWithValue)(t, 'at'));
+    const radiusTokens = atIdx === -1 ? nonWs : nonWs.slice(0, atIdx);
+    const posTokens = atIdx === -1 ? [] : nonWs.slice(atIdx + 1);
+    return {
+        type: 2 /* CLIP_PATH_TYPE.CIRCLE */,
+        radius: parseShapeRadius(radiusTokens),
+        ...parsePosition(posTokens)
+    };
+};
+/**
+ * ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )
+ */
+const parseEllipse = (values) => {
+    const nonWs = values.filter(parser_1.nonWhiteSpace);
+    const atIdx = nonWs.findIndex((t) => (0, parser_1.isIdentWithValue)(t, 'at'));
+    const radiusTokens = atIdx === -1 ? nonWs : nonWs.slice(0, atIdx);
+    const posTokens = atIdx === -1 ? [] : nonWs.slice(atIdx + 1);
+    return {
+        type: 3 /* CLIP_PATH_TYPE.ELLIPSE */,
+        rx: parseShapeRadius(radiusTokens.slice(0, 1)),
+        ry: parseShapeRadius(radiusTokens.slice(1, 2)),
+        ...parsePosition(posTokens)
+    };
+};
+/**
+ * polygon( [ <fill-rule>, ]? [ <length-percentage> <length-percentage> ]# )
+ * Each comma-separated group defines one vertex (x y).
+ * A leading fill-rule keyword (nonzero/evenodd) is skipped.
+ */
+const parsePolygon = (values) => {
+    const args = (0, parser_1.parseFunctionArgs)(values);
+    const points = [];
+    for (const arg of args) {
+        if (arg.length === 1 && (0, parser_1.isIdentToken)(arg[0]))
+            continue; // skip fill-rule
+        const lengths = arg.filter(length_percentage_1.isLengthPercentage);
+        if (lengths.length >= 2) {
+            points.push([lengths[0], lengths[1]]);
+        }
+    }
+    return { type: 4 /* CLIP_PATH_TYPE.POLYGON */, points };
+};
+/**
+ * path( [ <fill-rule>, ]? <string> )
+ * The string value is the SVG path data (coordinates in the element's local space).
+ */
+const parsePath = (values) => {
+    const stringToken = values.find((t) => t.type === 0 /* TokenType.STRING_TOKEN */);
+    if (!stringToken)
+        return NONE;
+    return { type: 5 /* CLIP_PATH_TYPE.PATH */, d: stringToken.value };
+};
+exports.clipPath = {
+    name: 'clip-path',
+    initialValue: 'none',
+    prefix: false,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        if ((0, parser_1.isIdentToken)(token) && token.value === 'none') {
+            return NONE;
+        }
+        if (token.type === 18 /* TokenType.FUNCTION */) {
+            switch (token.name) {
+                case 'inset':
+                    return parseInset(token.values);
+                case 'circle':
+                    return parseCircle(token.values);
+                case 'ellipse':
+                    return parseEllipse(token.values);
+                case 'polygon':
+                    return parsePolygon(token.values);
+                case 'path':
+                    return parsePath(token.values);
+            }
+        }
+        return NONE;
+    }
+};

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

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