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

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listStyleType = void 0;
+exports.listStyleType = {
+    name: 'list-style-type',
+    initialValue: 'none',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, type) => {
+        switch (type) {
+            case 'disc':
+                return 0 /* LIST_STYLE_TYPE.DISC */;
+            case 'circle':
+                return 1 /* LIST_STYLE_TYPE.CIRCLE */;
+            case 'square':
+                return 2 /* LIST_STYLE_TYPE.SQUARE */;
+            case 'decimal':
+                return 3 /* LIST_STYLE_TYPE.DECIMAL */;
+            case 'cjk-decimal':
+                return 4 /* LIST_STYLE_TYPE.CJK_DECIMAL */;
+            case 'decimal-leading-zero':
+                return 5 /* LIST_STYLE_TYPE.DECIMAL_LEADING_ZERO */;
+            case 'lower-roman':
+                return 6 /* LIST_STYLE_TYPE.LOWER_ROMAN */;
+            case 'upper-roman':
+                return 7 /* LIST_STYLE_TYPE.UPPER_ROMAN */;
+            case 'lower-greek':
+                return 8 /* LIST_STYLE_TYPE.LOWER_GREEK */;
+            case 'lower-alpha':
+                return 9 /* LIST_STYLE_TYPE.LOWER_ALPHA */;
+            case 'upper-alpha':
+                return 10 /* LIST_STYLE_TYPE.UPPER_ALPHA */;
+            case 'arabic-indic':
+                return 11 /* LIST_STYLE_TYPE.ARABIC_INDIC */;
+            case 'armenian':
+                return 12 /* LIST_STYLE_TYPE.ARMENIAN */;
+            case 'bengali':
+                return 13 /* LIST_STYLE_TYPE.BENGALI */;
+            case 'cambodian':
+                return 14 /* LIST_STYLE_TYPE.CAMBODIAN */;
+            case 'cjk-earthly-branch':
+                return 15 /* LIST_STYLE_TYPE.CJK_EARTHLY_BRANCH */;
+            case 'cjk-heavenly-stem':
+                return 16 /* LIST_STYLE_TYPE.CJK_HEAVENLY_STEM */;
+            case 'cjk-ideographic':
+                return 17 /* LIST_STYLE_TYPE.CJK_IDEOGRAPHIC */;
+            case 'devanagari':
+                return 18 /* LIST_STYLE_TYPE.DEVANAGARI */;
+            case 'ethiopic-numeric':
+                return 19 /* LIST_STYLE_TYPE.ETHIOPIC_NUMERIC */;
+            case 'georgian':
+                return 20 /* LIST_STYLE_TYPE.GEORGIAN */;
+            case 'gujarati':
+                return 21 /* LIST_STYLE_TYPE.GUJARATI */;
+            case 'gurmukhi':
+                return 22 /* LIST_STYLE_TYPE.GURMUKHI */;
+            case 'hebrew':
+                return 52 /* LIST_STYLE_TYPE.HEBREW */;
+            case 'hiragana':
+                return 23 /* LIST_STYLE_TYPE.HIRAGANA */;
+            case 'hiragana-iroha':
+                return 24 /* LIST_STYLE_TYPE.HIRAGANA_IROHA */;
+            case 'japanese-formal':
+                return 25 /* LIST_STYLE_TYPE.JAPANESE_FORMAL */;
+            case 'japanese-informal':
+                return 26 /* LIST_STYLE_TYPE.JAPANESE_INFORMAL */;
+            case 'kannada':
+                return 27 /* LIST_STYLE_TYPE.KANNADA */;
+            case 'katakana':
+                return 28 /* LIST_STYLE_TYPE.KATAKANA */;
+            case 'katakana-iroha':
+                return 29 /* LIST_STYLE_TYPE.KATAKANA_IROHA */;
+            case 'khmer':
+                return 30 /* LIST_STYLE_TYPE.KHMER */;
+            case 'korean-hangul-formal':
+                return 31 /* LIST_STYLE_TYPE.KOREAN_HANGUL_FORMAL */;
+            case 'korean-hanja-formal':
+                return 32 /* LIST_STYLE_TYPE.KOREAN_HANJA_FORMAL */;
+            case 'korean-hanja-informal':
+                return 33 /* LIST_STYLE_TYPE.KOREAN_HANJA_INFORMAL */;
+            case 'lao':
+                return 34 /* LIST_STYLE_TYPE.LAO */;
+            case 'lower-armenian':
+                return 35 /* LIST_STYLE_TYPE.LOWER_ARMENIAN */;
+            case 'malayalam':
+                return 36 /* LIST_STYLE_TYPE.MALAYALAM */;
+            case 'mongolian':
+                return 37 /* LIST_STYLE_TYPE.MONGOLIAN */;
+            case 'myanmar':
+                return 38 /* LIST_STYLE_TYPE.MYANMAR */;
+            case 'oriya':
+                return 39 /* LIST_STYLE_TYPE.ORIYA */;
+            case 'persian':
+                return 40 /* LIST_STYLE_TYPE.PERSIAN */;
+            case 'simp-chinese-formal':
+                return 41 /* LIST_STYLE_TYPE.SIMP_CHINESE_FORMAL */;
+            case 'simp-chinese-informal':
+                return 42 /* LIST_STYLE_TYPE.SIMP_CHINESE_INFORMAL */;
+            case 'tamil':
+                return 43 /* LIST_STYLE_TYPE.TAMIL */;
+            case 'telugu':
+                return 44 /* LIST_STYLE_TYPE.TELUGU */;
+            case 'thai':
+                return 45 /* LIST_STYLE_TYPE.THAI */;
+            case 'tibetan':
+                return 46 /* LIST_STYLE_TYPE.TIBETAN */;
+            case 'trad-chinese-formal':
+                return 47 /* LIST_STYLE_TYPE.TRAD_CHINESE_FORMAL */;
+            case 'trad-chinese-informal':
+                return 48 /* LIST_STYLE_TYPE.TRAD_CHINESE_INFORMAL */;
+            case 'upper-armenian':
+                return 49 /* LIST_STYLE_TYPE.UPPER_ARMENIAN */;
+            case 'disclosure-open':
+                return 50 /* LIST_STYLE_TYPE.DISCLOSURE_OPEN */;
+            case 'disclosure-closed':
+                return 51 /* LIST_STYLE_TYPE.DISCLOSURE_CLOSED */;
+            case 'none':
+            default:
+                return -1 /* LIST_STYLE_TYPE.NONE */;
+        }
+    }
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marginLeft = exports.marginBottom = exports.marginRight = exports.marginTop = void 0;
+const marginForSide = (side) => ({
+    name: `margin-${side}`,
+    initialValue: '0',
+    prefix: false,
+    type: 4 /* PropertyDescriptorParsingType.TOKEN_VALUE */
+});
+exports.marginTop = marginForSide('top');
+exports.marginRight = marginForSide('right');
+exports.marginBottom = marginForSide('bottom');
+exports.marginLeft = marginForSide('left');

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mixBlendMode = exports.MIX_BLEND_MODE = void 0;
+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.mixBlendMode = {
+    name: 'mix-blend-mode',
+    initialValue: 'normal',
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    prefix: false,
+    parse: (_context, token) => {
+        return VALID_VALUES.has(token) ? token : exports.MIX_BLEND_MODE.NORMAL;
+    }
+};

