html-minifier 4.0.0 → 5.0.1

package/src/lib/file-write.js

@@ -0,0 +1,87 @@
+/**
+ * Output writing for the CLI, shared by in-process runs and the worker pool
+ */
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+// A random name is taken by chance only, so a few attempts are plenty
+const ATTEMPTS_MAX = 10;
+// As many links as a system commonly follows before reporting a loop
+const LINKS_MAX = 40;
+
+/**
+ * The file a write replaces: the output itself or, for a symlink, the file it
+ * points to—followed by hand where that file does not exist yet, which
+ * `realpath` cannot resolve
+ * @param {string} outputFile
+ * @returns {Promise<string>}
+ */
+async function resolveTarget(outputFile) {
+  let file = outputFile;
+  for (let i = 0; i < LINKS_MAX; i++) {
+    try {
+      return await fs.promises.realpath(file);
+    } catch {
+      const link = await fs.promises.readlink(file).catch(() => undefined);
+      if (link === undefined) return file;
+      // A relative link is read from the real location of its folder
+      const dir = await fs.promises.realpath(path.dirname(file)).catch(() => path.dirname(file));
+      file = path.resolve(dir, link);
+    }
+  }
+  // A loop, which writing through wouldn’t resolve either—refused, so the rename can’t replace it
+  throw Object.assign(new Error(`ELOOP: Too many symbolic links encountered, '${outputFile}'`), { code: 'ELOOP', path: outputFile });
+}
+
+/**
+ * Create a temporary file next to the target under a random name, exclusively,
+ * so that it can neither be predicted nor write through a file or link already there
+ * @param {string} targetFile
+ * @param {number | undefined} mode
+ */
+async function openTempFile(targetFile, mode) {
+  for (let attempt = 1; ; attempt++) {
+    const tempFile = path.join(path.dirname(targetFile), `.${path.basename(targetFile)}.${crypto.randomBytes(8).toString('hex')}.tmp`);
+    try {
+      return { tempFile, handle: await fs.promises.open(tempFile, 'wx', mode) };
+    } catch (err) {
+      if (/** @type {any} */ (err).code !== 'EEXIST' || attempt >= ATTEMPTS_MAX) throw err;
+    }
+  }
+}
+
+/**
+ * Write a file by way of a temporary file in the same folder, so that an exit
+ * that leaves no chance to clean up—a native crash in a minifier, an OOM
+ * kill—cannot leave a half-written file where the output belongs
+ * @param {string} outputFile
+ * @param {string} data
+ */
+export async function writeFileAtomic(outputFile, data) {
+  // A rename would replace a symlink itself, so work on the file it points to
+  const targetFile = await resolveTarget(outputFile);
+  // The rename replaces the output rather than writing through it, so its mode is carried over
+  const stats = await fs.promises.stat(targetFile).catch(() => undefined);
+  const mode = stats ? stats.mode & 0o7777 : undefined;
+
+  // Outside the `try`, so that only a file this write created is ever removed
+  const { tempFile, handle } = await openTempFile(targetFile, mode);
+
+  try {
+    try {
+      await handle.writeFile(data, 'utf8');
+    } finally {
+      await handle.close();
+    }
+    // `mode` on creation is subject to the umask, so the exact bits have to be set separately
+    if (mode !== undefined) {
+      await fs.promises.chmod(tempFile, mode);
+    }
+    await fs.promises.rename(tempFile, targetFile);
+  } catch (err) {
+    await fs.promises.rm(tempFile, { force: true });
+    throw err;
+  }
+}

package/src/lib/fragments.js

