tailwindcss 0.0.0-oxide-insiders.dddaded → 0.0.0-oxide-insiders.b2e3cf2

package/lib/lib/getModuleDependencies.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "default", {
+    enumerable: !0,
     get: ()=>getModuleDependencies
 });
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -17,18 +15,7 @@ let jsExtensions = [
     ".js",
     ".cjs",
     ".mjs"
-];
-// 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 = [
+], jsResolutionOrder = [
     "",
     ".js",
     ".cjs",
@@ -38,8 +25,7 @@ let jsResolutionOrder = [
     ".mts",
     ".jsx",
     ".tsx"
-];
-let tsResolutionOrder = [
+], tsResolutionOrder = [
     "",
     ".ts",
     ".cts",
@@ -50,48 +36,26 @@ let tsResolutionOrder = [
     ".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) {
-    if (absoluteFilePath === null) return new Set();
-    return new Set(_getModuleDependencies(absoluteFilePath, _path.default.dirname(absoluteFilePath), new Set()));
+    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()));
 }

package/lib/lib/load-config.js

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

package/lib/lib/normalizeTailwindDirectives.js

@@ -1,84 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "default", {
+    enumerable: !0,
     get: ()=>normalizeTailwindDirectives
 });
-const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
-function _interopRequireDefault(obj) {
+const _log = function(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}
+}(require("../util/log"));
 function normalizeTailwindDirectives(root) {
-    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 ([
+    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)), [
             "layer",
             "responsive",
             "variants"
-        ].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.");
-                }
-            }
-        }
+        ].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.");
     }
     return {
         tailwindDirectives,

package/lib/lib/offsets.js

@@ -1,62 +1,34 @@
-// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Offsets", {
-    enumerable: true,
+    value: !0
+}), Object.defineProperty(exports, "Offsets", {
+    enumerable: !0,
     get: ()=>Offsets
 });
-const _bigSign = /*#__PURE__*/ _interopRequireDefault(require("../util/bigSign"));
-const _remapBitfieldJs = require("./remap-bitfield.js");
-function _interopRequireDefault(obj) {
+const _bigSign = function(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}
+}(require("../util/bigSign")), _remapBitfieldJs = require("./remap-bitfield.js");
 class Offsets {
     constructor(){
-        /**
-     * Offsets for the next rule in a given layer
-     *
-     * @type {Record<Layer, bigint>}
-     */ this.offsets = {
+        this.offsets = {
             defaults: 0n,
             base: 0n,
             components: 0n,
             utilities: 0n,
             variants: 0n,
             user: 0n
-        };
-        /**
-     * Positions for a given layer
-     *
-     * @type {Record<Layer, bigint>}
-     */ this.layerPositions = {
+        }, 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
-        };
-        /**
-     * 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();
+        }, this.reservedVariantBits = 0n, this.variantOffsets = new Map();
     }
-    /**
-   * @param {Layer} layer
-   * @returns {RuleOffset}
-   */ create(layer) {
+    create(layer) {
         return {
             layer,
             parentLayer: layer,
@@ -67,238 +39,103 @@ class Offsets {
             options: []
         };
     }
-    /**
-   * @returns {RuleOffset}
-   */ arbitraryProperty() {
+    arbitraryProperty() {
         return {
             ...this.create("utilities"),
             arbitrary: 1n
         };
     }
-    /**
-   * Get the offset for a variant
-   *
-   * @param {string} variant
-   * @param {number} index
-   * @returns {RuleOffset}
-   */ forVariant(variant, index = 0) {
+    forVariant(variant, index = 0) {
         let offset = this.variantOffsets.get(variant);
-        if (offset === undefined) {
-            throw new Error(`Cannot find offset for unknown variant ${variant}`);
-        }
+        if (void 0 === offset) throw Error(`Cannot find offset for unknown variant ${variant}`);
         return {
             ...this.create("variants"),
             variants: offset << BigInt(index)
         };
     }
-    /**
-   * @param {RuleOffset} rule
-   * @param {RuleOffset} variant
-   * @param {VariantOption} options
-   * @returns {RuleOffset}
-   */ applyVariantOffset(rule, variant, options) {
-        options.variant = variant.variants;
-        return {
+    applyVariantOffset(rule, variant, options) {
+        return options.variant = variant.variants, {
             ...rule,
             layer: "variants",
-            parentLayer: rule.layer === "variants" ? rule.parentLayer : rule.layer,
+            parentLayer: "variants" === rule.layer ? 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
             ])
         };
     }
-    /**
-   * @param {RuleOffset} offset
-   * @param {number} parallelIndex
-   * @returns {RuleOffset}
-   */ applyParallelOffset(offset, parallelIndex) {
+    applyParallelOffset(offset, parallelIndex) {
         return {
             ...offset,
             parallelIndex: BigInt(parallelIndex)
         };
     }
-    /**
-   * 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));
-        }
+    recordVariants(variants, getLength) {
+        for (let variant of variants)this.recordVariant(variant, getLength(variant));
     }
-    /**
-   * 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 {
+    recordVariant(variant, fnCount = 1) {
+        return this.variantOffsets.set(variant, 1n << this.reservedVariantBits), this.reservedVariantBits += BigInt(fnCount), {
             ...this.create("variants"),
             variants: this.variantOffsets.get(variant)
         };
     }
-    /**
-   * @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];
+    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;
         }
-        // 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;
-                }
-                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;
+        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;
     }
-    /**
-   * 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)=>[
+    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;
+                }
+                return aLen - bLen;
+            })(a, z)), newOffsets = variants.map(([, offset])=>offset).sort((a, z)=>(0, _bigSign.default)(a - z));
+        return variants.map(([, oldOffset], i)=>[
                 oldOffset,
                 newOffsets[i]
-            ]);
-        // 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);
+            ]).filter(([a, z])=>a !== z);
     }
-    /**
-   * @template T
-   * @param {[RuleOffset, T][]} list
-   * @returns {[RuleOffset, T][]}
-   */ remapArbitraryVariantOffsets(list) {
+    remapArbitraryVariantOffsets(list) {
         let mapping = this.recalculateVariantOffsets();
-        // 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)=>{
+        return 0 === mapping.length ? list : list.map((item)=>{
             let [offset, rule] = item;
-            offset = {
-                ...offset,
-                variants: (0, _remapBitfieldJs.remapBitfield)(offset.variants, mapping)
-            };
             return [
-                offset,
+                offset = {
+                    ...offset,
+                    variants: (0, _remapBitfieldJs.remapBitfield)(offset.variants, mapping)
+                },
                 rule
             ];
         });
     }
-    /**
-   * @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)));
+    sort(list) {
+        return (list = this.remapArbitraryVariantOffsets(list)).sort(([a], [b])=>(0, _bigSign.default)(this.compare(a, b)));
     }
 }
-/**
- *
- * @param {bigint[]} nums
- * @returns {bigint|null}
- */ function max(nums) {
+function max(nums) {
     let max = null;
-    for (const num of nums){
-        max = max !== null && max !== void 0 ? max : num;
-        max = max > num ? max : num;
-    }
+    for (let num of nums)max = (max = null != max ? max : num) > 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;
-}