@uiw/react-md-editor 4.1.3 → 4.1.4

package/dist/mdeditor.js

@@ -1270,8 +1270,12 @@ function looksLikeANode(value) {
 
 ;// ../node_modules/unist-util-visit-parents/lib/color.js
 /**
+ * Color a string.
+ *
  * @param {string} d
+ *   Value.
  * @returns {string}
+ *   Colored value.
  */
 function color(d) {
   return d
@@ -1447,44 +1451,96 @@ function color(d) {
  *   List with one or two values, the first an action, the second an index.
  *
  * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult
- *   Any value that can be returned from a visitor.
+ *   Any value that can be returned from an enter visitor.
+ *
+ *   Like `VisitorResultExit`,
+ *   but `SKIP` can also be returned,
+ *   to not walk the children of the node,
+ *   and `ActionTuple` can be used to combine an action with an index.
+ *
+ * @typedef {Index | boolean | null | undefined | void} VisitorResultExit
+ *   Any value that can be returned from an exit visitor.
  */
 
 /**
  * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform the parent of node (the last of `ancestors`).
- *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
- *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
- *
- *   Removing the children property of an ancestor still results in them being
- *   traversed.
+ *   Handle a node (matching `test`, if given) before its children.
+ *
+ *   Changes inside `node` are walked next.
+ *   Replacing or removing it is easier in `exit`.
+ *   When replacing or removing it here,
+ *   return `SKIP` (as otherwise its old children are walked),
+ *   or `[SKIP, index]` to continue with the node now at `index`.
+ *   Changing next siblings (in walk order) is fine;
+ *   changing previous siblings needs a new `Index`.
+ *   Removing an ancestor or changing its previous siblings is not supported.
  * @param {Visited} node
  *   Found node.
  * @param {Array<VisitedParents>} ancestors
  *   Ancestors of `node`.
+ * @param {number | undefined} index
+ *   Index of `node` in its parent (the last of `ancestors`),
+ *   or `undefined` for the tree itself.
  * @returns {VisitorResult}
  *   What to do next.
  *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
+ *   Like `VisitorExit`,
+ *   but `SKIP` can also be returned,
+ *   to not walk the children of `node`.
+ *   Passing a tuple back (`ActionTuple`) only makes sense as `[SKIP, Index]`.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [VisitedParents=UnistParent]
+ *   Ancestor type.
+ */
+
+/**
+ * @callback VisitorExit
+ *   Handle a node (matching `test`, if given) after its children.
  *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
+ *   Changes inside `node` are not walked,
+ *   which makes this a good place to change `node` based on its children,
+ *   or to replace or remove it.
+ *   When removing `node` or changing previous siblings (in walk order),
+ *   return a new `Index`.
+ *   Removing an ancestor or changing its previous siblings is not supported.
+ * @param {Visited} node
+ *   Found node.
+ * @param {Array<VisitedParents>} ancestors
+ *   Ancestors of `node`.
+ * @param {number | undefined} index
+ *   Index of `node` in its parent (the last of `ancestors`),
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResultExit}
+ *   What to do next.
+ *
+ *   `CONTINUE` (`true`, nothing) continues as normal,
+ *   `EXIT` (`false`) stops traversing,
+ *   and `Index` continues at that sibling.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [VisitedParents=UnistParent]
+ *   Ancestor type.
+ */
+
+/**
  * @template {UnistNode} [Visited=UnistNode]
  *   Visited node type.
  * @template {UnistParent} [VisitedParents=UnistParent]
  *   Ancestor type.
+ * @typedef Visitors
+ *   Handle nodes when entering and exiting them.
+ *   The `enter` visitor is optional while `exit` is required.
+ *
+ *   Pass an `enter` visitor directly to only handle nodes when entering them.
+ *
+ *   `enter` is called before children (if any) are walked and `exit` after that.
+ *   `exit` is still called when `enter` returns `SKIP`.
+ *   Both `enter` and `exit` are only called for nodes that match an optional `test`.
+ * @property {Visitor<Visited, VisitedParents> | null | undefined} [enter]
+ *   Handle a node before its children (optional).
+ * @property {VisitorExit<Visited, VisitedParents>} exit
+ *   Handle a node after its children.
  */
 
 /**
@@ -1498,6 +1554,17 @@ function color(d) {
  *   Test type.
  */
 
+/**
+ * @typedef {Visitors<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitors
+ *   Build typed `Visitors` from a tree and a test.
+ *
+ *   It will infer which values are passed as `node` and which as `parents`.
+ * @template {UnistNode} [Tree=UnistNode]
+ *   Tree type.
+ * @template {Test} [Check=Test]
+ *   Test type.
+ */
+
 
 
 
@@ -1516,6 +1583,7 @@ const EXIT = false
 
 /**
  * Do not traverse this node’s children.
+ * Only works when entering a node.
  */
 const SKIP = 'skip'
 
@@ -1523,10 +1591,13 @@ const SKIP = 'skip'
  * Visit nodes, with ancestral information.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -1535,29 +1606,72 @@ const SKIP = 'skip'
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check>} enter
+ *   Handle each node when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {Check} check
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree>} enter
+ *   Handle each node when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {BuildVisitors<Tree>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} test
- *   `unist-util-is`-compatible test
- * @param {Visitor | boolean | null | undefined} [visitor]
- *   Handle each node.
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
  * @param {boolean | null | undefined} [reverse]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -1566,28 +1680,89 @@ const SKIP = 'skip'
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function visitParents(tree, test, visitor, reverse) {
+function visitParents(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  reverse
+) {
+  if (!tree || typeof tree !== 'object') {
+    throw new Error('Unexpected value `' + tree + '` for `tree`, expected node')
+  }
+
+  let preorder = true
   /** @type {Test} */
   let check
+  /** @type {Visitors | Visitor} */
+  let visitors
+  /** @type {Visitor | null | undefined} */
+  let enter
+  /** @type {VisitorExit | null | undefined} */
+  let exit
+
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
+  if (
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
+  ) {
+    check = /** @type {Test} */ (testOrEnterOrVisitors)
+    visitors = enterOrVisitorsOrReverse
+    if (reverse) preorder = false
+  }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitors | Visitor} */ (testOrEnterOrVisitors)
+    if (enterOrVisitorsOrReverse) preorder = false
+  }
 
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor
-    // @ts-expect-error no visitor given, so `visitor` is test.
-    visitor = test
+  if (typeof visitors === 'function') {
+    enter = visitors
+  } else if (visitors && typeof visitors === 'object') {
+    if (visitors.enter === null || visitors.enter === undefined) {
+      // Empty.
+    } else if (typeof visitors.enter === 'function') {
+      enter = visitors.enter
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.enter +
+          '` for `visitors.enter`, expected optional visitor'
+      )
+    }
+
+    if (typeof visitors.exit === 'function') {
+      exit = visitors.exit
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.exit +
+          '` for `visitors.exit`, expected visitor (pass a visitor directly if you only want an enter visitor)'
+      )
+    }
   } else {
-    // @ts-expect-error visitor given, so `test` isn’t a visitor.
-    check = test
+    throw new Error(
+      'Unexpected value `' +
+        visitors +
+        '` for `enter` or `visitors`, expected visitor or object with visitors'
+    )
   }
 
   const is = convert(check)
