html2canvas-pro 2.4.5 → 2.5.1

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

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.image = exports.isRepeatingLinearGradient = exports.isRadialGradient = exports.isLinearGradient = void 0;
-exports.isSupportedImage = isSupportedImage;
-const linear_gradient_1 = require("./functions/linear-gradient");
-const _prefix_linear_gradient_1 = require("./functions/-prefix-linear-gradient");
-const _webkit_gradient_1 = require("./functions/-webkit-gradient");
-const radial_gradient_1 = require("./functions/radial-gradient");
-const _prefix_radial_gradient_1 = require("./functions/-prefix-radial-gradient");
-const repeating_linear_gradient_1 = require("./functions/repeating-linear-gradient");
-const isLinearGradient = (background) => {
-    return background.type === 1 /* CSSImageType.LINEAR_GRADIENT */;
-};
-exports.isLinearGradient = isLinearGradient;
-const isRadialGradient = (background) => {
-    return background.type === 2 /* CSSImageType.RADIAL_GRADIENT */;
-};
-exports.isRadialGradient = isRadialGradient;
-const isRepeatingLinearGradient = (background) => {
-    return background.type === 3 /* CSSImageType.REPEATING_LINEAR_GRADIENT */;
-};
-exports.isRepeatingLinearGradient = isRepeatingLinearGradient;
-exports.image = {
-    name: 'image',
-    parse: (context, value) => {
-        if (value.type === 22 /* TokenType.URL_TOKEN */) {
-            const image = { url: value.value, type: 0 /* CSSImageType.URL */ };
-            context.cache.addImage(value.value);
-            return image;
-        }
-        if (value.type === 18 /* TokenType.FUNCTION */) {
-            const imageFunction = SUPPORTED_IMAGE_FUNCTIONS[value.name];
-            if (typeof imageFunction === 'undefined') {
-                throw new Error(`Attempting to parse an unsupported image function "${value.name}"`);
-            }
-            return imageFunction(context, value.values);
-        }
-        throw new Error(`Unsupported image type ${value.type}`);
-    }
-};
-function isSupportedImage(value) {
-    return (!(value.type === 20 /* TokenType.IDENT_TOKEN */ && value.value === 'none') &&
-        (value.type !== 18 /* TokenType.FUNCTION */ || !!SUPPORTED_IMAGE_FUNCTIONS[value.name]));
-}
-const SUPPORTED_IMAGE_FUNCTIONS = {
-    'linear-gradient': linear_gradient_1.linearGradient,
-    '-moz-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
-    '-ms-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
-    '-o-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
-    '-webkit-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
-    'radial-gradient': radial_gradient_1.radialGradient,
-    '-moz-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
-    '-ms-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
-    '-o-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
-    '-webkit-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
-    '-webkit-gradient': _webkit_gradient_1.webkitGradient,
-    'repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
-    '-webkit-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
-    '-moz-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
-    '-ms-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
-    '-o-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient
-};

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

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

package/dist/lib/css/types/length-percentage.js

