html-minifier-next 6.2.7 → 6.2.9

package/src/lib/options.js

@@ -1,5 +1,3 @@
-// Imports
-
 import { createUrlMinifier } from './urls.js';
 import { LRU, stableStringify, hashContent, identity, lowercase, replaceAsync, parseRegExp } from './utils.js';
 import { RE_TRAILING_SEMICOLON } from './constants.js';
@@ -8,8 +6,17 @@ import { wrapCSS, unwrapCSS } from './content.js';
 import { getPreset, getPresetNames } from '../presets.js';
 import { optionDefaults } from './option-definitions.js';
 
+// Type definitions
+
+/**
+ * @typedef {Record<string, any>} MinifierOptions
+ */
+
+// @@ Extract a `ProcessedOptions` typedef (with `name`, `log`, `canCollapseWhitespace`, `canTrimWhitespace`,`minifyCSS`, `minifyJS`, `minifyURLs` typed as required, non-optional) to replace the current `Record<string, any>` escape hatch and eliminate the `/** @type {Function} */` casts in htmlminifier.js
+
 // Helper functions
 
+/** @param {MinifierOptions} options */
 function shouldMinifyInnerHTML(options) {
   return Boolean(
     options.collapseWhitespace ||
@@ -25,18 +32,12 @@ function shouldMinifyInnerHTML(options) {
 // Main options processor
 
 /**
- * @param {Partial<MinifierOptions>} inputOptions - User-provided options
- * @param {Object} deps - Dependencies from htmlminifier.js
- * @param {Function} deps.getLightningCSS - Function to lazily load Lightning CSS
- * @param {Function} deps.getTerser - Function to lazily load Terser
- * @param {Function} deps.getSwc - Function to lazily load @swc/core
- * @param {Function} deps.getSvgo - Function to lazily load SVGO
- * @param {LRU} deps.cssMinifyCache - CSS minification cache
- * @param {LRU} deps.jsMinifyCache - JS minification cache
- * @param {LRU} deps.svgMinifyCache - SVG minification cache
+ * @param {MinifierOptions} inputOptions - User-provided options
+ * @param {{getLightningCSS?: Function | undefined, getTerser?: Function | undefined, getSwc?: Function | undefined, getSvgo?: Function | undefined, cssMinifyCache?: LRU | undefined, jsMinifyCache?: LRU | undefined, svgMinifyCache?: LRU | undefined}} [deps] - Dependencies from htmlminifier.js
  * @returns {MinifierOptions} Normalized options with defaults applied
  */
 const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getSvgo, cssMinifyCache, jsMinifyCache, svgMinifyCache } = {}) => {
+  /** @type {MinifierOptions} */
   const options = {
     name: lowercase,
     canCollapseWhitespace,
@@ -49,13 +50,13 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     minifySVG: null
   };
 
-  const parseRegExpArray = (arr) => {
-    return Array.isArray(arr) ? arr.map(parseRegExp) : arr;
+  const parseRegExpArray = (/** @type {unknown} */ arr) => {
+    return Array.isArray(arr) ? arr.map(parseRegExp) : [];
   };
 
   // Helper for nested arrays (e.g., `customAttrSurround: [[start, end], …]`)
-  const parseNestedRegExpArray = (arr) => {
-    if (!Array.isArray(arr)) return arr;
+  const parseNestedRegExpArray = (/** @type {unknown} */ arr) => {
+    if (!Array.isArray(arr)) return [];
     return arr.map(item => {
       // If item is an array (a pair), recursively convert each element
       if (Array.isArray(item)) {
@@ -96,13 +97,16 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         options.log = option;
       }
     } else if (key === 'minifyCSS' && typeof option !== 'function') {
-      if (!option) {
+      if (!option || !getLightningCSS || !cssMinifyCache) {
         return;
       }
 
       const lightningCssOptions = typeof option === 'object' ? option : {};
+      // Capture to preserve TypeScript narrowing across the async closure boundary below
+      const cssLoader = getLightningCSS;
+      const cssCache = cssMinifyCache;
 
-      options.minifyCSS = async function (text, type) {
+      options.minifyCSS = async function (/** @type {string} */ text, /** @type {string} */ type) {
         // Fast path: Nothing to minify
         if (!text || !text.trim()) {
           return text;
@@ -114,7 +118,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           text = await replaceAsync(
             text,
             /(url\s*\(\s*)(?:"([^"]*)"|'([^']*)'|([^\s)]+))(\s*\))/ig,
-            async function (match, prefix, dq, sq, unq, suffix) {
+            async function (/** @type {string} */ match, /** @type {string} */ prefix, /** @type {string | undefined} */ dq, /** @type {string | undefined} */ sq, /** @type {string | undefined} */ unq, /** @type {string} */ suffix) {
               const quote = dq != null ? '"' : (sq != null ? "'" : '');
               const url = dq ?? sq ?? unq ?? '';
               try {
@@ -139,8 +143,8 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           : (inputCSS + '|' + type + '|' + cssSig);
 
         try {
-          const cached = cssMinifyCache.get(cssKey);
-          if (cached) {
+          const cached = cssCache.get(cssKey);
+          if (cached !== undefined) {
             // Support both resolved values and in-flight promises
             return await cached;
           }
@@ -148,7 +152,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           // In-flight promise caching: Prevent duplicate concurrent minifications
           // of the same CSS content (same pattern as JS minification)
           const inFlight = (async () => {
-            const transformCSS = await getLightningCSS();
+            const transformCSS = await cssLoader();
             // Note: `Buffer.from()` is required—Lightning CSS API expects Uint8Array
             const result = transformCSS({
               filename: 'input.css',
@@ -175,12 +179,12 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
             return (text.trim() && !outputCSS.trim() && (looksLikeTemplate || hasUID)) ? text : outputCSS;
           })();
 
-          cssMinifyCache.set(cssKey, inFlight);
+          cssCache.set(cssKey, inFlight);
           const resolved = await inFlight;
-          cssMinifyCache.set(cssKey, resolved);
+          cssCache.set(cssKey, resolved);
           return resolved;
         } catch (err) {
-          cssMinifyCache.delete(cssKey);
+          cssCache.delete(cssKey);
           if (!options.continueOnMinifyError) {
             throw err;
           }
@@ -189,10 +193,15 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         }
       };
     } else if (key === 'minifyJS' && typeof option !== 'function') {
-      if (!option) {
+      if (!option || !getTerser || !getSwc || !jsMinifyCache) {
         return;
       }
 
+      // Capture to preserve TypeScript narrowing across the async closure boundary below
+      const loadTerser = getTerser;
+      const loadSwc = getSwc;
+      const jsCache = jsMinifyCache;
+
       // Parse configuration
       const config = typeof option === 'object' ? option : {};
       const engine = (config.engine || 'terser').toLowerCase();
@@ -227,7 +236,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         cont: !!options.continueOnMinifyError
       });
 
-      options.minifyJS = async function (text, inline, isModule) {
+      options.minifyJS = async function (/** @type {string} */ text, /** @type {boolean} */ inline, /** @type {boolean} */ isModule) {
         const start = text.match(/^\s*<!--.*/);
         const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
 
@@ -249,8 +258,8 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           jsKey = (code.length > 2048 ? (hashContent(code) + '|') : (code + '|'))
             + (inline ? '1' : '0') + '|' + (isModule ? 'm' : '') + '|' + useEngine + '|' + optsSig;
 
-          const cached = jsMinifyCache.get(jsKey);
-          if (cached) {
+          const cached = jsCache.get(jsKey);
+          if (cached !== undefined) {
             return await cached;
           }
 
@@ -266,11 +275,11 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
                 },
                 ...(isModule ? { module: true } : {}) // Overrides user options: module detection takes precedence for `<script type=module>`
               };
-              const terser = await getTerser();
+              const terser = await loadTerser();
               const result = await terser(code, terserCallOptions);
               return result.code.replace(RE_TRAILING_SEMICOLON, '');
             } else if (useEngine === 'swc') {
-              const swc = await getSwc();
+              const swc = await loadSwc();
               // `swc.minify()` takes compress and mangle directly as options
               const result = await swc.minify(code, {
                 compress: true,
@@ -283,12 +292,12 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
             throw new Error(`Unknown JS minifier engine: ${useEngine}`);
           })();
 
-          jsMinifyCache.set(jsKey, inFlight);
+          jsCache.set(jsKey, inFlight);
           const resolved = await inFlight;
-          jsMinifyCache.set(jsKey, resolved);
+          jsCache.set(jsKey, resolved);
           return resolved;
         } catch (err) {
-          if (jsKey) jsMinifyCache.delete(jsKey);
+          if (jsKey) jsCache.delete(jsKey);
           if (!options.continueOnMinifyError) {
             throw err;
           }
@@ -314,7 +323,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
       // Create instance-specific cache (results depend on site configuration)
       const instanceCache = new LRU(500);
 
-      options.minifyURLs = function (text) {
+      options.minifyURLs = function (/** @type {string} */ text) {
         // Fast-path: Skip if text doesn’t look like a URL that needs processing
         // Only process if contains URL-like characters (`/`, `:`, `#`, `?`) or spaces that need encoding
         if (!/[/:?#\s]/.test(text)) {
@@ -341,10 +350,14 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         }
       };
     } else if (key === 'minifySVG' && typeof option !== 'function') {
-      if (!option) {
+      if (!option || !getSvgo || !svgMinifyCache) {
         return;
       }
 
+      // Capture to preserve TypeScript narrowing across the async closure boundary below
+      const loadSvgo = getSvgo;
+      const svgCache = svgMinifyCache;
+
       const svgoOptions = typeof option === 'object' ? option : {};
 
       // Pre-compute option signature for cache keys
@@ -353,7 +366,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         cont: !!options.continueOnMinifyError
       });
 
-      options.minifySVG = async function (svgContent) {
+      options.minifySVG = async function (/** @type {string} */ svgContent) {
         if (!svgContent || !svgContent.trim()) {
           return svgContent;
         }
@@ -364,23 +377,23 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           : (svgContent + '|' + svgSig);
 
         try {
-          const cached = svgMinifyCache.get(svgKey);
-          if (cached) {
+          const cached = svgCache.get(svgKey);
+          if (cached !== undefined) {
             return await cached;
           }
 
           const inFlight = (async () => {
-            const optimize = await getSvgo();
+            const optimize = await loadSvgo();
             const result = optimize(svgContent, svgoOptions);
             return result.data;
           })();
 
-          svgMinifyCache.set(svgKey, inFlight);
+          svgCache.set(svgKey, inFlight);
           const resolved = await inFlight;
-          svgMinifyCache.set(svgKey, resolved);
+          svgCache.set(svgKey, resolved);
           return resolved;
         } catch (err) {
-          svgMinifyCache.delete(svgKey);
+          svgCache.delete(svgKey);
           if (!options.continueOnMinifyError) {
             throw err;
           }

package/src/lib/utils.js

@@ -1,13 +1,17 @@
 // Stringify for options signatures (sorted keys, shallow, nested objects)
 
+/**
+ * @param {unknown} obj
+ * @returns {string}
+ */
 function stableStringify(obj) {
   if (obj == null || typeof obj !== 'object') return JSON.stringify(obj);
   if (Array.isArray(obj)) return '[' + obj.map(stableStringify).join(',') + ']';
   const keys = Object.keys(obj).sort();
   let out = '{';
   for (let i = 0; i < keys.length; i++) {
-    const k = keys[i];
-    out += JSON.stringify(k) + ':' + stableStringify(obj[k]) + (i < keys.length - 1 ? ',' : '');
+    const k = keys[i] ?? '';
+    out += JSON.stringify(k) + ':' + stableStringify(/** @type {Record<string, unknown>} */ (obj)[k]) + (i < keys.length - 1 ? ',' : '');
   }
   return out + '}';
 }
@@ -17,8 +21,10 @@ function stableStringify(obj) {
 class LRU {
   constructor(limit = 200) {
     this.limit = limit;
+    /** @type {Map<string, unknown>} */
     this.map = new Map();
   }
+  /** @param {string} key */
   get(key) {
     if (this.map.has(key)) {
       const v = this.map.get(key);
@@ -28,19 +34,25 @@ class LRU {
     }
     return undefined;
   }
+  /**
+   * @param {string} key
+   * @param {unknown} value
+   */
   set(key, value) {
     if (this.map.has(key)) this.map.delete(key);
     this.map.set(key, value);
     if (this.map.size > this.limit) {
       const first = this.map.keys().next().value;
-      this.map.delete(first);
+      if (first !== undefined) this.map.delete(first);
     }
   }
+  /** @param {string} key */
   delete(key) { this.map.delete(key); }
 }
 
 // FNV-1a 32-bit hash for large-input cache keys
 
+/** @param {string} str */
 function hashContent(str) {
   let hash = 2166136261;
   for (let i = 0; i < str.length; i++) {
@@ -52,6 +64,7 @@ function hashContent(str) {
 
 // Unique ID generator
 
+/** @param {string} value */
 function uniqueId(value) {
   let id;
   do {
@@ -62,14 +75,17 @@ function uniqueId(value) {
 
 // Identity and transform functions
 
+/** @param {string} value */
 function identity(value) {
   return value;
 }
 
+/** @param {unknown} value */
 function isThenable(value) {
-  return value != null && typeof value === 'object' && typeof value.then === 'function';
+  return value != null && typeof value === 'object' && typeof /** @type {any} */ (value).then === 'function';
 }
 
+/** @param {string} value */
 function lowercase(value) {
   return value.toLowerCase();
 }
@@ -84,25 +100,28 @@ function lowercase(value) {
  * @returns {Promise<string>} Processed string
  */
 async function replaceAsync(str, regex, asyncFn) {
+  /** @type {Promise<string>[]} */
   const promises = [];
 
-  str.replace(regex, (match, ...args) => {
+  str.replace(regex, /** @returns {string} */ (match, ...args) => {
     const promise = asyncFn(match, ...args);
     promises.push(promise);
+    return match;
   });
 
   const data = await Promise.all(promises);
-  return str.replace(regex, () => data.shift());
+  return str.replace(regex, () => data.shift() ?? '');
 }
 
 // String patterns to RegExp conversion (for JSON config support)
 
+/** @param {string | RegExp} value */
 function parseRegExp(value) {
   if (typeof value === 'string') {
     if (!value) return undefined; // Empty string = not configured
     const match = value.match(/^\/(.+)\/([dgimsuvy]*)$/);
     if (match) {
-      return new RegExp(match[1], match[2]);
+      return new RegExp(match[1] ?? '', match[2] ?? '');
     }
     return new RegExp(value);
   }

package/src/lib/whitespace.js

@@ -1,5 +1,3 @@
-// Imports
-
 import {
   RE_WS_START,
   RE_WS_END,
@@ -15,6 +13,7 @@ import {
 
 // Trim whitespace
 
+/** @param {string} str */
 const trimWhitespace = str => {
   if (!str) return str;
   // Fast path: If no whitespace at start or end, return early
@@ -26,6 +25,7 @@ const trimWhitespace = str => {
 
 // Collapse all whitespace
 
+/** @param {string} str */
 function collapseWhitespaceAll(str) {
   if (!str) return str;
   // Fast path: If there are no common whitespace characters, return early
@@ -33,7 +33,7 @@ function collapseWhitespaceAll(str) {
     return str;
   }
   // No-break space is specifically handled inside the replacer function here:
-  return str.replace(RE_ALL_WS_NBSP, function (spaces) {
+  return str.replace(RE_ALL_WS_NBSP, function (/** @param {string} spaces */ spaces) {
     // Preserve standalone tabs
     if (spaces === '\t') return '\t';
     // Fast path: No no-break space, common case—just collapse to single space
@@ -46,7 +46,14 @@ function collapseWhitespaceAll(str) {
 
 // Collapse whitespace with options
 
-function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
+/**
+ * @param {string} str
+ * @param {{preserveLineBreaks?: boolean | undefined, conservativeCollapse?: boolean | undefined}} options
+ * @param {boolean} trimLeft
+ * @param {boolean} trimRight
+ * @param {boolean} [collapseAll]
+ */
+function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = false) {
   let lineBreakBefore = ''; let lineBreakAfter = '';
 
   if (!str) return str;
@@ -66,7 +73,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
     // (avoids polynomial backtracking with end-anchored lazy quantifiers)
     const WS_CHARS = ' \n\r\t\f';
     let leadEnd = 0;
-    while (leadEnd < str.length && WS_CHARS.includes(str[leadEnd])) {
+    while (leadEnd < str.length && WS_CHARS.includes(str.charAt(leadEnd))) {
       leadEnd++;
     }
     if (leadEnd > 0) {
@@ -77,7 +84,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
       }
     }
     let trailStart = str.length;
-    while (trailStart > 0 && WS_CHARS.includes(str[trailStart - 1])) {
+    while (trailStart > 0 && WS_CHARS.includes(str.charAt(trailStart - 1))) {
       trailStart--;
     }
     if (trailStart < str.length) {
@@ -91,7 +98,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
 
   if (trimLeft) {
     // No-break space is specifically handled inside the replacer function
-    str = str.replace(/^[ \n\r\t\f\xA0]+/, function (spaces) {
+    str = str.replace(/^[ \n\r\t\f\xA0]+/, function (/** @type {string} */ spaces) {
       const conservative = !lineBreakBefore && options.conservativeCollapse;
       if (conservative && spaces === '\t') {
         return '\t';
@@ -104,7 +111,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
     // Find trailing whitespace boundary manually (avoids polynomial backtracking
     // with `/[ \n\r\t\f\xA0]+$/` on strings with long internal whitespace runs)
     let end = str.length;
-    while (end > 0 && ' \n\r\t\f\xA0'.includes(str[end - 1])) {
+    while (end > 0 && ' \n\r\t\f\xA0'.includes(str.charAt(end - 1))) {
       end--;
     }
     if (end < str.length) {
@@ -135,14 +142,24 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
 
 // Collapse whitespace smartly based on surrounding tags
 
+/**
+ * @param {string} str
+ * @param {string} prevTag
+ * @param {string} nextTag
+ * @param {Array<{name: string, value?: string}>} prevAttrs
+ * @param {Array<{name: string, value?: string}>} nextAttrs
+ * @param {{preserveLineBreaks?: boolean, conservativeCollapse?: boolean, collapseInlineTagWhitespace?: boolean}} options
+ * @param {Set<string>} inlineElements
+ * @param {Set<string>} inlineTextSet
+ */
 function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet) {
   const prevTagName = prevTag && (prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag);
   const nextTagName = nextTag && (nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag);
 
   // Helper: Check if an input element has `type="hidden"`
-  const isHiddenInput = (tagName, attrs) => {
+  const isHiddenInput = (/** @type {string} */ tagName, /** @type {Array<{name: string, value?: string}>} */ attrs) => {
     if (tagName !== 'input' || !attrs || !attrs.length) return false;
-    const typeAttr = attrs.find(attr => attr.name === 'type');
+    const typeAttr = attrs.find((/** @type {{name: string, value?: string}} */ attr) => attr.name === 'type');
     return typeAttr && typeAttr.value === 'hidden';
   };
 
@@ -206,7 +223,7 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
     }
   }
 
-  return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
+  return collapseWhitespace(str, options, Boolean(trimLeft), Boolean(trimRight), Boolean(prevTag && nextTag));
 }
 
 // Collapse/trim whitespace for given tag
@@ -214,10 +231,12 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
 const noCollapseWhitespaceTags = new Set(['script', 'style', 'pre', 'textarea']);
 const noTrimWhitespaceTags = new Set(['pre', 'textarea']);
 
+/** @param {string} tag */
 function canCollapseWhitespace(tag) {
   return !noCollapseWhitespaceTags.has(tag);
 }
 
+/** @param {string} tag */
 function canTrimWhitespace(tag) {
   return !noTrimWhitespaceTags.has(tag);
 }

package/src/presets.js

@@ -47,7 +47,7 @@ export const presets = {
 export function getPreset(name) {
   if (!name) return null;
   const normalizedName = name.toLowerCase();
-  return presets[normalizedName] || null;
+  return /** @type {Record<string, object>} */ (presets)[normalizedName] || null;
 }
 
 /**

package/src/tokenchain.js

@@ -1,17 +1,29 @@
 class Sorter {
+  constructor() {
+    /** @type {string[]} */
+    this.keys = [];
+    /** @type {Map<string, Sorter>} */
+    this.sorterMap = new Map();
+  }
+
+  /**
+   * @param {string[]} tokens
+   * @param {number} fromIndex
+   * @returns {string[]}
+   */
   sort(tokens, fromIndex = 0) {
-    for (let i = 0, len = this.keys.length; i < len; i++) {
-      const token = this.keys[i];
+    for (const token of this.keys) {
 
       // Single pass: Count matches and collect non-matches
       let matchCount = 0;
       const others = [];
 
       for (let j = fromIndex; j < tokens.length; j++) {
-        if (tokens[j] === token) {
+        const t = /** @type {string} */ (tokens[j]);
+        if (t === token) {
           matchCount++;
         } else {
-          others.push(tokens[j]);
+          others.push(t);
         }
       }
 
@@ -21,12 +33,12 @@ class Sorter {
         for (let j = 0; j < matchCount; j++) {
           tokens[writeIdx++] = token;
         }
-        for (let j = 0; j < others.length; j++) {
-          tokens[writeIdx++] = others[j];
+        for (const other of others) {
+          tokens[writeIdx++] = other;
         }
 
         const newFromIndex = fromIndex + matchCount;
-        return this.sorterMap.get(token).sort(tokens, newFromIndex);
+        return this.sorterMap.get(token)?.sort(tokens, newFromIndex) ?? tokens;
       }
     }
     return tokens;
@@ -35,22 +47,24 @@ class Sorter {
 
 class TokenChain {
   constructor() {
-    // Use map instead of object properties for better performance
+    /** @type {Map<string, {arrays: string[][], processed: number}>} */
     this.map = new Map();
   }
 
+  /** @param {string[]} tokens */
   add(tokens) {
     tokens.forEach((token) => {
-      if (!this.map.has(token)) {
-        this.map.set(token, { arrays: [], processed: 0 });
+      let entry = this.map.get(token);
+      if (!entry) {
+        entry = { arrays: [], processed: 0 };
+        this.map.set(token, entry);
       }
-      this.map.get(token).arrays.push(tokens);
+      entry.arrays.push(tokens);
     });
   }
 
   createSorter() {
     const sorter = new Sorter();
-    sorter.sorterMap = new Map();
 
     // Convert map entries to array and sort by frequency (descending), then alphabetically
     const entries = Array.from(this.map.entries()).sort((a, b) => {
@@ -63,18 +77,17 @@ class TokenChain {
       return a[0].localeCompare(b[0]);
     });
 
-    sorter.keys = [];
-
     entries.forEach(([token, data]) => {
       if (data.processed < data.arrays.length) {
         const chain = new TokenChain();
 
         data.arrays.forEach((tokens) => {
           // Build new array without the current token instead of splicing
+          /** @type {string[]} */
           const filtered = [];
-          for (let i = 0; i < tokens.length; i++) {
-            if (tokens[i] !== token) {
-              filtered.push(tokens[i]);
+          for (const t of tokens) {
+            if (t !== token) {
+              filtered.push(t);
             }
           }