@antv/g/es/css/cssom/CSSNumericValue.js

import { __assign, __extends, __read, __spreadArray, __values } from "tslib";
import { DCHECK, DCHECK_EQ, DCHECK_NE } from '../../utils/assert';
import { CSSMathOperator } from './CSSMathOperator';
import { CSSStyleValue, CSSStyleValueType } from './CSSStyleValue';
import { Nested, ParenLess, UnitType } from './types'; // https://drafts.css-houdini.org/css-typed-om/#enumdef-cssnumericbasetype

export var BaseType;

(function (BaseType) {
  BaseType[BaseType["kLength"] = 0] = "kLength";
  BaseType[BaseType["kAngle"] = 1] = "kAngle";
  BaseType[BaseType["kTime"] = 2] = "kTime";
  BaseType[BaseType["kFrequency"] = 3] = "kFrequency";
  BaseType[BaseType["kResolution"] = 4] = "kResolution";
  BaseType[BaseType["kFlex"] = 5] = "kFlex";
  BaseType[BaseType["kPercent"] = 6] = "kPercent";
  BaseType[BaseType["kNumBaseTypes"] = 7] = "kNumBaseTypes";
})(BaseType || (BaseType = {}));

export function unitTypeToBaseType(unit) {
  DCHECK_NE(unit, UnitType.kNumber);

  switch (unit) {
    case UnitType.kEms:
    case UnitType.kExs:
    case UnitType.kPixels:
    case UnitType.kCentimeters:
    case UnitType.kMillimeters:
    case UnitType.kQuarterMillimeters:
    case UnitType.kInches:
    case UnitType.kPoints:
    case UnitType.kPicas:
    case UnitType.kUserUnits:
    case UnitType.kViewportWidth:
    case UnitType.kViewportHeight:
    case UnitType.kViewportInlineSize:
    case UnitType.kViewportBlockSize:
    case UnitType.kViewportMin:
    case UnitType.kViewportMax:
    case UnitType.kSmallViewportWidth:
    case UnitType.kSmallViewportHeight:
    case UnitType.kSmallViewportInlineSize:
    case UnitType.kSmallViewportBlockSize:
    case UnitType.kSmallViewportMin:
    case UnitType.kSmallViewportMax:
    case UnitType.kLargeViewportWidth:
    case UnitType.kLargeViewportHeight:
    case UnitType.kLargeViewportInlineSize:
    case UnitType.kLargeViewportBlockSize:
    case UnitType.kLargeViewportMin:
    case UnitType.kLargeViewportMax:
    case UnitType.kDynamicViewportWidth:
    case UnitType.kDynamicViewportHeight:
    case UnitType.kDynamicViewportInlineSize:
    case UnitType.kDynamicViewportBlockSize:
    case UnitType.kDynamicViewportMin:
    case UnitType.kDynamicViewportMax:
    case UnitType.kContainerWidth:
    case UnitType.kContainerHeight:
    case UnitType.kContainerInlineSize:
    case UnitType.kContainerBlockSize:
    case UnitType.kContainerMin:
    case UnitType.kContainerMax:
    case UnitType.kRems:
    case UnitType.kChs:
      return BaseType.kLength;

    case UnitType.kMilliseconds:
    case UnitType.kSeconds:
      return BaseType.kTime;

    case UnitType.kDegrees:
    case UnitType.kRadians:
    case UnitType.kGradians:
    case UnitType.kTurns:
      return BaseType.kAngle;

    case UnitType.kHertz:
    case UnitType.kKilohertz:
      return BaseType.kFrequency;

    case UnitType.kDotsPerPixel:
    case UnitType.kDotsPerInch:
    case UnitType.kDotsPerCentimeter:
      return BaseType.kResolution;

    case UnitType.kFraction:
      return BaseType.kFlex;

    case UnitType.kPercentage:
      return BaseType.kPercent;

    default:
      return BaseType.kLength;
  }
}
export function baseTypeToString(baseType) {
  switch (baseType) {
    case BaseType.kLength:
      return 'length';

    case BaseType.kAngle:
      return 'angle';

    case BaseType.kTime:
      return 'time';

    case BaseType.kFrequency:
      return 'frequency';

    case BaseType.kResolution:
      return 'resolution';

    case BaseType.kFlex:
      return 'flex';

    case BaseType.kPercent:
      return 'percent';

    default:
      break;
  }

  return '';
}

