From 29fd94a24efe5c55b01d3ad525c0520328f99278 Mon Sep 17 00:00:00 2001
From: Titus Wormer <tituswormer@gmail.com>
Date: Tue, 17 Sep 2024 16:47:04 +0200
Subject: [PATCH] Refactor to externalize `hast-util-minify-whitespace`

---
 package.json                                  |   1 +
 packages/hast-util-minify-whitespace/.npmrc   |   2 +
 packages/hast-util-minify-whitespace/index.js |  69 ++
 .../lib/block.js                              |   0
 .../lib/content.js                            |   0
 .../hast-util-minify-whitespace/lib/index.js  | 377 ++++++++
 .../lib/skippable.js                          |   0
 .../hast-util-minify-whitespace/package.json  |  56 ++
 .../hast-util-minify-whitespace/readme.md     | 213 +++++
 packages/hast-util-minify-whitespace/test.js  | 850 ++++++++++++++++++
 .../hast-util-minify-whitespace/tsconfig.json |   3 +
 packages/rehype-minify-whitespace/index.js    |   2 +-
 .../rehype-minify-whitespace/lib/index.js     | 363 +-------
 .../rehype-minify-whitespace/package.json     |   5 +-
 14 files changed, 1577 insertions(+), 364 deletions(-)
 create mode 100644 packages/hast-util-minify-whitespace/.npmrc
 create mode 100644 packages/hast-util-minify-whitespace/index.js
 rename packages/{rehype-minify-whitespace => hast-util-minify-whitespace}/lib/block.js (100%)
 rename packages/{rehype-minify-whitespace => hast-util-minify-whitespace}/lib/content.js (100%)
 create mode 100644 packages/hast-util-minify-whitespace/lib/index.js
 rename packages/{rehype-minify-whitespace => hast-util-minify-whitespace}/lib/skippable.js (100%)
 create mode 100644 packages/hast-util-minify-whitespace/package.json
 create mode 100644 packages/hast-util-minify-whitespace/readme.md
 create mode 100644 packages/hast-util-minify-whitespace/test.js
 create mode 100644 packages/hast-util-minify-whitespace/tsconfig.json

diff --git a/package.json b/package.json
index 688490a..2bb54bc 100644
--- a/package.json
+++ b/package.json
@@ -24,6 +24,7 @@
     "packages/hast-util-is-css-style/",
     "packages/hast-util-is-event-handler/",
     "packages/hast-util-is-javascript/",
+    "packages/hast-util-minify-whitespace/",
     "packages/hast-util-to-string/",
     "packages/rehype-concat-css-style/",
     "packages/rehype-concat-javascript/",