package/dist/lib/css/property-descriptors/object-fit.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectFit = void 0;
+const parser_1 = require("../syntax/parser");
+exports.objectFit = {
+    name: 'object-fit',
+    initialValue: 'fill',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return tokens.filter(parser_1.isIdentToken).reduce((bit, token) => {
+            return bit | parseDisplayValue(token.value);
+        }, 0 /* OBJECT_FIT.FILL */);
+    }
+};
+const parseDisplayValue = (display) => {
+    switch (display) {
+        case 'contain':
+            return 2 /* OBJECT_FIT.CONTAIN */;
+        case 'cover':
+            return 4 /* OBJECT_FIT.COVER */;
+        case 'none':
+            return 8 /* OBJECT_FIT.NONE */;
+        case 'scale-down':
+            return 16 /* OBJECT_FIT.SCALE_DOWN */;
+    }
+    return 0 /* OBJECT_FIT.FILL */;
+};

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPosition = void 0;
+const parser_1 = require("../syntax/parser");
+const length_percentage_1 = require("../types/length-percentage");
+exports.objectPosition = {
+    name: 'object-position',
+    initialValue: '50% 50%',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        const result = [];
+        let i = 0;
+        while (i < tokens.length && result.length < 2) {
+            const token = tokens[i];
+            if ((0, parser_1.isIdentToken)(token)) {
+                switch (token.value) {
+                    case 'left':
+                    case 'top':
+                        result.push(length_percentage_1.ZERO_LENGTH);
+                        break;
+                    case 'center':
+                        result.push(length_percentage_1.FIFTY_PERCENT);
+                        break;
+                    case 'right':
+                    case 'bottom':
+                        result.push(length_percentage_1.HUNDRED_PERCENT);
+                        break;
+                }
+            }
+            else if ((0, length_percentage_1.isLengthPercentage)(token)) {
+                result.push(token);
+            }
+            i++;
+        }
+        // Fill to 2 values with defaults
+        while (result.length < 2) {
+            result.push(length_percentage_1.FIFTY_PERCENT);
+        }
+        return [result[0], result[1]];
+    }
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opacity = void 0;
+const parser_1 = require("../syntax/parser");
+exports.opacity = {
+    name: 'opacity',
+    initialValue: '1',
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    prefix: false,
+    parse: (_context, token) => {
+        if ((0, parser_1.isNumberToken)(token)) {
+            return token.number;
+        }
+        return 1;
+    }
+};

