tailwindcss-3d-styles 1.2.0

package/css-utilities/transform-box.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TransformBox", {
+    enumerable: true,
+    get: function() {
+        return TransformBox;
+    }
+});
+var _call_super = require("@swc/helpers/_/_call_super");
+var _class_call_check = require("@swc/helpers/_/_class_call_check");
+var _define_property = require("@swc/helpers/_/_define_property");
+var _inherits = require("@swc/helpers/_/_inherits");
+var _base = require("./base");
+var TransformBox = /*#__PURE__*/ function(Base) {
+    "use strict";
+    _inherits._(TransformBox, Base);
+    function TransformBox() {
+        _class_call_check._(this, TransformBox);
+        var _this;
+        _this = _call_super._(this, TransformBox, arguments), _define_property._(_this, "utilities", function() {
+            _this.api.matchUtilities({
+                'transform-box': function(value) {
+                    return {
+                        'transform-box': value
+                    };
+                }
+            }, {
+                values: _this.api.theme('transformBox')
+            });
+        });
+        return _this;
+    }
+    return TransformBox;
+}(_base.Base);
+_define_property._(TransformBox, "defaultTheme", {
+    content: 'content-box',
+    border: 'border-box',
+    fill: 'fill-box',
+    stroke: 'stroke-box',
+    view: 'view-box'
+});

package/css-utilities/transform-core.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TransformCore", {
+    enumerable: true,
+    get: function() {
+        return TransformCore;
+    }
+});
+var _call_super = require("@swc/helpers/_/_call_super");
+var _class_call_check = require("@swc/helpers/_/_class_call_check");
+var _define_property = require("@swc/helpers/_/_define_property");
+var _inherits = require("@swc/helpers/_/_inherits");
+var _object_spread = require("@swc/helpers/_/_object_spread");
+var _base = require("./base");
+var _scale = require("./scale");
+var _transform = require("./transform");
+var _translate = require("./translate");
+var TransformCore = /*#__PURE__*/ function(Base) {
+    "use strict";
+    _inherits._(TransformCore, Base);
+    function TransformCore() {
+        _class_call_check._(this, TransformCore);
+        var _this;
+        _this = _call_super._(this, TransformCore, arguments), _define_property._(_this, "utilities", function() {
+            var transformValue2d = _this.legacy ? _transform.Transform.normaliseLegacyFunctionValues({
+                dimension: '2d'
+            }) : _transform.Transform.normaliseFunctionValues({
+                dimension: '2d'
+            });
+            var transformValue3d = _this.legacy ? _transform.Transform.normaliseLegacyFunctionValues() : _transform.Transform.normaliseFunctionValues();
+            var transformDeclarations2d = {
+                '--webkit-transform': transformValue2d,
+                transform: transformValue2d
+            };
+            var transformDeclarations3d = {
+                '--webkit-transform': transformValue3d,
+                transform: transformValue3d
+            };
+            _this.api.addUtilities({
+                // Leaving `.transform` utility here for backward compatibility,
+                // not really sure what purpose it serves though
+                '.transform': transformDeclarations2d,
+                '.transform-cpu': _this.legacy ? transformDeclarations2d : _object_spread._({
+                    translate: _translate.Translate.normaliseFunctionValues({
+                        dimension: '2d'
+                    }),
+                    scale: _scale.Scale.normaliseFunctionValues({
+                        dimension: '2d'
+                    })
+                }, transformDeclarations2d),
+                '.transform-gpu': _this.legacy ? transformDeclarations3d : _object_spread._({
+                    translate: _translate.Translate.normaliseFunctionValues(),
+                    scale: _scale.Scale.normaliseFunctionValues()
+                }, transformDeclarations3d),
+                '.transform-none': _this.legacy ? {
+                    '--webkit-transform': 'none',
+                    transform: 'none'
+                } : {
+                    translate: 'none',
+                    scale: 'none',
+                    '--webkit-transform': 'none',
+                    transform: 'none'
+                }
+            });
+        });
+        return _this;
+    }
+    return TransformCore;
+}(_base.Base);