var CSSNumericValueType =
/** @class */
function () {
  function CSSNumericValueType(unit, exponent) {
    if (unit === void 0) {
      unit = UnitType.kNumber;
    }

    if (exponent === void 0) {
      exponent = 1;
    }

    this.exponents = [];
    this.numNonZeroEntries = 0;
    this.percentHint = BaseType.kPercent;
    this.hasPercentHint = false;
    this.exponents = new Array(BaseType.kNumBaseTypes).fill(0);

    if (unit !== UnitType.kNumber) {
      this.setExponent(unitTypeToBaseType(unit), exponent);
    }
  }

  CSSNumericValueType.prototype.applyPercentHint = function (hint) {
    DCHECK_NE(hint, BaseType.kPercent);
    this.setExponent(hint, this.exponent(hint) + this.exponent(BaseType.kPercent));
    this.setExponent(BaseType.kPercent, 0);
    this.percentHint = hint;
    this.hasPercentHint = true;
  };

  CSSNumericValueType.prototype.hasNonZeroEntries = function () {
    return this.numNonZeroEntries > 0;
  };

  CSSNumericValueType.prototype.isOnlyNonZeroEntry = function (baseType, value) {
    DCHECK_NE(value, 0);
    return this.numNonZeroEntries === 1 && this.exponent(baseType) === value;
  };

  CSSNumericValueType.prototype.exponent = function (type) {
    return this.exponents[type];
  };

  CSSNumericValueType.prototype.setExponent = function (type, newValue) {
    var oldValue = this.exponents[type];

    if (oldValue == 0 && newValue !== 0) {
      this.numNonZeroEntries++;
    } else if (oldValue !== 0 && newValue == 0) {
      this.numNonZeroEntries--;
    }

    this.exponents[type] = newValue;
  };

  CSSNumericValueType.negateExponents = function (type) {
    type.exponents.forEach(function (v) {
      return v *= -1;
    });
    return type;
  };

  CSSNumericValueType.prototype.matchesBaseType = function (baseType) {
    DCHECK_NE(baseType, BaseType.kPercent);
    return this.isOnlyNonZeroEntry(baseType, 1) && !this.hasPercentHint;
  };

  CSSNumericValueType.prototype.matchesPercentage = function () {
    return this.isOnlyNonZeroEntry(BaseType.kPercent, 1);
  };

  CSSNumericValueType.prototype.matchesBaseTypePercentage = function (baseType) {
    DCHECK_NE(baseType, BaseType.kPercent);
    return this.isOnlyNonZeroEntry(baseType, 1) || this.isOnlyNonZeroEntry(BaseType.kPercent, 1);
  };

  CSSNumericValueType.prototype.matchesNumber = function () {
    return !this.hasNonZeroEntries() && !this.hasPercentHint;
  };

  CSSNumericValueType.prototype.matchesNumberPercentage = function () {
    return !this.hasNonZeroEntries() || this.isOnlyNonZeroEntry(BaseType.kPercent, 1);
  };

  CSSNumericValueType.add = function (type1, type2, error) {
    if (type1.hasPercentHint && type2.hasPercentHint && type1.percentHint != type2.percentHint) {
      error = true;
      return type1;
    }

    if (type1.hasPercentHint) type2.applyPercentHint(type1.percentHint);else if (type2.hasPercentHint) type1.applyPercentHint(type2.percentHint);
    DCHECK_EQ(type1.percentHint, type2.percentHint); // Match up base types. Try to use the percent hint to match up any
    // differences.

    for (var i = 0; i < BaseType.kNumBaseTypes; ++i) {
      var base_type = i;

      if (type1.exponents[i] !== type2.exponents[i]) {
        if (base_type !== BaseType.kPercent) {
          type1.applyPercentHint(base_type);
          type2.applyPercentHint(base_type);
        }

        if (type1.exponents[i] !== type2.exponents[i]) {
          error = true;
          return type1;
        }
      }
    }

    error = false;
    return type1;
  };

  CSSNumericValueType.multiply = function (type1, type2, error) {
    if (type1.hasPercentHint && type2.hasPercentHint && type1.percentHint != type2.percentHint) {
      error = true;
      return type1;
    }

    if (type1.hasPercentHint) type2.applyPercentHint(type1.percentHint);else if (type2.hasPercentHint) type1.applyPercentHint(type2.percentHint);

    for (var i = 0; i < BaseType.kNumBaseTypes; ++i) {
      var base_type = i;
      type1.setExponent(base_type, type1.exponent(base_type) + type2.exponent(base_type));
    }

    error = false;
    return type1;
  };

  return CSSNumericValueType;
}();

export { CSSNumericValueType };
/**
 * CSSNumericValue is the base class for numeric and length typed CSS Values.
 * @see https://drafts.css-houdini.org/css-typed-om/#numeric-objects
 * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSNumericValue
 * @see https://chromium.googlesource.com/chromium/src/+/refs/heads/main/third_party/blink/renderer/core/css/cssom/css_numeric_value.idl
 */

