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

package/dist/lib/css/syntax/token-types.js

@@ -0,0 +1,10 @@
+"use strict";
+// https://www.w3.org/TR/css-syntax-3
+// Token type system — enums, interfaces, and union types consumed by
+// the tokenizer, parser, and property descriptors.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLAG_NUMBER = exports.FLAG_INTEGER = exports.FLAG_ID = exports.FLAG_UNRESTRICTED = void 0;
+exports.FLAG_UNRESTRICTED = 1 << 0;
+exports.FLAG_ID = 1 << 1;
+exports.FLAG_INTEGER = 1 << 2;
+exports.FLAG_NUMBER = 1 << 3;

package/dist/lib/css/syntax/tokenizer.js

@@ -0,0 +1,502 @@
+"use strict";
+// https://www.w3.org/TR/css-syntax-3
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tokenizer = exports.COLUMN_TOKEN = exports.INCLUDE_MATCH_TOKEN = exports.DASH_MATCH_TOKEN = exports.SUBSTRING_MATCH_TOKEN = exports.SUFFIX_MATCH_TOKEN = exports.PREFIX_MATCH_TOKEN = exports.CDO_TOKEN = exports.CDC_TOKEN = exports.BAD_STRING_TOKEN = exports.BAD_URL_TOKEN = exports.EOF_TOKEN = exports.WHITESPACE_TOKEN = exports.RIGHT_SQUARE_BRACKET_TOKEN = exports.LEFT_SQUARE_BRACKET_TOKEN = exports.RIGHT_CURLY_BRACKET_TOKEN = exports.LEFT_CURLY_BRACKET_TOKEN = exports.RIGHT_PARENTHESIS_TOKEN = exports.LEFT_PARENTHESIS_TOKEN = exports.SEMICOLON_TOKEN = exports.COLON_TOKEN = exports.COMMA_TOKEN = exports.isNumberStart = exports.isNameStartCodePoint = exports.isIdentifierStart = exports.isValidEscape = exports.isNameCodePoint = exports.isWhiteSpace = exports.isHex = exports.isDigit = exports.FLAG_NUMBER = exports.FLAG_INTEGER = exports.FLAG_ID = exports.FLAG_UNRESTRICTED = void 0;
+const css_line_break_1 = require("css-line-break");
+const token_types_1 = require("./token-types");
+const token_constants_1 = require("./token-constants");
+const token_constants_2 = require("./token-constants");
+const token_singletons_1 = require("./token-singletons");
+var token_types_2 = require("./token-types");
+Object.defineProperty(exports, "FLAG_UNRESTRICTED", { enumerable: true, get: function () { return token_types_2.FLAG_UNRESTRICTED; } });
+Object.defineProperty(exports, "FLAG_ID", { enumerable: true, get: function () { return token_types_2.FLAG_ID; } });
+Object.defineProperty(exports, "FLAG_INTEGER", { enumerable: true, get: function () { return token_types_2.FLAG_INTEGER; } });
+Object.defineProperty(exports, "FLAG_NUMBER", { enumerable: true, get: function () { return token_types_2.FLAG_NUMBER; } });
+var token_constants_3 = require("./token-constants");
+Object.defineProperty(exports, "isDigit", { enumerable: true, get: function () { return token_constants_3.isDigit; } });
+Object.defineProperty(exports, "isHex", { enumerable: true, get: function () { return token_constants_3.isHex; } });
+Object.defineProperty(exports, "isWhiteSpace", { enumerable: true, get: function () { return token_constants_3.isWhiteSpace; } });
+Object.defineProperty(exports, "isNameCodePoint", { enumerable: true, get: function () { return token_constants_3.isNameCodePoint; } });
+Object.defineProperty(exports, "isValidEscape", { enumerable: true, get: function () { return token_constants_3.isValidEscape; } });
+Object.defineProperty(exports, "isIdentifierStart", { enumerable: true, get: function () { return token_constants_3.isIdentifierStart; } });
+Object.defineProperty(exports, "isNameStartCodePoint", { enumerable: true, get: function () { return token_constants_3.isNameStartCodePoint; } });
+Object.defineProperty(exports, "isNumberStart", { enumerable: true, get: function () { return token_constants_3.isNumberStart; } });
+var token_singletons_2 = require("./token-singletons");
+Object.defineProperty(exports, "COMMA_TOKEN", { enumerable: true, get: function () { return token_singletons_2.COMMA_TOKEN; } });
+Object.defineProperty(exports, "COLON_TOKEN", { enumerable: true, get: function () { return token_singletons_2.COLON_TOKEN; } });
+Object.defineProperty(exports, "SEMICOLON_TOKEN", { enumerable: true, get: function () { return token_singletons_2.SEMICOLON_TOKEN; } });
+Object.defineProperty(exports, "LEFT_PARENTHESIS_TOKEN", { enumerable: true, get: function () { return token_singletons_2.LEFT_PARENTHESIS_TOKEN; } });
+Object.defineProperty(exports, "RIGHT_PARENTHESIS_TOKEN", { enumerable: true, get: function () { return token_singletons_2.RIGHT_PARENTHESIS_TOKEN; } });
+Object.defineProperty(exports, "LEFT_CURLY_BRACKET_TOKEN", { enumerable: true, get: function () { return token_singletons_2.LEFT_CURLY_BRACKET_TOKEN; } });
+Object.defineProperty(exports, "RIGHT_CURLY_BRACKET_TOKEN", { enumerable: true, get: function () { return token_singletons_2.RIGHT_CURLY_BRACKET_TOKEN; } });
+Object.defineProperty(exports, "LEFT_SQUARE_BRACKET_TOKEN", { enumerable: true, get: function () { return token_singletons_2.LEFT_SQUARE_BRACKET_TOKEN; } });
+Object.defineProperty(exports, "RIGHT_SQUARE_BRACKET_TOKEN", { enumerable: true, get: function () { return token_singletons_2.RIGHT_SQUARE_BRACKET_TOKEN; } });
+Object.defineProperty(exports, "WHITESPACE_TOKEN", { enumerable: true, get: function () { return token_singletons_2.WHITESPACE_TOKEN; } });
+Object.defineProperty(exports, "EOF_TOKEN", { enumerable: true, get: function () { return token_singletons_2.EOF_TOKEN; } });
+Object.defineProperty(exports, "BAD_URL_TOKEN", { enumerable: true, get: function () { return token_singletons_2.BAD_URL_TOKEN; } });
+Object.defineProperty(exports, "BAD_STRING_TOKEN", { enumerable: true, get: function () { return token_singletons_2.BAD_STRING_TOKEN; } });
+Object.defineProperty(exports, "CDC_TOKEN", { enumerable: true, get: function () { return token_singletons_2.CDC_TOKEN; } });
+Object.defineProperty(exports, "CDO_TOKEN", { enumerable: true, get: function () { return token_singletons_2.CDO_TOKEN; } });
+Object.defineProperty(exports, "PREFIX_MATCH_TOKEN", { enumerable: true, get: function () { return token_singletons_2.PREFIX_MATCH_TOKEN; } });
+Object.defineProperty(exports, "SUFFIX_MATCH_TOKEN", { enumerable: true, get: function () { return token_singletons_2.SUFFIX_MATCH_TOKEN; } });
+Object.defineProperty(exports, "SUBSTRING_MATCH_TOKEN", { enumerable: true, get: function () { return token_singletons_2.SUBSTRING_MATCH_TOKEN; } });
+Object.defineProperty(exports, "DASH_MATCH_TOKEN", { enumerable: true, get: function () { return token_singletons_2.DASH_MATCH_TOKEN; } });
+Object.defineProperty(exports, "INCLUDE_MATCH_TOKEN", { enumerable: true, get: function () { return token_singletons_2.INCLUDE_MATCH_TOKEN; } });
+Object.defineProperty(exports, "COLUMN_TOKEN", { enumerable: true, get: function () { return token_singletons_2.COLUMN_TOKEN; } });
+class Tokenizer {
+    static get() {
+        return Tokenizer._pool.pop() || new Tokenizer();
+    }
+    static release(tokenizer) {
+        if (Tokenizer._pool.length < Tokenizer.MAX_POOL_SIZE) {
+            tokenizer._reset();
+            Tokenizer._pool.push(tokenizer);
+        }
+    }
+    constructor() {
+        this._value = [];
+    }
+    _reset() {
+        this._value = [];
+    }
+    write(chunk) {
+        this._value = this._value.concat((0, css_line_break_1.toCodePoints)(chunk));
+    }
+    read() {
+        const tokens = [];
+        let token = this.consumeToken();
+        while (token !== token_singletons_1.EOF_TOKEN) {
+            tokens.push(token);
+            token = this.consumeToken();
+        }
+        return tokens;
+    }
+    consumeToken() {
+        const codePoint = this.consumeCodePoint();
+        switch (codePoint) {
+            case token_constants_1.QUOTATION_MARK:
+                return this.consumeStringToken(token_constants_1.QUOTATION_MARK);
+            case token_constants_1.NUMBER_SIGN: {
+                const c1 = this.peekCodePoint(0);
+                const c2 = this.peekCodePoint(1);
+                const c3 = this.peekCodePoint(2);
+                if ((0, token_constants_2.isNameCodePoint)(c1) || (0, token_constants_2.isValidEscape)(c2, c3)) {
+                    const flags = (0, token_constants_2.isIdentifierStart)(c1, c2, c3) ? token_types_1.FLAG_ID : token_types_1.FLAG_UNRESTRICTED;
+                    const value = this.consumeName();
+                    return { type: 5 /* TokenType.HASH_TOKEN */, value, flags };
+                }
+                break;
+            }
+            case token_constants_1.DOLLAR_SIGN:
+                if (this.peekCodePoint(0) === token_constants_1.EQUALS_SIGN) {
+                    this.consumeCodePoint();
+                    return token_singletons_1.SUFFIX_MATCH_TOKEN;
+                }
+                break;
+            case token_constants_1.APOSTROPHE:
+                return this.consumeStringToken(token_constants_1.APOSTROPHE);
+            case token_constants_1.LEFT_PARENTHESIS:
+                return token_singletons_1.LEFT_PARENTHESIS_TOKEN;
+            case token_constants_1.RIGHT_PARENTHESIS:
+                return token_singletons_1.RIGHT_PARENTHESIS_TOKEN;
+            case token_constants_1.ASTERISK:
+                if (this.peekCodePoint(0) === token_constants_1.EQUALS_SIGN) {
+                    this.consumeCodePoint();
+                    return token_singletons_1.SUBSTRING_MATCH_TOKEN;
+                }
+                break;
+            case token_constants_1.PLUS_SIGN:
+                if ((0, token_constants_2.isNumberStart)(codePoint, this.peekCodePoint(0), this.peekCodePoint(1))) {
+                    this.reconsumeCodePoint(codePoint);
+                    return this.consumeNumericToken();
+                }
+                break;
+            case token_constants_1.COMMA:
+                return token_singletons_1.COMMA_TOKEN;
+            case token_constants_1.HYPHEN_MINUS: {
+                const e1 = codePoint;
+                const e2 = this.peekCodePoint(0);
+                const e3 = this.peekCodePoint(1);
+                if ((0, token_constants_2.isNumberStart)(e1, e2, e3)) {
+                    this.reconsumeCodePoint(codePoint);
+                    return this.consumeNumericToken();
+                }
+                if ((0, token_constants_2.isIdentifierStart)(e1, e2, e3)) {
+                    this.reconsumeCodePoint(codePoint);
+                    return this.consumeIdentLikeToken();
+                }
+                if (e2 === token_constants_1.HYPHEN_MINUS && e3 === token_constants_1.GREATER_THAN_SIGN) {
+                    this.consumeCodePoint();
+                    this.consumeCodePoint();
+                    return token_singletons_1.CDC_TOKEN;
+                }
+                break;
+            }
+            case token_constants_1.FULL_STOP:
+                if ((0, token_constants_2.isNumberStart)(codePoint, this.peekCodePoint(0), this.peekCodePoint(1))) {
+                    this.reconsumeCodePoint(codePoint);
+                    return this.consumeNumericToken();
+                }
+                break;
+            case token_constants_1.SOLIDUS:
+                if (this.peekCodePoint(0) === token_constants_1.ASTERISK) {
+                    this.consumeCodePoint();
+                    while (true) {
+                        let c = this.consumeCodePoint();
+                        if (c === token_constants_1.ASTERISK) {
+                            c = this.consumeCodePoint();
+                            if (c === token_constants_1.SOLIDUS) {
+                                return this.consumeToken();
+                            }
+                        }
+                        if (c === token_constants_1.EOF) {
+                            return this.consumeToken();
+                        }
+                    }
+                }
+                break;
+            case token_constants_1.COLON:
+                return token_singletons_1.COLON_TOKEN;
+            case token_constants_1.SEMICOLON:
+                return token_singletons_1.SEMICOLON_TOKEN;
+            case token_constants_1.LESS_THAN_SIGN:
+                if (this.peekCodePoint(0) === token_constants_1.EXCLAMATION_MARK &&
+                    this.peekCodePoint(1) === token_constants_1.HYPHEN_MINUS &&
+                    this.peekCodePoint(2) === token_constants_1.HYPHEN_MINUS) {
+                    this.consumeCodePoint();
+                    this.consumeCodePoint();
+                    return token_singletons_1.CDO_TOKEN;
+                }
+                break;
+            case token_constants_1.COMMERCIAL_AT: {
+                const a1 = this.peekCodePoint(0);
+                const a2 = this.peekCodePoint(1);
+                const a3 = this.peekCodePoint(2);
+                if ((0, token_constants_2.isIdentifierStart)(a1, a2, a3)) {
+                    const value = this.consumeName();
+                    return { type: 7 /* TokenType.AT_KEYWORD_TOKEN */, value };
+                }
+                break;
+            }
+            case token_constants_1.LEFT_SQUARE_BRACKET:
+                return token_singletons_1.LEFT_SQUARE_BRACKET_TOKEN;
+            case token_constants_1.REVERSE_SOLIDUS:
+                if ((0, token_constants_2.isValidEscape)(codePoint, this.peekCodePoint(0))) {
+                    this.reconsumeCodePoint(codePoint);
+                    return this.consumeIdentLikeToken();
+                }
+                break;
+            case token_constants_1.RIGHT_SQUARE_BRACKET:
+                return token_singletons_1.RIGHT_SQUARE_BRACKET_TOKEN;
+            case token_constants_1.CIRCUMFLEX_ACCENT:
+                if (this.peekCodePoint(0) === token_constants_1.EQUALS_SIGN) {
+                    this.consumeCodePoint();
+                    return token_singletons_1.PREFIX_MATCH_TOKEN;
+                }
+                break;
+            case token_constants_1.LEFT_CURLY_BRACKET:
+                return token_singletons_1.LEFT_CURLY_BRACKET_TOKEN;
+            case token_constants_1.RIGHT_CURLY_BRACKET:
+                return token_singletons_1.RIGHT_CURLY_BRACKET_TOKEN;
+            case token_constants_1.u:
+            case token_constants_1.U: {
+                const u1 = this.peekCodePoint(0);
+                const u2 = this.peekCodePoint(1);
+                if (u1 === token_constants_1.PLUS_SIGN && ((0, token_constants_2.isHex)(u2) || u2 === token_constants_1.QUESTION_MARK)) {
+                    this.consumeCodePoint();
+                    this.consumeUnicodeRangeToken();
+                }
+                this.reconsumeCodePoint(codePoint);
+                return this.consumeIdentLikeToken();
+            }
+            case token_constants_1.VERTICAL_LINE:
+                if (this.peekCodePoint(0) === token_constants_1.EQUALS_SIGN) {
+                    this.consumeCodePoint();
+                    return token_singletons_1.DASH_MATCH_TOKEN;
+                }
+                if (this.peekCodePoint(0) === token_constants_1.VERTICAL_LINE) {
+                    this.consumeCodePoint();
+                    return token_singletons_1.COLUMN_TOKEN;
+                }
+                break;
+            case token_constants_1.TILDE:
+                if (this.peekCodePoint(0) === token_constants_1.EQUALS_SIGN) {
+                    this.consumeCodePoint();
+                    return token_singletons_1.INCLUDE_MATCH_TOKEN;
+                }
+                break;
+            case token_constants_1.EOF:
+                return token_singletons_1.EOF_TOKEN;
+        }
+        if ((0, token_constants_2.isWhiteSpace)(codePoint)) {
+            this.consumeWhiteSpace();
+            return token_singletons_1.WHITESPACE_TOKEN;
+        }
+        if ((0, token_constants_2.isDigit)(codePoint)) {
+            this.reconsumeCodePoint(codePoint);
+            return this.consumeNumericToken();
+        }
+        if ((0, token_constants_2.isNameStartCodePoint)(codePoint)) {
+            this.reconsumeCodePoint(codePoint);
+            return this.consumeIdentLikeToken();
+        }
+        return { type: 6 /* TokenType.DELIM_TOKEN */, value: (0, css_line_break_1.fromCodePoint)(codePoint) };
+    }
+    consumeCodePoint() {
+        const value = this._value.shift();
+        return typeof value === 'undefined' ? -1 : value;
+    }
+    reconsumeCodePoint(codePoint) {
+        this._value.unshift(codePoint);
+    }
+    peekCodePoint(delta) {
+        if (delta >= this._value.length) {
+            return -1;
+        }
+        return this._value[delta];
+    }
+    consumeUnicodeRangeToken() {
+        const digits = [];
+        let codePoint = this.consumeCodePoint();
+        while ((0, token_constants_2.isHex)(codePoint) && digits.length < 6) {
+            digits.push(codePoint);
+            codePoint = this.consumeCodePoint();
+        }
+        let questionMarks = false;
+        while (codePoint === token_constants_1.QUESTION_MARK && digits.length < 6) {
+            digits.push(codePoint);
+            codePoint = this.consumeCodePoint();
+            questionMarks = true;
+        }
+        if (questionMarks) {
+            const start = parseInt((0, css_line_break_1.fromCodePoint)(...digits.map((digit) => (digit === token_constants_1.QUESTION_MARK ? token_constants_1.ZERO : digit))), 16);
+            const end = parseInt((0, css_line_break_1.fromCodePoint)(...digits.map((digit) => (digit === token_constants_1.QUESTION_MARK ? token_constants_1.F : digit))), 16);
+            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start, end };
+        }
+        const start = parseInt((0, css_line_break_1.fromCodePoint)(...digits), 16);
+        if (this.peekCodePoint(0) === token_constants_1.HYPHEN_MINUS && (0, token_constants_2.isHex)(this.peekCodePoint(1))) {
+            this.consumeCodePoint();
+            codePoint = this.consumeCodePoint();
+            const endDigits = [];
+            while ((0, token_constants_2.isHex)(codePoint) && endDigits.length < 6) {
+                endDigits.push(codePoint);
+                codePoint = this.consumeCodePoint();
+            }
+            const end = parseInt((0, css_line_break_1.fromCodePoint)(...endDigits), 16);
+            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start, end };
+        }
+        else {
+            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start, end: start };
+        }
+    }
+    consumeIdentLikeToken() {
+        const value = this.consumeName();
+        if (value.toLowerCase() === 'url' && this.peekCodePoint(0) === token_constants_1.LEFT_PARENTHESIS) {
+            this.consumeCodePoint();
+            return this.consumeUrlToken();
+        }
+        else if (this.peekCodePoint(0) === token_constants_1.LEFT_PARENTHESIS) {
+            this.consumeCodePoint();
+            return { type: 19 /* TokenType.FUNCTION_TOKEN */, value };
+        }
+        return { type: 20 /* TokenType.IDENT_TOKEN */, value };
+    }
+    consumeUrlToken() {
+        const value = [];
+        this.consumeWhiteSpace();
+        if (this.peekCodePoint(0) === token_constants_1.EOF) {
+            return { type: 22 /* TokenType.URL_TOKEN */, value: '' };
+        }
+        const next = this.peekCodePoint(0);
+        if (next === token_constants_1.APOSTROPHE || next === token_constants_1.QUOTATION_MARK) {
+            const stringToken = this.consumeStringToken(this.consumeCodePoint());
+            if (stringToken.type === 0 /* TokenType.STRING_TOKEN */) {
+                this.consumeWhiteSpace();
+                if (this.peekCodePoint(0) === token_constants_1.EOF || this.peekCodePoint(0) === token_constants_1.RIGHT_PARENTHESIS) {
+                    this.consumeCodePoint();
+                    return { type: 22 /* TokenType.URL_TOKEN */, value: stringToken.value };
+                }
+            }
+            this.consumeBadUrlRemnants();
+            return token_singletons_1.BAD_URL_TOKEN;
+        }
+        while (true) {
+            const codePoint = this.consumeCodePoint();
+            if (codePoint === token_constants_1.EOF || codePoint === token_constants_1.RIGHT_PARENTHESIS) {
+                return { type: 22 /* TokenType.URL_TOKEN */, value: (0, css_line_break_1.fromCodePoint)(...value) };
+            }
+            else if ((0, token_constants_2.isWhiteSpace)(codePoint)) {
+                this.consumeWhiteSpace();
+                if (this.peekCodePoint(0) === token_constants_1.EOF || this.peekCodePoint(0) === token_constants_1.RIGHT_PARENTHESIS) {
+                    this.consumeCodePoint();
+                    return { type: 22 /* TokenType.URL_TOKEN */, value: (0, css_line_break_1.fromCodePoint)(...value) };
+                }
+                this.consumeBadUrlRemnants();
+                return token_singletons_1.BAD_URL_TOKEN;
+            }
+            else if (codePoint === token_constants_1.QUOTATION_MARK ||
+                codePoint === token_constants_1.APOSTROPHE ||
+                codePoint === token_constants_1.LEFT_PARENTHESIS ||
+                (0, token_constants_2.isNonPrintableCodePoint)(codePoint)) {
+                this.consumeBadUrlRemnants();
+                return token_singletons_1.BAD_URL_TOKEN;
+            }
+            else if (codePoint === token_constants_1.REVERSE_SOLIDUS) {
+                if ((0, token_constants_2.isValidEscape)(codePoint, this.peekCodePoint(0))) {
+                    value.push(this.consumeEscapedCodePoint());
+                }
+                else {
+                    this.consumeBadUrlRemnants();
+                    return token_singletons_1.BAD_URL_TOKEN;
+                }
+            }
+            else {
+                value.push(codePoint);
+            }
+        }
+    }
+    consumeWhiteSpace() {
+        while ((0, token_constants_2.isWhiteSpace)(this.peekCodePoint(0))) {
+            this.consumeCodePoint();
+        }
+    }
+    consumeBadUrlRemnants() {
+        while (true) {
+            const codePoint = this.consumeCodePoint();
+            if (codePoint === token_constants_1.RIGHT_PARENTHESIS || codePoint === token_constants_1.EOF) {
+                return;
+            }
+            if ((0, token_constants_2.isValidEscape)(codePoint, this.peekCodePoint(0))) {
+                this.consumeEscapedCodePoint();
+            }
+        }
+    }
+    consumeStringSlice(count) {
+        const SLICE_STACK_SIZE = 50000;
+        let value = '';
+        while (count > 0) {
+            const amount = Math.min(SLICE_STACK_SIZE, count);
+            value += (0, css_line_break_1.fromCodePoint)(...this._value.splice(0, amount));
+            count -= amount;
+        }
+        this._value.shift();
+        return value;
+    }
+    consumeStringToken(endingCodePoint) {
+        let value = '';
+        let i = 0;
+        do {
+            const codePoint = this._value[i];
+            if (codePoint === token_constants_1.EOF || codePoint === undefined || codePoint === endingCodePoint) {
+                value += this.consumeStringSlice(i);
+                return { type: 0 /* TokenType.STRING_TOKEN */, value };
+            }
+            if (codePoint === token_constants_1.LINE_FEED) {
+                this._value.splice(0, i);
+                return token_singletons_1.BAD_STRING_TOKEN;
+            }
+            if (codePoint === token_constants_1.REVERSE_SOLIDUS) {
+                const next = this._value[i + 1];
+                if (next !== token_constants_1.EOF && next !== undefined) {
+                    if (next === token_constants_1.LINE_FEED) {
+                        value += this.consumeStringSlice(i);
+                        i = -1;
+                        this._value.shift();
+                    }
+                    else if ((0, token_constants_2.isValidEscape)(codePoint, next)) {
+                        value += this.consumeStringSlice(i);
+                        value += (0, css_line_break_1.fromCodePoint)(this.consumeEscapedCodePoint());
+                        i = -1;
+                    }
+                }
+            }
+            i++;
+        } while (true);
+    }
+    consumeNumber() {
+        const repr = [];
+        let type = token_types_1.FLAG_INTEGER;
+        let c1 = this.peekCodePoint(0);
+        if (c1 === token_constants_1.PLUS_SIGN || c1 === token_constants_1.HYPHEN_MINUS) {
+            repr.push(this.consumeCodePoint());
+        }
+        while ((0, token_constants_2.isDigit)(this.peekCodePoint(0))) {
+            repr.push(this.consumeCodePoint());
+        }
+        c1 = this.peekCodePoint(0);
+        let c2 = this.peekCodePoint(1);
+        if (c1 === token_constants_1.FULL_STOP && (0, token_constants_2.isDigit)(c2)) {
+            repr.push(this.consumeCodePoint(), this.consumeCodePoint());
+            type = token_types_1.FLAG_NUMBER;
+            while ((0, token_constants_2.isDigit)(this.peekCodePoint(0))) {
+                repr.push(this.consumeCodePoint());
+            }
+        }
+        c1 = this.peekCodePoint(0);
+        c2 = this.peekCodePoint(1);
+        const c3 = this.peekCodePoint(2);
+        if ((c1 === token_constants_1.E || c1 === token_constants_1.e) && (((c2 === token_constants_1.PLUS_SIGN || c2 === token_constants_1.HYPHEN_MINUS) && (0, token_constants_2.isDigit)(c3)) || (0, token_constants_2.isDigit)(c2))) {
+            repr.push(this.consumeCodePoint(), this.consumeCodePoint());
+            type = token_types_1.FLAG_NUMBER;
+            while ((0, token_constants_2.isDigit)(this.peekCodePoint(0))) {
+                repr.push(this.consumeCodePoint());
+            }
+        }
+        return [(0, token_constants_2.stringToNumber)(repr), type];
+    }
+    consumeNumericToken() {
+        const [number, flags] = this.consumeNumber();
+        const c1 = this.peekCodePoint(0);
+        const c2 = this.peekCodePoint(1);
+        const c3 = this.peekCodePoint(2);
+        if ((0, token_constants_2.isIdentifierStart)(c1, c2, c3)) {
+            const unit = this.consumeName();
+            return { type: 15 /* TokenType.DIMENSION_TOKEN */, number, flags, unit };
+        }
+        if (c1 === token_constants_1.PERCENTAGE_SIGN) {
+            this.consumeCodePoint();
+            return { type: 16 /* TokenType.PERCENTAGE_TOKEN */, number, flags };
+        }
+        return { type: 17 /* TokenType.NUMBER_TOKEN */, number, flags };
+    }
+    consumeEscapedCodePoint() {
+        const codePoint = this.consumeCodePoint();
+        if ((0, token_constants_2.isHex)(codePoint)) {
+            let hex = (0, css_line_break_1.fromCodePoint)(codePoint);
+            while ((0, token_constants_2.isHex)(this.peekCodePoint(0)) && hex.length < 6) {
+                hex += (0, css_line_break_1.fromCodePoint)(this.consumeCodePoint());
+            }
+            if ((0, token_constants_2.isWhiteSpace)(this.peekCodePoint(0))) {
+                this.consumeCodePoint();
+            }
+            const hexCodePoint = parseInt(hex, 16);
+            if (hexCodePoint === 0 || (0, token_constants_2.isSurrogateCodePoint)(hexCodePoint) || hexCodePoint > 0x10ffff) {
+                return token_constants_1.REPLACEMENT_CHARACTER;
+            }
+            return hexCodePoint;
+        }
+        if (codePoint === token_constants_1.EOF) {
+            return token_constants_1.REPLACEMENT_CHARACTER;
+        }
+        return codePoint;
+    }
+    consumeName() {
+        let result = '';
+        while (true) {
+            const codePoint = this.consumeCodePoint();
+            if ((0, token_constants_2.isNameCodePoint)(codePoint)) {
+                result += (0, css_line_break_1.fromCodePoint)(codePoint);
+            }
+            else if ((0, token_constants_2.isValidEscape)(codePoint, this.peekCodePoint(0))) {
+                result += (0, css_line_break_1.fromCodePoint)(this.consumeEscapedCodePoint());
+            }
+            else {
+                this.reconsumeCodePoint(codePoint);
+                return result;
+            }
+        }
+    }
+}
+exports.Tokenizer = Tokenizer;
+Tokenizer._pool = [];
+Tokenizer.MAX_POOL_SIZE = 40;

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

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

