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

package/dist/lib/css/property-descriptors/text-underline-offset.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textUnderlineOffset = void 0;
+const parser_1 = require("../syntax/parser");
+exports.textUnderlineOffset = {
+    name: 'text-underline-offset',
+    initialValue: 'auto',
+    prefix: false,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        if ((0, parser_1.isIdentToken)(token)) {
+            if (token.value === 'auto') {
+                return 'auto';
+            }
+        }
+        if ((0, parser_1.isDimensionToken)(token)) {
+            // Return pixel value
+            return token.number;
+        }
+        // Default to auto
+        return 'auto';
+    }
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOrigin = void 0;
+const length_percentage_1 = require("../types/length-percentage");
+const tokenizer_1 = require("../syntax/tokenizer");
+const DEFAULT_VALUE = {
+    type: 16 /* TokenType.PERCENTAGE_TOKEN */,
+    number: 50,
+    flags: tokenizer_1.FLAG_INTEGER
+};
+const DEFAULT = [DEFAULT_VALUE, DEFAULT_VALUE];
+exports.transformOrigin = {
+    name: 'transform-origin',
+    initialValue: '50% 50%',
+    prefix: true,
+    type: 1 /* PropertyDescriptorParsingType.LIST */,
+    parse: (_context, tokens) => {
+        const origins = tokens.filter(length_percentage_1.isLengthPercentage);
+        if (origins.length !== 2) {
+            return DEFAULT;
+        }
+        return [origins[0], origins[1]];
+    }
+};

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = void 0;
+const angle_1 = require("../types/angle");
+exports.transform = {
+    name: 'transform',
+    initialValue: 'none',
+    prefix: true,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'none') {
+            return null;
+        }
+        if (token.type === 18 /* TokenType.FUNCTION */) {
+            const transformFunction = SUPPORTED_TRANSFORM_FUNCTIONS[token.name];
+            if (typeof transformFunction === 'undefined') {
+                throw new Error(`Attempting to parse an unsupported transform function "${token.name}"`);
+            }
+            return transformFunction(_context, token.values);
+        }
+        return null;
+    }
+};
+const matrix = (_context, args) => {
+    const values = args.filter((arg) => arg.type === 17 /* TokenType.NUMBER_TOKEN */).map((arg) => arg.number);
+    return values.length === 6 ? values : null;
+};
+// doesn't support 3D transforms at the moment
+const matrix3d = (_context, args) => {
+    const values = args.filter((arg) => arg.type === 17 /* TokenType.NUMBER_TOKEN */).map((arg) => arg.number);
+    const [a1, b1, {}, {}, a2, b2, {}, {}, {}, {}, {}, {}, a4, b4, {}, {}] = values;
+    return values.length === 16 ? [a1, b1, a2, b2, a4, b4] : null;
+};
+const rotate = (context, args) => {
+    if (args.length !== 1) {
+        return null;
+    }
+    const arg = args[0];
+    let radians = 0;
+    if (arg.type === 17 /* TokenType.NUMBER_TOKEN */ && arg.number === 0) {
+        radians = 0;
+    }
+    else if (arg.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+        radians = angle_1.angle.parse(context, arg);
+    }
+    else {
+        return null;
+    }
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    return [cos, sin, -sin, cos, 0, 0];
+};
+const SUPPORTED_TRANSFORM_FUNCTIONS = {
+    matrix: matrix,
+    matrix3d: matrix3d,
+    rotate: rotate
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visibility = void 0;
+exports.visibility = {
+    name: 'visibility',
+    initialValue: 'none',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, visibility) => {
+        switch (visibility) {
+            case 'hidden':
+                return 1 /* VISIBILITY.HIDDEN */;
+            case 'collapse':
+                return 2 /* VISIBILITY.COLLAPSE */;
+            case 'visible':
+            default:
+                return 0 /* VISIBILITY.VISIBLE */;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/webkit-line-clamp.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webkitLineClamp = void 0;
+/**
+ * -webkit-line-clamp property descriptor
+ * Used with display: -webkit-box and -webkit-box-orient: vertical
+ * to limit text to a specific number of lines
+ */
+exports.webkitLineClamp = {
+    name: '-webkit-line-clamp',
+    initialValue: 'none',
+    prefix: true,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        // 'none' means no line clamping
+        if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'none') {
+            return 0;
+        }
+        // Number value specifies the number of lines
+        if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
+            return Math.max(0, Math.floor(token.number));
+        }
+        // Default to 0 (no clamping)
+        return 0;
+    }
+};

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

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