var CSSNumericValue =
/** @class */
function (_super) {
  __extends(CSSNumericValue, _super);

  function CSSNumericValue(type_) {
    var _this = _super.call(this) || this;

    _this.type_ = type_;
    return _this;
  }
  /**
   * @see https://chromium.googlesource.com/chromium/src/+/refs/heads/main/third_party/blink/renderer/core/css/cssom/css_numeric_value.cc#296
   */


  CSSNumericValue.fromNumberish = function (value) {
    if (typeof value === 'number') {
      return new CSSUnitValue(value, UnitType.kNumber);
    }

    return value;
  };

  CSSNumericValue.fromPercentish = function (value) {
    if (typeof value === 'number') {
      return new CSSUnitValue(value * 100, UnitType.kPercentage);
    }

    return value;
  };

  CSSNumericValue.prototype.getType = function () {
    return CSSStyleValueType.kUnknownType;
  }; // toCSSValue() {
  //   return null;
  // }

  /**
   * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSNumericValue/equals
   */


  CSSNumericValue.prototype.equals = function () {
    var _this = this;

    var numberishes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      numberishes[_i] = arguments[_i];
    }

    var values = cssNumberishesToNumericValues(numberishes);
    return values.every(function (value) {
      return _this.equals(value);
    });
  };
  /**
   * @see https://chromium.googlesource.com/chromium/src/+/refs/heads/main/third_party/blink/renderer/core/css/cssom/css_numeric_value.cc#439
   */


  CSSNumericValue.prototype.add = function () {
    var numberishes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      numberishes[_i] = arguments[_i];
    }

    var values = cssNumberishesToNumericValues(numberishes);
    prependValueForArithmetic(CSSStyleValueType.kSumType, values, this); // eg. 1px + 2px = 3px

    var unitValue = maybeSimplifyAsUnitValue(values, CSSMathOperator.kAdd);

    if (unitValue) {
      return unitValue;
    }

    return CSSMathSum.create(values);
  };
  /**
   * @see https://chromium.googlesource.com/chromium/src/+/refs/heads/main/third_party/blink/renderer/core/css/cssom/css_numeric_value.cc#452
   */


  CSSNumericValue.prototype.sub = function () {
    var numberishes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      numberishes[_i] = arguments[_i];
    }

    var values = cssNumberishesToNumericValues(numberishes);
    values = values.map(function (value) {
      return value.negate();
    });
    prependValueForArithmetic(CSSStyleValueType.kSumType, values, this); // eg. 3px - 2px = 1px

    var unitValue = maybeSimplifyAsUnitValue(values, CSSMathOperator.kAdd);

    if (unitValue) {
      return unitValue;
    }

    return CSSMathSum.create(values);
  };
  /**
   * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSNumericValue/mul
   */


  CSSNumericValue.prototype.mul = function () {
    var numberishes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      numberishes[_i] = arguments[_i];
    }

    var values = cssNumberishesToNumericValues(numberishes);
    prependValueForArithmetic(CSSStyleValueType.kProductType, values, this);
    var unitValue = maybeMultiplyAsUnitValue(values);

    if (unitValue) {
      return unitValue;
    }

    return CSSMathProduct.create(values);
  };
  /**
   * eg. calc(24px / 4%)
   * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSNumericValue/div
   */


  CSSNumericValue.prototype.div = function () {
    var numberishes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      numberishes[_i] = arguments[_i];
    }

    var values = cssNumberishesToNumericValues(numberishes);
    values = values.map(function (value) {
      return value.invert();
    });
    prependValueForArithmetic(CSSStyleValueType.kProductType, values, this);
    var unitValue = maybeMultiplyAsUnitValue(values);

    if (unitValue) {
      return unitValue;
    }

    return CSSMathProduct.create(values);
  };

  CSSNumericValue.prototype.min = function () {
    var numberishes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      numberishes[_i] = arguments[_i];
    }

    var values = cssNumberishesToNumericValues(numberishes);
    prependValueForArithmetic(CSSStyleValueType.kMinType, values, this);
    var unitValue = maybeSimplifyAsUnitValue(values, CSSMathOperator.kMin);

    if (unitValue) {
      return unitValue;
    }

    return CSSMathMin.create(values);
  };

  CSSNumericValue.prototype.max = function () {
    var numberishes = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      numberishes[_i] = arguments[_i];
    }

    var values = cssNumberishesToNumericValues(numberishes);
    prependValueForArithmetic(CSSStyleValueType.kMaxType, values, this);
    var unitValue = maybeSimplifyAsUnitValue(values, CSSMathOperator.kMax);

    if (unitValue) {
      return unitValue;
    }

    return CSSMathMax.create(values);
  };
  /**
   * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSNumericValue/to
   * @see https://chromium.googlesource.com/chromium/src/+/refs/heads/main/third_party/blink/renderer/core/css/cssom/css_numeric_value.cc#331
   */


  CSSNumericValue.prototype.to = function (unitOrName) {
    var sum = this.sumValue();
    if (sum.length === 0 || sum.length !== 1) return null;
    var value = cssNumericSumValueEntryToUnitValue(sum[0]);
    if (!value) return null;
    var unit;

    if (typeof unitOrName === 'string') {
      unit = CSSUnitValue.unitFromName(unitOrName);
    } else {
      unit = unitOrName;
    }

    return value.convertTo(unit);
  };
  /**
   * converts the object's value to a CSSMathSum object to values of the specified unit.
   * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSNumericValue/toSum
   */


  CSSNumericValue.prototype.toSum = function () {
    var e_1, _a, e_2, _b, e_3, _c;

    var unit_strings = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      unit_strings[_i] = arguments[_i];
    }

    try {
      for (var unit_strings_1 = __values(unit_strings), unit_strings_1_1 = unit_strings_1.next(); !unit_strings_1_1.done; unit_strings_1_1 = unit_strings_1.next()) {
        var unit_string = unit_strings_1_1.value;

        if (!CSSNumericValue.isValidUnit(CSSNumericValue.unitFromName(unit_string))) {
          return null;
        }
      }
    } catch (e_1_1) {
      e_1 = {
        error: e_1_1
      };
    } finally {
      try {
        if (unit_strings_1_1 && !unit_strings_1_1.done && (_a = unit_strings_1.return)) _a.call(unit_strings_1);
      } finally {
        if (e_1) throw e_1.error;
      }
    }

    var sum = this.sumValue();

    if (!sum.length) {
      return null;
    }

    var values = [];

    try {
      for (var sum_1 = __values(sum), sum_1_1 = sum_1.next(); !sum_1_1.done; sum_1_1 = sum_1.next()) {
        var term = sum_1_1.value;
        var value = cssNumericSumValueEntryToUnitValue(term);

        if (!value) {
          return null;
        }

        values.push(value);
      }
    } catch (e_2_1) {
      e_2 = {
        error: e_2_1
      };
    } finally {
      try {
        if (sum_1_1 && !sum_1_1.done && (_b = sum_1.return)) _b.call(sum_1);
      } finally {
        if (e_2) throw e_2.error;
      }
    }

    if (unit_strings.length === 0) {
      values.sort(function (a, b) {
        return a.unit - b.unit;
      }); // We got 'values' from a sum value, so it must be a valid CSSMathSum.

      var result_1 = CSSMathSum.create(values);
      DCHECK(!!result_1);
      return result_1;
    }

    var result = [];

    var _loop_1 = function _loop_1(unit_string) {
      var target_unit = CSSNumericValue.unitFromName(unit_string);
      DCHECK(CSSNumericValue.isValidUnit(target_unit)); // Collect all the terms that are compatible with this unit.
      // We mark used terms as null so we don't use them again.

      var total_value = values.reduce(function (cur_sum, value, i) {
        if (value) {
          var unit_value = value;
          var converted_value = unit_value.convertTo(target_unit);

          if (converted_value) {
            cur_sum += converted_value.value;
            values[i] = null;
          }
        }

        return cur_sum;
      }, 0);
      result.push(new CSSUnitValue(total_value, target_unit));
    };

    try {
      for (var unit_strings_2 = __values(unit_strings), unit_strings_2_1 = unit_strings_2.next(); !unit_strings_2_1.done; unit_strings_2_1 = unit_strings_2.next()) {
        var unit_string = unit_strings_2_1.value;

        _loop_1(unit_string);
      }
    } catch (e_3_1) {
      e_3 = {
        error: e_3_1
      };
    } finally {
      try {
        if (unit_strings_2_1 && !unit_strings_2_1.done && (_c = unit_strings_2.return)) _c.call(unit_strings_2);
      } finally {
        if (e_3) throw e_3.error;
      }
    }

    if (values.some(function (v) {
      return !!v;
    })) {
      throw new Error('There were leftover terms that were not converted');
    }

    return CSSMathSum.create(result);
  };
  /**
   * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSNumericValue/type
   * @see https://chromium.googlesource.com/chromium/src/+/refs/heads/main/third_party/blink/renderer/core/css/cssom/css_numeric_value.cc#414
   */


  CSSNumericValue.prototype.type = function () {
    var type = {
      length: 0,
      angle: 0,
      time: 0,
      frequency: 0,
      resolution: 0,
      flex: 0,
      percent: 0,
      percentHint: 'length'
    };
    var exponent = this.type_.exponent(BaseType.kLength);

    if (exponent) {
      type.length = exponent;
    }

    exponent = this.type_.exponent(BaseType.kAngle);

    if (exponent) {
      type.angle = exponent;
    }

    exponent = this.type_.exponent(BaseType.kTime);

    if (exponent) {
      type.time = exponent;
    }

    exponent = this.type_.exponent(BaseType.kFrequency);

    if (exponent) {
      type.frequency = exponent;
    }

    exponent = this.type_.exponent(BaseType.kResolution);

    if (exponent) {
      type.resolution = exponent;
    }

    exponent = this.type_.exponent(BaseType.kFlex);

    if (exponent) {
      type.flex = exponent;
    }

    exponent = this.type_.exponent(BaseType.kPercent);

    if (exponent) {
      type.percent = exponent;
    }

    if (this.type_.hasPercentHint) {
      type.percentHint = baseTypeToString(this.type_.percentHint);
    }

    return type;
  };

  CSSNumericValue.isValidUnit = function (unit) {
    if (unit === UnitType.kUserUnits) return false;
    if (unit === UnitType.kNumber || unit == UnitType.kPercentage || this.isLength(unit) || this.isAngle(unit) || this.isTime(unit) || this.isFrequency(unit) || this.isResolution(unit) || this.isFlex(unit)) return true;
    return false;
  };

  CSSNumericValue.prototype.negate = function () {
    return CSSMathNegate.create(this);
  };

  CSSNumericValue.prototype.invert = function () {
    return CSSMathInvert.create(this);
  };

  return CSSNumericValue;
}(CSSStyleValue);