@@ -0,0 +1,340 @@
+/**
+ * Custom fragment matching
+ *
+ * `ignoreCustomFragments` patterns nearly always describe the same shape: a literal
+ * opening delimiter, an any-character or negated-class body, and a literal closing
+ * delimiter, as in `<%[\s\S]*?%>` or `\{\{[^}]*?\}\}`. Such a fragment can be found
+ * with `indexOf` in linear time, where running the pattern as a regex costs O(n²)
+ * on input that opens fragments it never closes—and can cost far more than that when
+ * the pattern itself backtracks. Patterns of other shapes keep running as regexes,
+ * one per pattern, so each keeps its own flags.
+ */
+
+const RE_WHITESPACE = /\s/;
+
+// Any-character and negated-class bodies; without the `s` flag, `.` is itself a
+// negated class, excluding line terminators
+const RE_DELIMITED = /^(.*?)(?:\[\\s\\S\]|\[\\S\\s\]|\[\^\]|(\.)|\[\^((?:\\[^]|[^\]\\])+)\])(?:([*+])|\{(\d+)(?:,(\d*))?\})\?(.*)$/;
+
+// Flags that leave literal matching alone, so a pattern carrying them can still be
+// scanned for; `i` in particular cannot, since case folding moves character indexes
+const RE_LITERAL_FLAGS = /^[gds]*$/;
+
+/**
+ * @typedef {{open: string, close: string, min: number, max: number, excluded: RegExp | null}} DelimitedFragment
+ *  Literal delimiters around a body, found by scanning; `excluded` holds the
+ *  characters a negated-class body cannot cross, null when the body spans every
+ *  character
+ * @typedef {{search: RegExp, anchored: RegExp, close: string | null}} PatternFragment
+ *  Everything else, found by running the pattern itself; `close` holds the literal
+ *  every match ends with, where one follows an unbounded any-character body
+ */
+
+/**
+ * Read a regex source as a literal string, so it can be matched with `indexOf`
+ * @param {string} source
+ * @returns {string | null} Null when the source is more than literal characters
+ */
+function toLiteral(source) {
+  let literal = '';
+
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i] ?? '';
+    if (char === '\\') {
+      const escaped = source[++i];
+      // A trailing backslash is half an escape the body token was split out of,
+      // as in `<%\.*?%>`, where the `.` is literal and not a body
+      if (escaped === undefined) return null;
+      // `\n` and friends are literal characters, `\s` and `\1` are not
+      if (escaped === 'n') literal += '\n';
+      else if (escaped === 't') literal += '\t';
+      else if (escaped === 'r') literal += '\r';
+      else if (escaped === 'f') literal += '\f';
+      else if (escaped === 'v') literal += '\v';
+      else if (/[A-Za-z0-9]/.test(escaped)) return null;
+      else literal += escaped;
+    } else if ('.*+?()[]{}|^$'.includes(char)) {
+      return null;
+    } else {
+      literal += char;
+    }
+  }
+
+  return literal;
+}
+
+/**
+ * Describe a fragment pattern as literal delimiters around an any-character body
+ * @param {RegExp} pattern
+ * @returns {DelimitedFragment | null} Null when the pattern has another shape, which
+ *  the caller answers by running it as a regex
+ */
+function toDelimitedFragment(pattern) {
+  if (!RE_LITERAL_FLAGS.test(pattern.flags)) return null;
+
+  const match = RE_DELIMITED.exec(pattern.source);
+  if (!match) return null;
+
+  const [, rawOpen, dot, negated, simple, exact, upper, rawClose] = match;
+  const open = toLiteral(rawOpen ?? '');
+  const close = toLiteral(rawClose ?? '');
+  // Both delimiters have to be there: without them a match has no boundary to scan to
+  if (!open || !close) return null;
+
+  // The class content doubles as the search for characters the body cannot cross;
+  // a `.` body spans every character under the `s` flag, and excludes line
+  // terminators without it
+  const inner = dot ? (pattern.flags.includes('s') ? null : '\\n\\r\\u2028\\u2029') : negated ?? null;
+
+  const min = simple ? (simple === '+' ? 1 : 0) : Number(exact);
+  const max = simple || upper === '' ? Infinity : Number(upper ?? exact);
+
+  return { open, close, min, max, excluded: inner === null ? null : new RegExp('[' + inner + ']', 'g') };
+}
+
+/**
+ * Whether a regex source has a `|` outside groups and classes, which lets a match skip the rest
+ * @param {string} source
+ * @returns {boolean}
+ */
+function hasTopLevelAlternation(source) {
+  let depth = 0;
+  let inClass = false;
+
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i];
+    if (char === '\\') i++;
+    else if (inClass) inClass = char !== ']';
+    else if (char === '[') inClass = true;
+    else if (char === '(') depth++;
+    else if (char === ')') depth--;
+    else if (char === '|' && depth === 0) return true;
+  }
+
+  return false;
+}
+
+/**
+ * The literal all matches of a pattern end with, where an unbounded any-character body leads
+ * up to it: Without that literal ahead, each opener runs the body to the end of the input
+ * only to fail, which costs O(n²) on input that opens fragments it never closes
+ * @param {RegExp} pattern
+ * @returns {string | null}
+ */
+function toClosingLiteral(pattern) {
+  const match = RE_DELIMITED.exec(pattern.source);
+  if (!match) return null;
+
+  const [, rawOpen, dot, negated, simple, , , rawClose] = match;
+  if (!simple || negated !== undefined || (dot && !pattern.flags.includes('s'))) return null;
+  if (hasTopLevelAlternation(rawOpen ?? '')) return null;
+
+  const close = toLiteral(rawClose ?? '');
+  // `indexOf` can stand in for the pattern only where case folding leaves the literal alone
+  if (!close || (pattern.flags.includes('i') && close.toLowerCase() !== close.toUpperCase())) return null;
+
+  return close;
+}
+
+/**
+ * Prepare a fragment pattern for matching, by scanning where the shape allows it
+ * @param {RegExp} pattern
+ * @returns {DelimitedFragment | PatternFragment}
+ */
+function toFragment(pattern) {
+  const delimited = toDelimitedFragment(pattern);
+  if (delimited) return delimited;
+
+  // `g` and `y` are ours to set, the rest belong to the pattern
+  const flags = pattern.flags.replace(/[gy]/g, '');
+  return {
+    search: new RegExp(pattern.source, flags + 'g'),
+    anchored: new RegExp(pattern.source, flags + 'y'),
+    close: toClosingLiteral(pattern)
+  };
+}
+
+/**
+ * Replace runs of custom fragments, and the whitespace padding them
+ * @param {string} value - Document to scan
+ * @param {(DelimitedFragment | PatternFragment)[]} fragments - In the order the patterns
+ *  were given, since the earliest match wins and ties go to the pattern listed first
+ * @param {(match: string) => string} replacer - Called with each match, as `replace` would
+ * @returns {string}
+ */
+function replaceCustomFragments(value, fragments, replacer) {
+  // Where each fragment's next match may start, its next closing delimiter may be
+  // found, and its next excluded character sits; all only ever move forward, which
+  // is what keeps the whole scan linear
+  const found = fragments.map(() => /** @type {{start: number, end: number} | null} */ (null));
+  const closesAt = fragments.map(() => -1);
+  const excludedAt = fragments.map(() => -1);
+  const exhausted = fragments.map(() => false);
+
+  /**
+   * Whether a body region holds a character its class excludes
+   * @param {DelimitedFragment} fragment
+   * @param {number} index - Which fragment, for the forward-only bookkeeping
+   * @param {number} bodyStart
+   * @param {number} close
+   * @returns {boolean}
+   */
+  const bodyBlocked = (fragment, index, bodyStart, close) => {
+    if (!fragment.excluded) return false;
+    if (/** @type {number} */ (excludedAt[index]) < bodyStart) {
+      fragment.excluded.lastIndex = bodyStart;
+      const blocked = fragment.excluded.exec(value);
+      excludedAt[index] = blocked ? blocked.index : Infinity;
+    }
+    return /** @type {number} */ (excludedAt[index]) < close;
+  };
+
+  /**
+   * Earliest match of one delimited fragment at or after `from`
+   * @param {DelimitedFragment} fragment
+   * @param {number} index - Which fragment, for the forward-only bookkeeping
+   * @param {number} from
+   * @param {boolean} anchored - Whether the match has to start exactly at `from`
+   * @returns {{start: number, end: number} | null}
+   */
+  const scan = (fragment, index, from, anchored) => {
+    // The closing delimiter first: An opener starting with `<` is slow to find in markup
+    if (/** @type {number} */ (closesAt[index]) < from) {
+      closesAt[index] = value.indexOf(fragment.close, from);
+      if (closesAt[index] === -1) {
+        exhausted[index] = true;
+        return null;
+      }
+    }
+
+    let openFrom = from;
+
+    for (;;) {
+      const open = anchored
+        ? (value.startsWith(fragment.open, from) ? from : -1)
+        : value.indexOf(fragment.open, openFrom);
+      if (open === -1) {
+        if (!anchored) exhausted[index] = true;
+        return null;
+      }
+
+      const bodyStart = open + fragment.open.length;
+      if (/** @type {number} */ (closesAt[index]) < bodyStart + fragment.min) {
+        closesAt[index] = value.indexOf(fragment.close, bodyStart + fragment.min);
+      }
+      const close = /** @type {number} */ (closesAt[index]);
+      if (close === -1) {
+        exhausted[index] = true;
+        return null;
+      }
+
+      if (close - bodyStart <= fragment.max && !bodyBlocked(fragment, index, bodyStart, close)) {
+        return { start: open, end: close + fragment.close.length };
+      }
+      // The body is longer than the pattern allows, or holds a character its class
+      // excludes, so the match has to start later
+      if (anchored) return null;
+      openFrom = open + 1;
+    }
+  };
+
+  /**
+   * Earliest match of one regex fragment at or after `from`
+   * @param {PatternFragment} fragment
+   * @param {number} index - Which fragment, for the forward-only bookkeeping
+   * @param {number} from
+   * @param {boolean} anchored
+   * @returns {{start: number, end: number} | null}
+   */
+  const run = (fragment, index, from, anchored) => {
+    if (fragment.close !== null) {
+      // `Infinity` marks a closing literal that is nowhere ahead, so the search is not repeated
+      if (/** @type {number} */ (closesAt[index]) < from) {
+        const close = value.indexOf(fragment.close, from);
+        closesAt[index] = close === -1 ? Infinity : close;
+      }
+      if (closesAt[index] === Infinity) return null;
+    }
+
+    const pattern = anchored ? fragment.anchored : fragment.search;
+    pattern.lastIndex = from;
+
+    for (;;) {
+      const match = pattern.exec(value);
+      if (!match) return null;
+      // A pattern that matches nothing would leave the run in place forever
+      if (match[0].length > 0) return { start: match.index, end: match.index + match[0].length };
+      if (anchored) return null;
+      pattern.lastIndex = match.index + 1;
+    }
+  };
+
+  /**
+   * @param {number} from
+   * @param {boolean} anchored
+   * @returns {{start: number, end: number} | null}
+   */
+  const find = (from, anchored) => {
+    /** @type {{start: number, end: number} | null} */
+    let earliest = null;
+
+    for (let i = 0; i < fragments.length; i++) {
+      if (exhausted[i]) continue;
+      const fragment = /** @type {DelimitedFragment | PatternFragment} */ (fragments[i]);
+
+      /** @type {{start: number, end: number} | null} */
+      let match;
+      if (anchored) {
+        match = 'open' in fragment ? scan(fragment, i, from, true) : run(fragment, i, from, true);
+      } else {
+        // Matches only ever move forward, so the last one found still stands
+        const previous = found[i];
+        match = previous && previous.start >= from
+          ? previous
+          : ('open' in fragment ? scan(fragment, i, from, false) : run(fragment, i, from, false));
+        found[i] = match;
+        // Nothing ahead now means nothing ahead later, either
+        if (!match) exhausted[i] = true;
+      }
+
+      // Ties go to the fragment listed first, the way alternation would resolve them
+      if (match && (!earliest || match.start < earliest.start)) earliest = match;
+    }
+
+    return earliest;
+  };
+
+  let out = '';
+  let copied = 0;
+  let search = 0;
+
+  while (search <= value.length) {
+    const first = find(search, false);
+    if (!first) break;
+
+    // Fragments running straight into each other are one match
+    let end = first.end;
+    for (;;) {
+      const next = find(end, true);
+      if (!next) break;
+      end = next.end;
+    }
+
+    // …as is the whitespace on either side, back to where the last match left off
+    let start = first.start;
+    while (start > copied && RE_WHITESPACE.test(value[start - 1] ?? '')) start--;
+    while (end < value.length && RE_WHITESPACE.test(value[end] ?? '')) end++;
+
+    out += value.slice(copied, start) + replacer(value.slice(start, end));
+    copied = end;
+    search = end;
+  }
+
+  return copied === 0 ? value : out + value.slice(copied);
+}
+
+export {
+  toDelimitedFragment,
+  toFragment,
+  replaceCustomFragments
+};