package/dist/lib/css/property-descriptors/webkit-text-stroke-width.js

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordBreak = exports.WORD_BREAK = void 0;
+var WORD_BREAK;
+(function (WORD_BREAK) {
+    WORD_BREAK["NORMAL"] = "normal";
+    WORD_BREAK["BREAK_ALL"] = "break-all";
+    WORD_BREAK["KEEP_ALL"] = "keep-all";
+})(WORD_BREAK || (exports.WORD_BREAK = WORD_BREAK = {}));
+exports.wordBreak = {
+    name: 'word-break',
+    initialValue: 'normal',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, wordBreak) => {
+        switch (wordBreak) {
+            case 'break-all':
+                return WORD_BREAK.BREAK_ALL;
+            case 'keep-all':
+                return WORD_BREAK.KEEP_ALL;
+            case 'normal':
+            default:
+                return WORD_BREAK.NORMAL;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/writing-mode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writingMode = exports.isSidewaysWritingMode = exports.isVerticalWritingMode = void 0;
+const isVerticalWritingMode = (writingMode) => writingMode !== 0 /* WRITING_MODE.HORIZONTAL_TB */;
+exports.isVerticalWritingMode = isVerticalWritingMode;
+const isSidewaysWritingMode = (writingMode) => writingMode === 3 /* WRITING_MODE.SIDEWAYS_RL */ || writingMode === 4 /* WRITING_MODE.SIDEWAYS_LR */;
+exports.isSidewaysWritingMode = isSidewaysWritingMode;
+exports.writingMode = {
+    name: 'writing-mode',
+    initialValue: 'horizontal-tb',
+    prefix: false,
+    type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
+    parse: (_context, writingMode) => {
+        switch (writingMode) {
+            case 'vertical-rl':
+                return 1 /* WRITING_MODE.VERTICAL_RL */;
+            case 'vertical-lr':
+                return 2 /* WRITING_MODE.VERTICAL_LR */;
+            case 'sideways-rl':
+                return 3 /* WRITING_MODE.SIDEWAYS_RL */;
+            case 'sideways-lr':
+                return 4 /* WRITING_MODE.SIDEWAYS_LR */;
+            case 'horizontal-tb':
+            default:
+                return 0 /* WRITING_MODE.HORIZONTAL_TB */;
+        }
+    }
+};

package/dist/lib/css/property-descriptors/z-index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zIndex = void 0;
+const parser_1 = require("../syntax/parser");
+exports.zIndex = {
+    name: 'z-index',
+    initialValue: 'auto',
+    prefix: false,
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    parse: (_context, token) => {
+        if (token.type === 20 /* TokenType.IDENT_TOKEN */) {
+            return { auto: true, order: 0 };
+        }
+        if ((0, parser_1.isNumberToken)(token)) {
+            return { auto: false, order: token.number };
+        }
+        throw new Error(`Invalid z-index number parsed`);
+    }
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoom = void 0;
+exports.zoom = {
+    name: 'zoom',
+    initialValue: '1',
+    type: 0 /* PropertyDescriptorParsingType.VALUE */,
+    prefix: false,
+    parse: (_context, token) => {
+        if (token.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
+            return Math.max(0, token.number / 100);
+        }
+        if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
+            return Math.max(0, token.number);
+        }
+        return 1;
+    }
+};

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunctionArgs = exports.nonFunctionArgSeparator = exports.nonWhiteSpace = exports.isIdentWithValue = exports.isStringToken = exports.isIdentToken = exports.isNumberToken = exports.isDimensionToken = exports.Parser = void 0;
+const tokenizer_1 = require("./tokenizer");
+class Parser {
+    constructor(tokens) {
+        this._tokens = tokens;
+    }
+    static create(value) {
+        const tokenizer = new tokenizer_1.Tokenizer();
+        tokenizer.write(value);
+        return new Parser(tokenizer.read());
+    }
+    static parseValue(value) {
+        return Parser.create(value).parseComponentValue();
+    }
+    static parseValues(value) {
+        return Parser.create(value).parseComponentValues();
+    }
+    parseComponentValue() {
+        let token = this.consumeToken();
+        while (token.type === 31 /* TokenType.WHITESPACE_TOKEN */) {
+            token = this.consumeToken();
+        }
+        if (token.type === 32 /* TokenType.EOF_TOKEN */) {
+            throw new SyntaxError(`Error parsing CSS component value, unexpected EOF`);
+        }
+        this.reconsumeToken(token);
+        const value = this.consumeComponentValue();
+        do {
+            token = this.consumeToken();
+        } while (token.type === 31 /* TokenType.WHITESPACE_TOKEN */);
+        if (token.type === 32 /* TokenType.EOF_TOKEN */) {
+            return value;
+        }
+        throw new SyntaxError(`Error parsing CSS component value, multiple values found when expecting only one`);
+    }
+    parseComponentValues() {
+        const values = [];
+        while (true) {
+            const value = this.consumeComponentValue();
+            if (value.type === 32 /* TokenType.EOF_TOKEN */) {
+                return values;
+            }
+            values.push(value);
+        }
+    }
+    consumeComponentValue() {
+        const token = this.consumeToken();
+        switch (token.type) {
+            case 11 /* TokenType.LEFT_CURLY_BRACKET_TOKEN */:
+            case 28 /* TokenType.LEFT_SQUARE_BRACKET_TOKEN */:
+            case 2 /* TokenType.LEFT_PARENTHESIS_TOKEN */:
+                return this.consumeSimpleBlock(token.type);
+            case 19 /* TokenType.FUNCTION_TOKEN */:
+                return this.consumeFunction(token);
+        }
+        return token;
+    }
+    consumeSimpleBlock(type) {
+        const block = { type, values: [] };
+        let token = this.consumeToken();
+        while (true) {
+            if (token.type === 32 /* TokenType.EOF_TOKEN */ || isEndingTokenFor(token, type)) {
+                return block;
+            }
+            this.reconsumeToken(token);
+            block.values.push(this.consumeComponentValue());
+            token = this.consumeToken();
+        }
+    }
+    consumeFunction(functionToken) {
+        const cssFunction = {
+            name: functionToken.value,
+            values: [],
+            type: 18 /* TokenType.FUNCTION */
+        };
+        while (true) {
+            const token = this.consumeToken();
+            if (token.type === 32 /* TokenType.EOF_TOKEN */ || token.type === 3 /* TokenType.RIGHT_PARENTHESIS_TOKEN */) {
+                return cssFunction;
+            }
+            this.reconsumeToken(token);
+            cssFunction.values.push(this.consumeComponentValue());
+        }
+    }
+    consumeToken() {
+        const token = this._tokens.shift();
+        return typeof token === 'undefined' ? tokenizer_1.EOF_TOKEN : token;
+    }
+    reconsumeToken(token) {
+        this._tokens.unshift(token);
+    }
+}
+exports.Parser = Parser;
+const isDimensionToken = (token) => token.type === 15 /* TokenType.DIMENSION_TOKEN */;
+exports.isDimensionToken = isDimensionToken;
+const isNumberToken = (token) => token.type === 17 /* TokenType.NUMBER_TOKEN */;
+exports.isNumberToken = isNumberToken;
+const isIdentToken = (token) => token.type === 20 /* TokenType.IDENT_TOKEN */;
+exports.isIdentToken = isIdentToken;
+const isStringToken = (token) => token.type === 0 /* TokenType.STRING_TOKEN */;
+exports.isStringToken = isStringToken;
+const isIdentWithValue = (token, value) => (0, exports.isIdentToken)(token) && token.value === value;
+exports.isIdentWithValue = isIdentWithValue;
+const nonWhiteSpace = (token) => token.type !== 31 /* TokenType.WHITESPACE_TOKEN */;
+exports.nonWhiteSpace = nonWhiteSpace;
+const nonFunctionArgSeparator = (token) => token.type !== 31 /* TokenType.WHITESPACE_TOKEN */ && token.type !== 4 /* TokenType.COMMA_TOKEN */;
+exports.nonFunctionArgSeparator = nonFunctionArgSeparator;
+const parseFunctionArgs = (tokens) => {
+    const args = [];
+    let arg = [];
+    tokens.forEach((token) => {
+        if (token.type === 4 /* TokenType.COMMA_TOKEN */) {
+            if (arg.length === 0) {
+                throw new Error(`Error parsing function args, zero tokens for arg`);
+            }
+            args.push(arg);
+            arg = [];
+            return;
+        }
+        if (token.type !== 31 /* TokenType.WHITESPACE_TOKEN */) {
+            arg.push(token);
+        }
+    });
+    if (arg.length) {
+        args.push(arg);
+    }
+    return args;
+};
+exports.parseFunctionArgs = parseFunctionArgs;
+const isEndingTokenFor = (token, type) => {
+    if (type === 11 /* TokenType.LEFT_CURLY_BRACKET_TOKEN */ && token.type === 12 /* TokenType.RIGHT_CURLY_BRACKET_TOKEN */) {
+        return true;
+    }
+    if (type === 28 /* TokenType.LEFT_SQUARE_BRACKET_TOKEN */ && token.type === 29 /* TokenType.RIGHT_SQUARE_BRACKET_TOKEN */) {
+        return true;
+    }
+    return type === 2 /* TokenType.LEFT_PARENTHESIS_TOKEN */ && token.type === 3 /* TokenType.RIGHT_PARENTHESIS_TOKEN */;
+};

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

@@ -0,0 +1,214 @@
+"use strict";
+// CSS tokenizer code-point constants and character-classification predicates.
+// Pure functions with no runtime dependencies — usable without the Tokenizer class.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E = exports.A = exports.z = exports.u = exports.f = exports.e = exports.a = exports.ZERO = exports.EOF = exports.DELETE = exports.INFORMATION_SEPARATOR_ONE = exports.SHIFT_OUT = exports.LINE_TABULATION = exports.BACKSPACE = exports.NULL = exports.FULL_STOP = exports.SEMICOLON = exports.COLON = exports.COMMA = exports.PLUS_SIGN = exports.ASTERISK = exports.REPLACEMENT_CHARACTER = exports.CONTROL = exports.TILDE = exports.VERTICAL_LINE = exports.RIGHT_CURLY_BRACKET = exports.QUESTION_MARK = exports.LEFT_CURLY_BRACKET = exports.CIRCUMFLEX_ACCENT = exports.RIGHT_SQUARE_BRACKET = exports.LEFT_SQUARE_BRACKET = exports.COMMERCIAL_AT = exports.GREATER_THAN_SIGN = exports.LESS_THAN_SIGN = exports.EXCLAMATION_MARK = exports.HYPHEN_MINUS = exports.LOW_LINE = exports.RIGHT_PARENTHESIS = exports.LEFT_PARENTHESIS = exports.APOSTROPHE = exports.PERCENTAGE_SIGN = exports.DOLLAR_SIGN = exports.NUMBER_SIGN = exports.EQUALS_SIGN = exports.QUOTATION_MARK = exports.SPACE = exports.CHARACTER_TABULATION = exports.REVERSE_SOLIDUS = exports.SOLIDUS = exports.LINE_FEED = void 0;
+exports.stringToNumber = exports.isNumberStart = exports.isIdentifierStart = exports.isValidEscape = exports.isNonPrintableCodePoint = exports.isNameCodePoint = exports.isNameStartCodePoint = exports.isWhiteSpace = exports.isNonASCIICodePoint = exports.isLetter = exports.isUpperCaseLetter = exports.isLowerCaseLetter = exports.isHex = exports.isSurrogateCodePoint = exports.isDigit = exports.Z = exports.U = exports.F = void 0;
+const LINE_FEED = 0x000a;
+exports.LINE_FEED = LINE_FEED;
+const SOLIDUS = 0x002f;
+exports.SOLIDUS = SOLIDUS;
+const REVERSE_SOLIDUS = 0x005c;
+exports.REVERSE_SOLIDUS = REVERSE_SOLIDUS;
+const CHARACTER_TABULATION = 0x0009;
+exports.CHARACTER_TABULATION = CHARACTER_TABULATION;
+const SPACE = 0x0020;
+exports.SPACE = SPACE;
+const QUOTATION_MARK = 0x0022;
+exports.QUOTATION_MARK = QUOTATION_MARK;
+const EQUALS_SIGN = 0x003d;
+exports.EQUALS_SIGN = EQUALS_SIGN;
+const NUMBER_SIGN = 0x0023;
+exports.NUMBER_SIGN = NUMBER_SIGN;
+const DOLLAR_SIGN = 0x0024;
+exports.DOLLAR_SIGN = DOLLAR_SIGN;
+const PERCENTAGE_SIGN = 0x0025;
+exports.PERCENTAGE_SIGN = PERCENTAGE_SIGN;
+const APOSTROPHE = 0x0027;
+exports.APOSTROPHE = APOSTROPHE;
+const LEFT_PARENTHESIS = 0x0028;
+exports.LEFT_PARENTHESIS = LEFT_PARENTHESIS;
+const RIGHT_PARENTHESIS = 0x0029;
+exports.RIGHT_PARENTHESIS = RIGHT_PARENTHESIS;
+const LOW_LINE = 0x005f;
+exports.LOW_LINE = LOW_LINE;
+const HYPHEN_MINUS = 0x002d;
+exports.HYPHEN_MINUS = HYPHEN_MINUS;
+const EXCLAMATION_MARK = 0x0021;
+exports.EXCLAMATION_MARK = EXCLAMATION_MARK;
+const LESS_THAN_SIGN = 0x003c;
+exports.LESS_THAN_SIGN = LESS_THAN_SIGN;
+const GREATER_THAN_SIGN = 0x003e;
+exports.GREATER_THAN_SIGN = GREATER_THAN_SIGN;
+const COMMERCIAL_AT = 0x0040;
+exports.COMMERCIAL_AT = COMMERCIAL_AT;
+const LEFT_SQUARE_BRACKET = 0x005b;
+exports.LEFT_SQUARE_BRACKET = LEFT_SQUARE_BRACKET;
+const RIGHT_SQUARE_BRACKET = 0x005d;
+exports.RIGHT_SQUARE_BRACKET = RIGHT_SQUARE_BRACKET;
+const CIRCUMFLEX_ACCENT = 0x003d;
+exports.CIRCUMFLEX_ACCENT = CIRCUMFLEX_ACCENT;
+const LEFT_CURLY_BRACKET = 0x007b;
+exports.LEFT_CURLY_BRACKET = LEFT_CURLY_BRACKET;
+const QUESTION_MARK = 0x003f;
+exports.QUESTION_MARK = QUESTION_MARK;
+const RIGHT_CURLY_BRACKET = 0x007d;
+exports.RIGHT_CURLY_BRACKET = RIGHT_CURLY_BRACKET;
+const VERTICAL_LINE = 0x007c;
+exports.VERTICAL_LINE = VERTICAL_LINE;
+const TILDE = 0x007e;
+exports.TILDE = TILDE;
+const CONTROL = 0x0080;
+exports.CONTROL = CONTROL;
+const REPLACEMENT_CHARACTER = 0xfffd;
+exports.REPLACEMENT_CHARACTER = REPLACEMENT_CHARACTER;
+const ASTERISK = 0x002a;
+exports.ASTERISK = ASTERISK;
+const PLUS_SIGN = 0x002b;
+exports.PLUS_SIGN = PLUS_SIGN;
+const COMMA = 0x002c;
+exports.COMMA = COMMA;
+const COLON = 0x003a;
+exports.COLON = COLON;
+const SEMICOLON = 0x003b;
+exports.SEMICOLON = SEMICOLON;
+const FULL_STOP = 0x002e;
+exports.FULL_STOP = FULL_STOP;
+const NULL = 0x0000;
+exports.NULL = NULL;
+const BACKSPACE = 0x0008;
+exports.BACKSPACE = BACKSPACE;
+const LINE_TABULATION = 0x000b;
+exports.LINE_TABULATION = LINE_TABULATION;
+const SHIFT_OUT = 0x000e;
+exports.SHIFT_OUT = SHIFT_OUT;
+const INFORMATION_SEPARATOR_ONE = 0x001f;
+exports.INFORMATION_SEPARATOR_ONE = INFORMATION_SEPARATOR_ONE;
+const DELETE = 0x007f;
+exports.DELETE = DELETE;
+const EOF = -1;
+exports.EOF = EOF;
+const ZERO = 0x0030;
+exports.ZERO = ZERO;
+const a = 0x0061;
+exports.a = a;
+const e = 0x0065;
+exports.e = e;
+const f = 0x0066;
+exports.f = f;
+const u = 0x0075;
+exports.u = u;
+const z = 0x007a;
+exports.z = z;
+const A = 0x0041;
+exports.A = A;
+const E = 0x0045;
+exports.E = E;
+const F = 0x0046;
+exports.F = F;
+const U = 0x0055;
+exports.U = U;
+const Z = 0x005a;
+exports.Z = Z;
+const css_line_break_1 = require("css-line-break");
+const isDigit = (codePoint) => codePoint >= ZERO && codePoint <= 0x0039;
+exports.isDigit = isDigit;
+const isSurrogateCodePoint = (codePoint) => codePoint >= 0xd800 && codePoint <= 0xdfff;
+exports.isSurrogateCodePoint = isSurrogateCodePoint;
+const isHex = (codePoint) => isDigit(codePoint) || (codePoint >= A && codePoint <= F) || (codePoint >= a && codePoint <= f);
+exports.isHex = isHex;
+const isLowerCaseLetter = (codePoint) => codePoint >= a && codePoint <= z;
+exports.isLowerCaseLetter = isLowerCaseLetter;
+const isUpperCaseLetter = (codePoint) => codePoint >= A && codePoint <= Z;
+exports.isUpperCaseLetter = isUpperCaseLetter;
+const isLetter = (codePoint) => isLowerCaseLetter(codePoint) || isUpperCaseLetter(codePoint);
+exports.isLetter = isLetter;
+const isNonASCIICodePoint = (codePoint) => codePoint >= CONTROL;
+exports.isNonASCIICodePoint = isNonASCIICodePoint;
+const isWhiteSpace = (codePoint) => codePoint === LINE_FEED || codePoint === CHARACTER_TABULATION || codePoint === SPACE;
+exports.isWhiteSpace = isWhiteSpace;
+const isNameStartCodePoint = (codePoint) => isLetter(codePoint) || isNonASCIICodePoint(codePoint) || codePoint === LOW_LINE;
+exports.isNameStartCodePoint = isNameStartCodePoint;
+const isNameCodePoint = (codePoint) => isNameStartCodePoint(codePoint) || isDigit(codePoint) || codePoint === HYPHEN_MINUS;
+exports.isNameCodePoint = isNameCodePoint;
+const isNonPrintableCodePoint = (codePoint) => {
+    return ((codePoint >= NULL && codePoint <= BACKSPACE) ||
+        codePoint === LINE_TABULATION ||
+        (codePoint >= SHIFT_OUT && codePoint <= INFORMATION_SEPARATOR_ONE) ||
+        codePoint === DELETE);
+};
+exports.isNonPrintableCodePoint = isNonPrintableCodePoint;
+const isValidEscape = (c1, c2) => {
+    if (c1 !== REVERSE_SOLIDUS) {
+        return false;
+    }
+    return c2 !== LINE_FEED;
+};
+exports.isValidEscape = isValidEscape;
+const isIdentifierStart = (c1, c2, c3) => {
+    if (c1 === HYPHEN_MINUS) {
+        return isNameStartCodePoint(c2) || isValidEscape(c2, c3);
+    }
+    else if (isNameStartCodePoint(c1)) {
+        return true;
+    }
+    else if (c1 === REVERSE_SOLIDUS && isValidEscape(c1, c2)) {
+        return true;
+    }
+    return false;
+};
+exports.isIdentifierStart = isIdentifierStart;
+const isNumberStart = (c1, c2, c3) => {
+    if (c1 === PLUS_SIGN || c1 === HYPHEN_MINUS) {
+        if (isDigit(c2)) {
+            return true;
+        }
+        return c2 === FULL_STOP && isDigit(c3);
+    }
+    if (c1 === FULL_STOP) {
+        return isDigit(c2);
+    }
+    return isDigit(c1);
+};
+exports.isNumberStart = isNumberStart;
+const stringToNumber = (codePoints) => {
+    let c = 0;
+    let sign = 1;
+    if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) {
+        if (codePoints[c] === HYPHEN_MINUS) {
+            sign = -1;
+        }
+        c++;
+    }
+    const integers = [];
+    while (isDigit(codePoints[c])) {
+        integers.push(codePoints[c++]);
+    }
+    const int = integers.length ? parseInt((0, css_line_break_1.fromCodePoint)(...integers), 10) : 0;
+    if (codePoints[c] === FULL_STOP) {
+        c++;
+    }
+    const fraction = [];
+    while (isDigit(codePoints[c])) {
+        fraction.push(codePoints[c++]);
+    }
+    const fracd = fraction.length;
+    const frac = fracd ? parseInt((0, css_line_break_1.fromCodePoint)(...fraction), 10) : 0;
+    if (codePoints[c] === E || codePoints[c] === e) {
+        c++;
+    }
+    let expsign = 1;
+    if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) {
+        if (codePoints[c] === HYPHEN_MINUS) {
+            expsign = -1;
+        }
+        c++;
+    }
+    const exponent = [];
+    while (isDigit(codePoints[c])) {
+        exponent.push(codePoints[c++]);
+    }
+    const exp = exponent.length ? parseInt((0, css_line_break_1.fromCodePoint)(...exponent), 10) : 0;
+    return sign * (int + frac * Math.pow(10, -fracd)) * Math.pow(10, expsign * exp);
+};
+exports.stringToNumber = stringToNumber;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EOF_TOKEN = exports.WHITESPACE_TOKEN = exports.RIGHT_SQUARE_BRACKET_TOKEN = exports.LEFT_SQUARE_BRACKET_TOKEN = exports.SEMICOLON_TOKEN = exports.COLON_TOKEN = exports.CDC_TOKEN = exports.CDO_TOKEN = exports.BAD_STRING_TOKEN = exports.BAD_URL_TOKEN = exports.SUBSTRING_MATCH_TOKEN = exports.RIGHT_CURLY_BRACKET_TOKEN = exports.LEFT_CURLY_BRACKET_TOKEN = exports.INCLUDE_MATCH_TOKEN = exports.DASH_MATCH_TOKEN = exports.COLUMN_TOKEN = exports.PREFIX_MATCH_TOKEN = exports.SUFFIX_MATCH_TOKEN = exports.COMMA_TOKEN = exports.RIGHT_PARENTHESIS_TOKEN = exports.LEFT_PARENTHESIS_TOKEN = void 0;
+exports.LEFT_PARENTHESIS_TOKEN = {
+    type: 2 /* TokenType.LEFT_PARENTHESIS_TOKEN */
+};
+exports.RIGHT_PARENTHESIS_TOKEN = {
+    type: 3 /* TokenType.RIGHT_PARENTHESIS_TOKEN */
+};
+exports.COMMA_TOKEN = { type: 4 /* TokenType.COMMA_TOKEN */ };
+exports.SUFFIX_MATCH_TOKEN = { type: 13 /* TokenType.SUFFIX_MATCH_TOKEN */ };
+exports.PREFIX_MATCH_TOKEN = { type: 8 /* TokenType.PREFIX_MATCH_TOKEN */ };
+exports.COLUMN_TOKEN = { type: 21 /* TokenType.COLUMN_TOKEN */ };
+exports.DASH_MATCH_TOKEN = { type: 9 /* TokenType.DASH_MATCH_TOKEN */ };
+exports.INCLUDE_MATCH_TOKEN = { type: 10 /* TokenType.INCLUDE_MATCH_TOKEN */ };
+exports.LEFT_CURLY_BRACKET_TOKEN = {
+    type: 11 /* TokenType.LEFT_CURLY_BRACKET_TOKEN */
+};
+exports.RIGHT_CURLY_BRACKET_TOKEN = {
+    type: 12 /* TokenType.RIGHT_CURLY_BRACKET_TOKEN */
+};
+exports.SUBSTRING_MATCH_TOKEN = { type: 14 /* TokenType.SUBSTRING_MATCH_TOKEN */ };
+exports.BAD_URL_TOKEN = { type: 23 /* TokenType.BAD_URL_TOKEN */ };
+exports.BAD_STRING_TOKEN = { type: 1 /* TokenType.BAD_STRING_TOKEN */ };
+exports.CDO_TOKEN = { type: 25 /* TokenType.CDO_TOKEN */ };
+exports.CDC_TOKEN = { type: 24 /* TokenType.CDC_TOKEN */ };
+exports.COLON_TOKEN = { type: 26 /* TokenType.COLON_TOKEN */ };
+exports.SEMICOLON_TOKEN = { type: 27 /* TokenType.SEMICOLON_TOKEN */ };
+exports.LEFT_SQUARE_BRACKET_TOKEN = {
+    type: 28 /* TokenType.LEFT_SQUARE_BRACKET_TOKEN */
+};
+exports.RIGHT_SQUARE_BRACKET_TOKEN = {
+    type: 29 /* TokenType.RIGHT_SQUARE_BRACKET_TOKEN */
+};
+exports.WHITESPACE_TOKEN = { type: 31 /* TokenType.WHITESPACE_TOKEN */ };
+exports.EOF_TOKEN = { type: 32 /* TokenType.EOF_TOKEN */ };