export { CSSNumericValue };

function cssNumberishesToNumericValues(values) {
  return values.map(CSSNumericValue.fromNumberish);
}

function prependValueForArithmetic(type, values, value) {
  DCHECK(!!value);

  if (value.getType() === type) {
    values.unshift.apply(values, __spreadArray([], __read(value.numericValues()), false));
  } else {
    values.unshift(value);
  }
}

function cssNumericSumValueEntryToUnitValue(term) {
  if (Object.keys(term.units).length === 0) {
    return new CSSUnitValue(term.value);
  }

  if (Object.keys(term.units).length === 1 && term.units[Object.keys(term.units)[0]] === 1) {
    return new CSSUnitValue(term.value, Number(Object.keys(term.units)[0]));
  }

  return null;
}

function maybeSimplifyAsUnitValue(values, operator) {
  DCHECK(!!values.length);
  var first_unit_value = values[0] instanceof CSSUnitValue ? values[0] : null;
  if (!first_unit_value) return null;
  var final_value = first_unit_value.value;

  for (var i = 1; i < values.length; i++) {
    var unit_value = values[i] instanceof CSSUnitValue ? values[i] : null;
    if (!unit_value || unit_value.unit !== first_unit_value.unit) return null;

    if (operator === CSSMathOperator.kAdd) {
      final_value += unit_value.value;
    } else if (operator === CSSMathOperator.kMax) {
      final_value = Math.max(final_value, unit_value.value);
    } else if (operator === CSSMathOperator.kMin) {
      final_value = Math.min(final_value, unit_value.value);
    }
  }

  return new CSSUnitValue(final_value, first_unit_value.unit);
}

function maybeMultiplyAsUnitValue(values) {
  DCHECK(!!values.length); // We are allowed one unit value with type other than kNumber.

  var unit_other_than_number = UnitType.kNumber;
  var final_value = 1.0;

  for (var i = 0; i < values.length; i++) {
    var unit_value = values[i] instanceof CSSUnitValue ? values[i] : null;
    if (!unit_value) return null;

    if (unit_value.unit !== UnitType.kNumber) {
      if (unit_other_than_number !== UnitType.kNumber) return null;
      unit_other_than_number = unit_value.unit;
    }

    final_value *= unit_value.value;
  }

  return new CSSUnitValue(final_value, unit_other_than_number);
}
/**
 * Represents numeric values that can be expressed as a single number plus a
 * unit (or a naked number or percentage).
 * @see https://drafts.css-houdini.org/css-typed-om/#cssunitvalue
 */