@@ -1,197 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAbsoluteValue = exports.getAbsoluteValueForTuple = exports.HUNDRED_PERCENT = exports.FIFTY_PERCENT = exports.ZERO_LENGTH = exports.parseLengthPercentageTuple = exports.evaluateCalcToLengthPercentage = exports.parseOptionalCalcOrLength = exports.parseCalcForLengthPercentage = exports.isCalcFunction = exports.isCalcWithPercentage = exports.isLengthPercentage = void 0;
-const tokenizer_1 = require("../syntax/tokenizer");
-const parser_1 = require("../syntax/parser");
-const length_1 = require("./length");
-const safe_eval_1 = __importDefault(require("./safe-eval"));
-const isLengthPercentage = (token) => token.type === 16 /* TokenType.PERCENTAGE_TOKEN */ || (0, length_1.isLength)(token) || (0, exports.isCalcWithPercentage)(token);
-exports.isLengthPercentage = isLengthPercentage;
-/**
- * Check if a token is a CalcWithPercentage deferred token.
- * Accepts CSSValue (structural duck-type check) for use in type guards.
- */
-const isCalcWithPercentage = (token) => token.type === 17 /* TokenType.NUMBER_TOKEN */ && token._calcPercentage !== undefined;
-exports.isCalcWithPercentage = isCalcWithPercentage;
-/**
- * Check if a token is a calc() function
- */
-const isCalcFunction = (token) => token.type === 18 /* TokenType.FUNCTION */ && token.name === 'calc';
-exports.isCalcFunction = isCalcFunction;
-/**
- * Parse a calc() token and produce a LengthPercentage.
- *
- * Uses two-point evaluation to extract the percentage coefficient and pixel
- * offset from a calc() expression so it can be resolved later at render time
- * when the container size is known.
- *
- *   evaluate(0)   → pixelOffset
- *   evaluate(100) → percentage + pixelOffset   →  percentage = evaluate(100) - pixelOffset
- *
- * If the expression has no percentage component, returns a plain NUMBER_TOKEN
- * for backwards compatibility.
- */
-const parseCalcForLengthPercentage = (calcToken) => {
-    const withZero = (0, exports.evaluateCalcToLengthPercentage)(calcToken, 0);
-    if (!withZero)
-        return null;
-    const withHundred = (0, exports.evaluateCalcToLengthPercentage)(calcToken, 100);
-    if (!withHundred)
-        return null;
-    const pixelOffset = withZero.number;
-    const percentage = withHundred.number - pixelOffset;
-    // If there's no percentage component, return a plain NUMBER_TOKEN
-    if (percentage === 0) {
-        return withZero;
-    }
-    return {
-        type: 17 /* TokenType.NUMBER_TOKEN */,
-        number: pixelOffset,
-        flags: tokenizer_1.FLAG_INTEGER,
-        _calcPercentage: percentage,
-        _calcPixelOffset: pixelOffset
-    };
-};
-exports.parseCalcForLengthPercentage = parseCalcForLengthPercentage;
-/**
- * Convenience helper for parsing an optional calc() or length-percentage value.
- * Used by property descriptors that accept both calc() and regular length-percentage tokens.
- * Returns null if the value is neither a calc() function nor a length-percentage token.
- */
-const parseOptionalCalcOrLength = (value) => {
-    if ((0, exports.isCalcFunction)(value)) {
-        return (0, exports.parseCalcForLengthPercentage)(value);
-    }
-    return (0, exports.isLengthPercentage)(value) ? value : null;
-};
-exports.parseOptionalCalcOrLength = parseOptionalCalcOrLength;
-/**
- * Evaluate a calc() expression and convert to LengthPercentage token
- * Supports basic arithmetic: +, -, *, /
- * Note: Percentages in calc() are converted based on a context value
- */
-const evaluateCalcToLengthPercentage = (calcToken, contextValue = 0) => {
-    // Build expression string from tokens
-    const buildExpression = (values) => {
-        let expression = '';
-        for (const value of values) {
-            if (value.type === 31 /* TokenType.WHITESPACE_TOKEN */) {
-                continue;
-            }
-            if (value.type === 18 /* TokenType.FUNCTION */) {
-                if (value.name === 'calc') {
-                    const nested = buildExpression(value.values);
-                    if (nested === null)
-                        return null;
-                    expression += `(${nested})`;
-                }
-                else {
-                    return null;
-                }
-            }
-            else if (value.type === 17 /* TokenType.NUMBER_TOKEN */) {
-                expression += value.number.toString();
-            }
-            else if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
-                // Convert units to px
-                if (value.unit === 'px') {
-                    expression += value.number.toString();
-                }
-                else if (value.unit === 'rem' || value.unit === 'em') {
-                    expression += (value.number * 16).toString();
-                }
-                else {
-                    expression += value.number.toString();
-                }
-            }
-            else if (value.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
-                // Convert percentage to absolute value based on context
-                expression += ((value.number / 100) * contextValue).toString();
-            }
-            else if (value.type === 6 /* TokenType.DELIM_TOKEN */) {
-                const op = value.value;
-                if (op === '+' || op === '-' || op === '*' || op === '/') {
-                    expression += ` ${op} `;
-                }
-                else if (op === '(') {
-                    expression += '(';
-                }
-                else if (op === ')') {
-                    expression += ')';
-                }
-            }
-        }
-        return expression;
-    };
-    try {
-        const expression = buildExpression(calcToken.values);
-        if (expression === null || expression.trim() === '') {
-            return null;
-        }
-        // Evaluate the expression
-        // Uses safe arithmetic evaluator instead of new Function() for CodeQL
-        const result = (0, safe_eval_1.default)(expression);
-        if (typeof result === 'number' && !isNaN(result)) {
-            // Return as a number token in px
-            return {
-                type: 17 /* TokenType.NUMBER_TOKEN */,
-                number: result,
-                flags: tokenizer_1.FLAG_INTEGER
-            };
-        }
-    }
-    catch (e) {
-        return null;
-    }
-    return null;
-};
-exports.evaluateCalcToLengthPercentage = evaluateCalcToLengthPercentage;
-const parseLengthPercentageTuple = (tokens) => tokens.length > 1 ? [tokens[0], tokens[1]] : [tokens[0]];
-exports.parseLengthPercentageTuple = parseLengthPercentageTuple;
-exports.ZERO_LENGTH = {
-    type: 17 /* TokenType.NUMBER_TOKEN */,
-    number: 0,
-    flags: tokenizer_1.FLAG_INTEGER
-};
-exports.FIFTY_PERCENT = {
-    type: 16 /* TokenType.PERCENTAGE_TOKEN */,
-    number: 50,
-    flags: tokenizer_1.FLAG_INTEGER
-};
-exports.HUNDRED_PERCENT = {
-    type: 16 /* TokenType.PERCENTAGE_TOKEN */,
-    number: 100,
-    flags: tokenizer_1.FLAG_INTEGER
-};
-const getAbsoluteValueForTuple = (tuple, width, height) => {
-    const [x, y] = tuple;
-    return [(0, exports.getAbsoluteValue)(x, width), (0, exports.getAbsoluteValue)(typeof y !== 'undefined' ? y : x, height)];
-};
-exports.getAbsoluteValueForTuple = getAbsoluteValueForTuple;
-const getAbsoluteValue = (token, parent) => {
-    if ((0, exports.isCalcWithPercentage)(token)) {
-        return (token._calcPercentage / 100) * parent + token._calcPixelOffset;
-    }
-    if (token.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
-        return (token.number / 100) * parent;
-    }
-    if ((0, parser_1.isDimensionToken)(token)) {
-        switch (token.unit) {
-            case 'rem':
-            case 'em':
-                // NOTE: Assumes a 16px root font-size for rem/em units. A fully
-                // accurate implementation would require access to the element's
-                // computed font-size (em) or the root element's font-size (rem),
-                // which are not available in this pure-resolution function.
-                return 16 * token.number;
-            case 'px':
-            default:
-                return token.number;
-        }
-    }
-    return token.number;
-};
-exports.getAbsoluteValue = getAbsoluteValue;

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

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLength = void 0;
-const isLength = (token) => token.type === 17 /* TokenType.NUMBER_TOKEN */ || token.type === 15 /* TokenType.DIMENSION_TOKEN */;
-exports.isLength = isLength;