package/css-utilities/transform-style.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TransformStyle", {
+    enumerable: true,
+    get: function() {
+        return TransformStyle;
+    }
+});
+var _call_super = require("@swc/helpers/_/_call_super");
+var _class_call_check = require("@swc/helpers/_/_class_call_check");
+var _define_property = require("@swc/helpers/_/_define_property");
+var _inherits = require("@swc/helpers/_/_inherits");
+var _base = require("./base");
+var TransformStyle = /*#__PURE__*/ function(Base) {
+    "use strict";
+    _inherits._(TransformStyle, Base);
+    function TransformStyle() {
+        _class_call_check._(this, TransformStyle);
+        var _this;
+        _this = _call_super._(this, TransformStyle, arguments), _define_property._(_this, "utilities", function() {
+            _this.api.matchUtilities({
+                'transform-style': function(value) {
+                    return {
+                        'transform-style': value
+                    };
+                }
+            }, {
+                values: _this.api.theme('transformStyle')
+            });
+        });
+        return _this;
+    }
+    return TransformStyle;
+}(_base.Base);
+_define_property._(TransformStyle, "defaultTheme", {
+    flat: 'flat',
+    '3d': 'preserve-3d'
+});

package/css-utilities/transform.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Transform", {
+    enumerable: true,
+    get: function() {
+        return Transform;
+    }
+});
+var _call_super = require("@swc/helpers/_/_call_super");
+var _class_call_check = require("@swc/helpers/_/_class_call_check");
+var _define_property = require("@swc/helpers/_/_define_property");
+var _inherits = require("@swc/helpers/_/_inherits");
+var _object_spread = require("@swc/helpers/_/_object_spread");
+var _object_spread_props = require("@swc/helpers/_/_object_spread_props");
+var _lodash = require("lodash");
+var _base = require("./base");
+var _cssvalue = require("../utils/css-value");
+var _dimension = require("../utils/dimension");
+var _generateguard = require("../utils/generate-guard");
+var Transform = /*#__PURE__*/ function(Base) {
+    "use strict";
+    _inherits._(Transform, Base);
+    function Transform() {
+        _class_call_check._(this, Transform);
+        var _this;
+        _this = _call_super._(this, Transform, arguments), _define_property._(_this, "isProcessableValue", (0, _generateguard.generateGuard)(_lodash.isString, _lodash.isUndefined)), _define_property._(_this, "isProcessableValues", (0, _generateguard.generateGuard)([
+            _lodash.isPlainObject,
+            function(maybe) {
+                return (0, _lodash.every)((0, _lodash.keys)(maybe), _lodash.isString);
+            },
+            function(maybe) {
+                return (0, _lodash.every)((0, _lodash.values)(maybe), _this.isProcessableValue);
+            }
+        ])), _define_property._(_this, "normaliseValues", function(values) {
+            return _this.isProcessableValues(values) ? (0, _lodash.chain)(values).mapValues(function(angle) {
+                return (0, _cssvalue.normaliseAngleValue)(angle);
+            }).pickBy(function(angle, modifier) {
+                return (0, _lodash.isString)(modifier) && modifier !== '' && (0, _lodash.isString)(angle);
+            }).value() : {};
+        }), _define_property._(_this, "utilities", function() {
+            var rotateValues = _this.normaliseValues(_this.api.theme('rotate'));
+            var skewValues = _this.normaliseValues(_this.api.theme('skew'));
+            var transformDeclarations = _this.legacy ? Transform.legacyDeclarations() : Transform.declarations();
+            _this.api.matchUtilities({
+                rotate: function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-rotate-z': value
+                    }, _this.legacy ? transformDeclarations : {
+                        rotate: 'var(--tw-rotate-z)'
+                    });
+                },
+                'rotate-x': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-rotate-x': value
+                    }, transformDeclarations);
+                },
+                'rotate-y': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-rotate-y': value
+                    }, transformDeclarations);
+                },
+                'rotate-z': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-rotate-z': value
+                    }, _this.legacy ? transformDeclarations : {
+                        rotate: 'var(--tw-rotate-z)'
+                    });
+                }
+            }, {
+                values: rotateValues,
+                supportsNegativeValues: true
+            });
+            _this.api.matchUtilities({
+                'skew-x': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-skew-x': value
+                    }, transformDeclarations);
+                },
+                'skew-y': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-skew-y': value
+                    }, transformDeclarations);
+                }
+            }, {
+                values: skewValues,
+                supportsNegativeValues: true
+            });
+        });
+        return _this;
+    }
+    return Transform;
+}(_base.Base);
+_define_property._(Transform, "defaultFunctionValues", {
+    rotateX: 'var(--tw-rotate-x)',
+    rotateY: 'var(--tw-rotate-y)',
+    skewX: 'var(--tw-skew-x)',
+    skewY: 'var(--tw-skew-y)'
+});
+_define_property._(Transform, "defaultLegacyFunctionValues", _object_spread_props._(_object_spread._({}, Transform.defaultFunctionValues), {
+    translateX: 'var(--tw-translate-x)',
+    translateY: 'var(--tw-translate-y)',
+    translateZ: 'var(--tw-translate-z)',
+    rotateZ: 'var(--tw-rotate-z)',
+    scaleX: 'var(--tw-scale-x)',
+    scaleY: 'var(--tw-scale-y)',
+    scaleZ: 'var(--tw-scale-z)',
+    perspective: 'var(--tw-perspective)'
+}));
+_define_property._(Transform, "normaliseFunctionValues", function() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, dimension = _ref.dimension, rotateX = _ref.rotateX, rotateY = _ref.rotateY, skewX = _ref.skewX, skewY = _ref.skewY;
+    var safeDimension = (0, _dimension.normaliseDimension)(dimension);
+    var safeValues = {
+        rotateX: (0, _cssvalue.normaliseAngleValue)(rotateX, Transform.defaultFunctionValues.rotateX),
+        rotateY: (0, _cssvalue.normaliseAngleValue)(rotateY, Transform.defaultFunctionValues.rotateY),
+        skewX: (0, _cssvalue.normaliseAngleValue)(skewX, Transform.defaultFunctionValues.skewX),
+        skewY: (0, _cssvalue.normaliseAngleValue)(skewY, Transform.defaultFunctionValues.skewY)
+    };
+    return [
+        {
+            '3d': "rotateX(".concat(safeValues.rotateX, ") rotateY(").concat(safeValues.rotateY, ")"),
+            '2d': ''
+        },
+        "skewX(".concat(safeValues.skewX, ")"),
+        "skewY(".concat(safeValues.skewY, ")")
+    ].map(function(value) {
+        return (0, _lodash.isString)(value) ? value : value[safeDimension];
+    }).filter(function(value) {
+        return value !== '';
+    }).join(' ');
+});
+_define_property._(Transform, "normaliseLegacyFunctionValues", function() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, dimension = _ref.dimension, translateX = _ref.translateX, translateY = _ref.translateY, translateZ = _ref.translateZ, rotateX = _ref.rotateX, rotateY = _ref.rotateY, rotateZ = _ref.rotateZ, skewX = _ref.skewX, skewY = _ref.skewY, scaleX = _ref.scaleX, scaleY = _ref.scaleY, scaleZ = _ref.scaleZ, perspective = _ref.perspective;
+    var safeDimension = (0, _dimension.normaliseDimension)(dimension);
+    var safeValues = {
+        translateX: (0, _cssvalue.normaliseLengthPercentageValue)(translateX, Transform.defaultLegacyFunctionValues.translateX),
+        translateY: (0, _cssvalue.normaliseLengthPercentageValue)(translateY, Transform.defaultLegacyFunctionValues.translateY),
+        translateZ: (0, _cssvalue.normaliseLengthPercentageValue)(translateZ, Transform.defaultLegacyFunctionValues.translateZ),
+        rotateX: (0, _cssvalue.normaliseAngleValue)(rotateX, Transform.defaultLegacyFunctionValues.rotateX),
+        rotateY: (0, _cssvalue.normaliseAngleValue)(rotateY, Transform.defaultLegacyFunctionValues.rotateY),
+        rotateZ: (0, _cssvalue.normaliseAngleValue)(rotateZ, Transform.defaultLegacyFunctionValues.rotateZ),
+        skewX: (0, _cssvalue.normaliseAngleValue)(skewX, Transform.defaultLegacyFunctionValues.skewX),
+        skewY: (0, _cssvalue.normaliseAngleValue)(skewY, Transform.defaultLegacyFunctionValues.skewY),
+        scaleX: (0, _cssvalue.normaliseNumberPercentageValue)(scaleX, Transform.defaultLegacyFunctionValues.scaleX, {
+            lowerLimit: 0
+        }),
+        scaleY: (0, _cssvalue.normaliseNumberPercentageValue)(scaleY, Transform.defaultLegacyFunctionValues.scaleY, {
+            lowerLimit: 0
+        }),
+        scaleZ: (0, _cssvalue.normaliseNumberPercentageValue)(scaleZ, Transform.defaultLegacyFunctionValues.scaleZ, {
+            lowerLimit: 0
+        }),
+        perspective: (0, _cssvalue.normaliseLengthValue)(perspective, Transform.defaultLegacyFunctionValues.perspective)
+    };
+    return [
+        {
+            '3d': "translate3d(".concat(safeValues.translateX, ", ").concat(safeValues.translateY, ", ").concat(safeValues.translateZ, ")"),
+            '2d': "translate(".concat(safeValues.translateX, ", ").concat(safeValues.translateY, ")")
+        },
+        {
+            '3d': "rotateX(".concat(safeValues.rotateX, ") rotateY(").concat(safeValues.rotateY, ") rotateZ(").concat(safeValues.rotateZ, ")"),
+            '2d': "rotate(".concat(safeValues.rotateZ, ")")
+        },
+        "skewX(".concat(safeValues.skewX, ")"),
+        "skewY(".concat(safeValues.skewY, ")"),
+        "scaleX(".concat(safeValues.scaleX, ")"),
+        "scaleY(".concat(safeValues.scaleY, ")"),
+        {
+            '3d': "scaleZ(".concat(safeValues.scaleZ, ")"),
+            '2d': ''
+        },
+        {
+            '3d': "perspective(".concat(safeValues.perspective, ")"),
+            '2d': ''
+        }
+    ].map(function(value) {
+        return (0, _lodash.isString)(value) ? value : value[safeDimension];
+    }).filter(function(value) {
+        return value !== '';
+    }).join(' ');
+});
+_define_property._(Transform, "declarations", function() {
+    var values = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var functionValues = Transform.normaliseFunctionValues(values);
+    return {
+        '--webkit-transform': functionValues,
+        transform: functionValues
+    };
+});
+_define_property._(Transform, "legacyDeclarations", function() {
+    var values = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var functionValues = Transform.normaliseLegacyFunctionValues(values);
+    return {
+        '--webkit-transform': functionValues,
+        transform: functionValues
+    };
+});

