Roll your own Mustache-like plaintext template language with custom syntax and template directives.

var plaintemplate = require('plaintemplate')
var assert = require('assert')

var processor = plaintemplate(
  // Template directive handler
  function handler(token, context, stringify) {
    var directive = token.tag.trim()
    // Repeate a tag's contents five times.
    if (directive.startsWith('five')) {
      var output = ''
      for (var counter = 0; counter < 5; counter++) {
        output += stringify(token.content, context, handler)
      }
      return output
    // Insert a string from context.
    } else if (directive.startsWith('=')) {
      var key = directive.split(' ')[1]
      return context[key]
    } else throw new Error('Invalid directive')
  },
  // Use custom double-parentheses template tags.
  {open: '((', close: '))', start: '{', end: '}'}
)

processor(
  // Template input
  '(( five { ))Howdy, (( = name ))! (( } ))',
  // Context
  {name: 'John'},
  // Callback
  function (error, result) {
    assert.deepStrictEqual(
      result,
      'Howdy, John! ' +
      'Howdy, John! ' +
      'Howdy, John! ' +
      'Howdy, John! ' +
      'Howdy, John! '
    )
  }
)

The package exports a single function of two arguments:

1. Tag Hangler, optional (omit with undefined), a function of three arguments:

   1. Token, the plaintemplate-parse tag token object to stringify

   2. Context, the context in which the token is to be stringified

   3. Stringify, a function used to recursively stringify other plaintemplate-parse tokens, of three arguments:

      1. Content, an array of plaintemplate-parse text and tag token objects, probably a tag token's content property

      2. Context

      3. Tag Handler

   4. Callback, an error-first function

2. Parser Options, optional, an object, passed directly to plaintemplate-parse

The function returns another function of three arguments:

1. Input, a string, containing template text and tags

2. Context, an object, containing values that affect the template

3. Callback, an error-first function yielding the result of template processing

The default tag handler defines a number of template tag directives:

1. insert X. Replaces a tag with the value of X in context. Throws an error if X does not exist in context.

2. if X. Renders the tag's contents only if X exists in context and has a "truthy" value. Throws an error if X does not exist in context.

3. unless X. Renders the tag's contents only if X exists in context and has a "falsey" value. Throws an error if X does not exist in context.

4. each X. Renders the tag's contents once for every array element of X in context. Throws an error if X does not exist in context, or if X exists in context, but is not an array. Sets a number of additional variables in context when rendering the tag's contents:

   1. element, the array element being rendered

   2. odd, if the index of the element in the array (counting from 1) is odd

   3. even, if the index of the element in the array (counting from

      1. is even

   4. first, true if the element is the first element of the array

   5. last, true if the element is the last element of the array