html-minifier-next 7.5.3 → 8.0.0

package/src/htmlminifier.js

@@ -2,11 +2,13 @@ import { HTMLParser, endTag } from './htmlparser.js';
 import TokenChain from './tokenchain.js';
 import { presets, getPreset, getPresetNames } from './presets.js';
 
-import { LRU, identity, isThenable, lowercase, uniqueId } from './lib/utils.js';
+import { LRU, findTagEnd, identity, isThenable, lowercase, uniqueId } from './lib/utils.js';
+import { collectUsedSymbols } from './lib/unused-css.js';
 
 import {
   RE_LEGACY_ENTITIES,
   RE_ESCAPE_LT,
+  RE_STYLE_ELEMENT,
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
   specialContentElements,
@@ -53,6 +55,7 @@ import {
 } from './lib/content.js';
 
 import { processOptions } from './lib/options.js';
+import { toFragment, replaceCustomFragments } from './lib/fragments.js';
 
 /** @import { ProcessedOptions } from './lib/options.js' */
 
@@ -61,7 +64,7 @@ import { processOptions } from './lib/options.js';
 /**
  * @typedef {Object} HTMLAttribute
  *  Representation of an attribute from the HTML parser.
- *  Internal counterpart: `HTMLAttribute` in `lib/attributes.js`—keep in sync.
+ *  Internal counterpart: `HTMLAttribute` in lib/attributes.js—keep in sync.
  *
  * @prop {string} name
  * @prop {string} [value]
@@ -194,11 +197,13 @@ import { processOptions } from './lib/options.js';
  *
  *  Default: `[/^on[a-z]{3,}$/]`
  *
- * @prop {number} [customFragmentQuantifierLimit]
- *  Limits the quantifier used when building a safe regex for custom
- *  fragments to avoid ReDoS. See source use for details.
+ * @prop {boolean} [strictCustomFragments]
+ *  Rejects `ignoreCustomFragments` patterns that risk catastrophic backtracking,
+ *  rather than warning about them: those that compound quantifiers or alternation
+ *  (`(a+)+`, `(a|b)*`), those that repeat the same unbounded atom twice in a row
+ *  (`.*.*`), and those too long or too deeply nested to analyze at all.
  *
- *  Default: `200`
+ *  Default: `false`
  *
  * @prop {boolean} [decodeEntities]
  *  When true, decodes HTML entities in text and attributes before
@@ -437,6 +442,20 @@ import { processOptions } from './lib/options.js';
  *
  *  Default: `false`
  *
+ * @prop {boolean | {safelist?: Array<string | RegExp>, scripts?: boolean}} [removeUnusedCSS]
+ *  **Note that this can change how a document renders!**
+ *
+ *  Remove rules from `style` elements whose class or ID selectors the document
+ *  never references. Requires `minifyCSS` (removal runs through Lightning CSS)
+ *  and has no effect on `style` or `media` attributes.
+ *
+ *  Class names and IDs are collected from the markup, from `data-*` attributes,
+ *  and—unless `scripts` is set to `false`—from inline `script` elements. Names
+ *  that only ever appear in external scripts cannot be detected; list those
+ *  under `safelist` (strings or regular expressions) to keep them.
+ *
+ *  Default: `false`
+ *
  * @prop {boolean | ((tag: string, attrs: HTMLAttribute[]) => void)} [sortAttributes]
  *  When true, enables sorting of attributes. If a function is provided it
  *  will be used as a custom attribute sorter, which should mutate `attrs`
@@ -570,28 +589,6 @@ const RE_FOREIGN_ELEMENT_PROBE = /<(?:svg|math)[\s/>]/i;
 
 // Script merging
 
-/**
- * Find the index of the `>` that closes an opening tag, correctly skipping
- * over quoted attribute values (which may contain `>`).
- * @param {string} html
- * @param {number} pos - Start position (just after the tag name)
- * @returns {number} Index of the closing `>`, or -1 if not found
- */
-function findTagEnd(html, pos) {
-  let i = pos;
-  while (i < html.length) {
-    const ch = html[i];
-    if (ch === '>') return i;
-    if (ch === '"' || ch === "'") {
-      const q = ch;
-      i++;
-      while (i < html.length && html[i] !== q) i++;
-    }
-    i++;
-  }
-  return -1;
-}
-
 /**
  * Merge consecutive inline script tags into one (`mergeConsecutiveScripts`).
  * Only merges scripts that are compatible:
@@ -832,13 +829,12 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   const originalContinueOnParseError = options.continueOnParseError;
   options.continueOnParseError = true;
 
-  // Pre-compile regex patterns for UID replacement and custom fragments
+  // Pre-compile the UID replacement pattern, and read the fragments the way the
+  // main path does, so each keeps its own flags
   const uidReplacePattern = uidIgnore && ignoredMarkupChunks
     ? new RegExp('<!--' + uidIgnore + '(\\d+)-->', 'g')
     : null;
-  const customFragmentPattern = options.ignoreCustomFragments && options.ignoreCustomFragments.length > 0
-    ? new RegExp('(' + options.ignoreCustomFragments.map(re => re.source).join('|') + ')', 'g')
-    : null;
+  const customFragments = (options.ignoreCustomFragments || []).map(toFragment);
 
   try {
     // Expand UID tokens back to the original content for frequency analysis
@@ -858,8 +854,8 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     // because HTML comments in opening tags prevent proper attribute parsing;
     // removed with a space to preserve attribute boundaries
     let scanValue = firstPassOutput;
-    if (customFragmentPattern) {
-      scanValue = firstPassOutput.replace(customFragmentPattern, ' ');
+    if (customFragments.length) {
+      scanValue = replaceCustomFragments(firstPassOutput, customFragments, () => ' ');
     }
 
     await scan(scanValue);
@@ -1063,63 +1059,46 @@ async function minifyHTML(value, options, partialMarkup) {
     await createSortFns(value, options, uidIgnore ?? '', uidAttr ?? '', ignoredMarkupChunks);
   }
 
-  const customFragments = (options.ignoreCustomFragments || []).map(function (/** @type {RegExp} */ re) {
-    return re.source;
-  });
+  const customFragments = (options.ignoreCustomFragments || []).map(toFragment);
   if (customFragments.length) {
-    // Safe approach: Use bounded quantifiers instead of unlimited ones to prevent ReDoS
-    const maxQuantifier = options.customFragmentQuantifierLimit || 200;
-    const whitespacePattern = `\\s{0,${maxQuantifier}}`;
-
-    // Fast path: The padded replace below is costly on large inputs because the
-    // `\s{0,N}` padding makes the regex engine consume and backtrack at every
-    // whitespace run; since the padding is optional and the fragment group requires
-    // at least one match, a single unpadded probe that finds nothing proves the
-    // replace would be a no-op—so skip it entirely
-    const reFragmentProbe = new RegExp('(?:' + customFragments.join('|') + ')');
-    if (reFragmentProbe.test(value)) {
-      // Use bounded quantifiers to prevent ReDoS—this approach prevents exponential backtracking
-      const reCustomIgnore = new RegExp(
-        whitespacePattern + '(?:' + customFragments.join('|') + '){1,' + maxQuantifier + '}' + whitespacePattern,
-        'g'
-      );
-      // Temporarily replace custom ignored fragments with unique attributes
-      value = value.replace(reCustomIgnore, function (match) {
-        if (!uidAttr) {
-          uidAttr = uniqueId(value);
-          uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)' + uidAttr + '(\\s*)', 'g');
-          uidAttrLeadingPattern = new RegExp('^\\s*' + uidAttr + '(\\d+)' + uidAttr);
-
-          if (options.minifyCSS !== identity) {
-            options.minifyCSS = (function (/** @type {ProcessedOptions['minifyCSS']} */ fn) {
-              return function (/** @type {string} */ text, /** @type {string | undefined} */ type) {
-                text = text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
-                  const chunks = ignoredCustomMarkupChunks[+index];
-                  return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
-                });
-
-                return fn(text, type);
-              };
-            })(options.minifyCSS);
-          }
+    // Temporarily replace custom ignored fragments with unique attributes
+    const replaceFragment = function (/** @type {string} */ match) {
+      if (!uidAttr) {
+        uidAttr = uniqueId(value);
+        uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)' + uidAttr + '(\\s*)', 'g');
+        uidAttrLeadingPattern = new RegExp('^\\s*' + uidAttr + '(\\d+)' + uidAttr);
+
+        if (options.minifyCSS !== identity) {
+          options.minifyCSS = (function (/** @type {ProcessedOptions['minifyCSS']} */ fn) {
+            return function (/** @type {string} */ text, /** @type {string | undefined} */ type, /** @type {ProcessedOptions['cssContext']} */ context) {
+              text = text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
+                const chunks = ignoredCustomMarkupChunks[+index];
+                return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
+              });
 
-          if (options.minifyJS !== identity) {
-            options.minifyJS = (function (/** @type {ProcessedOptions['minifyJS']} */ fn) {
-              return function (/** @type {string} */ text, /** @type {boolean | undefined} */ inline, /** @type {boolean | undefined} */ isModule) {
-                return fn(text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
-                  const chunks = ignoredCustomMarkupChunks[+index];
-                  return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
-                }), inline, isModule);
-              };
-            })(options.minifyJS);
-          }
+              return fn(text, type, context);
+            };
+          })(options.minifyCSS);
         }
 