package/dist/lib/css/property-descriptors/overflow-wrap.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overflowWrap = void 0;
+exports.overflowWrap = {
+    name: 'overflow-wrap',
+    initialValue: 'normal',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, overflow) => {
+        switch (overflow) {
+            case 'break-word':
+                return "break-word" /* OVERFLOW_WRAP.BREAK_WORD */;
+            case 'normal':
+            default:
+                return "normal" /* OVERFLOW_WRAP.NORMAL */;
+        }
+    }
+};

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overflow = void 0;
+const parser_1 = require("../syntax/parser");
+exports.overflow = {
+    name: 'overflow',
+    initialValue: 'visible',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return tokens.filter(parser_1.isIdentToken).map((overflow) => {
+            switch (overflow.value) {
+                case 'hidden':
+                    return 1 /* OVERFLOW.HIDDEN */;
+                case 'scroll':
+                    return 2 /* OVERFLOW.SCROLL */;
+                case 'clip':
+                    return 3 /* OVERFLOW.CLIP */;
+                case 'auto':
+                    return 4 /* OVERFLOW.AUTO */;
+                case 'visible':
+                default:
+                    return 0 /* OVERFLOW.VISIBLE */;
+            }
+        });
+    }
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paddingLeft = exports.paddingBottom = exports.paddingRight = exports.paddingTop = void 0;
+const paddingForSide = (side) => ({
+    name: `padding-${side}`,
+    initialValue: '0',
+    prefix: false,
+    type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
+    format: 'length-percentage'
+});
+exports.paddingTop = paddingForSide('top');
+exports.paddingRight = paddingForSide('right');
+exports.paddingBottom = paddingForSide('bottom');
+exports.paddingLeft = paddingForSide('left');