-  const step = reverse ? -1 : 1
+  const step = preorder ? 1 : -1
 
   factory(tree, undefined, [])()
 
   /**
+   * Create a function to visit a node.
+   *
    * @param {UnistNode} node
+   *   Node to visit.
    * @param {number | undefined} index
+   *   Index of `node` in its parent.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @returns {() => Readonly<ActionTuple>}
+   *   Visit `node`.
    */
   function factory(node, index, parents) {
     const value = /** @type {Record<string, unknown>} */ (
@@ -1613,18 +1788,13 @@ function visitParents(tree, test, visitor, reverse) {
     return visit
 
     function visit() {
+      const matches =
+        !check || is(node, index, parents[parents.length - 1] || undefined)
       /** @type {Readonly<ActionTuple>} */
       let result = empty
-      /** @type {Readonly<ActionTuple>} */
-      let subresult
-      /** @type {number} */
-      let offset
-      /** @type {Array<UnistParent>} */
-      let grandparents
 
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        // @ts-expect-error: `visitor` is now a visitor.
-        result = toResult(visitor(node, parents))
+      if (enter && matches) {
+        result = toResult(enter(node, parents, index))
 
         if (result[0] === EXIT) {
           return result
@@ -1635,13 +1805,13 @@ function visitParents(tree, test, visitor, reverse) {
         const nodeAsParent = /** @type {UnistParent} */ (node)
 
         if (nodeAsParent.children && result[0] !== SKIP) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step
-          grandparents = parents.concat(nodeAsParent)
+          let offset = (preorder ? -1 : nodeAsParent.children.length) + step
+          const grandparents = [...parents, nodeAsParent]
 
           while (offset > -1 && offset < nodeAsParent.children.length) {
             const child = nodeAsParent.children[offset]
 
-            subresult = factory(child, offset, grandparents)()
+            const subresult = factory(child, offset, grandparents)()
 
             if (subresult[0] === EXIT) {
               return subresult
@@ -1653,6 +1823,23 @@ function visitParents(tree, test, visitor, reverse) {
         }
       }
 
+      if (exit && matches) {
+        const exitResult = toResult(exit(node, parents, index))
+
+        if (exitResult[0] === SKIP) {
+          throw new Error(
+            'Unexpected value `' +
+              exitResult[0] +
+              '` from `exit`, expected `CONTINUE`, `EXIT`, index, or nothing'
+          )
+        }
+
+        // Prefer a result from `exit` over `enter`.
+        if (exitResult[0] === EXIT || typeof exitResult[1] === 'number') {
+          return exitResult
+        }
+      }
+
       return result
     }
   }
@@ -1681,7 +1868,13 @@ function toResult(value) {
 ;// ../node_modules/unist-util-visit/lib/index.js
 /**
  * @import {Node as UnistNode, Parent as UnistParent} from 'unist'
- * @import {VisitorResult} from 'unist-util-visit-parents'
+ * @import {
+ *   InclusiveDescendant,
+ *   Matches,
+ *   Visitors as ParentsVisitors,
+ *   VisitorResult,
+ *   VisitorResultExit
+ * } from 'unist-util-visit-parents'
  */
 
 /**
@@ -1693,67 +1886,6 @@ function toResult(value) {
  *   which doesn’t work when publishing on npm.
  */
 
-// To do: use types from `unist-util-visit-parents` when it’s released.
-
-/**
- * @typedef {(
- *   Fn extends (value: any) => value is infer Thing
- *   ? Thing
- *   : Fallback
- * )} Predicate
- *   Get the value of a type guard `Fn`.
- * @template Fn
- *   Value; typically function that is a type guard (such as `(x): x is Y`).
- * @template Fallback
- *   Value to yield if `Fn` is not a type guard.
- */
-
-/**
- * @typedef {(
- *   Check extends null | undefined // No test.
- *   ? Value
- *   : Value extends {type: Check} // String (type) test.
- *   ? Value
- *   : Value extends Check // Partial test.
- *   ? Value
- *   : Check extends Function // Function test.
- *   ? Predicate<Check, Value> extends Value
- *     ? Predicate<Check, Value>
- *     : never
- *   : never // Some other test?
- * )} MatchesOne
- *   Check whether a node matches a primitive check in the type system.
- * @template Value
- *   Value; typically unist `Node`.
- * @template Check
- *   Value; typically `unist-util-is`-compatible test, but not arrays.
- */
-
-/**
- * @typedef {(
- *   Check extends ReadonlyArray<any>
- *   ? MatchesOne<Value, Check[number]>
- *   : MatchesOne<Value, Check>
- * )} Matches
- *   Check whether a node matches a check in the type system.
- * @template Value
- *   Value; typically unist `Node`.
- * @template Check
- *   Value; typically `unist-util-is`-compatible test.
- */
-
-/**
- * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
- *   Number; capped reasonably.
- */
-
-/**
- * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
- *   Increment a number in the type system.
- * @template {Uint} [I=0]
- *   Index.
- */
-
 /**
  * @typedef {(
  *   Node extends UnistParent
@@ -1779,89 +1911,64 @@ function toResult(value) {
  */
 
 /**
- * @typedef {(
- *   Depth extends Max
- *   ? never
- *   :
- *     | InternalParent<Node, Child>
- *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
- * )} InternalAncestor
- *   Collect nodes in `Tree` that can be ancestors of `Child`.
- * @template {UnistNode} Node
- *   All node types in a tree.
- * @template {UnistNode} Child
- *   Node to search for.
- * @template {Uint} [Max=10]
- *   Max; searches up to this depth.
- * @template {Uint} [Depth=0]
- *   Current depth.
- */
-
-/**
- * @typedef {(
- *   Tree extends UnistParent
- *     ? Depth extends Max
- *       ? Tree
- *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
- *     : Tree
- * )} InclusiveDescendant
- *   Collect all (inclusive) descendants of `Tree`.
+ * @callback Visitor
+ *   Handle a node (matching `test`, if given) before its children.
  *
- *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
- *   > recurse without actually running into an infinite loop, which the
- *   > previous version did.
- *   >
- *   > Practically, a max of `2` is typically enough assuming a `Root` is
- *   > passed, but it doesn’t improve performance.
- *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
- *   > Using up to `10` doesn’t hurt or help either.
- * @template {UnistNode} Tree
- *   Tree type.
- * @template {Uint} [Max=10]
- *   Max; searches up to this depth.
- * @template {Uint} [Depth=0]
- *   Current depth.
+ *   Like `Visitor` in `unist-util-visit-parents`,
+ *   but with `index` and `parent` instead of `parents`.
+ * @param {Visited} node
+ *   Found node.
+ * @param {Visited extends UnistNode ? number | undefined : never} index
+ *   Index of `node` in `parent`,
+ *   or `undefined` for the tree itself.
+ * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+ *   Parent of `node`,
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResult}
+ *   What to do next.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [Ancestor=UnistParent]
+ *   Ancestor type.
  */
 
 /**
- * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform `parent`.
+ * @callback VisitorExit
+ *   Handle a node (matching `test`, if given) after its children.
  *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
- *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
- *
- *   Removing the children property of `parent` still results in them being
- *   traversed.
+ *   Like `VisitorExit` in `unist-util-visit-parents`,
+ *   but with `index` and `parent` instead of `parents`.
  * @param {Visited} node
  *   Found node.
  * @param {Visited extends UnistNode ? number | undefined : never} index
- *   Index of `node` in `parent`.
+ *   Index of `node` in `parent`,
+ *   or `undefined` for the tree itself.
  * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
- *   Parent of `node`.
- * @returns {VisitorResult}
+ *   Parent of `node`,
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResultExit}
  *   What to do next.
- *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
- *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
  * @template {UnistNode} [Visited=UnistNode]
  *   Visited node type.
  * @template {UnistParent} [Ancestor=UnistParent]
  *   Ancestor type.
  */
 
+/**
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [Ancestor=UnistParent]
+ *   Ancestor type.
+ * @typedef Visitors
+ *   Handle nodes when entering and exiting them.
+ *
+ *   Like `Visitors` in `unist-util-visit-parents`.
+ * @property {Visitor<Visited, Ancestor> | null | undefined} [enter]
+ *   Handle a node before its children (optional).
+ * @property {VisitorExit<Visited, Ancestor>} exit
+ *   Handle a node after its children.
+ */
+
 /**
  * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
  *   Build a typed `Visitor` function from a node and all possible parents.
@@ -1905,6 +2012,25 @@ function toResult(value) {
  *   Test type.
  */
 
+/**
+ * @typedef {(
+ *   Visitors<
+ *     Matches<InclusiveDescendant<Tree>, Check>,
+ *     Parent<
+ *       Extract<InclusiveDescendant<Tree>, UnistParent>,
+ *       Matches<InclusiveDescendant<Tree>, Check>
+ *     >
+ *   >
+ * )} BuildVisitors
+ *   Build typed `Visitors` from a tree and a test.
+ *
+ *   It will infer which values are passed as `node` and which as `parent`.
+ * @template {UnistNode} [Tree=UnistNode]
+ *   Node type.
+ * @template {Test} [Check=Test]
+ *   Test type.
+ */
+
 
 
 
@@ -1913,10 +2039,13 @@ function toResult(value) {
  * Visit nodes.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -1925,29 +2054,48 @@ function toResult(value) {
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check> | BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree> | BuildVisitors<Tree>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} testOrVisitor
- *   `unist-util-is`-compatible test (optional, omit to pass a visitor).
- * @param {Visitor | boolean | null | undefined} [visitorOrReverse]
- *   Handle each node (when test is omitted, pass `reverse`).
- * @param {boolean | null | undefined} [maybeReverse=false]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
+ * @param {boolean | null | undefined} [maybeReverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -1956,39 +2104,90 @@ function toResult(value) {
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+function visit(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  maybeReverse
+) {
+  /** @type {Test} */
+  let check
+  /** @type {Visitor | Visitors} */
+  let visitors
   /** @type {boolean | null | undefined} */
   let reverse
-  /** @type {Test} */
-  let test
-  /** @type {Visitor} */
-  let visitor
 
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
   if (
-    typeof testOrVisitor === 'function' &&
-    typeof visitorOrReverse !== 'function'
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
   ) {
-    test = undefined
-    visitor = testOrVisitor
-    reverse = visitorOrReverse
-  } else {
-    // @ts-expect-error: assume the overload with test was given.
-    test = testOrVisitor
-    // @ts-expect-error: assume the overload with test was given.
-    visitor = visitorOrReverse
+    check = /** @type {Test} */ (testOrEnterOrVisitors)
+    visitors = enterOrVisitorsOrReverse
     reverse = maybeReverse
   }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitor | Visitors} */ (testOrEnterOrVisitors)
+    reverse = enterOrVisitorsOrReverse
+  }
 
-  visitParents(tree, test, overload, reverse)
+  if (typeof visitors === 'function') {
+    visitParents(tree, check, wrap(visitors), reverse)
+  } else {
+    visitParents(tree, check, wrapVisitors(visitors), reverse)
+  }
+}
+
+/**
+ * Turn `visit` visitors into `visitParents` visitors.
+ *
+ * @param {Visitors} visitors
+ *   Visitors for `visit`.
+ * @returns {ParentsVisitors}
+ *   Visitors for `visitParents`.
+ */
+function wrapVisitors(visitors) {
+  // Pass anything else straight to `visitParents` to get its errors.
+  if (!visitors || typeof visitors !== 'object') return visitors
+
+  return {
+    enter:
+      typeof visitors.enter === 'function'
+        ? wrap(visitors.enter)
+        : visitors.enter,
+    exit:
+      typeof visitors.exit === 'function' ? wrap(visitors.exit) : visitors.exit
+  }
+}
+
+/**
+ * Turn a `visit` visitor into a `visitParents` one.
+ *
+ * @template {VisitorResult} Result
+ *   Result type.
+ * @param {(node: UnistNode, index: number | undefined, parent: UnistParent | undefined) => Result} visitor
+ *   Visitor for `visit`.
+ * @returns {(node: UnistNode, parents: Array<UnistParent>, index: number | undefined) => Result}
+ *   Visitor for `visitParents`.
+ */
+function wrap(visitor) {
+  return overload
 
   /**
+   * Call `visitor` with `index` and `parent` instead of `parents`.
+   *
    * @param {UnistNode} node
+   *   Visited node.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @param {number | undefined} index
+   *   Index of `node` in its parent.
+   * @returns {Result}
+   *   What to do next.
    */
-  function overload(node, parents) {
-    const parent = parents[parents.length - 1]
-    const index = parent ? parent.children.indexOf(node) : undefined
-    return visitor(node, index, parent)
+  function overload(node, parents, index) {
+    return visitor(node, index, parents[parents.length - 1])
   }
 }
 
@@ -60673,7 +60872,7 @@ function state_createState(tree, options) {
     one,
     options: settings,
     patch: state_patch,
-    wrap
+    wrap: state_wrap
   }
 
   visit(tree, function (node) {
@@ -60887,7 +61086,7 @@ function defaultUnknownHandler(state, node) {
  * @returns {Array<HastText | Type>}
  *   Wrapped nodes.
  */
-function wrap(nodes, loose) {
+function state_wrap(nodes, loose) {
   /** @type {Array<HastText | Type>} */
   const result = []
   let index = -1
@@ -64824,7 +65023,7 @@ function escapeStringRegexp(string) {
  * @param {FindAndReplaceList | FindAndReplaceTuple} list
  *   Patterns to find.
  * @param {Options | null | undefined} [options]
- *   Configuration (when `find` is not `Find`).
+ *   Configuration (optional).
  * @returns {undefined}
  *   Nothing.
  */
@@ -64835,40 +65034,20 @@ function findAndReplace(tree, list, options) {
   let pairIndex = -1
 
   while (++pairIndex < pairs.length) {
-    visitParents(tree, 'text', visitor)
+    visitParents(tree, visitor)
   }
 
   /**
-   * Visit a text node, and handle it if it is not in an ignored parent.
+   * Handle text nodes and skip ignored nodes.
    *
-   * @type {BuildVisitor<Root, 'text'>}
+   * @type {BuildVisitor<Root>}
    */
-  function visitor(node, parents) {
-    let index = -1
-    /** @type {Parents | undefined} */
-    let grandparent
-
-    while (++index < parents.length) {
-      const parent = parents[index]
-      /** @type {Array<Nodes> | undefined} */
-      const siblings = grandparent ? grandparent.children : undefined
-
-      if (
-        ignored(
-          parent,
-          siblings ? siblings.indexOf(parent) : undefined,
-          grandparent
-        )
-      ) {
-        return
-      }
-
-      grandparent = parent
+  function visitor(node, parents, index) {
+    if (node.type === 'text' && typeof index === 'number') {
+      return handler(node, parents, index)
     }
 
-    if (grandparent) {
-      return handler(node, parents)
-    }
+    if (ignored(node, index, parents[parents.length - 1])) return (/* inlined export .SKIP */"skip")
   }
 
   /**
@@ -64878,17 +65057,16 @@ function findAndReplace(tree, list, options) {
    *   Text node to search in.
    * @param {Array<Parents>} parents
    *   Ancestors of `node`.
+   * @param {number} index
+   *   Index of `node` in its parent.
    * @returns {VisitorResult}
    *   Where to continue visiting.
    */
-  function handler(node, parents) {
+  function handler(node, parents, index) {
     const parent = parents[parents.length - 1]
     const find = pairs[pairIndex][0]
     const replace = pairs[pairIndex][1]
     let start = 0
-    /** @type {Array<Nodes>} */
-    const siblings = parent.children
-    const index = siblings.indexOf(node)
     let change = false
     /** @type {Array<PhrasingContent>} */
     let nodes = []
@@ -64987,12 +65165,10 @@ function toPairs(tupleOrList) {
   /** @type {Pairs} */
   const result = []
 
-  /** @type {FindAndReplaceList} */
-  // @ts-expect-error: correct.
   const list =
     !tupleOrList[0] || Array.isArray(tupleOrList[0])
-      ? tupleOrList
-      : [tupleOrList]
+      ? /** @type {FindAndReplaceList} */ (tupleOrList)
+      : [/** @type {FindAndReplaceTuple} */ (tupleOrList)]
 
   let index = -1
 
@@ -77626,7 +77802,7 @@ var commands_getCommands=function getCommands(){return[bold,italic,strikeThrough
    * `9` - `Tab`
    */if(!defaultTabEnable&&e.code&&e.code.toLowerCase()==='tab'){stopPropagation(e);var space=new Array(tabSize+1).join('  ');if(target.selectionStart!==target.selectionEnd){var _star=target.value.substring(0,target.selectionStart).split('\n');var _end=target.value.substring(0,target.selectionEnd).split('\n');var modifiedTextLine=[];_end.forEach(function(item,idx){if(item!==_star[idx]){modifiedTextLine.push(item);}});var modifiedText=modifiedTextLine.join('\n');var oldSelectText=target.value.substring(target.selectionStart,target.selectionEnd);var newStarNum=target.value.substring(0,target.selectionStart).length;textArea.setSelectionRange({start:target.value.indexOf(modifiedText),end:target.selectionEnd});var modifiedTextObj=insertBeforeEachLine(modifiedText,e.shiftKey?'':space);var text=modifiedTextObj.modifiedText;if(e.shiftKey){text=text.split('\n').map(function(item){return item.replace(new RegExp("^".concat(space)),'');}).join('\n');}textArea.replaceSelection(text);var startTabSize=e.shiftKey?-tabSize:tabSize;var endTabSize=e.shiftKey?-modifiedTextLine.length*tabSize:modifiedTextLine.length*tabSize;textArea.setSelectionRange({start:newStarNum+startTabSize,end:newStarNum+oldSelectText.length+endTabSize});}else{return insertTextAtPosition(target,space);}}else if(e.keyCode===13&&e.code.toLowerCase()==='enter'&&(/^(-|\*)\s/.test(currentLineStr)||/^\d+\.\s/.test(currentLineStr))&&!e.shiftKey){/**
      * `13` - `Enter`
-     */stopPropagation(e);var startStr='\n- ';if(currentLineStr.startsWith('*')){startStr='\n* ';}if(currentLineStr.startsWith('- [ ]')||currentLineStr.startsWith('- [X]')||currentLineStr.startsWith('- [x]')){startStr='\n- [ ] ';}if(/^\d+\.\s/.test(currentLineStr)){startStr="\n".concat(parseInt(currentLineStr)+1,". ");}return insertTextAtPosition(target,startStr);}else if(e.code&&e.code.toLowerCase()==='keyd'&&e.ctrlKey){// Duplicate lines
+     */stopPropagation(e);var atEndOfLine=target.selectionEnd===target.value.length||target.value[target.selectionEnd]==='\n';var emptyListItem=/^(?:[-*]|\d+\.)\s+$/.test(currentLineStr)||/^- \[[ xX]\]\s*$/.test(currentLineStr);if(target.selectionStart===target.selectionEnd&&atEndOfLine&&emptyListItem){textArea.setSelectionRange({start:target.selectionStart-currentLineStr.length,end:target.selectionEnd});return insertTextAtPosition(target,'');}var startStr='\n- ';if(currentLineStr.startsWith('*')){startStr='\n* ';}if(currentLineStr.startsWith('- [ ]')||currentLineStr.startsWith('- [X]')||currentLineStr.startsWith('- [x]')){startStr='\n- [ ] ';}if(/^\d+\.\s/.test(currentLineStr)){startStr="\n".concat(parseInt(currentLineStr)+1,". ");}return insertTextAtPosition(target,startStr);}else if(e.code&&e.code.toLowerCase()==='keyd'&&e.ctrlKey){// Duplicate lines
 stopPropagation(e);var selection={start:target.selectionStart,end:target.selectionEnd};var savedSelection=selection;selection=selectLine({text:target.value,selection:selection});var textToDuplicate=target.value.slice(selection.start,selection.end);textArea.setSelectionRange({start:selection.end,end:selection.end});insertTextAtPosition(target,"\n".concat(textToDuplicate));textArea.setSelectionRange({start:savedSelection.start,end:savedSelection.end});}else if(e.code&&e.code.toLowerCase()==='arrowup'&&e.altKey){handleLineMove(e,-1);}else if(e.code&&e.code.toLowerCase()==='arrowdown'&&e.altKey){handleLineMove(e,1);}}
 ;// ./src/components/TextArea/index.less
 // extracted by mini-css-extract-plugin