diff --git a/packages/hast-util-minify-whitespace/.npmrc b/packages/hast-util-minify-whitespace/.npmrc
new file mode 100644
index 0000000..3757b30
--- /dev/null
+++ b/packages/hast-util-minify-whitespace/.npmrc
@@ -0,0 +1,2 @@
+ignore-scripts=true
+package-lock=false
diff --git a/packages/hast-util-minify-whitespace/index.js b/packages/hast-util-minify-whitespace/index.js
new file mode 100644
index 0000000..268463f
--- /dev/null
+++ b/packages/hast-util-minify-whitespace/index.js
@@ -0,0 +1,69 @@
+/**
+ * hast utility to minify whitespace between elements.
+ *
+ * ## What is this?
+ *
+ * This package is a utility that can minify the whitespace between elements.
+ *
+ * ## When should I use this?
+ *
+ * You can use this package when you want to improve the size of HTML fragments.
+ *
+ * ## Use
+ *
+ * ```js
+ * import {h} from 'hastscript'
+ * import {minifyWhitespace} from 'hast-util-minify-whitespace'
+ *
+ * const tree = h('p', [
+ *   '  ',
+ *   h('strong', 'foo'),
+ *   '  ',
+ *   h('em', 'bar'),
+ *   '  ',
+ *   h('meta', {itemProp: true}),
+ *   '  '
+ * ])
+ *
+ * minifyWhitespace(tree)
+ *
+ * console.log(tree)
+ * //=> h('p', [h('strong', 'foo'), ' ', h('em', 'bar'), h('meta', {itemProp: true})])
+ * ```
+ *
+ * ## API
+ *
+ * ### `Options`
+ *
+ * Configuration (TypeScript type).
+ *
+ * ###### Fields
+ *
+ * * `newlines` (`boolean`, default: `false`)
+ *   — collapse whitespace containing newlines to `'\n'` instead of `' '`
+ *   (default: `false`);
+ *   the default is to collapse to a single space
+ *
+ * ###### Returns
+ *
+ * Nothing (`undefined`).
+ *
+ * ### `minifywhitespace(tree[, options])`
+ *
+ * Minify whitespace.
+ *
+ * ###### Parameters
+ *
+ * * `tree` (`Node`) — tree
+ * * `options` (`Options`, optional) — configuration
+ *
+ * ###### Returns
+ *
+ * Nothing (`undefined`).
+ */
+
+/**
+ * @typedef {import('./lib/index.js').Options} Options
+ */
+
+export {minifyWhitespace} from './lib/index.js'
diff --git a/packages/rehype-minify-whitespace/lib/block.js b/packages/hast-util-minify-whitespace/lib/block.js
similarity index 100%
rename from packages/rehype-minify-whitespace/lib/block.js
rename to packages/hast-util-minify-whitespace/lib/block.js
diff --git a/packages/rehype-minify-whitespace/lib/content.js b/packages/hast-util-minify-whitespace/lib/content.js
similarity index 100%
rename from packages/rehype-minify-whitespace/lib/content.js
rename to packages/hast-util-minify-whitespace/lib/content.js
diff --git a/packages/hast-util-minify-whitespace/lib/index.js b/packages/hast-util-minify-whitespace/lib/index.js
new file mode 100644
index 0000000..bd0ef22
--- /dev/null
+++ b/packages/hast-util-minify-whitespace/lib/index.js
@@ -0,0 +1,377 @@
+/**
+ * @import {Nodes, Parents, Text} from 'hast'
+ */
+
+/**
+ * @callback Collapse
+ *   Collapse a string.
+ * @param {string} value
+ *   Value to collapse.
+ * @returns {string}
+ *   Collapsed value.
+ *
+ * @typedef Options
+ *   Configuration.
+ * @property {boolean | null | undefined} [newlines=false]
+ *   Collapse whitespace containing newlines to `'\n'` instead of `' '`
+ *   (default: `false`); the default is to collapse to a single space.
+ *
+ * @typedef Result
+ *   Result.
+ * @property {boolean} remove
+ *   Whether to remove.
+ * @property {boolean} ignore
+ *   Whether to ignore.
+ * @property {boolean} stripAtStart
+ *   Whether to strip at the start.
+ *
+ * @typedef State
+ *   Info passed around.
+ * @property {Collapse} collapse
+ *   Collapse.
+ * @property {Whitespace} whitespace
+ *   Current whitespace.
+ * @property {boolean | undefined} [before]
+ *   Whether there is a break before (default: `false`).
+ * @property {boolean | undefined} [after]
+ *   Whether there is a break after (default: `false`).
+ *
+ * @typedef {'normal' | 'nowrap' | 'pre' | 'pre-wrap'} Whitespace
+ *   Whitespace setting.
+ */
+
+import {embedded} from 'hast-util-embedded'
+import {isElement} from 'hast-util-is-element'
+import {whitespace} from 'hast-util-whitespace'
+import {convert} from 'unist-util-is'
+import {blocks} from './block.js'
+import {content as contents} from './content.js'
+import {skippable as skippables} from './skippable.js'
+
+/** @type {Options} */
+const emptyOptions = {}
+const ignorableNode = convert(['comment', 'doctype'])
+
+/**
+ * Minify whitespace.
+ *
+ * @param {Nodes} tree
+ *   Tree.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export function minifyWhitespace(tree, options) {
+  const settings = options || emptyOptions
+
+  minify(tree, {
+    collapse: collapseFactory(
+      settings.newlines ? replaceNewlines : replaceWhitespace
+    ),
+    whitespace: 'normal'
+  })
+}
+
+/**
+ * @param {Nodes} node
+ *   Node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Result}
+ *   Result.
+ */
+function minify(node, state) {
+  if ('children' in node) {
+    const settings = {...state}
+
+    if (node.type === 'root' || blocklike(node)) {
+      settings.before = true
+      settings.after = true
+    }
+
+    settings.whitespace = inferWhiteSpace(node, state)
+
+    return all(node, settings)
+  }
+
+  if (node.type === 'text') {
+    if (state.whitespace === 'normal') {
+      return minifyText(node, state)
+    }
+
+    // Naïve collapse, but no trimming:
+    if (state.whitespace === 'nowrap') {
+      node.value = state.collapse(node.value)
+    }
+
+    // The `pre-wrap` or `pre` whitespace settings are neither collapsed nor
+    // trimmed.
+  }
+
+  return {ignore: ignorableNode(node), stripAtStart: false, remove: false}
+}
+
+/**
+ * @param {Text} node
+ *   Node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Result}
+ *   Result.
+ */
+function minifyText(node, state) {
+  const value = state.collapse(node.value)
+  const result = {ignore: false, stripAtStart: false, remove: false}
+  let start = 0
+  let end = value.length
+
+  if (state.before && removable(value.charAt(0))) {
+    start++
+  }
+
+  if (start !== end && removable(value.charAt(end - 1))) {
+    if (state.after) {
+      end--
+    } else {
+      result.stripAtStart = true
+    }
+  }
+
+  if (start === end) {
+    result.remove = true
+  } else {
+    node.value = value.slice(start, end)
+  }
+
+  return result
+}
+
+/**
+ * @param {Parents} parent
+ *   Node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Result}
+ *   Result.
+ */
+function all(parent, state) {
+  let before = state.before
+  const after = state.after
+  const children = parent.children
+  let length = children.length
+  let index = -1
+
+  while (++index < length) {
+    const result = minify(children[index], {
+      ...state,
+      after: collapsableAfter(children, index, after),
+      before
+    })
+
+    if (result.remove) {
+      children.splice(index, 1)
+      index--
+      length--
+    } else if (!result.ignore) {
+      before = result.stripAtStart
+    }
+
+    // If this element, such as a `<select>` or `<img>`, contributes content
+    // somehow, allow whitespace again.
+    if (content(children[index])) {
+      before = false
+    }
+  }
+
+  return {ignore: false, stripAtStart: Boolean(before || after), remove: false}
+}
+
+/**
+ * @param {Array<Nodes>} nodes
+ *   Nodes.
+ * @param {number} index
+ *   Index.
+ * @param {boolean | undefined} [after]
+ *   Whether there is a break after `nodes` (default: `false`).
+ * @returns {boolean | undefined}
+ *   Whether there is a break after the node at `index`.
+ */
+function collapsableAfter(nodes, index, after) {
+  while (++index < nodes.length) {
+    const node = nodes[index]
+    let result = inferBoundary(node)
+
+    if (result === undefined && 'children' in node && !skippable(node)) {
+      result = collapsableAfter(node.children, -1)
+    }
+
+    if (typeof result === 'boolean') {
+      return result
+    }
+  }
+
+  return after
+}
+
+/**
+ * Infer two types of boundaries:
+ *
+ * 1. `true` — boundary for which whitespace around it does not contribute
+ *    anything
+ * 2. `false` — boundary for which whitespace around it *does* contribute
+ *
+ * No result (`undefined`) is returned if it is unknown.
+ *
+ * @param {Nodes} node
+ *   Node.
+ * @returns {boolean | undefined}
+ *   Boundary.
+ */
+function inferBoundary(node) {
+  if (node.type === 'element') {
+    if (content(node)) {
+      return false
+    }
+
+    if (blocklike(node)) {
+      return true
+    }
+
+    // Unknown: either depends on siblings if embedded or metadata, or on
+    // children.
+  } else if (node.type === 'text') {
+    if (!whitespace(node)) {
+      return false
+    }
+  } else if (!ignorableNode(node)) {
+    return false
+  }
+}
+
+/**
+ * Infer whether a node is skippable.
+ *
+ * @param {Nodes} node
+ *   Node.
+ * @returns {boolean}
+ *   Whether `node` is skippable.
+ */
+function content(node) {
+  return embedded(node) || isElement(node, contents)
+}
+
+/**
+ * See: <https://html.spec.whatwg.org/#the-css-user-agent-style-sheet-and-presentational-hints>
+ *
+ * @param {Nodes} node
+ *   Node.
+ * @returns {boolean}
+ *   Whether `node` is block-like.
+ */
+function blocklike(node) {
+  return isElement(node, blocks)
+}
+
+/**
+ * @param {Parents} node
+ *   Node.
+ * @returns {boolean}
+ *   Whether `node` is skippable.
+ */
+function skippable(node) {
+  return (
+    Boolean(node.type === 'element' && node.properties.hidden) ||
+    ignorableNode(node) ||
+    isElement(node, skippables)
+  )
+}
+
+/**
+ * @param {string} character
+ *   Character.
+ * @returns {boolean}
+ *   Whether `character` is removable.
+ */
+function removable(character) {
+  return character === ' ' || character === '\n'
+}
+
+/**
+ * @type {Collapse}
+ */
+function replaceNewlines(value) {
+  const match = /\r?\n|\r/.exec(value)
+  return match ? match[0] : ' '
+}
+
+/**
+ * @type {Collapse}
+ */
+function replaceWhitespace() {
+  return ' '
+}
+
+/**
+ * @param {Collapse} replace
+ * @returns {Collapse}
+ *   Collapse.
+ */
+function collapseFactory(replace) {
+  return collapse
+
+  /**
+   * @type {Collapse}
+   */
+  function collapse(value) {
+    return String(value).replace(/[\t\n\v\f\r ]+/g, replace)
+  }
+}
+
+/**
+ * We don’t need to support void elements here (so `nobr wbr` -> `normal` is
+ * ignored).
+ *
+ * @param {Parents} node
+ *   Node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Whitespace}
+ *   Whitespace.
+ */
+function inferWhiteSpace(node, state) {
+  if ('tagName' in node && node.properties) {
+    switch (node.tagName) {
+      // Whitespace in script/style, while not displayed by CSS as significant,
+      // could have some meaning in JS/CSS, so we can’t touch them.
+      case 'listing':
+      case 'plaintext':
+      case 'script':
+      case 'style':
+      case 'xmp': {
+        return 'pre'
+      }
+
+      case 'nobr': {
+        return 'nowrap'
+      }
+
+      case 'pre': {
+        return node.properties.wrap ? 'pre-wrap' : 'pre'
+      }
+
+      case 'td':
+      case 'th': {
+        return node.properties.noWrap ? 'nowrap' : state.whitespace
+      }
+
+      case 'textarea': {
+        return 'pre-wrap'
+      }
+
+      default:
+    }
+  }
+
+  return state.whitespace
+}
diff --git a/packages/rehype-minify-whitespace/lib/skippable.js b/packages/hast-util-minify-whitespace/lib/skippable.js
similarity index 100%
rename from packages/rehype-minify-whitespace/lib/skippable.js
rename to packages/hast-util-minify-whitespace/lib/skippable.js
diff --git a/packages/hast-util-minify-whitespace/package.json b/packages/hast-util-minify-whitespace/package.json
new file mode 100644
index 0000000..962d260
--- /dev/null
+++ b/packages/hast-util-minify-whitespace/package.json
@@ -0,0 +1,56 @@
+{
+  "name": "hast-util-minify-whitespace",
+  "version": "0.0.0",
+  "description": "hast utility to get the plain-text value of a node",
+  "license": "MIT",
+  "keywords": [
+    "hast",
+    "hast-util",
+    "html",
+    "minify",
+    "unist",
+    "util",
+    "utility",
+    "whitespace"
+  ],
+  "repository": "https://github.com/rehypejs/rehype-minify/tree/main/packages/hast-util-minify-whitespace",
+  "bugs": "https://github.com/rehypejs/rehype-minify/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "index.d.ts",
+    "index.d.ts.map",
+    "index.js",
+    "lib/"
+  ],
+  "dependencies": {
+    "@types/hast": "^3.0.0",
+    "hast-util-embedded": "^3.0.0",
+    "hast-util-is-element": "^3.0.0",
+    "hast-util-whitespace": "^3.0.0",
+    "unist-util-is": "^6.0.0"
+  },
+  "scripts": {},
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "prettier": true,
+    "rules": {
+      "capitalized-comments": "off",
+      "unicorn/prefer-string-replace-all": "off"
+    }
+  }
+}
diff --git a/packages/hast-util-minify-whitespace/readme.md b/packages/hast-util-minify-whitespace/readme.md
new file mode 100644
index 0000000..38a84db
--- /dev/null
+++ b/packages/hast-util-minify-whitespace/readme.md
@@ -0,0 +1,213 @@
+<!--This file is generated-->
+
+# hast-util-minify-whitespace
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][funding-sponsors-badge]][funding]
+[![Backers][funding-backers-badge]][funding]
+[![Chat][chat-badge]][chat]
+
+[`hast`][hast] utility to minify whitespace between elements.
+
+## Contents
+
+* [What is this?](#what-is-this)
+* [When should I use this?](#when-should-i-use-this)
+* [Install](#install)
+* [Use](#use)
+* [API](#api)
+  * [`Options`](#options)
+  * [`minifywhitespace(tree[, options])`](#minifywhitespacetree-options)
+* [Syntax](#syntax)
+* [Syntax tree](#syntax-tree)
+* [Types](#types)
+* [Compatibility](#compatibility)
+* [Security](#security)
+* [Contribute](#contribute)
+* [License](#license)
+
+## What is this?
+
+This package is a utility that can minify the whitespace between elements.
+
+## When should I use this?
+
+You can use this package when you want to improve the size of HTML fragments.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install hast-util-minify-whitespace
+```
+
+In Deno with [`esm.sh`][esm-sh]:
+
+```js
+import {minifyWhitespace} from 'https://esm.sh/hast-util-minify-whitespace@0'
+```
+
+In browsers with [`esm.sh`][esm-sh]:
+
+```html
+<script type="module">
+  import {minifyWhitespace} from 'https://esm.sh/hast-util-minify-whitespace@0?bundle'
+</script>
+```
+
+## Use
+
+```js
+import {h} from 'hastscript'
+import {minifyWhitespace} from 'hast-util-minify-whitespace'
+
+const tree = h('p', [
+  '  ',
+  h('strong', 'foo'),
+  '  ',
+  h('em', 'bar'),
+  '  ',
+  h('meta', {itemProp: true}),
+  '  '
+])
+
+minifyWhitespace(tree)
+
+console.log(tree)
+//=> h('p', [h('strong', 'foo'), ' ', h('em', 'bar'), h('meta', {itemProp: true})])
+```
+
+## API
+
+This package exports the identifier
+`minifyWhitespace`.
+There is no default export.
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+* `newlines` (`boolean`, default: `false`)
+  — collapse whitespace containing newlines to `'\n'` instead of `' '`
+  (default: `false`);
+  the default is to collapse to a single space
+
+###### Returns
+
+Nothing (`undefined`).
+
+### `minifywhitespace(tree[, options])`
+
+Minify whitespace.
+
+###### Parameters
+
+* `tree` (`Node`) — tree
+* `options` (`Options`, optional) — configuration
+
+###### Returns
+
+Nothing (`undefined`).
+
+## Syntax
+
+HTML is parsed according to WHATWG HTML (the living standard), which is also
+followed by all browsers.
+
+## Syntax tree
+
+The syntax tree used is [hast][].
+
+## Types
+
+This package is fully typed with [TypeScript][].
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line,
+`hast-util-minify-whitespace@^0`,
+compatible with Node.js 16.
+
+## Security
+
+As **rehype** works on HTML and improper use of HTML can open you up to a
+[cross-site scripting (XSS)][xss] attack, use of rehype can also be unsafe.
+Use [`rehype-sanitize`][rehype-sanitize] to make the tree safe.
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`rehypejs/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+[author]: https://wooorm.com
+
+[build]: https://github.com/rehypejs/rehype-minify/actions
+
+[build-badge]: https://github.com/rehypejs/rehype-minify/workflows/main/badge.svg
+
+[chat]: https://github.com/rehypejs/rehype/discussions
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[coc]: https://github.com/rehypejs/.github/blob/main/code-of-conduct.md
+
+[contributing]: https://github.com/rehypejs/.github/blob/main/contributing.md
+
+[coverage]: https://codecov.io/github/rehypejs/rehype-minify
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/rehypejs/rehype-minify.svg
+
+[downloads]: https://www.npmjs.com/package/hast-util-minify-whitespace
+
+[downloads-badge]: https://img.shields.io/npm/dm/hast-util-minify-whitespace.svg
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esm-sh]: https://esm.sh
+
+[funding]: https://opencollective.com/unified
+
+[funding-backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[funding-sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[hast]: https://github.com/syntax-tree/hast
+
+[health]: https://github.com/rehypejs/.github
+
+[license]: https://github.com/rehypejs/rehype-minify/blob/main/license
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[rehype-sanitize]: https://github.com/rehypejs/rehype-sanitize
+
+[size]: https://bundlejs.com/?q=hast-util-minify-whitespace
+
+[size-badge]: https://img.shields.io/bundlejs/size/hast-util-minify-whitespace
+
+[support]: https://github.com/rehypejs/.github/blob/main/support.md
+
+[typescript]: https://www.typescriptlang.org
+
+[xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
diff --git a/packages/hast-util-minify-whitespace/test.js b/packages/hast-util-minify-whitespace/test.js
new file mode 100644
index 0000000..9b07fa6
--- /dev/null
+++ b/packages/hast-util-minify-whitespace/test.js
@@ -0,0 +1,850 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import {h} from 'hastscript'
+import {minifyWhitespace} from 'hast-util-minify-whitespace'
+
+test('hast-util-minify-whitespace', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(
+      Object.keys(await import('hast-util-minify-whitespace')).sort(),
+      ['minifyWhitespace']
+    )
+  })
+
+  await t.test('should work', async function () {
+    const tree = h('main', [
+      '  ',
+      h('p', [
+        '  ',
+        h('strong', 'foo'),
+        '  ',
+        h('em', 'bar'),
+        '  ',
+        h('meta', {itemProp: true}),
+        '  '
+      ]),
+      '  ',
+      h('p', [h('a', {href: 'example.com'}, ' baz'), '  ', h('em', ' qux')]),
+      '  '
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('main', [
+        h('p', [
+          h('strong', 'foo'),
+          ' ',
+          h('em', 'bar'),
+          h('meta', {itemProp: true})
+        ]),
+        h('p', [h('a', {href: 'example.com'}, 'baz'), ' ', h('em', 'qux')])
+      ])
+    )
+  })
+
+  await t.test('should work on `head`', async function () {
+    const tree = h('head', [
+      '  ',
+      h('meta', {itemProp: true}),
+      '  ',
+      h('noscript', [
+        '  ',
+        h('link', {rel: ['stylesheet'], href: 'index.css'}),
+        '  '
+      ])
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('head', [
+        h('meta', {itemProp: true}),
+        h('noscript', [h('link', {rel: ['stylesheet'], href: 'index.css'})])
+      ])
+    )
+  })
+
+  await t.test('should support `newlines`', async function () {
+    const tree = h('main', [
+      '  ',
+      h('p', [
+        '\n ',
+        h('strong', 'foo'),
+        ' \n',
+        h('em', 'bar'),
+        ' \n',
+        h('meta', {itemProp: true}),
+        ' \n'
+      ]),
+      ' \n',
+      h('p', [h('a', {href: 'example.com'}, ' baz'), '  ', h('em', ' qux')]),
+      '  '
+    ])
+
+    minifyWhitespace(tree, {newlines: true})
+
+    assert.deepEqual(
+      tree,
+      h('main', [
+        h('p', [
+          h('strong', 'foo'),
+          '\n',
+          h('em', 'bar'),
+          h('meta', {itemProp: true})
+        ]),
+        h('p', [h('a', {href: 'example.com'}, 'baz'), ' ', h('em', 'qux')])
+      ])
+    )
+  })
+
+  await t.test(
+    'should trim whitespace around `<br>` elements',
+    async function () {
+      const tree = h('main', ['  a  ', h('br'), ' c '])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(tree, h('main', ['a', h('br'), 'c']))
+    }
+  )
+
+  await t.test('should trim whitespace in `<form>`s', async function () {
+    const tree = h('form', [
+      '  ',
+      h('input', {list: 'a'}),
+      '  ',
+      h('datalist', {id: 'a'}, [
+        '  ',
+        h('option', 'b'),
+        '  ',
+        h('option', 'c'),
+        '  '
+      ]),
+      '  '
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('form', [
+        h('input', {list: 'a'}),
+        h('datalist', {id: 'a'}, [h('option', 'b'), h('option', 'c')])
+      ])
+    )
+  })
+
+  await t.test(
+    'should trim whitespace around `<object>` elements',
+    async function () {
+      const tree = h('section', [
+        '  a  ',
+        h('object', ['  b  ', h('p', '  c  '), '  d  ']),
+        '  e  '
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('section', ['a ', h('object', ['b', h('p', 'c'), 'd ']), ' e'])
+      )
+    }
+  )
+
+  await t.test('should work between phrasing elements (1)', async function () {
+    const tree = h('main', [
+      h('p', [
+        h('strong', 'foo '),
+        h('em', 'bar '),
+        h('a', {href: 'example.com'}, ' baz '),
+        h('em', ' qux ')
+      ])
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('main', [
+        h('p', [
+          h('strong', 'foo '),
+          h('em', 'bar '),
+          h('a', {href: 'example.com'}, 'baz '),
+          h('em', 'qux')
+        ])
+      ])
+    )
+  })
+
+  await t.test('should work between phrasing elements (2)', async function () {
+    const tree = h('main', [
+      h('p', [' ', h('span', [' ', h('strong', ' '), ' ']), ' '])
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(tree, h('main', [h('p', [h('span', [h('strong')])])]))
+  })
+
+  await t.test('should work between phrasing elements (3)', async function () {
+    const tree = h('main', [h('strong', 'a'), h('span', [h('span', ' '), 'b'])])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('main', [h('strong', 'a'), h('span', [h('span', ' '), 'b'])])
+    )
+  })
+
+  await t.test(
+    'should drop w/o content in flow elements (1)',
+    async function () {
+      const tree = h('main', '  ')
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(tree, h('main'))
+    }
+  )
+
+  await t.test(
+    'should drop w/o content in flow elements (2)',
+    async function () {
+      const tree = h('main', '\n ')
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(tree, h('main'))
+    }
+  )
+
+  await t.test('should drop around flow elements (1)', async function () {
+    const tree = h('main', ['  ', h('p'), '  ', h('p'), '  '])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(tree, h('main', [h('p'), h('p')]))
+  })
+
+  await t.test('should drop around flow elements (2)', async function () {
+    const tree = h('main', ['  ', h('div', ['  ', ' foo ', ' \n', ' bar '])])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(tree, h('main', [h('div', ['foo ', 'bar'])]))
+  })
+
+  await t.test(
+    'should drop deep at the end of phrasing (1)',
+    async function () {
+      const tree = h('main', [
+        h('i', [
+          h('span', 'foo '),
+          h('a', {href: 'example.com'}, [h('span', 'bar ')])
+        ])
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('i', [
+            h('span', 'foo '),
+            h('a', {href: 'example.com'}, [h('span', 'bar')])
+          ])
+        ])
+      )
+    }
+  )
+
+  await t.test(
+    'should drop deep at the end of phrasing (2)',
+    async function () {
+      const tree = h('main', [
+        h('span', ['foo ', h('a', {href: 'example.com'}, 'bar'), ' baz'])
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('span', ['foo ', h('a', {href: 'example.com'}, 'bar'), ' baz'])
+        ])
+      )
+    }
+  )
+
+  await t.test(
+    'should drop deep at the end of phrasing (2)',
+    async function () {
+      const tree = h('main', [
+        h('p'),
+        h('i', [h('span', 'foo ')]),
+        h('i', [h('a', {href: 'example.com'}, [h('span', 'bar ')])])
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('p'),
+          h('i', [h('span', 'foo ')]),
+          h('i', [h('a', {href: 'example.com'}, [h('span', 'bar')])])
+        ])
+      )
+    }
+  )
+
+  await t.test('should drop a ton of complex whitespace', async function () {
+    const tree = h(undefined, [
+      {type: 'doctype'},
+      {type: 'text', value: '\n'},
+      h('html', [
+        '\n  ',
+        h('head', [
+          '\n    ',
+          h('meta', {charSet: 'utf8'}),
+          '\n    ',
+          h('title', ' a '),
+          '\n    ',
+          h('link', {rel: ['stylesheet']}),
+          '\n  '
+        ]),
+        '\n  ',
+        h('body', [
+          '\n    ',
+          h('h1', ['\n      bar  bar\n    ']),
+          '\n    ',
+          h('p', [
+            '\n      ',
+            h('strong', ['\n        foo\n      ']),
+            '\n      bar\n      ',
+            h('em', ['\n        baz\n      ']),
+            '\n    '
+          ]),
+          '\n  '
+        ])
+      ])
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h(undefined, [
+        {type: 'doctype'},
+        h('html', [
+          h('head', [
+            h('meta', {charSet: 'utf8'}),
+            h('title', 'a'),
+            h('link', {rel: ['stylesheet']})
+          ]),
+          h('body', [
+            h('h1', ['bar bar']),
+            h('p', [h('strong', ['foo ']), 'bar ', h('em', ['baz'])])
+          ])
+        ])
+      ])
+    )
+  })
+
+  await t.test(
+    'should prefer whitespace in earlier elements',
+    async function () {
+      const tree = h('p', [h('label', ' a '), ' ', h('input')])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(tree, h('p', [h('label', 'a '), h('input')]))
+    }
+  )
+
+  await t.test('should allow whitespace before an input', async function () {
+    const tree = h('p', [h('label', 'a'), ' ', h('input')])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(tree, h('p', [h('label', 'a'), ' ', h('input')]))
+  })
+
+  await t.test(
+    'should allow whitespace before an empty button',
+    async function () {
+      const tree = h('p', [h('label', 'a'), ' ', h('button')])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(tree, h('p', [h('label', 'a'), ' ', h('button')]))
+    }
+  )
+
+  await t.test('should trim whitespace between blocks', async function () {
+    const tree = h('main', [h('p', ' a '), ' b ', h('p', ' c ')])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(tree, h('main', [h('p', 'a'), 'b', h('p', 'c')]))
+  })
+
+  await t.test('should trim whitespace in head', async function () {
+    const tree = h(undefined, [
+      h('head', [
+        '  ',
+        h('meta', {charSet: 'utf8'}),
+        '  ',
+        h('title', '  a  '),
+        '  ',
+        h('link'),
+        '  ',
+        h('script', '  b  '),
+        '  ',
+        h('meta'),
+        '  ',
+        h('script', '  c  '),
+        '  ',
+        h('style', '  d  '),
+        '  '
+      ])
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h(undefined, [
+        h('head', [
+          h('meta', {charSet: 'utf8'}),
+          h('title', 'a'),
+          h('link'),
+          h('script', '  b  '),
+          h('meta'),
+          h('script', '  c  '),
+          h('style', '  d  ')
+        ])
+      ])
+    )
+  })
+
+  await t.test('should trim whitespace in selects', async function () {
+    const tree = h('p', [
+      '  a  ',
+      h('select', [
+        '  ',
+        h('optgroup', {label: 'b'}, [
+          '  ',
+          h('option', '  c  '),
+          '  ',
+          h('option', '  d  '),
+          '  '
+        ]),
+        '  '
+      ]),
+      '  e  '
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('p', [
+        'a ',
+        h('select', [
+          h('optgroup', {label: 'b'}, [h('option', 'c'), h('option', 'd')])
+        ]),
+        ' e'
+      ])
+    )
+  })
+
+  await t.test('should trim whitespace around media', async function () {
+    const tree = h('p', [
+      '  a  ',
+      h('img'),
+      '  b  ',
+      h('video'),
+      '  c  ',
+      h('audio'),
+      '  d  '
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('p', ['a ', h('img'), ' b ', h('video'), ' c ', h('audio'), ' d'])
+    )
+  })
+
+  await t.test('should trim whitespace inside media', async function () {
+    const tree = h('p', [
+      '  a  ',
+      h('video', [h('track'), '  b  ', h('a', '  c  '), '  d  ']),
+      '  e  '
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('p', ['a ', h('video', [h('track'), 'b ', h('a', 'c '), 'd ']), ' e'])
+    )
+  })
+
+  await t.test(
+    'should trim whitespace around comments (#1)',
+    async function () {
+      const tree = h('p', ['  a  ', {type: 'comment', value: '  b  '}, '  c  '])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('p', ['a ', {type: 'comment', value: '  b  '}, 'c'])
+      )
+    }
+  )
+
+  await t.test(
+    'should trim whitespace around comments (#2)',
+    async function () {
+      const tree = h('main', [
+        h('p', '  a  '),
+        {type: 'comment', value: '  b  '},
+        h('p', '  c  ')
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [h('p', 'a'), {type: 'comment', value: '  b  '}, h('p', 'c')])
+      )
+    }
+  )
+
+  await t.test(
+    'should trim whitespace around hidden elements',
+    async function () {
+      const tree = h('main', [
+        h('p', '  a  '),
+        '  ',
+        h('x', {hidden: true}, '  b  '),
+        '  ',
+        h('p', '  c  '),
+        '  ',
+        h('p', ['  d  ', h('x', {hidden: true}, '  e  '), '  f  '])
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('p', 'a'),
+          h('x', {hidden: true}, 'b'),
+          h('p', 'c'),
+          h('p', ['d ', h('x', {hidden: true}, 'e '), 'f'])
+        ])
+      )
+    }
+  )
+
+  await t.test(
+    'should not trim whitespace around unknown nodes',
+    async function () {
+      const tree = h('main', [
+        h('p', '  a  '),
+        '  ',
+        // @ts-expect-error: custom node.
+        {type: 'x'},
+        '  ',
+        h('p', '  c  '),
+        '  ',
+        // @ts-expect-error: custom node.
+        h('p', ['  d  ', {type: 'x'}, '  f  '])
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('p', 'a'),
+          // @ts-expect-error: custom node.
+          {type: 'x'},
+          h('p', 'c'),
+          // @ts-expect-error: custom node.
+          h('p', ['d ', {type: 'x'}, ' f'])
+        ])
+      )
+    }
+  )
+
+  await t.test(
+    'should not trim whitespace around unknown nodes',
+    async function () {
+      const tree = h('main', [
+        h('p', '  a  '),
+        '  ',
+        // @ts-expect-error: custom node.
+        {type: 'x'},
+        '  ',
+        h('p', '  c  '),
+        '  ',
+        // @ts-expect-error: custom node.
+        h('p', ['  d  ', {type: 'x'}, '  f  '])
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('p', 'a'),
+          // @ts-expect-error: custom node.
+          {type: 'x'},
+          h('p', 'c'),
+          // @ts-expect-error: custom node.
+          h('p', ['d ', {type: 'x'}, ' f'])
+        ])
+      )
+    }
+  )
+
+  await t.test('should not trim whitespace in `xmp`', async function () {
+    const tree = h('main', [
+      h('p', '  a  '),
+      '  ',
+      h('xmp', '  1 < 3  '),
+      '  ',
+      h('p', '  b  ')
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('main', [h('p', 'a'), h('xmp', '  1 < 3  '), h('p', 'b')])
+    )
+  })
+
+  await t.test('should not trim whitespace in `listing`', async function () {
+    const tree = h('main', [
+      h('p', '  a  '),
+      '  ',
+      h('listing', '  1 < 3  '),
+      '  ',
+      h('p', '  b  ')
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h('main', [h('p', 'a'), h('listing', '  1 < 3  '), h('p', 'b')])
+    )
+  })
+
+  await t.test('should trim whitespace in a fragment', async function () {
+    const tree = h(undefined, [h('p', '  a  '), '  ', h('p', '  b  ')])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(tree, h(undefined, [h('p', 'a'), h('p', 'b')]))
+  })
+
+  await t.test('should not trim whitespace in `plaintext`', async function () {
+    const tree = h(undefined, [
+      h('p', '  a  '),
+      '  ',
+      h('plaintext', '  1 < 3  ')
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h(undefined, [h('p', 'a'), h('plaintext', '  1 < 3  ')])
+    )
+  })
+
+  await t.test('should not trim whitespace in `listing`', async function () {
+    const tree = h(undefined, [
+      h('main', [
+        h('p', '  a  '),
+        '  ',
+        h('listing', '  1 < 3  '),
+        '  ',
+        h('p', '  b  ')
+      ])
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h(undefined, [
+        h('main', [h('p', 'a'), h('listing', '  1 < 3  '), h('p', 'b')])
+      ])
+    )
+  })
+
+  await t.test('should not trim whitespace in `listing`', async function () {
+    const tree = h(undefined, [
+      h('main', [
+        h('p', '  a  '),
+        '  ',
+        h('listing', '  1 < 3  '),
+        '  ',
+        h('p', '  b  ')
+      ])
+    ])
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(
+      tree,
+      h(undefined, [
+        h('main', [h('p', 'a'), h('listing', '  1 < 3  '), h('p', 'b')])
+      ])
+    )
+  })
+
+  await t.test(
+    'should collapse but not trim whitespace in `nobr`',
+    async function () {
+      const tree = h('p', [
+        '  ',
+        h('nobr', '  Long   line   with   no   breaks  '),
+        '  '
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(tree, h('p', [h('nobr', ' Long line with no breaks ')]))
+    }
+  )
+
+  await t.test(
+    'should not collapse or trim whitespace in `textarea`',
+    async function () {
+      const tree = h('p', ['  a  ', h('textarea', '  b  '), '  c  '])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(tree, h('p', ['a ', h('textarea', '  b  '), ' c']))
+    }
+  )
+
+  await t.test(
+    'should not collapse or trim whitespace in `pre`',
+    async function () {
+      const tree = h('main', [
+        h('p', '  a  '),
+        '  ',
+        h('pre', h('code', '  1 < 3  ')),
+        '  ',
+        h('p', '  b  ')
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [h('p', 'a'), h('pre', h('code', '  1 < 3  ')), h('p', 'b')])
+      )
+    }
+  )
+
+  await t.test(
+    'should not collapse or trim whitespace in `pre[wrap]`',
+    async function () {
+      const tree = h('main', [
+        h('p', '  a  '),
+        '  ',
+        h('pre', {wrap: true}, h('code', '  1 < 3  ')),
+        '  ',
+        h('p', '  b  ')
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('p', 'a'),
+          h('pre', {wrap: true}, h('code', '  1 < 3  ')),
+          h('p', 'b')
+        ])
+      )
+    }
+  )
+
+  await t.test(
+    'should collapse and trim whitespace in tables',
+    async function () {
+      const tree = h('main', [
+        '  ',
+        h('p', '  a  '),
+        '  ',
+        h('table', [
+          '  ',
+          h('thead', [
+            '  ',
+            h('tr', ['  ', h('th', {noWrap: true}, '  b  '), '  ']),
+            '  '
+          ]),
+          '  ',
+          h('tbody', ['  ', h('tr', ['  ', h('td', '  c  '), '  ']), '  '])
+        ]),
+        '  ',
+        h('p', '  d  '),
+        '  '
+      ])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', [
+          h('p', 'a'),
+          h('table', [
+            h('thead', [h('tr', [h('th', {noWrap: true}, ' b ')])]),
+            h('tbody', [h('tr', [h('td', 'c')])])
+          ]),
+          h('p', 'd')
+        ])
+      )
+    }
+  )
+
+  await t.test(
+    'should collapse and trim whitespace in tables',
+    async function () {
+      const tree = h('main', [' \u00A0 ', h('p', '  a \u00A0 '), ' \u00A0 '])
+
+      minifyWhitespace(tree)
+
+      assert.deepEqual(
+        tree,
+        h('main', ['\u00A0', h('p', 'a \u00A0'), '\u00A0'])
+      )
+    }
+  )
+
+  await t.test('should not collapse whitespace in scripts', async function () {
+    const tree = h('script', ' // a \n b ')
+
+    minifyWhitespace(tree)
+
+    assert.deepEqual(tree, h('script', ' // a \n b '))
+  })
+})
diff --git a/packages/hast-util-minify-whitespace/tsconfig.json b/packages/hast-util-minify-whitespace/tsconfig.json
new file mode 100644
index 0000000..4082f16
--- /dev/null
+++ b/packages/hast-util-minify-whitespace/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/packages/rehype-minify-whitespace/index.js b/packages/rehype-minify-whitespace/index.js
index aff2386..2901343 100644
--- a/packages/rehype-minify-whitespace/index.js
+++ b/packages/rehype-minify-whitespace/index.js
@@ -41,7 +41,7 @@
  */
 
 /**
- * @typedef {import('./lib/index.js').Options} Options
+ * @typedef {import('hast-util-minify-whitespace').Options} Options
  */
 
 export {default} from './lib/index.js'
diff --git a/packages/rehype-minify-whitespace/lib/index.js b/packages/rehype-minify-whitespace/lib/index.js
index 06e64c6..4afd549 100644
--- a/packages/rehype-minify-whitespace/lib/index.js
+++ b/packages/rehype-minify-whitespace/lib/index.js
@@ -1,56 +1,9 @@
 /**
- * @import {Nodes, Parents, Root, Text} from 'hast'
+ * @import {Options} from 'hast-util-minify-whitespace'
+ * @import {Root} from 'hast'
  */
 
-/**
- * @callback Collapse
- *   Collapse a string.
- * @param {string} value
- *   Value to collapse.
- * @returns {string}
- *   Collapsed value.
- *
- * @typedef Options
- *   Configuration.
- * @property {boolean | null | undefined} [newlines=false]
- *   Collapse whitespace containing newlines to `'\n'` instead of `' '`
- *   (default: `false`); the default is to collapse to a single space.
- *
- * @typedef Result
- *   Result.
- * @property {boolean} remove
- *   Whether to remove.
- * @property {boolean} ignore
- *   Whether to ignore.
- * @property {boolean} stripAtStart
- *   Whether to strip at the start.
- *
- * @typedef State
- *   Info passed around.
- * @property {Collapse} collapse
- *   Collapse.
- * @property {Whitespace} whitespace
- *   Current whitespace.
- * @property {boolean | undefined} [before]
- *   Whether there is a break before (default: `false`).
- * @property {boolean | undefined} [after]
- *   Whether there is a break after (default: `false`).
- *
- * @typedef {'normal' | 'nowrap' | 'pre' | 'pre-wrap'} Whitespace
- *   Whitespace setting.
- */
-
-import {embedded} from 'hast-util-embedded'
-import {isElement} from 'hast-util-is-element'
-import {whitespace} from 'hast-util-whitespace'
-import {convert} from 'unist-util-is'
-import {blocks} from './block.js'
-import {content as contents} from './content.js'
-import {skippable as skippables} from './skippable.js'
-
-/** @type {Options} */
-const emptyOptions = {}
-const ignorableNode = convert(['doctype', 'comment'])
+import {minifyWhitespace} from 'hast-util-minify-whitespace'
 
 /**
  * Minify whitespace.
@@ -61,11 +14,6 @@ const ignorableNode = convert(['doctype', 'comment'])
  *   Transform.
  */
 export default function rehypeMinifyWhitespace(options) {
-  const settings = options || emptyOptions
-  const collapse = collapseFactory(
-    settings.newlines ? replaceNewlines : replaceWhitespace
-  )
-
   /**
    * @param {Root} tree
    *   Tree.
@@ -73,309 +21,6 @@ export default function rehypeMinifyWhitespace(options) {
    *   Nothing.
    */
   return function (tree) {
-    minify(tree, {collapse, whitespace: 'normal'})
-  }
-}
-
-/**
- * @param {Nodes} node
- *   Node.
- * @param {State} state
- *   Info passed around.
- * @returns {Result}
- *   Result.
- */
-function minify(node, state) {
-  if ('children' in node) {
-    const settings = {...state}
-
-    if (node.type === 'root' || blocklike(node)) {
-      settings.before = true
-      settings.after = true
-    }
-
-    settings.whitespace = inferWhiteSpace(node, state)
-
-    return all(node, settings)
-  }
-
-  if (node.type === 'text') {
-    if (state.whitespace === 'normal') {
-      return minifyText(node, state)
-    }
-
-    // Naïve collapse, but no trimming:
-    if (state.whitespace === 'nowrap') {
-      node.value = state.collapse(node.value)
-    }
-
-    // The `pre-wrap` or `pre` whitespace settings are neither collapsed nor
-    // trimmed.
-  }
-
-  return {ignore: ignorableNode(node), stripAtStart: false, remove: false}
-}
-
-/**
- * @param {Text} node
- *   Node.
- * @param {State} state
- *   Info passed around.
- * @returns {Result}
- *   Result.
- */
-function minifyText(node, state) {
-  const value = state.collapse(node.value)
-  const result = {ignore: false, stripAtStart: false, remove: false}
-  let start = 0
-  let end = value.length
-
-  if (state.before && removable(value.charAt(0))) {
-    start++
-  }
-
-  if (start !== end && removable(value.charAt(end - 1))) {
-    if (state.after) {
-      end--
-    } else {
-      result.stripAtStart = true
-    }
-  }
-
-  if (start === end) {
-    result.remove = true
-  } else {
-    node.value = value.slice(start, end)
-  }
-
-  return result
-}
-
-/**
- * @param {Parents} parent
- *   Node.
- * @param {State} state
- *   Info passed around.
- * @returns {Result}
- *   Result.
- */
-function all(parent, state) {
-  let before = state.before
-  const after = state.after
-  const children = parent.children
-  let length = children.length
-  let index = -1
-
-  while (++index < length) {
-    const result = minify(children[index], {
-      ...state,
-      after: collapsableAfter(children, index, after),
-      before
-    })
-
-    if (result.remove) {
-      children.splice(index, 1)
-      index--
-      length--
-    } else if (!result.ignore) {
-      before = result.stripAtStart
-    }
-
-    // If this element, such as a `<select>` or `<img>`, contributes content
-    // somehow, allow whitespace again.
-    if (content(children[index])) {
-      before = false
-    }
-  }
-
-  return {ignore: false, stripAtStart: Boolean(before || after), remove: false}
-}
-
-/**
- * @param {Array<Nodes>} nodes
- *   Nodes.
- * @param {number} index
- *   Index.
- * @param {boolean | undefined} [after]
- *   Whether there is a break after `nodes` (default: `false`).
- * @returns {boolean | undefined}
- *   Whether there is a break after the node at `index`.
- */
-function collapsableAfter(nodes, index, after) {
-  while (++index < nodes.length) {
-    const node = nodes[index]
-    let result = inferBoundary(node)
-
-    if (result === undefined && 'children' in node && !skippable(node)) {
-      result = collapsableAfter(node.children, -1)
-    }
-
-    if (typeof result === 'boolean') {
-      return result
-    }
-  }
-
-  return after
-}
-
-/**
- * Infer two types of boundaries:
- *
- * 1. `true` — boundary for which whitespace around it does not contribute
- *    anything
- * 2. `false` — boundary for which whitespace around it *does* contribute
- *
- * No result (`undefined`) is returned if it is unknown.
- *
- * @param {Nodes} node
- *   Node.
- * @returns {boolean | undefined}
- *   Boundary.
- */
-function inferBoundary(node) {
-  if (node.type === 'element') {
-    if (content(node)) {
-      return false
-    }
-
-    if (blocklike(node)) {
-      return true
-    }
-
-    // Unknown: either depends on siblings if embedded or metadata, or on
-    // children.
-  } else if (node.type === 'text') {
-    if (!whitespace(node)) {
-      return false
-    }
-  } else if (!ignorableNode(node)) {
-    return false
+    minifyWhitespace(tree, options)
   }
 }
-
-/**
- * Infer whether a node is skippable.
- *
- * @param {Nodes} node
- *   Node.
- * @returns {boolean}
- *   Whether `node` is skippable.
- */
-function content(node) {
-  return embedded(node) || isElement(node, contents)
-}
-
-/**
- * See: <https://html.spec.whatwg.org/#the-css-user-agent-style-sheet-and-presentational-hints>
- *
- * @param {Nodes} node
- *   Node.
- * @returns {boolean}
- *   Whether `node` is block-like.
- */
-function blocklike(node) {
-  return isElement(node, blocks)
-}
-
-/**
- * @param {Parents} node
- *   Node.
- * @returns {boolean}
- *   Whether `node` is skippable.
- */
-function skippable(node) {
-  return (
-    Boolean(node.type === 'element' && node.properties.hidden) ||
-    ignorableNode(node) ||
-    isElement(node, skippables)
-  )
-}
-
-/**
- * @param {string} character
- *   Character.
- * @returns {boolean}
- *   Whether `character` is removable.
- */
-function removable(character) {
-  return character === ' ' || character === '\n'
-}
-
-/**
- * @type {Collapse}
- */
-function replaceNewlines(value) {
-  const match = /\r?\n|\r/.exec(value)
-  return match ? match[0] : ' '
-}
-
-/**
- * @type {Collapse}
- */
-function replaceWhitespace() {
-  return ' '
-}
-
-/**
- * @param {Collapse} replace
- * @returns {Collapse}
- *   Collapse.
- */
-function collapseFactory(replace) {
-  return collapse
-
-  /**
-   * @type {Collapse}
-   */
-  function collapse(value) {
-    return String(value).replace(/[\t\n\v\f\r ]+/g, replace)
-  }
-}
-
-/**
- * We don’t need to support void elements here (so `nobr wbr` -> `normal` is
- * ignored).
- *
- * @param {Parents} node
- *   Node.
- * @param {State} state
- *   Info passed around.
- * @returns {Whitespace}
- *   Whitespace.
- */
-function inferWhiteSpace(node, state) {
-  if ('tagName' in node && node.properties) {
-    switch (node.tagName) {
-      // Whitespace in script/style, while not displayed by CSS as significant,
-      // could have some meaning in JS/CSS, so we can’t touch them.
-      case 'listing':
-      case 'plaintext':
-      case 'script':
-      case 'style':
-      case 'xmp': {
-        return 'pre'
-      }
-
-      case 'nobr': {
-        return 'nowrap'
-      }
-
-      case 'pre': {
-        return node.properties.wrap ? 'pre-wrap' : 'pre'
-      }
-
-      case 'td':
-      case 'th': {
-        return node.properties.noWrap ? 'nowrap' : state.whitespace
-      }
-
-      case 'textarea': {
-        return 'pre-wrap'
-      }
-
-      default:
-    }
-  }
-
-  return state.whitespace
-}
diff --git a/packages/rehype-minify-whitespace/package.json b/packages/rehype-minify-whitespace/package.json
index 21dc4c6..ffe82b4 100644
--- a/packages/rehype-minify-whitespace/package.json
+++ b/packages/rehype-minify-whitespace/package.json
@@ -37,10 +37,7 @@
   ],
   "dependencies": {
     "@types/hast": "^3.0.0",
-    "hast-util-embedded": "^3.0.0",
-    "hast-util-is-element": "^3.0.0",
-    "hast-util-whitespace": "^3.0.0",
-    "unist-util-is": "^6.0.0"
+    "hast-util-minify-whitespace": "^0.0.0"
   },
   "scripts": {},
   "typeCoverage": {