package/dist/lib/css/property-descriptors/paint-order.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paintOrder = void 0;
+const parser_1 = require("../syntax/parser");
+exports.paintOrder = {
+    name: 'paint-order',
+    initialValue: 'normal',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        const DEFAULT_VALUE = [0 /* PAINT_ORDER_LAYER.FILL */, 1 /* PAINT_ORDER_LAYER.STROKE */, 2 /* PAINT_ORDER_LAYER.MARKERS */];
+        const layers = [];
+        tokens.filter(parser_1.isIdentToken).forEach((token) => {
+            switch (token.value) {
+                case 'stroke':
+                    layers.push(1 /* PAINT_ORDER_LAYER.STROKE */);
+                    break;
+                case 'fill':
+                    layers.push(0 /* PAINT_ORDER_LAYER.FILL */);
+                    break;
+                case 'markers':
+                    layers.push(2 /* PAINT_ORDER_LAYER.MARKERS */);
+                    break;
+            }
+        });
+        DEFAULT_VALUE.forEach((value) => {
+            if (layers.indexOf(value) === -1) {
+                layers.push(value);
+            }
+        });
+        return layers;
+    }
+};

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.position = void 0;
+exports.position = {
+    name: 'position',
+    initialValue: 'static',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, position) => {
+        switch (position) {
+            case 'relative':
+                return 1 /* POSITION.RELATIVE */;
+            case 'absolute':
+                return 2 /* POSITION.ABSOLUTE */;
+            case 'fixed':
+                return 3 /* POSITION.FIXED */;
+            case 'sticky':
+                return 4 /* POSITION.STICKY */;
+        }
+        return 0 /* POSITION.STATIC */;
+    }
+};

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuote = exports.quotes = void 0;
+const parser_1 = require("../syntax/parser");
+exports.quotes = {
+    name: 'quotes',
+    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;
+        }
+        const quotes = [];
+        const filtered = tokens.filter(parser_1.isStringToken);
+        if (filtered.length % 2 !== 0) {
+            return null;
+        }
+        for (let i = 0; i < filtered.length; i += 2) {
+            const open = filtered[i].value;
+            const close = filtered[i + 1].value;
+            quotes.push({ open, close });
+        }
+        return quotes;
+    }
+};
+const getQuote = (quotes, depth, open) => {
+    if (!quotes) {
+        return '';
+    }
+    const quote = quotes[Math.min(depth, quotes.length - 1)];
+    if (!quote) {
+        return '';
+    }
+    return open ? quote.open : quote.close;
+};
+exports.getQuote = getQuote;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rotate = void 0;
+const angle_1 = require("../types/angle");
+exports.rotate = {
+    name: 'rotate',
+    initialValue: 'none',
+    prefix: false,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'none') {
+            return null;
+        }
+        if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
+            if (token.number === 0) {
+                return 0;
+            }
+        }
+        if (token.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+            // Parse angle and convert to degrees for storage
+            const radians = angle_1.angle.parse(_context, token);
+            // Store as degrees for consistency
+            return (radians * 180) / Math.PI;
+        }
+        return null;
+    }
+};

package/dist/lib/css/property-descriptors/text-align.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textAlign = void 0;
+exports.textAlign = {
+    name: 'text-align',
+    initialValue: 'left',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, textAlign) => {
+        switch (textAlign) {
+            case 'right':
+                return 2 /* TEXT_ALIGN.RIGHT */;
+            case 'center':
+            case 'justify':
+                return 1 /* TEXT_ALIGN.CENTER */;
+            case 'left':
+            default:
+                return 0 /* TEXT_ALIGN.LEFT */;
+        }
+    }
+};

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

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

