"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    VALID_ANGLE_UNITS: function() {
        return VALID_ANGLE_UNITS;
    },
    VALID_LENGTH_UNITS: function() {
        return VALID_LENGTH_UNITS;
    },
    VALID_TIME_UNITS: function() {
        return VALID_TIME_UNITS;
    },
    normaliseAlphaValue: function() {
        return normaliseAlphaValue;
    },
    normaliseAnglePercentageValue: function() {
        return normaliseAnglePercentageValue;
    },
    normaliseAngleValue: function() {
        return normaliseAngleValue;
    },
    normaliseLengthPercentageValue: function() {
        return normaliseLengthPercentageValue;
    },
    normaliseLengthValue: function() {
        return normaliseLengthValue;
    },
    normaliseNumberPercentageValue: function() {
        return normaliseNumberPercentageValue;
    },
    normaliseNumberValue: function() {
        return normaliseNumberValue;
    },
    normalisePercentageValue: function() {
        return normalisePercentageValue;
    },
    normaliseTimePercentageValue: function() {
        return normaliseTimePercentageValue;
    },
    normaliseTimeValue: function() {
        return normaliseTimeValue;
    },
    normaliseUnionValue: function() {
        return normaliseUnionValue;
    },
    normaliseUnitValue: function() {
        return normaliseUnitValue;
    },
    toNumericValue: function() {
        return toNumericValue;
    },
    toNumericValueAndUnit: function() {
        return toNumericValueAndUnit;
    },
    toStringValue: function() {
        return toStringValue;
    }
});
var _object_spread = require("@swc/helpers/_/_object_spread");
var _to_consumable_array = require("@swc/helpers/_/_to_consumable_array");
var _lodash = require("lodash");
var _generateguard = require("./generate-guard");
var VALID_LENGTH_UNITS = [
    "ch",
    "em",
    "ex",
    "ic",
    "rem",
    "vh",
    "vw",
    "vmax",
    "vmin",
    "vb",
    "vi",
    "cqw",
    "cqh",
    "cqi",
    "cqb",
    "cqmin",
    "cqmax",
    "px",
    "cm",
    "mm",
    "Q",
    "in",
    "pc",
    "pt"
];
var VALID_ANGLE_UNITS = [
    "deg",
    "grad",
    "rad",
    "turn"
];
var VALID_TIME_UNITS = [
    "s",
    "ms"
];
var toStringValue = function(value) {
    if ((0, _lodash.isString)(value)) {
        return value.trim();
    }
    if ((0, _lodash.isFinite)(value)) {
        return String(value);
    }
    return undefined;
};
var toNumericValue = function(value) {
    if ((0, _lodash.isFinite)(value)) {
        return Number(value);
    }
    if ((0, _lodash.isString)(value)) {
        var trimmed = value.trim();
        if (trimmed === "") {
            return undefined;
        }
        var maybeNumber = Number(trimmed);
        if (isNaN(maybeNumber)) {
            return undefined;
        }
        return maybeNumber;
    }
    return undefined;
};
var toNumericValueAndUnit = function(value, validUnits) {
    var stringValue = toStringValue(value);
    var evaluated = {
        value: undefined,
        unit: undefined
    };
    if ((0, _lodash.isUndefined)(stringValue)) {
        return evaluated;
    }
    if (stringValue === "") {
        return evaluated;
    }
    var strippedStringValue = stringValue.replace(/\s/g, "");
    var safeValidUnits = (0, _lodash.chain)(validUnits).castArray().uniq().filter((0, _generateguard.generateGuard)([
        _lodash.isString,
        function(maybe) {
            return maybe !== "";
        }
    ])).value();
    if (safeValidUnits.length > 0) {
        var unitsUnion = safeValidUnits.join("|");
        var unitsMatch = strippedStringValue.match(new RegExp("(?:".concat(unitsUnion, ")$")));
        if ((0, _lodash.isArray)(unitsMatch) && unitsMatch.length === 1) {
            evaluated.unit = unitsMatch[0];
        }
    }
    // Simple numbers without units
    var numberValue = toNumericValue(strippedStringValue);
    if ((0, _lodash.isNumber)(numberValue)) {
        evaluated.value = numberValue;
        return evaluated;
    }
    var unitlessStringValue = (0, _lodash.isString)(evaluated.unit) ? strippedStringValue.replace(new RegExp("".concat(evaluated.unit, "$")), "") : strippedStringValue;
    var unitlessNumberValue = toNumericValue(unitlessStringValue);
    if ((0, _lodash.isNumber)(unitlessNumberValue)) {
        evaluated.value = unitlessNumberValue;
        return evaluated;
    }
    var rescueStringValue = unitlessStringValue.replace(/[^\d.-]/g, "").replace(/\b-/g, "");
    var rescueNumberValue = toNumericValue(rescueStringValue);
    if ((0, _lodash.isNumber)(rescueNumberValue)) {
        evaluated.value = rescueNumberValue;
        return evaluated;
    }
    return evaluated;
};
var normaliseUnionValue = function(value, defaultValue, allowedValues) {
    var safeValue = toStringValue(value);
    var safeDefaultValue = toStringValue(defaultValue);
    if ((0, _lodash.isUndefined)(safeValue)) {
        return safeDefaultValue;
    }
    var safeAllowedValues = (0, _lodash.chain)(defaultValue).castArray().concat(allowedValues !== null && allowedValues !== void 0 ? allowedValues : []).uniq().filter(_lodash.isString).map(_lodash.trim).value();
    var matchedIndex = (0, _lodash.chain)(safeAllowedValues).map(_lodash.toLower).indexOf((0, _lodash.toLower)(safeValue)).value();
    if (matchedIndex !== -1) {
        return safeAllowedValues[matchedIndex];
    }
    return safeDefaultValue;
};
var isLimit = (0, _generateguard.generateGuard)([
    _lodash.isPlainObject,
    function(maybe) {
        return (0, _lodash.isNumber)((0, _lodash.get)(maybe, "limit"));
    },
    function(maybe) {
        return (0, _lodash.has)(maybe, "inclusive") ? (0, _lodash.isBoolean)((0, _lodash.get)(maybe, "inclusive")) : true;
    },
    function(maybe) {
        return (0, _lodash.has)(maybe, "adjustBy") ? (0, _lodash.isNumber)((0, _lodash.get)(maybe, "adjustBy")) : true;
    }
]);
// Not a type guard
var isVar = function(maybe) {
    return /^var\(\s*--[a-zA-Z0-9-]+\s*(,\s*.+)?\s*\)$/.test(maybe);
};
// Not a type guard
var isCalc = function(maybe) {
    return /^calc\(\s*(?:var\(\s*--[a-zA-Z0-9-]+\s*(,\s*.+)?\s*\)|[0-9]+[a-zA-Z%]*)\s+[*/+-]\s+(?:var\(\s*--[a-zA-Z0-9-]+\s*(,\s*.+)?\s*\)|[0-9]+[a-zA-Z%]*)\s*\)$/.test(maybe);
};
var normaliseUnitValue = function(value, defaultValue, options) {
    var safeValue = toStringValue(value);
    var safeDefaultValue = toStringValue(defaultValue);
    var _ref = (0, _lodash.isObject)(options) && (0, _lodash.isPlainObject)(options) ? options : {}, defaultNil = _ref.defaultNil, allowNone = _ref.allowNone, allowVar = _ref.allowVar, allowCalc = _ref.allowCalc, defaultUnit = _ref.defaultUnit, validUnits = _ref.validUnits, disallowValues = _ref.disallowValues, allowDecimal = _ref.allowDecimal, upperLimit = _ref.upperLimit, lowerLimit = _ref.lowerLimit;
    var safeDefaultNil = (0, _lodash.isString)(defaultNil) && (0, _lodash.includes)([
        "0",
        "none",
        ""
    ], defaultNil) ? defaultNil : "0";
    if ((0, _lodash.isUndefined)(safeValue)) {
        return safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
    }
    var safeAllowNone = (0, _lodash.isBoolean)(allowNone) ? allowNone : true;
    if (safeAllowNone && safeValue.toLowerCase() === "none") {
        return "none";
    }
    var safeAllowVar = (0, _lodash.isBoolean)(allowVar) ? allowVar : true;
    // Return a var() if that is allowed - fairly coarse validation
    if (safeValue.startsWith("var(")) {
        return safeAllowVar && isVar(safeValue) ? safeValue : safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
    }
    var safeAllowCalc = (0, _lodash.isBoolean)(allowCalc) ? allowCalc : false;
    // Return a calc() if that is allowed - fairly coarse validation
    if (safeValue.startsWith("calc(")) {
        return safeAllowCalc && isCalc(safeValue) ? safeValue : safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
    }
    var _toStringValue;
    var safeDefaultUnit = (_toStringValue = toStringValue(defaultUnit)) !== null && _toStringValue !== void 0 ? _toStringValue : "";
    var safeValidUnits = (0, _lodash.chain)(safeDefaultUnit).castArray().concat(validUnits !== null && validUnits !== void 0 ? validUnits : []).filter(_lodash.isString).value();
    // Get the number value and unit from the string
    var _toNumericValueAndUnit = toNumericValueAndUnit(safeValue, safeValidUnits), safeNumberValue = _toNumericValueAndUnit.value, unit = _toNumericValueAndUnit.unit;
    var _ref1;
    var safeUnit = (_ref1 = unit !== null && unit !== void 0 ? unit : defaultUnit) !== null && _ref1 !== void 0 ? _ref1 : "";
    // From here on we are dealing with number values
    if (!(0, _lodash.isNumber)(safeNumberValue)) {
        return safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
    }
    var safeDisallowValues = (0, _lodash.chain)(disallowValues).castArray().filter(_lodash.isNumber).value();
    var safeAllowDecimal = (0, _lodash.isBoolean)(allowDecimal) ? allowDecimal : true;
    // Set up an integer value
    var safeIntegerValue = Math.round(safeNumberValue);
    // Check the value isn't disallowed
    // - use integer value if decimals are not allowed
    if ((0, _lodash.includes)(safeDisallowValues, safeAllowDecimal ? safeNumberValue : safeIntegerValue)) {
        return safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
    }
    var evaluated = {
        value: safeAllowDecimal ? safeNumberValue : safeIntegerValue,
        unit: safeUnit
    };
    var safeUpperLimit = (0, _lodash.isNumber)(upperLimit) ? {
        limit: upperLimit,
        inclusive: true,
        adjustBy: 1
    } : isLimit(upperLimit) ? {
        limit: upperLimit.limit,
        inclusive: (0, _lodash.isBoolean)(upperLimit.inclusive) ? upperLimit.inclusive : true,
        adjustBy: (0, _lodash.isNumber)(upperLimit.adjustBy) && upperLimit.adjustBy !== 0 ? upperLimit.adjustBy : 1
    } : false;
    // Set the evaluated value within the upper limit
    if (safeUpperLimit) {
        if (safeUpperLimit.inclusive) {
            if (safeNumberValue > safeUpperLimit.limit) {
                evaluated.value = safeUpperLimit.limit;
            }
        } else {
            if (safeNumberValue >= safeUpperLimit.limit) {
                evaluated.value = safeUpperLimit.limit - safeUpperLimit.adjustBy;
            }
        }
    }
    var safeLowerLimit = (0, _lodash.isNumber)(lowerLimit) ? {
        limit: lowerLimit,
        inclusive: true,
        adjustBy: 1
    } : isLimit(lowerLimit) ? {
        limit: lowerLimit.limit,
        inclusive: (0, _lodash.isBoolean)(lowerLimit.inclusive) ? lowerLimit.inclusive : true,
        adjustBy: (0, _lodash.isNumber)(lowerLimit.adjustBy) && lowerLimit.adjustBy !== 0 ? lowerLimit.adjustBy : 1
    } : false;
    // Set the evaluated value within the lower limit
    if (safeLowerLimit) {
        if (safeLowerLimit.inclusive) {
            if (safeNumberValue < safeLowerLimit.limit) {
                evaluated.value = safeLowerLimit.limit;
            }
        } else {
            if (safeNumberValue <= safeLowerLimit.limit) {
                evaluated.value = safeLowerLimit.limit + safeLowerLimit.adjustBy;
            }
        }
    }
    if (evaluated.value === 0 && defaultNil) {
        return defaultNil;
    }
    return "".concat(String(evaluated.value)).concat(evaluated.unit);
};
var normaliseAlphaValue = function(value, defaultValue, options) {
    var safeValue = toStringValue(value);
    var safeDefaultValue = toStringValue(defaultValue);
    if ((0, _lodash.isUndefined)(safeValue)) {
        return safeDefaultValue;
    }
    if (safeValue.indexOf("%") !== -1) {
        return normalisePercentageValue(value, defaultValue, _object_spread._({
            lowerLimit: 0,
            upperLimit: 100
        }, options === null || options === void 0 ? void 0 : options.percentage));
    }
    return normaliseNumberValue(value, defaultValue, _object_spread._({
        lowerLimit: 0,
        upperLimit: 1
    }, options === null || options === void 0 ? void 0 : options.number));
};
var normaliseAngleValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        defaultUnit: "deg",
        validUnits: VALID_ANGLE_UNITS
    }, options));
};
var normaliseAnglePercentageValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        defaultUnit: "deg",
        validUnits: _to_consumable_array._(VALID_ANGLE_UNITS).concat([
            "%"
        ])
    }, options));
};
var normaliseLengthValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        defaultUnit: "px",
        validUnits: VALID_LENGTH_UNITS
    }, options));
};
var normaliseLengthPercentageValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        defaultUnit: "px",
        validUnits: _to_consumable_array._(VALID_LENGTH_UNITS).concat([
            "%"
        ])
    }, options));
};
var normaliseNumberValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, options);
};
var normaliseNumberPercentageValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        validUnits: [
            "",
            "%"
        ]
    }, options));
};
var normalisePercentageValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        defaultUnit: "%",
        validUnits: [
            "%"
        ]
    }, options));
};
var normaliseTimeValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        defaultUnit: "s",
        validUnits: VALID_TIME_UNITS
    }, options));
};
var normaliseTimePercentageValue = function(value, defaultValue, options) {
    return normaliseUnitValue(value, defaultValue, _object_spread._({
        defaultUnit: "s",
        validUnits: _to_consumable_array._(VALID_TIME_UNITS).concat([
            "%"
        ])
    }, options));
};