package/css-utilities/translate.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Translate", {
+    enumerable: true,
+    get: function() {
+        return Translate;
+    }
+});
+var _call_super = require("@swc/helpers/_/_call_super");
+var _class_call_check = require("@swc/helpers/_/_class_call_check");
+var _define_property = require("@swc/helpers/_/_define_property");
+var _inherits = require("@swc/helpers/_/_inherits");
+var _object_spread = require("@swc/helpers/_/_object_spread");
+var _lodash = require("lodash");
+var _base = require("./base");
+var _transform = require("./transform");
+var _cssvalue = require("../utils/css-value");
+var _dimension = require("../utils/dimension");
+var _generateguard = require("../utils/generate-guard");
+var Translate = /*#__PURE__*/ function(Base) {
+    "use strict";
+    _inherits._(Translate, Base);
+    function Translate() {
+        _class_call_check._(this, Translate);
+        var _this;
+        _this = _call_super._(this, Translate, arguments), _define_property._(_this, "isProcessableValue", (0, _generateguard.generateGuard)(_lodash.isString, _lodash.isUndefined)), _define_property._(_this, "isProcessableValues", (0, _generateguard.generateGuard)([
+            _lodash.isPlainObject,
+            function(maybe) {
+                return (0, _lodash.every)((0, _lodash.keys)(maybe), _lodash.isString);
+            },
+            function(maybe) {
+                return (0, _lodash.every)((0, _lodash.values)(maybe), _this.isProcessableValue);
+            }
+        ])), _define_property._(_this, "normaliseValues", function(values) {
+            return _this.isProcessableValues(values) ? (0, _lodash.chain)(values).mapValues(function(duration) {
+                return (0, _cssvalue.normaliseLengthPercentageValue)(duration);
+            }).pickBy(function(duration, modifier) {
+                return (0, _lodash.isString)(modifier) && modifier !== '' && (0, _lodash.isString)(duration);
+            }).value() : {};
+        }), _define_property._(_this, "utilities", function() {
+            var values = _this.normaliseValues(_this.api.theme('translate'));
+            var cssDeclarations = _this.legacy ? Translate.legacyDeclarations() : Translate.declarations();
+            _this.api.matchUtilities({
+                'translate-x': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-translate-x': value
+                    }, cssDeclarations);
+                },
+                'translate-y': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-translate-y': value
+                    }, cssDeclarations);
+                }
+            }, {
+                values: values,
+                supportsNegativeValues: true
+            });
+            _this.api.matchUtilities({
+                'translate-z': function(value) {
+                    return _object_spread._({
+                        '@defaults transform': {},
+                        '--tw-translate-z': value
+                    }, cssDeclarations);
+                }
+            }, {
+                values: (0, _lodash.pickBy)(values, function(value) {
+                    return !value.endsWith('%');
+                }),
+                supportsNegativeValues: true
+            });
+        });
+        return _this;
+    }
+    return Translate;
+}(_base.Base);
+_define_property._(Translate, "defaultFunctionValues", {
+    translateX: 'var(--tw-translate-x)',
+    translateY: 'var(--tw-translate-y)',
+    translateZ: 'var(--tw-translate-z)'
+});
+_define_property._(Translate, "normaliseFunctionValues", function() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, dimension = _ref.dimension, translateX = _ref.translateX, translateY = _ref.translateY, translateZ = _ref.translateZ;
+    var safeValues = [
+        (0, _cssvalue.normaliseLengthPercentageValue)(translateX, Translate.defaultFunctionValues.translateX),
+        (0, _cssvalue.normaliseLengthPercentageValue)(translateY, Translate.defaultFunctionValues.translateY)
+    ];
+    if ((0, _dimension.normaliseDimension)(dimension) === '3d') {
+        safeValues.push((0, _cssvalue.normaliseLengthValue)(translateZ, Translate.defaultFunctionValues.translateZ));
+    }
+    return safeValues.join(' ');
+});
+_define_property._(Translate, "declarations", function() {
+    var values = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    return {
+        translate: Translate.normaliseFunctionValues(values)
+    };
+});
+_define_property._(Translate, "legacyDeclarations", function() {
+    return _transform.Transform.legacyDeclarations();
+});