package/dist/lib/css/types/safe-eval.js

@@ -1,80 +0,0 @@
-"use strict";
-/**
- * Safe arithmetic expression evaluator — replaces `new Function()`.
- *
- * Supports only: numbers, +, -, *, /, parentheses.
- * Does NOT execute arbitrary code. Returns NaN on any illegal token.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-// Regex that matches a token: number (int or float) | operator | parentheses
-const ARITH_TOKEN_RE = /(\d+(?:\.\d+)?|[+\-*/()])/g;
-const safeEvalArithmetic = (expr) => {
-    const tokens = expr.match(ARITH_TOKEN_RE);
-    if (!tokens) {
-        return NaN;
-    }
-    // Shunting-yard algorithm: infix → postfix (RPN), then evaluate.
-    const output = [];
-    const ops = [];
-    const precedence = { '+': 1, '-': 1, '*': 2, '/': 2 };
-    for (const tok of tokens) {
-        if (/^\d+(?:\.\d+)?$/.test(tok)) {
-            output.push(parseFloat(tok));
-        }
-        else if (tok === '(') {
-            ops.push(tok);
-        }
-        else if (tok === ')') {
-            while (ops.length && ops[ops.length - 1] !== '(') {
-                output.push(ops.pop());
-            }
-            if (!ops.length)
-                return NaN; // mismatched parens
-            ops.pop(); // discard '('
-        }
-        else {
-            // operator: + - * /
-            while (ops.length && precedence[ops[ops.length - 1]] >= precedence[tok]) {
-                output.push(ops.pop());
-            }
-            ops.push(tok);
-        }
-    }
-    while (ops.length) {
-        const op = ops.pop();
-        if (op === '(')
-            return NaN; // mismatched parens
-        output.push(op);
-    }
-    // Evaluate RPN
-    const stack = [];
-    for (const item of output) {
-        if (typeof item === 'number') {
-            stack.push(item);
-        }
-        else {
-            const b = stack.pop();
-            const a = stack.pop();
-            if (a === undefined || b === undefined)
-                return NaN;
-            switch (item) {
-                case '+':
-                    stack.push(a + b);
-                    break;
-                case '-':
-                    stack.push(a - b);
-                    break;
-                case '*':
-                    stack.push(a * b);
-                    break;
-                case '/':
-                    stack.push(b === 0 ? NaN : a / b);
-                    break;
-                default:
-                    return NaN;
-            }
-        }
-    }
-    return stack.length === 1 ? stack[0] : NaN;
-};
-exports.default = safeEvalArithmetic;

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.time = void 0;
-exports.time = {
-    name: 'time',
-    parse: (_context, value) => {
-        if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
-            switch (value.unit.toLowerCase()) {
-                case 's':
-                    return 1000 * value.number;
-                case 'ms':
-                    return value.number;
-            }
-        }
-        throw new Error(`Unsupported time type`);
-    }
-};