-        const token = uidAttr + ignoredCustomMarkupChunks.length + uidAttr;
-        ignoredCustomMarkupChunks.push(/^(\s*)[\s\S]*?(\s*)$/.exec(match));
-        return '\t' + token + '\t';
-      });
-    }
+        if (options.minifyJS !== identity) {
+          options.minifyJS = (function (/** @type {ProcessedOptions['minifyJS']} */ fn) {
+            return function (/** @type {string} */ text, /** @type {boolean | undefined} */ inline, /** @type {boolean | undefined} */ isModule) {
+              return fn(text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
+                const chunks = ignoredCustomMarkupChunks[+index];
+                return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
+              }), inline, isModule);
+            };
+          })(options.minifyJS);
+        }
+      }
+
+      const token = uidAttr + ignoredCustomMarkupChunks.length + uidAttr;
+      ignoredCustomMarkupChunks.push(/^(\s*)[\s\S]*?(\s*)$/.exec(match));
+      return '\t' + token + '\t';
+    };
+
+    value = replaceCustomFragments(value, customFragments, replaceFragment);
   }
 
   function canCollapseWhitespace(/** @type {string} */ tag, /** @type {HTMLAttribute[]} */ attrs) {
@@ -1758,7 +1737,7 @@ async function minifyHTML(value, options, partialMarkup) {
           text = await options.minifyJS(text, false, isModuleScript);
         }
         if (needsMinifyCSS) {
-          text = await options.minifyCSS(text);
+          text = await options.minifyCSS(text, undefined, options.cssContext);
         }
         charsFinalize(text);
       })();