package/dist/lib/css/types/angle.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deg = exports.parseNamedSide = exports.isAngle = exports.angle = void 0;
+const parser_1 = require("../syntax/parser");
+const length_percentage_1 = require("./length-percentage");
+const DEG = 'deg';
+const GRAD = 'grad';
+const RAD = 'rad';
+const TURN = 'turn';
+exports.angle = {
+    name: 'angle',
+    parse: (_context, value) => {
+        if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+            switch (value.unit) {
+                case DEG:
+                    return (Math.PI * value.number) / 180;
+                case GRAD:
+                    return (Math.PI / 200) * value.number;
+                case RAD:
+                    return value.number;
+                case TURN:
+                    return Math.PI * 2 * value.number;
+            }
+        }
+        throw new Error(`Unsupported angle type`);
+    }
+};
+const isAngle = (value) => {
+    if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+        if (value.unit === DEG || value.unit === GRAD || value.unit === RAD || value.unit === TURN) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.isAngle = isAngle;
+const parseNamedSide = (tokens) => {
+    const sideOrCorner = tokens
+        .filter(parser_1.isIdentToken)
+        .map((ident) => ident.value)
+        .join(' ');
+    switch (sideOrCorner) {
+        case 'to bottom right':
+        case 'to right bottom':
+        case 'left top':
+        case 'top left':
+            return [length_percentage_1.ZERO_LENGTH, length_percentage_1.ZERO_LENGTH];
+        case 'to top':
+        case 'bottom':
+            return (0, exports.deg)(0);
+        case 'to bottom left':
+        case 'to left bottom':
+        case 'right top':
+        case 'top right':
+            return [length_percentage_1.ZERO_LENGTH, length_percentage_1.HUNDRED_PERCENT];
+        case 'to right':
+        case 'left':
+            return (0, exports.deg)(90);
+        case 'to top left':
+        case 'to left top':
+        case 'right bottom':
+        case 'bottom right':
+            return [length_percentage_1.HUNDRED_PERCENT, length_percentage_1.HUNDRED_PERCENT];
+        case 'to bottom':
+        case 'top':
+            return (0, exports.deg)(180);
+        case 'to top right':
+        case 'to right top':
+        case 'left bottom':
+        case 'bottom left':
+            return [length_percentage_1.HUNDRED_PERCENT, length_percentage_1.ZERO_LENGTH];
+        case 'to left':
+        case 'right':
+            return (0, exports.deg)(270);
+    }
+    return 0;
+};
+exports.parseNamedSide = parseNamedSide;
+const deg = (deg) => (Math.PI * deg) / 180;
+exports.deg = deg;

package/dist/lib/css/types/color-math.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Color mathematics utilities
+ * Extracted to break circular dependency between srgb.ts and color-utilities.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiplyMatrices = exports.clamp = void 0;
+/**
+ * Clamp a value between min and max
+ */
+const clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};
+exports.clamp = clamp;
+/**
+ * Multiply two 3x3 matrices
+ */
+const multiplyMatrices = (A, B) => {
+    return [
+        A[0] * B[0] + A[1] * B[1] + A[2] * B[2],
+        A[3] * B[0] + A[4] * B[1] + A[5] * B[2],
+        A[6] * B[0] + A[7] * B[1] + A[8] * B[2]
+    ];
+};
+exports.multiplyMatrices = multiplyMatrices;