package/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+var _object_spread = require("@swc/helpers/_/_object_spread");
+var _plugin = /*#__PURE__*/ _interop_require_default._(require("tailwindcss/plugin"));
+var _cssanimations = require("./css-animations");
+var _cssutilities = require("./css-utilities");
+var _ensure = require("./utils/ensure");
+// Default CSS variables, modelled from core
+var DEFAULT_VARIABLE_VALUES = {
+    '--tw-perspective': 'none',
+    '--tw-translate-x': '0',
+    '--tw-translate-y': '0',
+    '--tw-translate-z': '0',
+    '--tw-rotate-x': '0',
+    '--tw-rotate-y': '0',
+    '--tw-rotate-z': '0',
+    '--tw-skew-x': '0',
+    '--tw-skew-y': '0',
+    '--tw-scale-x': '1',
+    '--tw-scale-y': '1',
+    '--tw-scale-z': '1'
+};
+var optionDefaults = {
+    legacy: false
+};
+var tailwindCss3d = _plugin.default.withOptions(function() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : optionDefaults, _ref_legacy = _ref.legacy, legacy = _ref_legacy === void 0 ? optionDefaults.legacy : _ref_legacy;
+    var safeLegacy = (0, _ensure.ensureBoolean)(legacy, optionDefaults.legacy);
+    return function(api) {
+        var localAPI = api;
+        // Replace the transform core plugin defaults and add some new ones
+        localAPI.addDefaults('transform', DEFAULT_VARIABLE_VALUES);
+        var perspective = new _cssutilities.Perspective(localAPI, safeLegacy);
+        var transformStyle = new _cssutilities.TransformStyle(localAPI);
+        var translate = new _cssutilities.Translate(localAPI, safeLegacy);
+        var transform = new _cssutilities.Transform(localAPI, safeLegacy);
+        var scale = new _cssutilities.Scale(localAPI, safeLegacy);
+        var backface = new _cssutilities.Backface(localAPI);
+        var perspectiveOrigin = new _cssutilities.PerspectiveOrigin(localAPI);
+        var transformBox = new _cssutilities.TransformBox(localAPI);
+        var transformCore = new _cssutilities.TransformCore(localAPI, safeLegacy);
+        // New CSS Utilities
+        perspective.utilities();
+        transformStyle.utilities();
+        translate.utilities();
+        transform.utilities();
+        scale.utilities();
+        backface.utilities();
+        perspectiveOrigin.utilities();
+        transformBox.utilities();
+        transformCore.utilities();
+    };
+}, function() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : optionDefaults, _ref_legacy = _ref.legacy, legacy = _ref_legacy === void 0 ? optionDefaults.legacy : _ref_legacy;
+    var safeLegacy = (0, _ensure.ensureBoolean)(legacy, optionDefaults.legacy);
+    var spin = new _cssanimations.Spin(safeLegacy);
+    var bounce = new _cssanimations.Bounce(safeLegacy);
+    var bounceAndSpin = new _cssanimations.BounceAndSpin(safeLegacy);
+    return {
+        theme: {
+            // Set new theme defaults
+            perspective: _cssutilities.Perspective.defaultTheme,
+            transformStyle: _cssutilities.TransformStyle.defaultTheme,
+            backface: _cssutilities.Backface.defaultTheme,
+            perspectiveOrigin: _cssutilities.PerspectiveOrigin.defaultTheme,
+            transformBox: _cssutilities.TransformBox.defaultTheme,
+            spin: spin.defaultTheme,
+            bounce: bounce.defaultTheme,
+            bounceAndSpin: bounceAndSpin.defaultTheme,
+            extend: {
+                // Update the core transform transition property
+                transitionProperty: {
+                    transform: safeLegacy ? 'transform' : 'perspective, translate, scale, transform, perspective, rotate'
+                },
+                // New CSS keyframes and animations
+                keyframes: function(pluginUtilities) {
+                    return _object_spread._({}, spin.keyframes(), bounce.keyframes(pluginUtilities), bounceAndSpin.keyframes(pluginUtilities));
+                },
+                animation: function(pluginUtilities) {
+                    return _object_spread._({}, spin.animation(pluginUtilities), bounce.animation(pluginUtilities), bounceAndSpin.animation(pluginUtilities));
+                }
+            }
+        },
+        // Disable some core plugins which are superceded by this plugin
+        corePlugins: {
+            rotate: false,
+            scale: false,
+            skew: false,
+            transform: false,
+            translate: false
+        }
+    };
+});
+module.exports = tailwindCss3d;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "tailwindcss-3d-styles",
+  "displayName": "3D Plugin for Tailwind CSS",
+  "description": "Add 3D transforms to your TailwindCSS project",
+  "keywords": [
+    "TailwindCSS"
+  ],
+  "version": "1.2.0",
+  "license": "MIT",
+  "peerDependencies": {
+    "tailwindcss": ">=3.2.0 <4.0.0"
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.17",
+    "lodash": "4.17.21"
+  },
+  "main": "index.js",
+  "types": "types/index.d.ts"
+}

