tailwindcss 0.0.0-oxide-insiders.a7fe2fe → 0.0.0-oxide-insiders.759a8c2

package/lib/lib/getModuleDependencies.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>getModuleDependencies
+    value: true
 });
-const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getModuleDependencies;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
@@ -15,7 +19,18 @@ let jsExtensions = [
     ".js",
     ".cjs",
     ".mjs"
-], jsResolutionOrder = [
+];
+// Given the current file `a.ts`, we want to make sure that when importing `b` that we resolve
+// `b.ts` before `b.js`
+//
+// E.g.:
+//
+// a.ts
+//   b // .ts
+//   c // .ts
+// a.js
+//   b // .js or .ts
+let jsResolutionOrder = [
     "",
     ".js",
     ".cjs",
@@ -25,7 +40,8 @@ let jsExtensions = [
     ".mts",
     ".jsx",
     ".tsx"
-], tsResolutionOrder = [
+];
+let tsResolutionOrder = [
     "",
     ".ts",
     ".cts",
@@ -36,26 +52,48 @@ let jsExtensions = [
     ".mjs",
     ".jsx"
 ];
+function resolveWithExtension(file, extensions) {
+    // Try to find `./a.ts`, `./a.ts`, ... from `./a`
+    for (let ext of extensions){
+        let full = `${file}${ext}`;
+        if (_fs.default.existsSync(full) && _fs.default.statSync(full).isFile()) {
+            return full;
+        }
+    }
+    // Try to find `./a/index.js` from `./a`
+    for (let ext of extensions){
+        let full = `${file}/index${ext}`;
+        if (_fs.default.existsSync(full)) {
+            return full;
+        }
+    }
+    return null;
+}
+function* _getModuleDependencies(filename, base, seen, ext = _path.default.extname(filename)) {
+    // Try to find the file
+    let absoluteFile = resolveWithExtension(_path.default.resolve(base, filename), jsExtensions.includes(ext) ? jsResolutionOrder : tsResolutionOrder);
+    if (absoluteFile === null) return; // File doesn't exist
+    // Prevent infinite loops when there are circular dependencies
+    if (seen.has(absoluteFile)) return; // Already seen
+    seen.add(absoluteFile);
+    // Mark the file as a dependency
+    yield absoluteFile;
+    // Resolve new base for new imports/requires
+    base = _path.default.dirname(absoluteFile);
+    ext = _path.default.extname(absoluteFile);
+    let contents = _fs.default.readFileSync(absoluteFile, "utf-8");
+    // Find imports/requires
+    for (let match of [
+        ...contents.matchAll(/import[\s\S]*?['"](.{3,}?)['"]/gi),
+        ...contents.matchAll(/import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi),
+        ...contents.matchAll(/require\(['"`](.+)['"`]\)/gi)
+    ]){
+        // Bail out if it's not a relative file
+        if (!match[1].startsWith(".")) continue;
+        yield* _getModuleDependencies(match[1], base, seen, ext);
+    }
+}
 function getModuleDependencies(absoluteFilePath) {
-    return null === absoluteFilePath ? new Set() : new Set(function* _getModuleDependencies(filename, base, seen, ext = _path.default.extname(filename)) {
-        let absoluteFile = function(file, extensions) {
-            for (let ext of extensions){
-                let full = `${file}${ext}`;
-                if (_fs.default.existsSync(full) && _fs.default.statSync(full).isFile()) return full;
-            }
-            for (let ext of extensions){
-                let full = `${file}/index${ext}`;
-                if (_fs.default.existsSync(full)) return full;
-            }
-            return null;
-        }(_path.default.resolve(base, filename), jsExtensions.includes(ext) ? jsResolutionOrder : tsResolutionOrder);
-        if (null === absoluteFile || seen.has(absoluteFile)) return;
-        seen.add(absoluteFile), yield absoluteFile, base = _path.default.dirname(absoluteFile), ext = _path.default.extname(absoluteFile);
-        let contents = _fs.default.readFileSync(absoluteFile, "utf-8");
-        for (let match of [
-            ...contents.matchAll(/import[\s\S]*?['"](.{3,}?)['"]/gi),
-            ...contents.matchAll(/import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi),
-            ...contents.matchAll(/require\(['"`](.+)['"`]\)/gi)
-        ])match[1].startsWith(".") && (yield* _getModuleDependencies(match[1], base, seen, ext));
-    }(absoluteFilePath, _path.default.dirname(absoluteFilePath), new Set()));
+    if (absoluteFilePath === null) return new Set();
+    return new Set(_getModuleDependencies(absoluteFilePath, _path.default.dirname(absoluteFilePath), new Set()));
 }

package/lib/lib/load-config.js

@@ -1,32 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "loadConfig", {
-    enumerable: !0,
-    get: ()=>loadConfig
+    value: true
 });
-const _jiti = function(obj) {
+Object.defineProperty(exports, "loadConfig", {
+    enumerable: true,
+    get: function() {
+        return loadConfig;
+    }
+});
+const _jiti = /*#__PURE__*/ _interop_require_default(require("jiti"));
+const _sucrase = require("sucrase");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("jiti")), _sucrase = require("sucrase");
+}
 let jiti = null;
+function lazyJiti() {
+    return jiti !== null && jiti !== void 0 ? jiti : jiti = (0, _jiti.default)(__filename, {
+        interopDefault: true,
+        transform: (opts)=>{
+            return (0, _sucrase.transform)(opts.source, {
+                transforms: [
+                    "typescript",
+                    "imports"
+                ]
+            });
+        }
+    });
+}
 function loadConfig(path) {
-    var _config_default;
     let config = function() {
         try {
             return path ? require(path) : {};
         } catch  {
-            return (null != jiti ? jiti : jiti = (0, _jiti.default)(__filename, {
-                interopDefault: !0,
-                transform: (opts)=>(0, _sucrase.transform)(opts.source, {
-                        transforms: [
-                            "typescript",
-                            "imports"
-                        ]
-                    })
-            }))(path);
+            return lazyJiti()(path);
         }
     }();
-    return null !== (_config_default = config.default) && void 0 !== _config_default ? _config_default : config;
+    var _config_default;
+    return (_config_default = config.default) !== null && _config_default !== void 0 ? _config_default : config;
 }

package/lib/lib/normalizeTailwindDirectives.js

@@ -1,40 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>normalizeTailwindDirectives
+    value: true
 });
-const _log = function(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return normalizeTailwindDirectives;
+    }
+});
+const _log = /*#__PURE__*/ _interop_require_default(require("../util/log"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("../util/log"));
+}
 function normalizeTailwindDirectives(root) {
-    let tailwindDirectives = new Set(), layerDirectives = new Set(), applyDirectives = new Set();
-    if (root.walkAtRules((atRule)=>{
-        "apply" === atRule.name && applyDirectives.add(atRule), "import" === atRule.name && ('"tailwindcss/base"' === atRule.params || "'tailwindcss/base'" === atRule.params ? (atRule.name = "tailwind", atRule.params = "base") : '"tailwindcss/components"' === atRule.params || "'tailwindcss/components'" === atRule.params ? (atRule.name = "tailwind", atRule.params = "components") : '"tailwindcss/utilities"' === atRule.params || "'tailwindcss/utilities'" === atRule.params ? (atRule.name = "tailwind", atRule.params = "utilities") : ('"tailwindcss/screens"' === atRule.params || "'tailwindcss/screens'" === atRule.params || '"tailwindcss/variants"' === atRule.params || "'tailwindcss/variants'" === atRule.params) && (atRule.name = "tailwind", atRule.params = "variants")), "tailwind" === atRule.name && ("screens" === atRule.params && (atRule.params = "variants"), tailwindDirectives.add(atRule.params)), [
+    let tailwindDirectives = new Set();
+    let layerDirectives = new Set();
+    let applyDirectives = new Set();
+    root.walkAtRules((atRule)=>{
+        if (atRule.name === "apply") {
+            applyDirectives.add(atRule);
+        }
+        if (atRule.name === "import") {
+            if (atRule.params === '"tailwindcss/base"' || atRule.params === "'tailwindcss/base'") {
+                atRule.name = "tailwind";
+                atRule.params = "base";
+            } else if (atRule.params === '"tailwindcss/components"' || atRule.params === "'tailwindcss/components'") {
+                atRule.name = "tailwind";
+                atRule.params = "components";
+            } else if (atRule.params === '"tailwindcss/utilities"' || atRule.params === "'tailwindcss/utilities'") {
+                atRule.name = "tailwind";
+                atRule.params = "utilities";
+            } else if (atRule.params === '"tailwindcss/screens"' || atRule.params === "'tailwindcss/screens'" || atRule.params === '"tailwindcss/variants"' || atRule.params === "'tailwindcss/variants'") {
+                atRule.name = "tailwind";
+                atRule.params = "variants";
+            }
+        }
+        if (atRule.name === "tailwind") {
+            if (atRule.params === "screens") {
+                atRule.params = "variants";
+            }
+            tailwindDirectives.add(atRule.params);
+        }
+        if ([
             "layer",
             "responsive",
             "variants"
-        ].includes(atRule.name) && ([
-            "responsive",
-            "variants"
-        ].includes(atRule.name) && _log.default.warn(`${atRule.name}-at-rule-deprecated`, [
-            `The \`@${atRule.name}\` directive has been deprecated in Tailwind CSS v3.0.`,
-            "Use `@layer utilities` or `@layer components` instead.",
-            "https://tailwindcss.com/docs/upgrade-guide#replace-variants-with-layer"
-        ]), layerDirectives.add(atRule));
-    }), !tailwindDirectives.has("base") || !tailwindDirectives.has("components") || !tailwindDirectives.has("utilities")) {
-        for (let rule of layerDirectives)if ("layer" === rule.name && [
-            "base",
-            "components",
-            "utilities"
-        ].includes(rule.params)) {
-            if (!tailwindDirectives.has(rule.params)) throw rule.error(`\`@layer ${rule.params}\` is used but no matching \`@tailwind ${rule.params}\` directive is present.`);
-        } else if ("responsive" === rule.name) {
-            if (!tailwindDirectives.has("utilities")) throw rule.error("`@responsive` is used but `@tailwind utilities` is missing.");
-        } else if ("variants" === rule.name && !tailwindDirectives.has("utilities")) throw rule.error("`@variants` is used but `@tailwind utilities` is missing.");
+        ].includes(atRule.name)) {
+            if ([
+                "responsive",
+                "variants"
+            ].includes(atRule.name)) {
+                _log.default.warn(`${atRule.name}-at-rule-deprecated`, [
+                    `The \`@${atRule.name}\` directive has been deprecated in Tailwind CSS v3.0.`,
+                    `Use \`@layer utilities\` or \`@layer components\` instead.`,
+                    "https://tailwindcss.com/docs/upgrade-guide#replace-variants-with-layer"
+                ]);
+            }
+            layerDirectives.add(atRule);
+        }
+    });
+    if (!tailwindDirectives.has("base") || !tailwindDirectives.has("components") || !tailwindDirectives.has("utilities")) {
+        for (let rule of layerDirectives){
+            if (rule.name === "layer" && [
+                "base",
+                "components",
+                "utilities"
+            ].includes(rule.params)) {
+                if (!tailwindDirectives.has(rule.params)) {
+                    throw rule.error(`\`@layer ${rule.params}\` is used but no matching \`@tailwind ${rule.params}\` directive is present.`);
+                }
+            } else if (rule.name === "responsive") {
+                if (!tailwindDirectives.has("utilities")) {
+                    throw rule.error("`@responsive` is used but `@tailwind utilities` is missing.");
+                }
+            } else if (rule.name === "variants") {
+                if (!tailwindDirectives.has("utilities")) {
+                    throw rule.error("`@variants` is used but `@tailwind utilities` is missing.");
+                }
+            }
+        }
     }
     return {
         tailwindDirectives,

package/lib/lib/offsets.js

@@ -1,34 +1,64 @@
+// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "Offsets", {
-    enumerable: !0,
-    get: ()=>Offsets
+    value: true
 });
-const _bigSign = function(obj) {
+Object.defineProperty(exports, "Offsets", {
+    enumerable: true,
+    get: function() {
+        return Offsets;
+    }
+});
+const _bigSign = /*#__PURE__*/ _interop_require_default(require("../util/bigSign"));
+const _remapbitfield = require("./remap-bitfield.js");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("../util/bigSign")), _remapBitfieldJs = require("./remap-bitfield.js");
+}
 class Offsets {
     constructor(){
-        this.offsets = {
+        /**
+     * Offsets for the next rule in a given layer
+     *
+     * @type {Record<Layer, bigint>}
+     */ this.offsets = {
             defaults: 0n,
             base: 0n,
             components: 0n,
             utilities: 0n,
             variants: 0n,
             user: 0n
-        }, this.layerPositions = {
+        };
+        /**
+     * Positions for a given layer
+     *
+     * @type {Record<Layer, bigint>}
+     */ this.layerPositions = {
             defaults: 0n,
             base: 1n,
             components: 2n,
             utilities: 3n,
+            // There isn't technically a "user" layer, but we need to give it a position
+            // Because it's used for ordering user-css from @apply
             user: 4n,
             variants: 5n
-        }, this.reservedVariantBits = 0n, this.variantOffsets = new Map();
+        };
+        /**
+     * The total number of functions currently registered across all variants (including arbitrary variants)
+     *
+     * @type {bigint}
+     */ this.reservedVariantBits = 0n;
+        /**
+     * Positions for a given variant
+     *
+     * @type {Map<string, bigint>}
+     */ this.variantOffsets = new Map();
     }
-    create(layer) {
+    /**
+   * @param {Layer} layer
+   * @returns {RuleOffset}
+   */ create(layer) {
         return {
             layer,
             parentLayer: layer,
@@ -39,103 +69,238 @@ class Offsets {
             options: []
         };
     }
-    arbitraryProperty() {
+    /**
+   * @returns {RuleOffset}
+   */ arbitraryProperty() {
         return {
             ...this.create("utilities"),
             arbitrary: 1n
         };
     }
-    forVariant(variant, index = 0) {
+    /**
+   * Get the offset for a variant
+   *
+   * @param {string} variant
+   * @param {number} index
+   * @returns {RuleOffset}
+   */ forVariant(variant, index = 0) {
         let offset = this.variantOffsets.get(variant);
-        if (void 0 === offset) throw Error(`Cannot find offset for unknown variant ${variant}`);
+        if (offset === undefined) {
+            throw new Error(`Cannot find offset for unknown variant ${variant}`);
+        }
         return {
             ...this.create("variants"),
             variants: offset << BigInt(index)
         };
     }
-    applyVariantOffset(rule, variant, options) {
-        return options.variant = variant.variants, {
+    /**
+   * @param {RuleOffset} rule
+   * @param {RuleOffset} variant
+   * @param {VariantOption} options
+   * @returns {RuleOffset}
+   */ applyVariantOffset(rule, variant, options) {
+        options.variant = variant.variants;
+        return {
             ...rule,
             layer: "variants",
-            parentLayer: "variants" === rule.layer ? rule.parentLayer : rule.layer,
+            parentLayer: rule.layer === "variants" ? rule.parentLayer : rule.layer,
             variants: rule.variants | variant.variants,
             options: options.sort ? [].concat(options, rule.options) : rule.options,
+            // TODO: Technically this is wrong. We should be handling parallel index on a per variant basis.
+            // We'll take the max of all the parallel indexes for now.
+            // @ts-ignore
             parallelIndex: max([
                 rule.parallelIndex,
                 variant.parallelIndex
             ])
         };
     }
-    applyParallelOffset(offset, parallelIndex) {
+    /**
+   * @param {RuleOffset} offset
+   * @param {number} parallelIndex
+   * @returns {RuleOffset}
+   */ applyParallelOffset(offset, parallelIndex) {
         return {
             ...offset,
             parallelIndex: BigInt(parallelIndex)
         };
     }
-    recordVariants(variants, getLength) {
-        for (let variant of variants)this.recordVariant(variant, getLength(variant));
+    /**
+   * Each variant gets 1 bit per function / rule registered.
+   * This is because multiple variants can be applied to a single rule and we need to know which ones are present and which ones are not.
+   * Additionally, every unique group of variants is grouped together in the stylesheet.
+   *
+   * This grouping is order-independent. For instance, we do not differentiate between `hover:focus` and `focus:hover`.
+   *
+   * @param {string[]} variants
+   * @param {(name: string) => number} getLength
+   */ recordVariants(variants, getLength) {
+        for (let variant of variants){
+            this.recordVariant(variant, getLength(variant));
+        }
     }
-    recordVariant(variant, fnCount = 1) {
-        return this.variantOffsets.set(variant, 1n << this.reservedVariantBits), this.reservedVariantBits += BigInt(fnCount), {
+    /**
+   * The same as `recordVariants` but for a single arbitrary variant at runtime.
+   * @param {string} variant
+   * @param {number} fnCount
+   *
+   * @returns {RuleOffset} The highest offset for this variant
+   */ recordVariant(variant, fnCount = 1) {
+        this.variantOffsets.set(variant, 1n << this.reservedVariantBits);
+        // Ensure space is reserved for each "function" in the parallel variant
+        // by offsetting the next variant by the number of parallel variants
+        // in the one we just added.
+        // Single functions that return parallel variants are NOT handled separately here
+        // They're offset by 1 (or the number of functions) as usual
+        // And each rule returned is tracked separately since the functions are evaluated lazily.
+        // @see `RuleOffset.parallelIndex`
+        this.reservedVariantBits += BigInt(fnCount);
+        return {
             ...this.create("variants"),
             variants: this.variantOffsets.get(variant)
         };
     }
-    compare(a, b) {
-        if (a.layer !== b.layer) return this.layerPositions[a.layer] - this.layerPositions[b.layer];
-        if (a.parentLayer !== b.parentLayer) return this.layerPositions[a.parentLayer] - this.layerPositions[b.parentLayer];
-        for (let aOptions of a.options)for (let bOptions of b.options){
-            var _max;
-            if (aOptions.id !== bOptions.id || !aOptions.sort || !bOptions.sort) continue;
-            let maxFnVariant = null !== (_max = max([
-                aOptions.variant,
-                bOptions.variant
-            ])) && void 0 !== _max ? _max : 0n, mask = ~(maxFnVariant | maxFnVariant - 1n);
-            if ((a.variants & mask) != (b.variants & mask)) continue;
-            let result = aOptions.sort({
-                value: aOptions.value,
-                modifier: aOptions.modifier
-            }, {
-                value: bOptions.value,
-                modifier: bOptions.modifier
-            });
-            if (0 !== result) return result;
+    /**
+   * @param {RuleOffset} a
+   * @param {RuleOffset} b
+   * @returns {bigint}
+   */ compare(a, b) {
+        // Sort layers together
+        if (a.layer !== b.layer) {
+            return this.layerPositions[a.layer] - this.layerPositions[b.layer];
         }
-        return a.variants !== b.variants ? a.variants - b.variants : a.parallelIndex !== b.parallelIndex ? a.parallelIndex - b.parallelIndex : a.arbitrary !== b.arbitrary ? a.arbitrary - b.arbitrary : a.index - b.index;
-    }
-    recalculateVariantOffsets() {
-        let variants = Array.from(this.variantOffsets.entries()).filter(([v])=>v.startsWith("[")).sort(([a], [z])=>(function(a, b) {
-                let aLen = a.length, bLen = b.length, minLen = aLen < bLen ? aLen : bLen;
-                for(let i = 0; i < minLen; i++){
-                    let cmp = a.charCodeAt(i) - b.charCodeAt(i);
-                    if (0 !== cmp) return cmp;
+        // When sorting the `variants` layer, we need to sort based on the parent layer as well within
+        // this variants layer.
+        if (a.parentLayer !== b.parentLayer) {
+            return this.layerPositions[a.parentLayer] - this.layerPositions[b.parentLayer];
+        }
+        // Sort based on the sorting function
+        for (let aOptions of a.options){
+            for (let bOptions of b.options){
+                if (aOptions.id !== bOptions.id) continue;
+                if (!aOptions.sort || !bOptions.sort) continue;
+                var _max;
+                let maxFnVariant = (_max = max([
+                    aOptions.variant,
+                    bOptions.variant
+                ])) !== null && _max !== void 0 ? _max : 0n;
+                // Create a mask of 0s from bits 1..N where N represents the mask of the Nth bit
+                let mask = ~(maxFnVariant | maxFnVariant - 1n);
+                let aVariantsAfterFn = a.variants & mask;
+                let bVariantsAfterFn = b.variants & mask;
+                // If the variants the same, we _can_ sort them
+                if (aVariantsAfterFn !== bVariantsAfterFn) {
+                    continue;
                 }
-                return aLen - bLen;
-            })(a, z)), newOffsets = variants.map(([, offset])=>offset).sort((a, z)=>(0, _bigSign.default)(a - z));
-        return variants.map(([, oldOffset], i)=>[
+                let result = aOptions.sort({
+                    value: aOptions.value,
+                    modifier: aOptions.modifier
+                }, {
+                    value: bOptions.value,
+                    modifier: bOptions.modifier
+                });
+                if (result !== 0) return result;
+            }
+        }
+        // Sort variants in the order they were registered
+        if (a.variants !== b.variants) {
+            return a.variants - b.variants;
+        }
+        // Make sure each rule returned by a parallel variant is sorted in ascending order
+        if (a.parallelIndex !== b.parallelIndex) {
+            return a.parallelIndex - b.parallelIndex;
+        }
+        // Always sort arbitrary properties after other utilities
+        if (a.arbitrary !== b.arbitrary) {
+            return a.arbitrary - b.arbitrary;
+        }
+        // Sort utilities, components, etc… in the order they were registered
+        return a.index - b.index;
+    }
+    /**
+   * Arbitrary variants are recorded in the order they're encountered.
+   * This means that the order is not stable between environments and sets of content files.
+   *
+   * In order to make the order stable, we need to remap the arbitrary variant offsets to
+   * be in alphabetical order starting from the offset of the first arbitrary variant.
+   */ recalculateVariantOffsets() {
+        // Sort the variants by their name
+        let variants = Array.from(this.variantOffsets.entries()).filter(([v])=>v.startsWith("[")).sort(([a], [z])=>fastCompare(a, z));
+        // Sort the list of offsets
+        // This is not necessarily a discrete range of numbers which is why
+        // we're using sort instead of creating a range from min/max
+        let newOffsets = variants.map(([, offset])=>offset).sort((a, z)=>(0, _bigSign.default)(a - z));
+        // Create a map from the old offsets to the new offsets in the new sort order
+        /** @type {[bigint, bigint][]} */ let mapping = variants.map(([, oldOffset], i)=>[
                 oldOffset,
                 newOffsets[i]
-            ]).filter(([a, z])=>a !== z);
+            ]);
+        // Remove any variants that will not move letting us skip
+        // remapping if everything happens to be in order
+        return mapping.filter(([a, z])=>a !== z);
     }
-    remapArbitraryVariantOffsets(list) {
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ remapArbitraryVariantOffsets(list) {
         let mapping = this.recalculateVariantOffsets();
-        return 0 === mapping.length ? list : list.map((item)=>{
+        // No arbitrary variants? Nothing to do.
+        // Everyhing already in order? Nothing to do.
+        if (mapping.length === 0) {
+            return list;
+        }
+        // Remap every variant offset in the list
+        return list.map((item)=>{
             let [offset, rule] = item;
+            offset = {
+                ...offset,
+                variants: (0, _remapbitfield.remapBitfield)(offset.variants, mapping)
+            };
             return [
-                offset = {
-                    ...offset,
-                    variants: (0, _remapBitfieldJs.remapBitfield)(offset.variants, mapping)
-                },
+                offset,
                 rule
             ];
         });
     }
-    sort(list) {
-        return (list = this.remapArbitraryVariantOffsets(list)).sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
+    /**
+   * @template T
+   * @param {[RuleOffset, T][]} list
+   * @returns {[RuleOffset, T][]}
+   */ sort(list) {
+        list = this.remapArbitraryVariantOffsets(list);
+        return list.sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
     }
 }
-function max(nums) {
+/**
+ *
+ * @param {bigint[]} nums
+ * @returns {bigint|null}
+ */ function max(nums) {
     let max = null;
-    for (let num of nums)max = (max = null != max ? max : num) > num ? max : num;
+    for (const num of nums){
+        max = max !== null && max !== void 0 ? max : num;
+        max = max > num ? max : num;
+    }
     return max;
 }
+/**
+ * A fast ASCII order string comparison function.
+ *
+ * Using `.sort()` without a custom compare function is faster
+ * But you can only use that if you're sorting an array of
+ * only strings. If you're sorting strings inside objects
+ * or arrays, you need must use a custom compare function.
+ *
+ * @param {string} a
+ * @param {string} b
+ */ function fastCompare(a, b) {
+    let aLen = a.length;
+    let bLen = b.length;
+    let minLen = aLen < bLen ? aLen : bLen;
+    for(let i = 0; i < minLen; i++){
+        let cmp = a.charCodeAt(i) - b.charCodeAt(i);
+        if (cmp !== 0) return cmp;
+    }
+    return aLen - bLen;
+}