Add support for returning false to not replace

* Add support for returning `false` to not replace
* Fix to not recurse into replacements
* Refactor to improve bundle size

Author: wooorm

index.js

@@ -6,6 +6,8 @@ var escape = require('escape-string-regexp')
 
 var defaultIgnore = ['title', 'script', 'style', 'svg', 'math']
 
+var splice = [].splice
+
 module.exports = findAndReplace
 
 findAndReplace.ignore = defaultIgnore
@@ -36,82 +38,78 @@ function findAndReplace(tree, find, replace, options) {
     return handler
 
     function handler(node, parent) {
-      var siblings = parent.children
-      var pos = siblings.indexOf(node)
-      var value = node.value
       var find = pair[0]
       var replace = pair[1]
-      var lastIndex = 0
       var nodes = []
-      var subvalue
-      var index
-      var length
+      var start = 0
+      var index = parent.children.indexOf(node)
+      var position
       var match
       var subhandler
+      var value
 
       find.lastIndex = 0
 
-      match = find.exec(value)
+      match = find.exec(node.value)
 
       while (match) {
-        index = match.index
-        subvalue = value.slice(lastIndex, index)
+        position = match.index
+        value = replace.apply(
+          null,
+          [].concat(match, {index: match.index, input: match.input})
+        )
 
-        if (subvalue) {
-          nodes.push({type: 'text', value: subvalue})
-        }
+        if (value !== false) {
+          if (start !== position) {
+            nodes.push({type: 'text', value: node.value.slice(start, position)})
+          }
 
-        subvalue = replace.apply(null, match)
+          if (typeof value === 'string' && value.length > 0) {
+            value = {type: 'text', value: value}
+          }
 
-        if (subvalue) {
-          if (typeof subvalue === 'string') {
-            subvalue = {type: 'text', value: subvalue}
+          if (value) {
+            nodes.push(value)
           }
 
-          nodes.push(subvalue)
+          start = position + match[0].length
         }
 
-        lastIndex = index + match[0].length
-
         if (!find.global) {
           break
         }
 
-        match = find.exec(value)
+        match = find.exec(node.value)
       }
 
-      if (index === undefined) {
+      if (position === undefined) {
         nodes = [node]
+        index--
       } else {
-        subvalue = value.slice(lastIndex)
-
-        if (subvalue) {
-          nodes.push({type: 'text', value: subvalue})
+        if (start < node.value.length) {
+          nodes.push({type: 'text', value: node.value.slice(start)})
         }
 
-        parent.children = siblings
-          .slice(0, pos)
-          .concat(nodes)
-          .concat(siblings.slice(pos + 1))
-      }
-
-      if (pairs.length <= 1) {
-        return
+        nodes.unshift(index, 1)
+        splice.apply(parent.children, nodes)
       }
 
-      length = nodes.length
-      index = -1
-      subhandler = handlerFactory(pairs.slice(1))
+      if (pairs.length > 1) {
+        subhandler = handlerFactory(pairs.slice(1))
+        position = -1
 
-      while (++index < length) {
-        node = nodes[index]
+        while (++position < nodes.length) {
+          node = nodes[position]
 
-        if (node.type === 'text') {
-          subhandler(node, parent)
-        } else {
-          search(node, settings, subhandler)
+          if (node.type === 'text') {
+            subhandler(node, parent)
+          } else {
+            search(node, settings, subhandler)
+          }
         }
       }
+
+      return index + nodes.length + 1
     }
   }
 }
@@ -125,12 +123,11 @@ function search(tree, options, handler) {
   return result
 
   function visitor(node, parents) {
-    var length = parents.length
     var index = -1
     var parent
     var grandparent
 
-    while (++index < length) {
+    while (++index < parents.length) {
       parent = parents[index]
 
       if (
@@ -146,25 +143,23 @@ function search(tree, options, handler) {
       grandparent = parent
     }
 
-    handler(node, grandparent)
+    return handler(node, grandparent)
   }
 }
 
 function toPairs(schema) {
   var result = []
   var key
-  var length
   var index
 
   if (typeof schema !== 'object') {
     throw new Error('Expected array or object as schema')
   }
 
   if ('length' in schema) {
-    length = schema.length
     index = -1
 
-    while (++index < length) {
+    while (++index < schema.length) {
       result.push([
         toExpression(schema[index][0]),
         toFunction(schema[index][1])

readme.md

@@ -91,11 +91,11 @@ Partial matches are not supported.
 *   `replace` (`string` or `Function`)
     — Value to insert.
     When `string`, turned into a [`Text`][text] node.
-    When `Function`, invoked with the results of calling `RegExp.exec` as
-    arguments, in which case it can return a [`Node`][node] or a `string`, which
-    is in the latter case wrapped in a [`Text`][text] node
+    When `Function`, called with the results of calling `RegExp.exec` as
+    arguments, in which case it can return a [`Node`][node] or a `string` (which
+    is wrapped in a [`Text`][text] node), or `false` to not replace
 *   `search` (`Object` or `Array`)
-    — Perform multiple find-and-replace’s.
+    — Perform multiple find-and-replaces.
     When `Array`, each entry is a tuple (`Array`) of a `find` (at `0`) and
     `replace` (at `1`).
     When `Object`, each key is a `find` (in string form) and each value is a

test.js

@@ -166,6 +166,12 @@ test('findAndReplace', function (t) {
     'should ignore from options'
   )
 
+  t.deepEqual(
+    findAndReplace(create(), 'emphasis', () => false),
+    create(),
+    'should not replace when returning `false`'
+  )
+
   t.deepEqual(
     findAndReplace(h('p', 'Some emphasis, importance, and code.'), {
       importance: function (match) {