restream/build/SyncReplaceable.js

const { checkRule, hideStack } = require('./lib');

/**
  * _SyncReplaceable_ function receives the whole string and returns the result of transform rules which are either sync function replacers or string replacements (see https://github.com/artdecocode/restream#rule-type for more info). This is not a class and just a function.
  * @param {string|!Buffer} input The string or buffer to transform synchronously using the replacements. Does not support asynchronous replacements.
  * @param {!Array<!_restream.Rule>} rules An array with rules.
  * @return {string}
  * @example
```
// markdown __ to html <em> implementation
const stream = SyncReplaceable('__hello world__', {
  re: /__(\S+)__/g,
  replacement(match, p1) {
    return `<em>${p1}</em>`
  },
})
```
  */
function SyncReplaceable(input, rules) {
  /**
   * @suppress {globalThis}
   */
  function replace() {
    const fr = rules.filter(checkRule)
    const s = fr.reduce((acc, { re, replacement }) => {
      /** @type {string} */
      let Acc = acc
      if (this._broke) return Acc

      if (typeof replacement == 'string') {
        Acc = Acc.replace(re, replacement)
      } else {
        let commonError
        const t = Acc.replace(re, (match, ...args) => {
          commonError = new Error()
          try {
            if (this._broke) return match
            const p = replacement.call(this, match, ...args)
            return p
          } catch (e) { // hide stack for sync stack traces
            hideStack(commonError, e)
          }
        })
        return t
      }
    }, `${input}`)
    return s
  }
  replace.brake = () => { replace._broke = true }
  return replace.call(replace)
}

module.exports=SyncReplaceable

/**
 * @suppress {nonStandardJsDocs}
 * @typedef {import('..').Rule} _restream.Rule
 */