tailwindcss-3d-styles 1.2.0

package/types/css-utilities/backface.d.ts

@@ -0,0 +1,9 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+export declare class Backface extends Base implements CSSUtility {
+    static defaultTheme: {
+        visible: string;
+        hidden: string;
+    };
+    utilities: () => void;
+}

package/types/css-utilities/base.d.ts

@@ -0,0 +1,6 @@
+import { type LocalPluginAPI } from '@/common';
+export declare abstract class Base {
+    protected api: LocalPluginAPI;
+    protected legacy: boolean;
+    constructor(api: LocalPluginAPI, legacy?: boolean);
+}

package/types/css-utilities/index.d.ts

@@ -0,0 +1,18 @@
+import { type ResolvableTo } from 'tailwindcss/types/config';
+import { type KeyValuePair } from '@/common';
+declare module '@/css-utilities' {
+    interface CSSUtility {
+        defaultTheme?: ResolvableTo<KeyValuePair<string, any>>;
+        utilities: () => void;
+        normaliseFunctionValues?: (values: Record<string, any>) => string;
+    }
+}
+export * from './backface';
+export * from './perspective';
+export * from './perspective-origin';
+export * from './scale';
+export * from './transform';
+export * from './transform-box';
+export * from './transform-core';
+export * from './transform-style';
+export * from './translate';

package/types/css-utilities/perspective-origin.d.ts

@@ -0,0 +1,6 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+export declare class PerspectiveOrigin extends Base implements CSSUtility {
+    static defaultTheme: (import("tailwindcss/types/config").ResolvableTo<import("tailwindcss/types/config").KeyValuePair<string, string>> | undefined) & Record<"bottom" | "center" | "left" | "right" | "top" | "top-right" | "bottom-right" | "bottom-left" | "top-left", string>;
+    utilities: () => void;
+}

package/types/css-utilities/perspective.d.ts

@@ -0,0 +1,26 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+import { type UnsafeCSSValue } from '@/utils/css-value';
+import { type Dimension } from '@/utils/dimension';
+interface NormaliseFunctionValuesOptions {
+    dimension?: Dimension;
+    perspective?: UnsafeCSSValue;
+}
+interface PerspectiveDeclarations {
+    perspective: string;
+}
+export declare class Perspective extends Base implements CSSUtility {
+    static defaultTheme: {
+        none: string;
+        250: string;
+        500: string;
+        750: string;
+        1000: string;
+    };
+    static defaultFunctionValues: Required<Omit<NormaliseFunctionValuesOptions, 'dimension'>>;
+    static normaliseFunctionValues: ({ dimension, perspective, }?: NormaliseFunctionValuesOptions) => string;
+    static declarations: (values?: NormaliseFunctionValuesOptions) => PerspectiveDeclarations;
+    static legacyDeclarations: () => import("@/css-utilities").TransformDeclarations;
+    utilities: () => void;
+}
+export {};

package/types/css-utilities/scale.d.ts

@@ -0,0 +1,24 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+import { type UnsafeCSSValue } from '@/utils/css-value';
+import { type Dimension } from '@/utils/dimension';
+interface NormaliseFunctionValuesOptions {
+    dimension?: Dimension;
+    scaleX?: UnsafeCSSValue;
+    scaleY?: UnsafeCSSValue;
+    scaleZ?: UnsafeCSSValue;
+}
+interface ScaleDeclarations {
+    scale: string;
+}
+export declare class Scale extends Base implements CSSUtility {
+    private isProcessableValue;
+    private isProcessableValues;
+    private normaliseValues;
+    static defaultFunctionValues: Required<Omit<NormaliseFunctionValuesOptions, 'dimension'>>;
+    static normaliseFunctionValues: ({ dimension, scaleX, scaleY, scaleZ, }?: NormaliseFunctionValuesOptions) => string;
+    static declarations: (values?: NormaliseFunctionValuesOptions) => ScaleDeclarations;
+    static legacyDeclarations: () => import("@/css-utilities").TransformDeclarations;
+    utilities: () => void;
+}
+export {};

package/types/css-utilities/transform-box.d.ts

@@ -0,0 +1,12 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+export declare class TransformBox extends Base implements CSSUtility {
+    static defaultTheme: {
+        content: string;
+        border: string;
+        fill: string;
+        stroke: string;
+        view: string;
+    };
+    utilities: () => void;
+}

package/types/css-utilities/transform-core.d.ts

@@ -0,0 +1,5 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+export declare class TransformCore extends Base implements CSSUtility {
+    utilities: () => void;
+}

package/types/css-utilities/transform-style.d.ts

@@ -0,0 +1,9 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+export declare class TransformStyle extends Base implements CSSUtility {
+    static defaultTheme: {
+        flat: string;
+        '3d': string;
+    };
+    utilities: () => void;
+}

package/types/css-utilities/transform.d.ts

