html-minifier 3.5.21 → 5.0.0

package/src/tokenchain.js

@@ -1,71 +1,157 @@
-'use strict';
+class Sorter {
+  constructor() {
+    // Rank per token, in the order the keys were added—looked up per token, so a
+    // token list sorts in one pass instead of one scan per known key
+    /** @type {Map<string, number>} */
+    this.rank = new Map();
+    /** @type {Map<string, Sorter | (() => Sorter)>} */
+    this.sorterMap = new Map();
+  }
+
+  /** @param {string} token */
+  child(token) {
+    let child = this.sorterMap.get(token);
+    // Nested sorters are built on first use, as most are never reached
+    if (typeof child === 'function') {
+      child = child();
+      this.sorterMap.set(token, child);
+    }
+    return child;
+  }
+
+  /**
+   * @param {string[]} tokens
+   * @param {number} fromIndex
+   * @returns {string[]}
+   */
+  sort(tokens, fromIndex = 0) {
+    // The present token with the lowest rank comes first—the same choice scanning
+    // the keys in order would make
+    let best = null;
+    let bestRank = Infinity;
+    for (let j = fromIndex; j < tokens.length; j++) {
+      const rank = this.rank.get(/** @type {string} */ (tokens[j]));
+      if (rank !== undefined && rank < bestRank) {
+        bestRank = rank;
+        best = /** @type {string} */ (tokens[j]);
+      }
+    }
+    if (best === null) return tokens;
+
+    // Single pass: Count matches and collect non-matches
+    let matchCount = 0;
+    const others = [];
+    for (let j = fromIndex; j < tokens.length; j++) {
+      const t = /** @type {string} */ (tokens[j]);
+      if (t === best) {
+        matchCount++;
+      } else {
+        others.push(t);
+      }
+    }
+
+    // Rebuild: `matchCount` instances of the best token first, then others
+    let writeIdx = fromIndex;
+    for (let j = 0; j < matchCount; j++) {
+      tokens[writeIdx++] = best;
+    }
+    for (const other of others) {
+      tokens[writeIdx++] = other;
+    }
 
-function Sorter() {
+    return this.child(best)?.sort(tokens, fromIndex + matchCount) ?? tokens;
+  }
 }
 
-Sorter.prototype.sort = function(tokens, fromIndex) {
-  fromIndex = fromIndex || 0;
-  for (var i = 0, len = this.keys.length; i < len; i++) {
-    var key = this.keys[i];
-    var token = key.slice(1);
-    var index = tokens.indexOf(token, fromIndex);
-    if (index !== -1) {
-      do {
-        if (index !== fromIndex) {
-          tokens.splice(index, 1);
-          tokens.splice(fromIndex, 0, token);
-        }
-        fromIndex++;
-      } while ((index = tokens.indexOf(token, fromIndex)) !== -1);
-      return this[key].sort(tokens, fromIndex);
+const compareLocale = new Intl.Collator().compare;
+
+class TokenChain {
+  constructor() {
+    // Identical token lists are kept once, with how often they occurred
+    /** @type {Map<string, {lists: Map<string, {tokens: string[], weight: number}>, count: number, processed: number}>} */
+    this.map = new Map();
+  }
+
+  /**
+   * @param {string[]} tokens
+   * @param {number} [weight]
+   */
+  add(tokens, weight = 1) {
+    // Tokens hold no whitespace, so a space-joined key is unique
+    const key = tokens.join(' ');
+    for (const token of tokens) {
+      let entry = this.map.get(token);
+      if (!entry) {
+        entry = { lists: new Map(), count: 0, processed: 0 };
+        this.map.set(token, entry);
+      }
+      const list = entry.lists.get(key);
+      if (list) {
+        list.weight += weight;
+      } else {
+        entry.lists.set(key, { tokens, weight });
+      }
+      entry.count += weight;
     }
   }
-  return tokens;
-};
 
-function TokenChain() {
-}
+  /** @param {Map<string, number>} [localeRanks] */
+  createSorter(localeRanks) {
+    const sorter = new Sorter();
 
-TokenChain.prototype = {
-  add: function(tokens) {
-    var self = this;
-    tokens.forEach(function(token) {
-      var key = '$' + token;
-      if (!self[key]) {
-        self[key] = [];
-        self[key].processed = 0;
+    // Rank all tokens in locale order once, so nested chains break ties on numbers;
+    // tokens the collator deems equal share a rank and keep the stable sort’s order
+    if (!localeRanks) {
+      localeRanks = new Map();
+      const tokens = Array.from(this.map.keys()).sort(compareLocale);
+      let rank = 0;
+      for (let i = 0; i < tokens.length; i++) {
+        const token = /** @type {string} */ (tokens[i]);
+        if (i && compareLocale(/** @type {string} */ (tokens[i - 1]), token) !== 0) {
+          rank++;
+        }
+        localeRanks.set(token, rank);
       }
-      self[key].push(tokens);
+    }
+    const ranks = localeRanks;
+
+    // Sort tokens by usage frequency (descending), then alphabetically
+    const entries = Array.from(this.map.entries()).sort((a, b) => {
+      const countDiff = b[1].count - a[1].count;
+      if (countDiff !== 0) return countDiff;
+      return /** @type {number} */ (ranks.get(a[0])) - /** @type {number} */ (ranks.get(b[0]));
     });
-  },
-  createSorter: function() {
-    var self = this;
-    var sorter = new Sorter();
-    sorter.keys = Object.keys(self).sort(function(j, k) {
-      var m = self[j].length;
-      var n = self[k].length;
-      return m < n ? 1 : m > n ? -1 : j < k ? -1 : j > k ? 1 : 0;
-    }).filter(function(key) {
-      if (self[key].processed < self[key].length) {
-        var token = key.slice(1);
-        var chain = new TokenChain();
-        self[key].forEach(function(tokens) {
-          var index;
-          while ((index = tokens.indexOf(token)) !== -1) {
-            tokens.splice(index, 1);
+
+    for (const [token, data] of entries) {
+      if (data.processed < data.count) {
+        const lists = data.lists;
+        for (const { tokens, weight } of lists.values()) {
+          for (const t of tokens) {
+            if (t !== token) {
+              const tData = this.map.get(t);
+              if (tData) {
+                tData.processed += weight;
+              }
+            }
+          }
+        }
+
+        sorter.rank.set(token, sorter.rank.size);
+        sorter.sorterMap.set(token, () => {
+          const chain = new TokenChain();
+          for (const { tokens, weight } of lists.values()) {
+            const filtered = tokens.filter(t => t !== token);
+            if (filtered.length > 0) {
+              chain.add(filtered, weight);
+            }
           }
-          tokens.forEach(function(token) {
-            self['$' + token].processed++;
-          });
-          chain.add(tokens.slice(0));
+          return chain.createSorter(ranks);
         });
-        sorter[key] = chain.createSorter();
-        return true;
       }
-      return false;
-    });
+    }
+
     return sorter;
   }
-};
+}
 
-module.exports = TokenChain;
+export default TokenChain;

package/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2010-2018 Juriy "kangax" Zaytsev
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.

package/sample-cli-config-file.conf

@@ -1,39 +0,0 @@
-{
-  "caseSensitive": false,
-  "collapseBooleanAttributes": true,
-  "collapseInlineTagWhitespace": false,
-  "collapseWhitespace": true,
-  "conservativeCollapse": false,
-  "customAttrCollapse": ".*",
-  "decodeEntities": true,
-  "html5": true,
-  "ignoreCustomFragments": [
-    "<#[\\s\\S]*?#>",
-    "<%[\\s\\S]*?%>",
-    "<\\?[\\s\\S]*?\\?>"
-  ],
-  "includeAutoGeneratedTags": false,
-  "keepClosingSlash": false,
-  "maxLineLength": 0,
-  "minifyCSS": true,
-  "minifyJS": true,
-  "preserveLineBreaks": false,
-  "preventAttributesEscaping": false,
-  "processConditionalComments": true,
-  "processScripts": [
-    "text/html"
-  ],
-  "removeAttributeQuotes": true,
-  "removeComments": true,
-  "removeEmptyAttributes": true,
-  "removeEmptyElements": true,
-  "removeOptionalTags": true,
-  "removeRedundantAttributes": true,
-  "removeScriptTypeAttributes": true,
-  "removeStyleLinkTypeAttributes": true,
-  "removeTagWhitespace": true,
-  "sortAttributes": true,
-  "sortClassName": true,
-  "trimCustomFragments": true,
-  "useShortDoctype": true
-}

package/src/utils.js

@@ -1,18 +0,0 @@
-'use strict';
-
-function createMap(values, ignoreCase) {
-  var map = {};
-  values.forEach(function(value) {
-    map[value] = 1;
-  });
-  return ignoreCase ? function(value) {
-    return map[value.toLowerCase()] === 1;
-  } : function(value) {
-    return map[value] === 1;
-  };
-}
-
-exports.createMap = createMap;
-exports.createMapFromString = function(values, ignoreCase) {
-  return createMap(values.split(/,/), ignoreCase);
-};