var CSSUnitValue =
/** @class */
function (_super) {
  __extends(CSSUnitValue, _super);

  function CSSUnitValue(value, unitOrName) {
    if (unitOrName === void 0) {
      unitOrName = UnitType.kNumber;
    }

    var _this = this;

    var unit;

    if (typeof unitOrName === 'string') {
      unit = CSSUnitValue.unitFromName(unitOrName);
    } else {
      unit = unitOrName;
    }

    DCHECK(CSSUnitValue.isValidUnit(unit));
    _this = _super.call(this, new CSSNumericValueType(unit)) || this;
    _this.unit = unit;
    _this.value = value;
    return _this;
  } // static fromCSSValue(value: CSSNumericLiteralValue) {
  //   let unit = value.type;
  //   if (unit === UnitType.kInteger) unit = UnitType.kNumber;
  //   if (!this.isValidUnit(unit)) return null;
  //   return new CSSUnitValue(value.getDoubleValue(), unit);
  // }


  CSSUnitValue.toCanonicalUnit = function (unit) {
    return this.canonicalUnitTypeForCategory(this.unitTypeToUnitCategory(unit));
  };

  CSSUnitValue.toCanonicalUnitIfPossible = function (unit) {
    var canonical_unit = this.toCanonicalUnit(unit);
    if (canonical_unit === UnitType.kUnknown) return unit;
    return canonical_unit;
  };

  CSSUnitValue.formatInfinityOrNaN = function (number, suffix) {
    if (suffix === void 0) {
      suffix = '';
    }

    var result = '';

    if (!Number.isFinite(number)) {
      if (number > 0) result = 'infinity';else result = '-infinity';
    } else {
      DCHECK(Number.isNaN(number));
      result = 'NaN';
    }

    return result += suffix;
  };

  CSSUnitValue.formatNumber = function (number, suffix) {
    if (suffix === void 0) {
      suffix = '';
    }

    return number + suffix;
  };

  CSSUnitValue.prototype.clone = function () {
    return new CSSUnitValue(this.value, this.unit);
  };

  CSSUnitValue.prototype.convertTo = function (target_unit) {
    if (this.unit === target_unit) {
      return new CSSUnitValue(this.value, this.unit);
    } // Instead of defining the scale factors for every unit to every other unit,
    // we simply convert to the canonical unit and back since we already have
    // the scale factors for canonical units.


    var canonical_unit = CSSUnitValue.toCanonicalUnit(this.unit);

    if (canonical_unit !== CSSUnitValue.toCanonicalUnit(target_unit) || canonical_unit === UnitType.kUnknown) {
      return null;
    }

    var scale_factor = CSSStyleValue.conversionToCanonicalUnitsScaleFactor(this.unit) / CSSStyleValue.conversionToCanonicalUnitsScaleFactor(target_unit);
    return new CSSUnitValue(this.value * scale_factor, target_unit);
  };

  CSSUnitValue.prototype.equals = function (other) {
    var other_unit_value = other;
    return this.value === other_unit_value.value && this.unit === other_unit_value.unit;
  };

  CSSUnitValue.prototype.getType = function () {
    return CSSStyleValueType.kUnitType;
  }; // toCSSValue() {
  //   return new CSSNumericLiteralValue(this.value, this.unit);
  // }
  // // const CSSPrimitiveValue* ToCSSValueWithProperty(CSSPropertyID) const final;
  // toCalcExpressionNode() {
  //   return CSSMathExpressionNumericLiteral.create(
  //     new CSSNumericLiteralValue(this.value, this.unit),
  //   );
  // }


  CSSUnitValue.prototype.sumValue = function () {
    var sum = [];
    var unit_map = {};

    if (this.unit !== UnitType.kNumber) {
      unit_map[CSSUnitValue.toCanonicalUnitIfPossible(this.unit)] = 1;
    }

    sum.push({
      value: this.value * CSSStyleValue.conversionToCanonicalUnitsScaleFactor(this.unit),
      units: unit_map
    });
    return sum;
  };

  CSSUnitValue.prototype.negate = function () {
    return new CSSUnitValue(-this.value, this.unit);
  };

  CSSUnitValue.prototype.invert = function () {
    if (this.unit === UnitType.kNumber) {
      if (this.value === 0) return null;
      return new CSSUnitValue(1.0 / this.value, this.unit);
    }

    return CSSMathInvert.create(this);
  };

  CSSUnitValue.prototype.buildCSSText = function (n, p, result) {
    var text;

    switch (this.unit) {
      case UnitType.kUnknown:
        // FIXME
        break;

      case UnitType.kInteger:
        text = Number(this.value).toFixed(0);
        break;

      case UnitType.kNumber:
      case UnitType.kPercentage:
      case UnitType.kEms:
      case UnitType.kQuirkyEms:
      case UnitType.kExs:
      case UnitType.kRems:
      case UnitType.kChs:
      case UnitType.kPixels:
      case UnitType.kCentimeters:
      case UnitType.kDotsPerPixel:
      case UnitType.kDotsPerInch:
      case UnitType.kDotsPerCentimeter:
      case UnitType.kMillimeters:
      case UnitType.kQuarterMillimeters:
      case UnitType.kInches:
      case UnitType.kPoints:
      case UnitType.kPicas:
      case UnitType.kUserUnits:
      case UnitType.kDegrees:
      case UnitType.kRadians:
      case UnitType.kGradians:
      case UnitType.kMilliseconds:
      case UnitType.kSeconds:
      case UnitType.kHertz:
      case UnitType.kKilohertz:
      case UnitType.kTurns:
      case UnitType.kFraction:
      case UnitType.kViewportWidth:
      case UnitType.kViewportHeight:
      case UnitType.kViewportInlineSize:
      case UnitType.kViewportBlockSize:
      case UnitType.kViewportMin:
      case UnitType.kViewportMax:
      case UnitType.kSmallViewportWidth:
      case UnitType.kSmallViewportHeight:
      case UnitType.kSmallViewportInlineSize:
      case UnitType.kSmallViewportBlockSize:
      case UnitType.kSmallViewportMin:
      case UnitType.kSmallViewportMax:
      case UnitType.kLargeViewportWidth:
      case UnitType.kLargeViewportHeight:
      case UnitType.kLargeViewportInlineSize:
      case UnitType.kLargeViewportBlockSize:
      case UnitType.kLargeViewportMin:
      case UnitType.kLargeViewportMax:
      case UnitType.kDynamicViewportWidth:
      case UnitType.kDynamicViewportHeight:
      case UnitType.kDynamicViewportInlineSize:
      case UnitType.kDynamicViewportBlockSize:
      case UnitType.kDynamicViewportMin:
      case UnitType.kDynamicViewportMax:
      case UnitType.kContainerWidth:
      case UnitType.kContainerHeight:
      case UnitType.kContainerInlineSize:
      case UnitType.kContainerBlockSize:
      case UnitType.kContainerMin:
      case UnitType.kContainerMax:
        {
          var kMinInteger = -999999;
          var kMaxInteger = 999999;
          var value = this.value;
          var unit = CSSUnitValue.unitTypeToString(this.unit);

          if (value < kMinInteger || value > kMaxInteger) {
            var unit_1 = CSSUnitValue.unitTypeToString(this.unit);

            if (!Number.isFinite(value) || Number.isNaN(value)) {
              text = CSSUnitValue.formatInfinityOrNaN(value, unit_1);
            } else {
              text = CSSUnitValue.formatNumber(value, unit_1);
            }
          } else {
            text = "".concat(value).concat(unit);
          }
        }
    }

    result += text;
    return result;
  };

  return CSSUnitValue;
}(CSSNumericValue);