@@ -2094,6 +2073,25 @@ export const minify = async function (value, options) {
   }
   // Work on a shallow copy so per-call reassignments don’t reach the cached base
   const processedOptions = /** @type {ProcessedOptions} */ ({ ...processedBase });
+
+  // Warnings are deduplicated per document, so the state has to live on the per-call
+  // copy; the `minifyCSS` closure hangs off the memoized base, shared across calls
+  processedOptions.cssContext = { warned: new Set() };
+
+  // Unused-CSS removal needs the whole document’s symbols before the first `style`
+  // element is minified, so collect them upfront from the raw input. A document
+  // without a style sheet has nothing to remove from, and scanning it would be work
+  // spent on an empty result.
+  if (processedOptions.removeUnusedCSS && RE_STYLE_ELEMENT.test(value)) {
+    processedOptions.cssContext.usedSymbols = collectUsedSymbols(
+      value,
+      processedOptions.removeUnusedCSS.scripts,
+      value.indexOf('&') !== -1
+        ? /** @type {(text: string) => string} */ (await getDecodeHTML())
+        : undefined
+    );
+  }
+
   let result = await minifyHTML(value, processedOptions);
 
   // Post-processing: Merge consecutive inline scripts if enabled

package/src/htmlparser.js

@@ -5,7 +5,7 @@
  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  */
 
-import { isThenable } from './lib/utils.js';
+import { isThenable, embedSource } from './lib/utils.js';
 
 /** @import { HTMLAttribute } from './lib/attributes.js' */
 
@@ -141,9 +141,9 @@ function buildAttrRegex(handler) {
         throw new Error('`customAttrSurround` entries must be `[RegExp, RegExp]` pairs');
       }
       attrClauses[i] = '(?:' +
-        '(' + pair[0].source + ')\\s*' +
+        '(' + embedSource(pair[0]) + ')\\s*' +
         pattern +
-        '\\s*(' + pair[1].source + ')' +
+        '\\s*(' + embedSource(pair[1]) + ')' +
         ')';
     }
     attrClauses.push('(?:' + pattern + ')');
@@ -180,7 +180,7 @@ function joinSingleAttrAssigns(handler) {
   return singleAttrAssigns.concat(
     handler.customAttrAssign || []
   ).map(function (assign) {
-    return '(?:' + assign.source + ')';
+    return '(?:' + embedSource(assign) + ')';
   }).join('|');
 }
 

package/src/lib/attributes.js