package/types/common/index.d.ts

@@ -0,0 +1,7 @@
+import { type PluginAPI } from 'tailwindcss/types/config';
+declare module '@/common' {
+    type KeyValuePair<K extends keyof any = string, V = string> = Record<K, V>;
+    interface LocalPluginAPI extends PluginAPI {
+        addDefaults: (group: string, declarations: Record<string, string | string[]>) => void;
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare abstract class Base {
+    protected legacy: boolean;
+    constructor(legacy: boolean);
+}

package/types/css-animations/bounce-and-spin.d.ts

@@ -0,0 +1,19 @@
+import { type PluginUtils } from 'tailwindcss/types/config';
+import { type CSSAnimation } from '@/css-animations';
+import { Base } from '@/css-animations/base';
+type Value = [string, string];
+type Values = Record<string, Value>;
+export declare class BounceAndSpin extends Base implements CSSAnimation {
+    private isProcessablePrimitive;
+    private isProcessableValue;
+    private isProcessableValues;
+    private normaliseValues;
+    defaultTheme: Values;
+    keyframes: ({ theme }: PluginUtils) => {
+        [x: string]: boolean;
+    };
+    animation: ({ theme }: PluginUtils) => {
+        [x: string]: boolean;
+    };
+}
+export {};

package/types/css-animations/bounce.d.ts

@@ -0,0 +1,15 @@
+import { type PluginUtils } from 'tailwindcss/types/config';
+import { type CSSAnimation } from '@/css-animations';
+import { Base } from '@/css-animations/base';
+type Value = [string, string];
+type Values = Record<string, Value>;
+export declare class Bounce extends Base implements CSSAnimation {
+    private isProcessablePrimitive;
+    private isProcessableValue;
+    private isProcessableValues;
+    private normaliseValues;
+    defaultTheme: Values;
+    keyframes: ({ theme }: PluginUtils) => {};
+    animation: ({ theme }: PluginUtils) => {};
+}
+export {};

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

@@ -0,0 +1,12 @@
+import { type PluginUtils, type ResolvableTo } from 'tailwindcss/types/config';
+import { type KeyValuePair } from '@/common';
+declare module '@/css-animations' {
+    interface CSSAnimation {
+        defaultTheme?: ResolvableTo<KeyValuePair<string, any>>;
+        keyframes: (pluginUtilities: PluginUtils) => void;
+        animation: (pluginUtilities: PluginUtils) => void;
+    }
+}
+export * from './bounce';
+export * from './bounce-and-spin';
+export * from './spin';

package/types/css-animations/spin.d.ts

@@ -0,0 +1,16 @@
+import { type PluginUtils } from 'tailwindcss/types/config';
+import { type CSSAnimation } from '@/css-animations';
+import { Base } from '@/css-animations/base';
+type Value = string;
+type Values = Record<string, Value>;
+export declare class Spin extends Base implements CSSAnimation {
+    private isProcessableValue;
+    private isProcessableValues;
+    private normaliseValues;
+    defaultTheme: Values;
+    private xyKeyframes;
+    private zKeyframes;
+    keyframes: () => {};
+    animation: ({ theme }: PluginUtils) => {};
+}
+export {};