export { CSSUnitValue };
/**
 * The CSSMathValue interface of the CSS_Object_Model a base class for classes representing complex numeric values.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSMathValue
 * @see https://chromium.googlesource.com/chromium/src/+/refs/heads/main/third_party/blink/renderer/core/css/cssom/css_math_value.idl
 */

var CSSMathValue =
/** @class */
function (_super) {
  __extends(CSSMathValue, _super);

  function CSSMathValue() {
    return _super !== null && _super.apply(this, arguments) || this;
  } // From CSSNumericValue


  CSSMathValue.prototype.isUnitValue = function () {
    return false;
  };

  return CSSMathValue;
}(CSSNumericValue);

export { CSSMathValue };

var CSSMathInvert =
/** @class */
function (_super) {
  __extends(CSSMathInvert, _super);

  function CSSMathInvert(value, type) {
    var _this = _super.call(this, type) || this;

    _this.value = value;
    _this.operator = 'invert';
    return _this;
  }

  CSSMathInvert.create = function (value) {
    var type = CSSNumericValueType.negateExponents(value.type_);
    return new CSSMathInvert(value, type);
  };

  CSSMathInvert.prototype.clone = function () {
    return new CSSMathInvert(this.value, this.type_);
  };

  CSSMathInvert.prototype.getType = function () {
    return CSSStyleValueType.kInvertType;
  };

  CSSMathInvert.prototype.equals = function (other) {
    if (other.getType() !== CSSStyleValueType.kInvertType) {
      return false;
    } // We can safely cast here as we know 'other' has the same type as us.


    var other_invert = other;
    return this.value.equals(other_invert.value);
  };

  CSSMathInvert.prototype.sumValue = function () {
    var sum = this.value.sumValue();

    if (sum.length === 0 || sum.length !== 1 || sum[0].value === 0) {
      return null;
    }

    Object.keys(sum[0].units).forEach(function (key) {
      sum[0].units[key] *= -1;
    });
    sum[0].value = 1.0 / sum[0].value;
    return sum;
  }; // toCalcExpressionNode(): CSSMathExpressionNode {
  //   const right_side = this.value.toCalcExpressionNode();
  //   if (!right_side) {
  //     return null;
  //   }
  //   // return CSSMathExpressionOperation::CreateArithmeticOperation(
  //   //   CSSMathExpressionNumericLiteral::Create(
  //   //       1, UnitType.kNumber),
  //   //   right_side, CSSMathOperator.kDivide);
  //   return null;
  // }


  CSSMathInvert.prototype.buildCSSText = function (nested, paren_less, result) {
    if (paren_less == ParenLess.kNo) {
      result += nested === Nested.kYes ? '(' : 'calc(';
    }

    result += '1 / ';
    result = this.value.buildCSSText(Nested.kYes, ParenLess.kNo, result);

    if (paren_less === ParenLess.kNo) {
      result += ')';
    }

    return result;
  };

  return CSSMathInvert;
}(CSSMathValue);

export { CSSMathInvert };

var CSSMathNegate =
/** @class */
function (_super) {
  __extends(CSSMathNegate, _super);

  function CSSMathNegate(value, type) {
    var _this = _super.call(this, type) || this;

    _this.value = value;
    _this.operator = 'negate';
    return _this;
  }

  CSSMathNegate.create = function (value) {
    return new CSSMathNegate(value, value.type_);
  };

  CSSMathNegate.prototype.clone = function () {
    return new CSSMathNegate(this.value, this.type_);
  };

  CSSMathNegate.prototype.getType = function () {
    return CSSStyleValueType.kNegateType;
  };

  CSSMathNegate.prototype.equals = function (other) {
    if (other.getType() !== CSSStyleValueType.kNegateType) {
      return false;
    }

    var other_invert = other;
    return this.value.equals(other_invert.value);
  };

  CSSMathNegate.prototype.sumValue = function () {
    var sum = this.value.sumValue();

    if (sum.length === 0) {
      return null;
    }

    sum.forEach(function (term) {
      term.value *= -1;
    });
    return sum;
  }; // toCalcExpressionNode(): CSSMathExpressionNode {
  //   const right_side = this.value.toCalcExpressionNode();
  //   if (!right_side) {
  //     return null;
  //   }
  //   // return CSSMathExpressionOperation::CreateArithmeticOperationSimplified(
  //   //   CSSMathExpressionNumericLiteral::Create(
  //   //       -1, CSSPrimitiveValue::UnitType::kNumber),
  //   //   right_side, CSSMathOperator::kMultiply);
  // }


  CSSMathNegate.prototype.buildCSSText = function (nested, paren_less, result) {
    if (paren_less == ParenLess.kNo) {
      result += nested === Nested.kYes ? '(' : 'calc(';
    }

    result += '-';
    result = this.value.buildCSSText(Nested.kYes, ParenLess.kNo, result);

    if (paren_less === ParenLess.kNo) {
      result += ')';
    }

    return result;
  };

  return CSSMathNegate;
}(CSSMathValue);

export { CSSMathNegate };
export function typeCheck(values, op, error) {
  error = false;
  var final_type = values[0].type_;

  for (var i = 1; i < values.length; i++) {
    final_type = op(final_type, values[i].type_, error);
    if (error) return final_type;
  }

  return final_type;
} // Represents an arithmetic operation with one or more CSSNumericValues.