@@ -13,10 +13,12 @@ import {
   isBooleanValue,
   collapsibleValues,
   srcsetElements,
-  reEmptyAttribute
+  RE_EMPTY_ATTRIBUTE,
+  RE_STYLE_ELEMENT
 } from './constants.js';
 import { trimWhitespace, collapseWhitespaceAll } from './whitespace.js';
 import { shouldMinifyInnerHTML } from './options.js';
+import { collectUsedSymbols } from './unused-css.js';
 import { identity, isThenable } from './utils.js';
 
 /** @import { ProcessedOptions } from './options.js' */
@@ -25,10 +27,11 @@ import { identity, isThenable } from './utils.js';
 
 /**
  * @typedef {{ name: string, value?: string | undefined, quote?: string, customAssign?: string, customOpen?: string, customClose?: string }} HTMLAttribute
- *  Internal counterpart of the public typedef in `htmlminifier.js`—keep in sync.
+ *  Internal counterpart of the public typedef in htmlminifier.js—keep in sync.
  */
 
-// Lazy-load entities (used for `decodeEntities` and event-handler attribute decode before `minifyJS`)
+// Lazy-load entities (used for `decodeEntities`, event-handler attribute
+// decoding before `minifyJS`, and `srcdoc` decoding/re-encoding)
 
 /** @type {Promise<Function> | undefined} */
 let decodeHTMLStrictPromise;
@@ -39,6 +42,15 @@ async function getDecodeHTMLStrict() {
   return decodeHTMLStrictPromise;
 }
 
+/** @type {Promise<Function> | undefined} */
+let escapeAttributePromise;
+async function getEscapeAttribute() {
+  if (!escapeAttributePromise) {
+    escapeAttributePromise = import('entities').then(m => m.escapeAttribute);
+  }
+  return escapeAttributePromise;
+}
+
 // Validators
 
 /**
@@ -353,7 +365,7 @@ function canDeleteEmptyAttribute(tag, attrName, attrValue, options) {
   if (typeof options.removeEmptyAttributes === 'function') {
     return options.removeEmptyAttributes(attrName, tag);
   }
-  return (tag === 'input' && attrName === 'value') || reEmptyAttribute.test(attrName);
+  return (tag === 'input' && attrName === 'value') || RE_EMPTY_ATTRIBUTE.test(attrName);
 }
 
 /**
@@ -470,7 +482,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
         attrValue = attrValue.replace(/\s*;$/, ';');
       }
       const originalAttrValue = attrValue;
-      const cssResult = options.minifyCSS(attrValue, 'inline');
+      const cssResult = options.minifyCSS(attrValue, 'inline', options.cssContext);
       if (isThenable(cssResult)) {
         return cssResult
           .then((/** @type {string} */ minified) => {
@@ -581,7 +593,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
       return attrValue;
     }
     const originalAttrValue = attrValue;