package/src/lib/option-definitions.js

@@ -0,0 +1,246 @@
+/**
+ * Single source of truth for minifier option names, descriptions, types, and shared defaults
+ */
+
+/**
+ * @typedef {object} OptionDefinition
+ * @property {string} description Help text, phrased for the option’s primary CLI form
+ * @property {string} [descriptionAffirmative] Help text for what enabling the option does, where `description` describes the negated form
+ * @property {string} type Key into the parser and JSON Schema type maps in cli.js and scripts/build-schema.js
+ */
+
+/** @type {Record<string, OptionDefinition>} */
+const optionDefinitions = {
+  cacheCSS: {
+    description: 'Set CSS minification cache size (number of entries, default: 500)',
+    type: 'int'
+  },
+  cacheJS: {
+    description: 'Set JavaScript minification cache size (number of entries, default: 500)',
+    type: 'int'
+  },
+  cacheSVG: {
+    description: 'Set SVG minification cache size (number of entries, default: 500)',
+    type: 'int'
+  },
+  caseSensitive: {
+    description: 'Keep element and attribute names as written (e.g., for framework components like `<MyButton>`)',
+    type: 'boolean'
+  },
+  collapseAttributeWhitespace: {
+    description: 'Trim and collapse whitespace characters within attribute values',
+    type: 'boolean'
+  },
+  collapseBooleanAttributes: {
+    description: 'Omit attribute values from boolean attributes',
+    type: 'boolean'
+  },
+  collapseEmptyAttributes: {
+    description: 'Omit empty attribute values (e.g., `alt=""` → `alt`)',
+    type: 'boolean'
+  },
+  collapseInlineTagWhitespace: {
+    description: 'Collapse whitespace more aggressively between inline elements—use with `--collapse-whitespace`',
+    type: 'boolean'
+  },
+  collapseNoBreakSpaces: {
+    description: 'Remove whitespace next to no-break spaces, narrow no-break spaces, and figure spaces in text (e.g., `a &nbsp; b` → `a&nbsp;b`), keeping runs of them—use with `--collapse-whitespace`',
+    type: 'boolean'
+  },
+  collapseWhitespace: {
+    description: 'Collapse whitespace that contributes to text nodes in a document tree',
+    type: 'boolean'
+  },
+  conservativeCollapse: {
+    description: 'Always collapse to one space (never remove it entirely)—use with `--collapse-whitespace`',
+    type: 'boolean'
+  },
+  continueOnMinifyError: {
+    description: 'Abort on minification errors',
+    descriptionAffirmative: 'Continue on minification errors',
+    type: 'invertedBoolean'
+  },
+  continueOnParseError: {
+    description: 'Handle parse errors instead of aborting',
+    type: 'boolean'
+  },
+  customAttrAssign: {
+    description: 'Array of regexes that allow to support custom attribute assign expressions (e.g., `<div flex?="{{mode != cover}}"></div>`)',
+    type: 'regexpArray'
+  },
+  customAttrCollapse: {
+    description: 'Regex that specifies custom attribute to strip newlines from (e.g., `/ng-class/`)',
+    type: 'regexp'
+  },
+  customAttrSurround: {
+    description: 'Array of regexes that allow to support custom attribute surround expressions (e.g., `<input {{#if value}}checked="checked"{{/if}}>`)',
+    type: 'regexpArray'
+  },
+  customEventAttributes: {
+    description: 'Array of regexes that allow to support custom event attributes (e.g., `ng-click`)—use with `--minify-js`',
+    type: 'regexpArray'
+  },
+  decodeEntities: {
+    description: 'Use direct Unicode characters whenever possible',
+    type: 'boolean'
+  },
+  ignoreCustomComments: {
+    description: 'Array of regexes that allow to ignore matching comments',
+    type: 'regexpArray'
+  },
+  ignoreCustomFragments: {
+    description: 'Array of regexes that allow to ignore certain fragments, when matched (e.g., `<?php \u2026 ?>`, `{{ \u2026 }}`, etc.)',
+    type: 'regexpArray'
+  },
+  includeAutoGeneratedTags: {
+    description: 'Insert elements generated by HTML parser',
+    type: 'boolean'
+  },
+  inlineCustomElements: {
+    description: 'Array of names of custom elements which are inline, for whitespace handling—use with `--collapse-whitespace`',
+    type: 'jsonArray'
+  },
+  keepClosingSlash: {
+    description: 'Keep the trailing slash on void elements and other start tags that carry one, and read it as closing the element',
+    type: 'boolean'
+  },
+  maxInputLength: {
+    description: 'Maximum input length to prevent ReDoS attacks',
+    type: 'int'
+  },
+  maxLineLength: {
+    description: 'Specify a maximum line length; output will be split by newlines in tags only (between attributes or before a tag’s `>`), where they can’t change the page, so lines may run longer',
+    type: 'int'
+  },
+  mergeScripts: {
+    description: 'Merge consecutive inline `script` elements into one',
+    type: 'boolean'
+  },
+  minifyCSS: {
+    description: 'Minify CSS in `style` elements and attributes (uses Lightning CSS)',
+    type: 'jsonObject'
+  },
+  minifyJS: {
+    description: 'Minify JavaScript in `script` elements and event attributes (uses Terser or SWC; pass `{"engine": "swc"}` for SWC)',
+    type: 'jsonObject'
+  },
+  minifyJSON: {
+    description: 'Minify JSON in `script` elements (e.g., `application/ld+json`, `importmap`, etc.) by removing whitespace',
+    type: 'boolean'
+  },
+  minifySVG: {
+    description: 'Minify SVG elements (uses SVGO)',
+    type: 'jsonObject'
+  },
+  minifyURLs: {
+    description: 'Minify URLs in various attributes',
+    type: 'json'
+  },
+  noNewlinesBeforeTagClose: {
+    description: 'Never split a line in a tag that closes an element—use with `--max-line-length`',
+    type: 'boolean'
+  },
+  partialMarkup: {
+    description: 'Treat input as a partial HTML fragment, preserving stray end tags and unclosed tags',
+    type: 'boolean'
+  },
+  preserveLineBreaks: {
+    description: 'Always collapse to one line break (never remove it entirely) when whitespace between tags includes a line break—use with `--collapse-whitespace`',
+    type: 'boolean'
+  },
+  preventAttributesEscaping: {
+    description: 'Prevents the escaping of the values of attributes',
+    type: 'boolean'
+  },
+  processScripts: {
+    description: 'Array of strings corresponding to types of `script` elements to process through minifier (e.g., `text/ng-template`, `text/x-handlebars-template`, etc.)',
+    type: 'jsonArray'
+  },
+  quoteCharacter: {
+    description: 'Type of quote to use for attribute values (`\'` or `"`)',
+    type: 'string'
+  },
+  removeAttributeQuotes: {
+    description: 'Remove quotes around attributes when possible',
+    type: 'boolean'
+  },
+  removeComments: {
+    description: 'Strip HTML comments',
+    type: 'boolean'
+  },
+  removeDefaultTypeAttributes: {
+    description: 'Remove default `type` attributes from `style`/`link` (e.g., `type="text/css"`) and `script` (e.g., `type="text/javascript"`) elements; other `type` attribute values are left intact',
+    type: 'boolean'
+  },
+  removeEmptyAttributes: {
+    description: 'Remove all attributes with whitespace-only values',
+    type: 'boolean'
+  },
+  removeEmptyElements: {
+    description: 'Remove all elements with empty contents',
+    type: 'boolean'
+  },
+  removeEmptyElementsExcept: {
+    description: 'Array of elements to preserve (e.g., `td`, `<i class="test">`, etc.)—use with `--remove-empty-elements`',
+    type: 'jsonArray'
+  },
+  removeOptionalTags: {
+    description: 'Remove optional tags',
+    type: 'boolean'
+  },
+  removeRedundantAttributes: {
+    description: 'Remove attributes when value matches default or has no effect (as well as `rel` keywords and `meta` elements without effect)',
+    type: 'boolean'
+  },
+  removeTagWhitespace: {
+    description: 'Remove space between attributes whenever possible; note that this will result in invalid HTML',
+    type: 'boolean'
+  },
+  removeUnusedCSS: {
+    description: 'Remove CSS from `style` elements that name an element, class, or ID the document doesn’t reference—use with `--minify-css`, and `{"safelist": […]}` for names only external scripts use',
+    type: 'jsonObject'
+  },
+  selfCloseForeignElements: {
+    description: 'Self-close empty SVG and MathML elements (e.g., `<path d="…"></path>` → `<path d="…"/>`)',
+    type: 'boolean'
+  },
+  sortAttributes: {
+    description: 'Sort attributes by frequency',
+    type: 'boolean'
+  },
+  sortClassNames: {
+    description: 'Sort style classes by frequency',
+    type: 'boolean'
+  },
+  trimCustomFragments: {
+    description: 'Trim whitespace around custom fragments (`--ignore-custom-fragments`) where it does not affect the output—use with `--collapse-whitespace`',
+    type: 'boolean'
+  },
+  strictCustomFragments: {
+    description: 'Reject `ignoreCustomFragments` patterns that risk catastrophic backtracking (rather than warning about them)',
+    type: 'boolean'
+  },
+  useShortDoctype: {
+    description: 'Replaces the doctype with the short HTML doctype',
+    type: 'boolean'
+  }
+};
+
+const optionDefaults = {
+  continueOnMinifyError: true,
+  ignoreCustomComments: [
+    /^!/,
+    /^\s*#/
+  ],
+  ignoreCustomFragments: [
+    /<%[\s\S]*?%>/,
+    // Template code and XML declarations, not processing instructions HTML reads itself
+    /<\?(?:php[\t\n\r ]|=|\$|xml(?:-stylesheet)?(?![\w-])|\s)[\s\S]*?\?>/i
+  ],
+  includeAutoGeneratedTags: false
+};
+
+export {
+  optionDefinitions,
+  optionDefaults
+};