var CSSMathVariadic =
/** @class */
function (_super) {
  __extends(CSSMathVariadic, _super);

  function CSSMathVariadic(values, type) {
    var _this = _super.call(this, type) || this;

    _this.values = values;
    return _this;
  }

  CSSMathVariadic.prototype.numericValues = function () {
    return this.values;
  };

  CSSMathVariadic.prototype.equals = function (other) {
    if (this.getType() !== other.getType()) {
      return false;
    }

    return this.values.every(function (value, i) {
      return value.equals(other.values[i]);
    });
  };

  return CSSMathVariadic;
}(CSSMathValue);

export { CSSMathVariadic }; // Represents the minimum of one or more CSSNumericValues.
// @see https://drafts.css-houdini.org/css-typed-om/#cssmathsum

var CSSMathMin =
/** @class */
function (_super) {
  __extends(CSSMathMin, _super);

  function CSSMathMin() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.operator = 'min';
    return _this;
  }

  CSSMathMin.create = function (values) {
    var error = false;
    var final_type = typeCheck(values, CSSNumericValueType.add, error);
    return error ? null : new CSSMathMin(values, final_type);
  };

  CSSMathMin.prototype.clone = function () {
    return new CSSMathMin(this.values, this.type_);
  };

  CSSMathMin.prototype.getType = function () {
    return CSSStyleValueType.kMinType;
  };

  CSSMathMin.prototype.sumValue = function () {
    var e_4, _a;

    var cur_min = this.numericValues()[0].sumValue();

    if (!cur_min.length) {
      return null;
    }

    try {
      for (var _b = __values(this.numericValues()), _c = _b.next(); !_c.done; _c = _b.next()) {
        var value = _c.value;
        var child_sum = value.sumValue();

        if (!child_sum.length || JSON.stringify(child_sum[0].units) !== JSON.stringify(cur_min[0].units)) {
          return null;
        }

        if (child_sum[0].value < cur_min[0].value) {
          cur_min = child_sum;
        }
      }
    } catch (e_4_1) {
      e_4 = {
        error: e_4_1
      };
    } finally {
      try {
        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
      } finally {
        if (e_4) throw e_4.error;
      }
    }

    return cur_min;
  }; // toCalcExpressionNode() {
  //   const operands: CSSMathExpressionOperation[] = [];
  //   for (const value of this.numericValues()) {
  //     const operand = value.toCalcExpressionNode();
  //     if (!operand) {
  //       continue;
  //     }
  //     operands.push(operand as CSSMathExpressionOperation);
  //   }
  //   return CSSMathExpressionOperation.createComparisonFunction(operands, CSSMathOperator.kMin);
  // }


  CSSMathMin.prototype.buildCSSText = function (nested, paren_less, result) {
    var e_5, _a;

    result += 'min(';
    var first_iteration = true;

    try {
      for (var _b = __values(this.numericValues()), _c = _b.next(); !_c.done; _c = _b.next()) {
        var value = _c.value;
        if (!first_iteration) result += ', ';
        first_iteration = false;
        result = value.buildCSSText(Nested.kYes, ParenLess.kYes, result);
      }
    } catch (e_5_1) {
      e_5 = {
        error: e_5_1
      };
    } finally {
      try {
        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
      } finally {
        if (e_5) throw e_5.error;
      }
    }

    result += ')';
    return result;
  };

  return CSSMathMin;
}(CSSMathVariadic);

export { CSSMathMin }; // Represents the maximum of one or more CSSNumericValues.
// @see https://drafts.css-houdini.org/css-typed-om/#cssmathsum

var CSSMathMax =
/** @class */
function (_super) {
  __extends(CSSMathMax, _super);

  function CSSMathMax() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.operator = 'max';
    return _this;
  }

  CSSMathMax.create = function (values) {
    var error = false;
    var final_type = typeCheck(values, CSSNumericValueType.add, error);
    return error ? null : new CSSMathMax(values, final_type);
  };

  CSSMathMax.prototype.clone = function () {
    return new CSSMathMax(this.values, this.type_);
  };

  CSSMathMax.prototype.getType = function () {
    return CSSStyleValueType.kMaxType;
  };

  CSSMathMax.prototype.sumValue = function () {
    var e_6, _a;

    var cur_max = this.numericValues()[0].sumValue();

    if (!cur_max.length) {
      return null;
    }

    try {
      for (var _b = __values(this.numericValues()), _c = _b.next(); !_c.done; _c = _b.next()) {
        var value = _c.value;
        var child_sum = value.sumValue();

        if (!child_sum.length || JSON.stringify(child_sum[0].units) !== JSON.stringify(cur_max[0].units)) {
          return null;
        }

        if (child_sum[0].value < cur_max[0].value) {
          cur_max = child_sum;
        }
      }
    } catch (e_6_1) {
      e_6 = {
        error: e_6_1
      };
    } finally {
      try {
        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
      } finally {
        if (e_6) throw e_6.error;
      }
    }

    return cur_max;
  }; // toCalcExpressionNode() {
  //   const operands: CSSMathExpressionOperation[] = [];
  //   for (const value of this.numericValues()) {
  //     const operand = value.toCalcExpressionNode();
  //     if (!operand) {
  //       continue;
  //     }
  //     operands.push(operand as CSSMathExpressionOperation);
  //   }
  //   return CSSMathExpressionOperation.createComparisonFunction(operands, CSSMathOperator.kMax);
  // }


  CSSMathMax.prototype.buildCSSText = function (nested, paren_less, result) {
    var e_7, _a;

    result += 'max(';
    var first_iteration = true;

    try {
      for (var _b = __values(this.numericValues()), _c = _b.next(); !_c.done; _c = _b.next()) {
        var value = _c.value;
        if (!first_iteration) result += ', ';
        first_iteration = false;
        result = value.buildCSSText(Nested.kYes, ParenLess.kYes, result);
      }
    } catch (e_7_1) {
      e_7 = {
        error: e_7_1
      };
    } finally {
      try {
        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
      } finally {
        if (e_7) throw e_7.error;
      }
    }

    result += ')';
    return result;
  };

  return CSSMathMax;
}(CSSMathVariadic);

export { CSSMathMax };
/**
 * Represents the sum of one or more CSSNumericValues.
 * @see https://drafts.css-houdini.org/css-typed-om/#cssmathsum
 */