@@ -0,0 +1,38 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+import { type UnsafeCSSValue } from '@/utils/css-value';
+import { type Dimension } from '@/utils/dimension';
+interface NormaliseFunctionValuesOptions {
+    dimension?: Dimension;
+    rotateX?: UnsafeCSSValue;
+    rotateY?: UnsafeCSSValue;
+    skewX?: UnsafeCSSValue;
+    skewY?: UnsafeCSSValue;
+}
+interface NormaliseLegacyFunctionValuesOptions extends NormaliseFunctionValuesOptions {
+    translateX?: UnsafeCSSValue;
+    translateY?: UnsafeCSSValue;
+    translateZ?: UnsafeCSSValue;
+    rotateZ?: UnsafeCSSValue;
+    scaleX?: UnsafeCSSValue;
+    scaleY?: UnsafeCSSValue;
+    scaleZ?: UnsafeCSSValue;
+    perspective?: UnsafeCSSValue;
+}
+export interface TransformDeclarations {
+    '--webkit-transform': string;
+    transform: string;
+}
+export declare class Transform extends Base implements CSSUtility {
+    private isProcessableValue;
+    private isProcessableValues;
+    private normaliseValues;
+    static defaultFunctionValues: Required<Omit<NormaliseFunctionValuesOptions, 'dimension'>>;
+    static defaultLegacyFunctionValues: Required<Omit<NormaliseLegacyFunctionValuesOptions, 'dimension'>>;
+    static normaliseFunctionValues: ({ dimension, rotateX, rotateY, skewX, skewY, }?: NormaliseFunctionValuesOptions) => string;
+    static normaliseLegacyFunctionValues: ({ dimension, translateX, translateY, translateZ, rotateX, rotateY, rotateZ, skewX, skewY, scaleX, scaleY, scaleZ, perspective, }?: NormaliseLegacyFunctionValuesOptions) => string;
+    static declarations: (values?: NormaliseFunctionValuesOptions) => TransformDeclarations;
+    static legacyDeclarations: (values?: NormaliseLegacyFunctionValuesOptions) => TransformDeclarations;
+    utilities: () => void;
+}
+export {};

package/types/css-utilities/translate.d.ts

@@ -0,0 +1,24 @@
+import { type CSSUtility } from '@/css-utilities';
+import { Base } from '@/css-utilities/base';
+import { type UnsafeCSSValue } from '@/utils/css-value';
+import { type Dimension } from '@/utils/dimension';
+interface NormaliseFunctionValuesOptions {
+    dimension?: Dimension;
+    translateX?: UnsafeCSSValue;
+    translateY?: UnsafeCSSValue;
+    translateZ?: UnsafeCSSValue;
+}
+interface TranslateDeclarations {
+    translate: string;
+}
+export declare class Translate extends Base implements CSSUtility {
+    private isProcessableValue;
+    private isProcessableValues;
+    private normaliseValues;
+    static defaultFunctionValues: Required<Omit<NormaliseFunctionValuesOptions, 'dimension'>>;
+    static normaliseFunctionValues: ({ dimension, translateX, translateY, translateZ, }?: NormaliseFunctionValuesOptions) => string;
+    static declarations: (values?: NormaliseFunctionValuesOptions) => TranslateDeclarations;
+    static legacyDeclarations: () => import("@/css-utilities").TransformDeclarations;
+    utilities: () => void;
+}
+export {};

package/types/index.d.ts

@@ -0,0 +1,11 @@
+interface PluginOptions {
+    legacy?: boolean;
+}
+declare const tailwindCss3d: {
+    (options: PluginOptions): {
+        handler: import("tailwindcss/types/config").PluginCreator;
+        config?: Partial<import("tailwindcss/types/config").Config>;
+    };
+    __isOptionsFunction: true;
+};
+export = tailwindCss3d;

package/types/utils/css-value.d.ts

@@ -0,0 +1,48 @@
+export declare const VALID_LENGTH_UNITS: string[];
+export declare const VALID_ANGLE_UNITS: string[];
+export declare const VALID_TIME_UNITS: string[];
+export type UnsafeCSSValue = string | number | undefined;
+export declare const toStringValue: (value: UnsafeCSSValue) => string | undefined;
+export declare const toNumericValue: (value: UnsafeCSSValue) => number | undefined;
+interface NumericValueAndUnit {
+    value: number | undefined;
+    unit: string | undefined;
+}
+export declare const toNumericValueAndUnit: (value: UnsafeCSSValue, validUnits?: string | string[]) => NumericValueAndUnit;
+type NormaliseUnionValueFunction = (value: UnsafeCSSValue, defaultValue?: UnsafeCSSValue, allowedValues?: string | string[]) => string | undefined;
+export declare const normaliseUnionValue: NormaliseUnionValueFunction;
+interface Limit {
+    limit: number;
+    inclusive?: boolean;
+    adjustBy?: number;
+}
+interface NormaliseUnitValueOptions {
+    defaultNil?: '0' | 'none' | '';
+    allowNone?: boolean;
+    allowVar?: boolean;
+    allowCalc?: boolean;
+    defaultUnit?: string;
+    validUnits?: string[];
+    disallowValues?: number | number[];
+    allowDecimal?: boolean;
+    upperLimit?: number | Limit;
+    lowerLimit?: number | Limit;
+}
+type NormaliseUnitValueFunction = (value: UnsafeCSSValue, defaultValue?: UnsafeCSSValue, options?: NormaliseUnitValueOptions) => string;
+export declare const normaliseUnitValue: NormaliseUnitValueFunction;
+interface NormaliseAlphaValueOptions {
+    percentage?: NormaliseUnitValueOptions;
+    number?: NormaliseUnitValueOptions;
+}
+type NormaliseAlphaValueFunction = (value: UnsafeCSSValue, defaultValue?: UnsafeCSSValue, options?: NormaliseAlphaValueOptions) => string | undefined;
+export declare const normaliseAlphaValue: NormaliseAlphaValueFunction;
+export declare const normaliseAngleValue: NormaliseUnitValueFunction;
+export declare const normaliseAnglePercentageValue: NormaliseUnitValueFunction;
+export declare const normaliseLengthValue: NormaliseUnitValueFunction;
+export declare const normaliseLengthPercentageValue: NormaliseUnitValueFunction;
+export declare const normaliseNumberValue: NormaliseUnitValueFunction;
+export declare const normaliseNumberPercentageValue: NormaliseUnitValueFunction;
+export declare const normalisePercentageValue: NormaliseUnitValueFunction;
+export declare const normaliseTimeValue: NormaliseUnitValueFunction;
+export declare const normaliseTimePercentageValue: NormaliseUnitValueFunction;
+export {};