-    const cssResult = options.minifyCSS(attrValue, 'media');
+    const cssResult = options.minifyCSS(attrValue, 'media', options.cssContext);
     if (isThenable(cssResult)) {
       return cssResult.catch((/** @type {Error} */ err) => {
         if (!options.continueOnMinifyError) throw err;
@@ -593,17 +605,62 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
   }
 
   if (tag === 'iframe' && attrName === 'srcdoc') {
-    // Recursively minify HTML content within `srcdoc` attribute
     // Fast-path: Skip if nothing would change
     if (!shouldMinifyInnerHTML(options)) {
       return attrValue;
     }
-    return minifyHTMLSelf(attrValue, options, true);
+    return minifySrcdoc(attrValue, options, minifyHTMLSelf);
   }
 
   return attrValue;
 }
 
+/**
+ * Recursively minify the document an `iframe srcdoc` attribute holds.
+ *
+ * Browsers resolve character references before parsing `srcdoc`, so an
+ * entity-encoded document is decoded first (unless `decodeEntities` already
+ * did) and re-encoded afterwards—but only then, so a literal value passes
+ * through byte-identical.
+ *
+ * @param {string} attrValue
+ * @param {ProcessedOptions} options
+ * @param {Function} minifyHTMLSelf
+ * @returns {Promise<string>}
+ */
+async function minifySrcdoc(attrValue, options, minifyHTMLSelf) {
+  let markup = attrValue;
+  let wasEncoded = false;
+  if (!options.decodeEntities && attrValue.indexOf('&') !== -1) {
+    const decode = await getDecodeHTMLStrict();
+    markup = decode(attrValue);
+    wasEncoded = markup !== attrValue;
+  }
+
+  let srcdocOptions = options;
+  // The inner document sees none of the parent’s markup, so its style sheets
+  // minify against the symbols the `srcdoc` content references itself
+  if (options.removeUnusedCSS && RE_STYLE_ELEMENT.test(markup)) {
+    const decode = markup.indexOf('&') !== -1 ? await getDecodeHTMLStrict() : undefined;
+    srcdocOptions = {
+      ...options,
+      cssContext: {
+        warned: options.cssContext ? options.cssContext.warned : new Set(),
+        usedSymbols: collectUsedSymbols(markup, options.removeUnusedCSS.scripts, /** @type {((text: string) => string) | undefined} */ (decode))
+      }
+    };
+  }
+
+  try {
+    const minified = await minifyHTMLSelf(markup, srcdocOptions, true);
+    return wasEncoded ? (await getEscapeAttribute())(minified) : minified;
+  } catch (err) {
+    if (!options.continueOnMinifyError) throw err;
+    options.log && options.log(/** @type {Error} */ (err));
+    return attrValue;
+  }
+}
+
 /**
  * Choose appropriate quote character for an attribute value
  * @param {string} attrValue - The attribute value

package/src/lib/constants.js

@@ -16,6 +16,10 @@ const RE_ESCAPE_LT = /</g;
 const RE_ATTR_WS_CHECK = /[ \n\r\t\f]/;
 const RE_ATTR_WS_COLLAPSE = /[ \n\r\t\f]+/g;
 const RE_ATTR_WS_TRIM = /^[ \n\r\t\f]+|[ \n\r\t\f]+$/g;
+const RE_STYLE_ELEMENT = /<style[\s/>]/i;
+const RE_EMPTY_ATTRIBUTE = new RegExp(
+  '^(?:class|id|style|title|lang|dir|on(?:focus|blur|change|click|dblclick|mouse(' +
+  '?:down|up|over|move|out)|key(?:press|down|up)))$');
 
 // Inline element sets for whitespace handling
 
@@ -162,12 +166,6 @@ const trailingElements = new Set(['dt', 'thead']);
 
 const htmlElements = new Set(['a', 'abbr', 'acronym', 'address', 'applet', 'area', 'article', 'aside', 'audio', 'b', 'base', 'basefont', 'bdi', 'bdo', 'bgsound', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'command', 'content', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'image', 'img', 'input', 'ins', 'isindex', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'listing', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'multicol', 'nav', 'nobr', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'plaintext', 'pre', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'script', 'search', 'section', 'select', 'selectedcontent', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr', 'xmp']);
 
-// Empty attribute regex
-
-const reEmptyAttribute = new RegExp(
-  '^(?:class|id|style|title|lang|dir|on(?:focus|blur|change|click|dblclick|mouse(' +
-  '?:down|up|over|move|out)|key(?:press|down|up)))$');
-
 // Special content elements
 
 const specialContentElements = new Set(['script', 'style']);
@@ -192,6 +190,9 @@ export {
   RE_ATTR_WS_CHECK,
   RE_ATTR_WS_COLLAPSE,
   RE_ATTR_WS_TRIM,
+  RE_STYLE_ELEMENT,
+  RE_EMPTY_ATTRIBUTE,
+
   // Inline element sets
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
@@ -234,7 +235,6 @@ export {
   trailingElements,
   htmlElements,
 
-  // Regex
-  reEmptyAttribute,
+  // Special content elements
   specialContentElements
 };

package/src/lib/elements.js

@@ -137,7 +137,7 @@ function canRemoveElement(tag, attrs) {
 }
 
 /**
- * @param {string} str - Tag name or HTML-like element spec (e.g., “td” or “<span aria-hidden='true'>”)
+ * @param {string} str - Tag name or HTML-like element spec (e.g., `td` or `<span aria-hidden='true'>`)
  * @param {ProcessedOptions} options - Options object for name normalization
  * @returns {{tag: string, attrs: Object.<string, string|undefined>|null}|null} Parsed spec or null if invalid
  */
@@ -203,12 +203,12 @@ function parseRemoveEmptyElementsExcept(input, options) {
     if (typeof item === 'string') {
       const spec = parseElementSpec(item, options);
       if (!spec && options.log) {
-        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: “' + item + '”');
+        options.log('Warning: Unable to parse `removeEmptyElementsExcept` specification: “' + item + '”');
       }
       return spec;
     }
     if (options.log) {
-      options.log('Warning: “removeEmptyElementsExcept” specification must be a string, received: ' + typeof item);
+      options.log('Warning: `removeEmptyElementsExcept` specification must be a string, received: ' + typeof item);
     }
     return null;
   }).filter(Boolean));