var CSSMathSum =
/** @class */
function (_super) {
  __extends(CSSMathSum, _super);

  function CSSMathSum() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.operator = 'sum';
    return _this;
  }

  CSSMathSum.create = function (values) {
    var error = false;
    var finalType = typeCheck(values, CSSNumericValueType.add, error);
    return error ? null : new CSSMathSum(values, finalType);
  };

  CSSMathSum.numericTypeFromUnitMap = function (units) {
    var type = new CSSNumericValueType();
    Object.keys(units).forEach(function (key) {
      var exp = units[key];
      var error = false;
      type = CSSNumericValueType.multiply(type, new CSSNumericValueType(Number(key), exp), error);
      DCHECK(!error);
    });
    return type;
  };

  CSSMathSum.canCreateNumericTypeFromSumValue = function (sum) {
    var _this = this;

    DCHECK(!!sum.length);
    var first_type = this.numericTypeFromUnitMap(sum[0].units);
    return sum.every(function (term) {
      var error = false;
      CSSNumericValueType.add(first_type, _this.numericTypeFromUnitMap(term.units), error);
      return !error;
    });
  };

  CSSMathSum.prototype.clone = function () {
    return new CSSMathSum(this.values, this.type_);
  };

  CSSMathSum.prototype.getType = function () {
    return CSSStyleValueType.kSumType;
  }; // toCalcExpressionNode() {
  //   return this.toCalcExporessionNodeForVariadic(CSSMathOperator.kAdd);
  // }


  CSSMathSum.prototype.sumValue = function () {
    var sum = [];
    this.numericValues().forEach(function (value) {
      var child_sum = value.sumValue();

      if (!child_sum.length) {
        return null;
      }

      child_sum.forEach(function (term) {
        var index = sum.findIndex(function (s) {
          return JSON.stringify(s.units) === JSON.stringify(term.units);
        });

        if (index === -1) {
          sum.push(__assign({}, term));
        } else {
          sum[index].value += term.value;
        }
      });
    });
    if (!CSSMathSum.canCreateNumericTypeFromSumValue(sum)) return null;
    return sum;
  };

  CSSMathSum.prototype.buildCSSText = function (nested, paren_less, result) {
    if (paren_less == ParenLess.kNo) {
      result += nested === Nested.kYes ? '(' : 'calc(';
    }

    var values = this.numericValues();
    result = values[0].buildCSSText(Nested.kYes, ParenLess.kNo, result);

    for (var i = 1; i < values.length; i++) {
      var arg = values[i];

      if (arg.getType() === CSSStyleValueType.kNegateType) {
        result += ' - ';
        result = arg.value.buildCSSText(Nested.kYes, ParenLess.kNo, result);
      } else {
        result += ' + ';
        result = arg.buildCSSText(Nested.kYes, ParenLess.kNo, result);
      }
    }

    if (paren_less === ParenLess.kNo) {
      result += ')';
    }

    return result;
  };

  return CSSMathSum;
}(CSSMathVariadic);

export { CSSMathSum };
/**
 * Represents the product of one or more CSSNumericValues.
 * @see https://drafts.css-houdini.org/css-typed-om/#cssmathproduct
 */

var CSSMathProduct =
/** @class */
function (_super) {
  __extends(CSSMathProduct, _super);

  function CSSMathProduct() {
    var _this = _super !== null && _super.apply(this, arguments) || this;

    _this.operator = 'product';
    return _this;
  }

  CSSMathProduct.create = function (values) {
    var error = false;
    var finalType = typeCheck(values, CSSNumericValueType.multiply, error);
    return error ? null : new CSSMathProduct(values, finalType);
  };

  CSSMathProduct.multiplyUnitMaps = function (a, b) {
    Object.keys(b).forEach(function (key) {
      DCHECK_NE(b[key].value, 0);
      var old_value = key in a ? a[key].value : 0;

      if (old_value + b[key].value === 0) {
        delete a[key];
      } else {
        a[key] = old_value + b[key].value;
      }
    });
    return a;
  };

  CSSMathProduct.prototype.clone = function () {
    return new CSSMathProduct(this.values, this.type_);
  };

  CSSMathProduct.prototype.getType = function () {
    return CSSStyleValueType.kProductType;
  }; // toCalcExpressionNode() {
  //   return this.toCalcExporessionNodeForVariadic(CSSMathOperator.kMultiply);
  // }


  CSSMathProduct.prototype.sumValue = function () {
    var sum = [{
      value: 1,
      units: {}
    }];
    this.numericValues().forEach(function (value) {
      var child_sum = value.sumValue();

      if (!child_sum.length) {
        return null;
      }

      var new_sum = [];
      sum.forEach(function (a) {
        child_sum.forEach(function (b) {
          new_sum.push({
            value: a.value * b.value,
            units: CSSMathProduct.multiplyUnitMaps(a.units, b.units)
          });
        });
      });
      sum = new_sum;
    });
    return sum;
  };

  CSSMathProduct.prototype.buildCSSText = function (nested, paren_less, result) {
    if (paren_less == ParenLess.kNo) {
      result += nested === Nested.kYes ? '(' : 'calc(';
    }

    var values = this.numericValues();
    result = values[0].buildCSSText(Nested.kYes, ParenLess.kNo, result);

    for (var i = 1; i < values.length; i++) {
      var arg = values[i];

      if (arg.getType() === CSSStyleValueType.kInvertType) {
        result += ' / ';
        result = arg.value.buildCSSText(Nested.kYes, ParenLess.kNo, result);
      } else {
        result += ' * ';
        result = arg.buildCSSText(Nested.kYes, ParenLess.kNo, result);
      }
    }

    if (paren_less === ParenLess.kNo) {
      result += ')';
    }

    return result;
  };

  return CSSMathProduct;
}(CSSMathVariadic);

export { CSSMathProduct };
export var Opx = new CSSUnitValue(0, 'px');
export var Odeg = new CSSUnitValue(0, 'deg');