package/types/utils/dimension.d.ts

@@ -0,0 +1,3 @@
+export type Dimension = '3d' | '2d';
+export declare const isDimension: (maybe?: unknown) => maybe is Dimension;
+export declare const normaliseDimension: (dimension?: string) => Dimension;

package/types/utils/ensure.d.ts

@@ -0,0 +1,5 @@
+type Primitives = string | number | bigint | boolean | symbol | undefined | object | ((...args: any[]) => any);
+type PrimitiveStrings = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
+export declare const ensure: <T extends Primitives>(type: PrimitiveStrings | PrimitiveStrings[], maybe: any, fallback: T) => T;
+export declare const ensureBoolean: (maybe: any, fallback: boolean) => boolean;
+export {};

package/types/utils/generate-guard.d.ts

@@ -0,0 +1,8 @@
+type GuardTest = (arg: any) => boolean;
+type GuardTests = GuardTest | GuardTest[];
+type GuardTestGroups = GuardTests[];
+export declare const generateGuard: <T>(...testGroups: GuardTestGroups) => (maybe?: unknown) => maybe is T;
+export declare const isGuardTest: (maybe?: unknown) => maybe is GuardTest;
+export declare const isGuardTests: (maybe?: unknown) => maybe is GuardTests;
+export declare const isGuardTestGroups: (maybe?: unknown) => maybe is GuardTests;
+export {};

package/types/utils/lodash-transformers.d.ts

@@ -0,0 +1,6 @@
+type RecordAny = Record<string, any>;
+export declare const axesModifier: <T extends RecordAny>(axes?: string | string[], silentModifier?: string) => (result: T, value: any, modifier: string) => void;
+export declare const nameModifier: <T extends RecordAny>(name?: string, silentModifier?: string) => (result: T, value: any, modifier: string) => void;
+export declare const signModifier: <T extends RecordAny>(signs?: string | string[]) => (result: T, value: any, modifier: string) => void;
+export declare const addDurationWithGravity: <T extends RecordAny>() => (result: T, value: any, modifier: string) => void;
+export {};

package/utils/css-value.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get VALID_ANGLE_UNITS () {
+        return VALID_ANGLE_UNITS;
+    },
+    get VALID_LENGTH_UNITS () {
+        return VALID_LENGTH_UNITS;
+    },
+    get VALID_TIME_UNITS () {
+        return VALID_TIME_UNITS;
+    },
+    get normaliseAlphaValue () {
+        return normaliseAlphaValue;
+    },
+    get normaliseAnglePercentageValue () {
+        return normaliseAnglePercentageValue;
+    },
+    get normaliseAngleValue () {
+        return normaliseAngleValue;
+    },
+    get normaliseLengthPercentageValue () {
+        return normaliseLengthPercentageValue;
+    },
+    get normaliseLengthValue () {
+        return normaliseLengthValue;
+    },
+    get normaliseNumberPercentageValue () {
+        return normaliseNumberPercentageValue;
+    },
+    get normaliseNumberValue () {
+        return normaliseNumberValue;
+    },
+    get normalisePercentageValue () {
+        return normalisePercentageValue;
+    },
+    get normaliseTimePercentageValue () {
+        return normaliseTimePercentageValue;
+    },
+    get normaliseTimeValue () {
+        return normaliseTimeValue;
+    },
+    get normaliseUnionValue () {
+        return normaliseUnionValue;
+    },
+    get normaliseUnitValue () {
+        return normaliseUnitValue;
+    },
+    get toNumericValue () {
+        return toNumericValue;
+    },
+    get toNumericValueAndUnit () {
+        return toNumericValueAndUnit;
+    },
+    get toStringValue () {
+        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));
+};