package/dist/lib/css/property-descriptors/text-decoration-line.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textDecorationLine = void 0;
+const parser_1 = require("../syntax/parser");
+exports.textDecorationLine = {
+    name: 'text-decoration-line',
+    initialValue: 'none',
+    prefix: false,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        return tokens
+            .filter(parser_1.isIdentToken)
+            .map((token) => {
+            switch (token.value) {
+                case 'underline':
+                    return 1 /* TEXT_DECORATION_LINE.UNDERLINE */;
+                case 'overline':
+                    return 2 /* TEXT_DECORATION_LINE.OVERLINE */;
+                case 'line-through':
+                    return 3 /* TEXT_DECORATION_LINE.LINE_THROUGH */;
+                case 'none':
+                    return 4 /* TEXT_DECORATION_LINE.BLINK */;
+            }
+            return 0 /* TEXT_DECORATION_LINE.NONE */;
+        })
+            .filter((line) => line !== 0 /* TEXT_DECORATION_LINE.NONE */);
+    }
+};

package/dist/lib/css/property-descriptors/text-decoration-style.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textDecorationStyle = void 0;
+exports.textDecorationStyle = {
+    name: 'text-decoration-style',
+    initialValue: 'solid',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, style) => {
+        switch (style) {
+            case 'double':
+                return 1 /* TEXT_DECORATION_STYLE.DOUBLE */;
+            case 'dotted':
+                return 2 /* TEXT_DECORATION_STYLE.DOTTED */;
+            case 'dashed':
+                return 3 /* TEXT_DECORATION_STYLE.DASHED */;
+            case 'wavy':
+                return 4 /* TEXT_DECORATION_STYLE.WAVY */;
+            case 'solid':
+            default:
+                return 0 /* TEXT_DECORATION_STYLE.SOLID */;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/text-decoration-thickness.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textDecorationThickness = void 0;
+const parser_1 = require("../syntax/parser");
+exports.textDecorationThickness = {
+    name: 'text-decoration-thickness',
+    initialValue: 'auto',
+    prefix: false,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        if ((0, parser_1.isIdentToken)(token)) {
+            switch (token.value) {
+                case 'auto':
+                    return 'auto';
+                case 'from-font':
+                    return 'from-font';
+            }
+        }
+        if ((0, parser_1.isDimensionToken)(token)) {
+            // Convert to pixels
+            return token.number;
+        }
+        // Default to auto
+        return 'auto';
+    }
+};

package/dist/lib/css/property-descriptors/text-overflow.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textOverflow = void 0;
+exports.textOverflow = {
+    name: 'text-overflow',
+    initialValue: 'clip',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, textOverflow) => {
+        switch (textOverflow) {
+            case 'ellipsis':
+                return 1 /* TEXT_OVERFLOW.ELLIPSIS */;
+            case 'clip':
+            default:
+                return 0 /* TEXT_OVERFLOW.CLIP */;
+        }
+    }
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textShadow = 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.textShadow = {
+    name: 'text-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: color_1.COLORS.TRANSPARENT,
+                offsetX: length_percentage_1.ZERO_LENGTH,
+                offsetY: length_percentage_1.ZERO_LENGTH,
+                blur: length_percentage_1.ZERO_LENGTH
+            };
+            let c = 0;
+            for (let i = 0; i < values.length; i++) {
+                const token = values[i];
+                if ((0, length_1.isLength)(token)) {
+                    if (c === 0) {
+                        shadow.offsetX = token;
+                    }
+                    else if (c === 1) {
+                        shadow.offsetY = token;
+                    }
+                    else {
+                        shadow.blur = token;
+                    }
+                    c++;
+                }
+                else {
+                    shadow.color = color_1.color.parse(context, token);
+                }
+            }
+            return shadow;
+        });
+    }
+};

package/dist/lib/css/property-descriptors/text-transform.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textTransform = void 0;
+exports.textTransform = {
+    name: 'text-transform',
+    initialValue: 'none',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, textTransform) => {
+        switch (textTransform) {
+            case 'uppercase':
+                return 2 /* TEXT_TRANSFORM.UPPERCASE */;
+            case 'lowercase':
+                return 1 /* TEXT_TRANSFORM.LOWERCASE */;
+            case 'capitalize':
+                return 3 /* TEXT_TRANSFORM.CAPITALIZE */;
+        }
+        return 0 /* TEXT_TRANSFORM.NONE */;
+    }
+};