@heroku/heroku-cli-util 8.0.14 → 9.0.0-beta.0

package/lib/linewrap.js

@@ -1,783 +0,0 @@
-// code is from https://github.com/AnAppAMonth/linewrap
-
-// Presets
-var presetMap = {
-  'html': {
-    skipScheme: 'html',
-    lineBreakScheme: 'html',
-    whitespace: 'collapse'
-  }
-}
-
-// lineBreak Schemes
-var brPat = /<\s*br(?:[\s/]*|\s[^>]*)>/gi
-var lineBreakSchemeMap = {
-  'unix': [/\n/g, '\n'],
-  'dos': [/\r\n/g, '\r\n'],
-  'mac': [/\r/g, '\r'],
-  'html': [brPat, '<br>'],
-  'xhtml': [brPat, '<br/>']
-}
-
-// skip Schemes
-var skipSchemeMap = {
-  'ansi-color': /\x1B\[[^m]*m/g,
-  'html': /<[^>]*>/g,
-  'bbcode': /\[[^]]*\]/g
-}
-
-var modeMap = {
-  'soft': 1,
-  'hard': 1
-}
-
-var wsMap = {
-  'collapse': 1,
-  'default': 1,
-  'line': 1,
-  'all': 1
-}
-
-var rlbMap = {
-  'all': 1,
-  'multi': 1,
-  'none': 1
-}
-var rlbSMPat = /([sm])(\d+)/
-
-var escapePat = /[-/\\^$*+?.()|[\]{}]/g
-function escapeRegExp (s) {
-  return s.replace(escapePat, '\\$&')
-}
-
-var linewrap = module.exports = function (start, stop, params) {
-  if (typeof start === 'object') {
-    params = start
-    start = params.start
-    stop = params.stop
-  }
-
-  if (typeof stop === 'object') {
-    params = stop
-    start = start || params.start
-    stop = undefined
-  }
-
-  if (!stop) {
-    stop = start
-    start = 0
-  }
-
-  if (!params) { params = {}; }
-  // Supported options and default values.
-  var preset,
-    mode = 'soft',
-    whitespace = 'default',
-    tabWidth = 4,
-    skip, skipScheme, lineBreak, lineBreakScheme,
-    respectLineBreaks = 'all',
-    respectNum,
-    preservedLineIndent,
-    wrapLineIndent, wrapLineIndentBase
-
-  var skipPat
-  var lineBreakPat, lineBreakStr
-  var multiLineBreakPat
-  var preservedLinePrefix = ''
-  var wrapLineIndentPat, wrapLineInitPrefix = ''
-  var tabRepl
-  var item, flags
-  var i
-
-  // First process presets, because these settings can be overwritten later.
-  preset = params.preset
-  if (preset) {
-    if (!(preset instanceof Array)) {
-      preset = [preset]
-    }
-    for (i = 0; i < preset.length; i++) {
-      item = presetMap[preset[i]]
-      if (item) {
-        if (item.mode) {
-          mode = item.mode
-        }
-        if (item.whitespace) {
-          whitespace = item.whitespace
-        }
-        if (item.tabWidth !== undefined) {
-          tabWidth = item.tabWidth
-        }
-        if (item.skip) {
-          skip = item.skip
-        }
-        if (item.skipScheme) {
-          skipScheme = item.skipScheme
-        }
-        if (item.lineBreak) {
-          lineBreak = item.lineBreak
-        }
-        if (item.lineBreakScheme) {
-          lineBreakScheme = item.lineBreakScheme
-        }
-        if (item.respectLineBreaks) {
-          respectLineBreaks = item.respectLineBreaks
-        }
-        if (item.preservedLineIndent !== undefined) {
-          preservedLineIndent = item.preservedLineIndent
-        }
-        if (item.wrapLineIndent !== undefined) {
-          wrapLineIndent = item.wrapLineIndent
-        }
-        if (item.wrapLineIndentBase) {
-          wrapLineIndentBase = item.wrapLineIndentBase
-        }
-      } else {
-        throw new TypeError('preset must be one of "' + Object.keys(presetMap).join('", "') + '"')
-      }
-    }
-  }
-
-  if (params.mode) {
-    if (modeMap[params.mode]) {
-      mode = params.mode
-    } else {
-      throw new TypeError('mode must be one of "' + Object.keys(modeMap).join('", "') + '"')
-    }
-  }
-  // Available options: 'collapse', 'default', 'line', and 'all'
-  if (params.whitespace) {
-    if (wsMap[params.whitespace]) {
-      whitespace = params.whitespace
-    } else {
-      throw new TypeError('whitespace must be one of "' + Object.keys(wsMap).join('", "') + '"')
-    }
-  }
-
-  if (params.tabWidth !== undefined) {
-    if (parseInt(params.tabWidth, 10) >= 0) {
-      tabWidth = parseInt(params.tabWidth, 10)
-    } else {
-      throw new TypeError('tabWidth must be a non-negative integer')
-    }
-  }
-  tabRepl = new Array(tabWidth + 1).join(' ')
-
-  // Available options: 'all', 'multi', 'm\d+', 's\d+', 'none'
-  if (params.respectLineBreaks) {
-    if (rlbMap[params.respectLineBreaks] || rlbSMPat.test(params.respectLineBreaks)) {
-      respectLineBreaks = params.respectLineBreaks
-    } else {
-      throw new TypeError('respectLineBreaks must be one of "' + Object.keys(rlbMap).join('", "') +
-        '", "m<num>", "s<num>"')
-    }
-  }
-  // After these conversions, now we have 4 options in `respectLineBreaks`:
-  // 'all', 'none', 'm' and 's'.
-  // `respectNum` is applicable iff `respectLineBreaks` is either 'm' or 's'.
-  if (respectLineBreaks === 'multi') {
-    respectLineBreaks = 'm'
-    respectNum = 2
-  } else if (!rlbMap[respectLineBreaks]) {
-    var match = rlbSMPat.exec(respectLineBreaks)
-    respectLineBreaks = match[1]
-    respectNum = parseInt(match[2], 10)
-  }
-
-  if (params.preservedLineIndent !== undefined) {
-    if (parseInt(params.preservedLineIndent, 10) >= 0) {
-      preservedLineIndent = parseInt(params.preservedLineIndent, 10)
-    } else {
-      throw new TypeError('preservedLineIndent must be a non-negative integer')
-    }
-  }
-
-  if (preservedLineIndent > 0) {
-    preservedLinePrefix = new Array(preservedLineIndent + 1).join(' ')
-  }
-
-  if (params.wrapLineIndent !== undefined) {
-    if (!isNaN(parseInt(params.wrapLineIndent, 10))) {
-      wrapLineIndent = parseInt(params.wrapLineIndent, 10)
-    } else {
-      throw new TypeError('wrapLineIndent must be an integer')
-    }
-  }
-  if (params.wrapLineIndentBase) {
-    wrapLineIndentBase = params.wrapLineIndentBase
-  }
-
-  if (wrapLineIndentBase) {
-    if (wrapLineIndent === undefined) {
-      throw new TypeError('wrapLineIndent must be specified when wrapLineIndentBase is specified')
-    }
-    if (wrapLineIndentBase instanceof RegExp) {
-      wrapLineIndentPat = wrapLineIndentBase
-    } else if (typeof wrapLineIndentBase === 'string') {
-      wrapLineIndentPat = new RegExp(escapeRegExp(wrapLineIndentBase))
-    } else {
-      throw new TypeError('wrapLineIndentBase must be either a RegExp object or a string')
-    }
-  } else if (wrapLineIndent > 0) {
-    wrapLineInitPrefix = new Array(wrapLineIndent + 1).join(' ')
-  } else if (wrapLineIndent < 0) {
-    throw new TypeError('wrapLineIndent must be non-negative when a base is not specified')
-  }
-
-  // NOTE: For the two RegExps `skipPat` and `lineBreakPat` that can be specified
-  //       by the user:
-  //       1. We require them to be "global", so we have to convert them to global
-  //          if the user specifies a non-global regex.
-  //       2. We cannot call `split()` on them, because they may or may not contain
-  //          capturing parentheses which affect the output of `split()`.
-
-  // Precedence: Regex = Str > Scheme
-  if (params.skipScheme) {
-    if (skipSchemeMap[params.skipScheme]) {
-      skipScheme = params.skipScheme
-    } else {
-      throw new TypeError('skipScheme must be one of "' + Object.keys(skipSchemeMap).join('", "') + '"')
-    }
-  }
-  if (params.skip) {
-    skip = params.skip
-  }
-
-  if (skip) {
-    if (skip instanceof RegExp) {
-      skipPat = skip
-      if (!skipPat.global) {
-        flags = 'g'
-        if (skipPat.ignoreCase) { flags += 'i'; }
-        if (skipPat.multiline) { flags += 'm'; }
-        skipPat = new RegExp(skipPat.source, flags)
-      }
-    } else if (typeof skip === 'string') {
-      skipPat = new RegExp(escapeRegExp(skip), 'g')
-    } else {
-      throw new TypeError('skip must be either a RegExp object or a string')
-    }
-  }
-  if (!skipPat && skipScheme) {
-    skipPat = skipSchemeMap[skipScheme]
-  }
-
-  // Precedence:
-  // - for lineBreakPat: Regex > Scheme > Str
-  // - for lineBreakStr: Str > Scheme > Regex
-  if (params.lineBreakScheme) {
-    if (lineBreakSchemeMap[params.lineBreakScheme]) {
-      lineBreakScheme = params.lineBreakScheme
-    } else {
-      throw new TypeError('lineBreakScheme must be one of "' + Object.keys(lineBreakSchemeMap).join('", "') + '"')
-    }
-  }
-  if (params.lineBreak) {
-    lineBreak = params.lineBreak
-  }
-
-  if (lineBreakScheme) {
-    // Supported schemes: 'unix', 'dos', 'mac', 'html', 'xhtml'
-    item = lineBreakSchemeMap[lineBreakScheme]
-    if (item) {
-      lineBreakPat = item[0]
-      lineBreakStr = item[1]
-    }
-  }
-  if (lineBreak) {
-    if (lineBreak instanceof Array) {
-      if (lineBreak.length === 1) {
-        lineBreak = lineBreak[0]
-      } else if (lineBreak.length >= 2) {
-        if (lineBreak[0] instanceof RegExp) {
-          lineBreakPat = lineBreak[0]
-          if (typeof lineBreak[1] === 'string') {
-            lineBreakStr = lineBreak[1]
-          }
-        } else if (lineBreak[1] instanceof RegExp) {
-          lineBreakPat = lineBreak[1]
-          if (typeof lineBreak[0] === 'string') {
-            lineBreakStr = lineBreak[0]
-          }
-        } else if (typeof lineBreak[0] === 'string' && typeof lineBreak[1] === 'string') {
-          lineBreakPat = new RegExp(escapeRegExp(lineBreak[0]), 'g')
-          lineBreakStr = lineBreak[1]
-        } else {
-          lineBreak = lineBreak[0]
-        }
-      }
-    }
-    if (typeof lineBreak === 'string') {
-      lineBreakStr = lineBreak
-      if (!lineBreakPat) {
-        lineBreakPat = new RegExp(escapeRegExp(lineBreak), 'g')
-      }
-    } else if (lineBreak instanceof RegExp) {
-      lineBreakPat = lineBreak
-    } else if (!(lineBreak instanceof Array)) {
-      throw new TypeError('lineBreak must be a RegExp object, a string, or an array consisted of a RegExp object and a string')
-    }
-  }
-  // Only assign defaults when `lineBreakPat` is not assigned.
-  // So if `params.lineBreak` is a RegExp, we don't have a value in `lineBreakStr`
-  // yet. We will try to get the value from the input string, and if failed, we
-  // will throw an exception.
-  if (!lineBreakPat) {
-    lineBreakPat = /\n/g
-    lineBreakStr = '\n'
-  }
-
-  // Create `multiLineBreakPat` based on `lineBreakPat`, that matches strings
-  // consisted of one or more line breaks and zero or more whitespaces.
-  // Also convert `lineBreakPat` to global if not already so.
-  flags = 'g'
-  if (lineBreakPat.ignoreCase) { flags += 'i'; }
-  if (lineBreakPat.multiline) { flags += 'm'; }
-  multiLineBreakPat = new RegExp('\\s*(?:' + lineBreakPat.source + ')(?:' +
-    lineBreakPat.source + '|\\s)*', flags)
-  if (!lineBreakPat.global) {
-    lineBreakPat = new RegExp(lineBreakPat.source, flags)
-  }
-
-  // Initialize other useful variables.
-  var re = mode === 'hard' ? /\b/ : /(\S+\s+)/
-  var prefix = new Array(start + 1).join(' ')
-  var wsStrip = (whitespace === 'default' || whitespace === 'collapse'),
-    wsCollapse = (whitespace === 'collapse'),
-    wsLine = (whitespace === 'line'),
-    wsAll = (whitespace === 'all')
-  var tabPat = /\t/g,
-    collapsePat = /  +/g,
-    pPat = /^\s+/,
-    tPat = /\s+$/,
-    nonWsPat = /\S/,
-    wsPat = /\s/
-  var wrapLen = stop - start
-
-  return function (text) {
-    text = text.toString().replace(tabPat, tabRepl)
-
-    var match
-    if (!lineBreakStr) {
-      // Try to get lineBreakStr from `text`
-      lineBreakPat.lastIndex = 0
-      match = lineBreakPat.exec(text)
-      if (match) {
-        lineBreakStr = match[0]
-      } else {
-        throw new TypeError('Line break string for the output not specified')
-      }
-    }
-
-    // text -> blocks; each bloc -> segments; each segment -> chunks
-    var blocks, base = 0
-    var mo, arr, b, res
-    // Split `text` by line breaks.
-    blocks = []
-    multiLineBreakPat.lastIndex = 0
-    match = multiLineBreakPat.exec(text)
-    while(match) {
-      blocks.push(text.substring(base, match.index))
-
-      if (respectLineBreaks !== 'none') {
-        arr = []
-        b = 0
-        lineBreakPat.lastIndex = 0
-        mo = lineBreakPat.exec(match[0])
-        while(mo) {
-          arr.push(match[0].substring(b, mo.index))
-          b = mo.index + mo[0].length
-          mo = lineBreakPat.exec(match[0])
-        }
-        arr.push(match[0].substring(b))
-        blocks.push({type: 'break', breaks: arr})
-      } else {
-        // Strip line breaks and insert spaces when necessary.
-        if (wsCollapse) {
-          res = ' '
-        } else {
-          res = match[0].replace(lineBreakPat, '')
-        }
-        blocks.push({type: 'break', remaining: res})
-      }
-
-      base = match.index + match[0].length
-      match = multiLineBreakPat.exec(text)
-    }
-    blocks.push(text.substring(base))
-
-    var i, j, k
-    var segments
-    if (skipPat) {
-      segments = []
-      for (i = 0; i < blocks.length; i++) {
-        var bloc = blocks[i]
-        if (typeof bloc !== 'string') {
-          // This is an object.
-          segments.push(bloc)
-        } else {
-          base = 0
-          skipPat.lastIndex = 0
-          match = skipPat.exec(bloc)
-          while(match) {
-            segments.push(bloc.substring(base, match.index))
-            segments.push({type: 'skip', value: match[0]})
-            base = match.index + match[0].length
-            match = skipPat.exec(bloc)
-          }
-          segments.push(bloc.substring(base))
-        }
-      }
-    } else {
-      segments = blocks
-    }
-
-    var chunks = []
-    for (i = 0; i < segments.length; i++) {
-      var segment = segments[i]
-      if (typeof segment !== 'string') {
-        // This is an object.
-        chunks.push(segment)
-      } else {
-        if (wsCollapse) {
-          segment = segment.replace(collapsePat, ' ')
-        }
-
-        var parts = segment.split(re),
-          acc = []
-
-        for (j = 0; j < parts.length; j++) {
-          var x = parts[j]
-          if (mode === 'hard') {
-            for (k = 0; k < x.length; k += wrapLen) {
-              acc.push(x.slice(k, k + wrapLen))
-            }
-          } else { acc.push(x); }
-        }
-        chunks = chunks.concat(acc)
-      }
-    }
-
-    var curLine = 0,
-      curLineLength = start + preservedLinePrefix.length,
-      lines = [ prefix + preservedLinePrefix ],
-      // Holds the "real length" (excluding trailing whitespaces) of the
-      // current line if it exceeds `stop`, otherwise 0.
-      // ONLY USED when `wsAll` is true, in `finishOffCurLine()`.
-      bulge = 0,
-      // `cleanLine` is true iff we are at the beginning of an output line. By
-      // "beginning" we mean it doesn't contain any non-whitespace char yet.
-      // But its `curLineLength` can be greater than `start`, or even possibly
-      // be greater than `stop`, if `wsStrip` is false.
-      //
-      // Note that a "clean" line can still contain skip strings, in addition
-      // to whitespaces.
-      //
-      // This variable is used to allow us strip preceding whitespaces when
-      // `wsStrip` is true, or `wsLine` is true and `preservedLine` is false.
-      cleanLine = true,
-      // `preservedLine` is true iff we are in a preserved input line.
-      //
-      // It's used when `wsLine` is true to (combined with `cleanLine`) decide
-      // whether a whitespace is at the beginning of a preserved input line and
-      // should not be stripped.
-      preservedLine = true,
-      // The current indent prefix for wrapped lines.
-      wrapLinePrefix = wrapLineInitPrefix,
-      remnant
-
-    // Always returns '' if `beforeHardBreak` is true.
-    //
-    // Assumption: Each call of this function is always followed by a `lines.push()` call.
-    //
-    // This function can change the status of `cleanLine`, but we don't modify the value of
-    // `cleanLine` in this function. It's fine because `cleanLine` will be set to the correct
-    // value after the `lines.push()` call following this function call. We also don't update
-    // `curLineLength` when pushing a new line and it's safe for the same reason.
-    function finishOffCurLine (beforeHardBreak) {
-      var str = lines[curLine],
-        idx, ln, rBase
-
-      if (!wsAll) {
-        // Strip all trailing whitespaces past `start`.
-        idx = str.length - 1
-        while (idx >= start && str[idx] === ' ') { idx--; }
-        while (idx >= start && wsPat.test(str[idx])) { idx--; }
-        idx++
-
-        if (idx !== str.length) {
-          lines[curLine] = str.substring(0, idx)
-        }
-
-        if (preservedLine && cleanLine && wsLine && curLineLength > stop) {
-          // Add the remnants to the next line, just like when `wsAll` is true.
-          rBase = str.length - (curLineLength - stop)
-          if (rBase < idx) {
-            // We didn't reach `stop` when stripping due to a bulge.
-            rBase = idx
-          }
-        }
-      } else {
-        // Strip trailing whitespaces exceeding stop.
-        if (curLineLength > stop) {
-          bulge = bulge || stop
-          rBase = str.length - (curLineLength - bulge)
-          lines[curLine] = str.substring(0, rBase)
-        }
-        bulge = 0
-      }
-
-      // Bug: the current implementation of `wrapLineIndent` is buggy: we are not
-      // taking the extra space occupied by the additional indentation into account
-      // when wrapping the line. For example, in "hard" mode, we should hard-wrap
-      // long words at `wrapLen - wrapLinePrefix.length` instead of `wrapLen`
-      // and remnants should also be wrapped at `wrapLen - wrapLinePrefix.length`.
-      if (preservedLine) {
-        // This is a preserved line, and the next output line isn't a
-        // preserved line.
-        preservedLine = false
-        if (wrapLineIndentPat) {
-          idx = lines[curLine].substring(start).search(wrapLineIndentPat)
-          if (idx >= 0 && idx + wrapLineIndent > 0) {
-            wrapLinePrefix = new Array(idx + wrapLineIndent + 1).join(' ')
-          } else {
-            wrapLinePrefix = ''
-          }
-        }
-      }
-
-      // Some remnants are left to the next line.
-      if (rBase) {
-        while (rBase + wrapLen < str.length) {
-          if (wsAll) {
-            ln = str.substring(rBase, rBase + wrapLen)
-            lines.push(prefix + wrapLinePrefix + ln)
-          } else {
-            lines.push(prefix + wrapLinePrefix)
-          }
-          rBase += wrapLen
-          curLine++
-        }
-        if (beforeHardBreak) {
-          if (wsAll) {
-            ln = str.substring(rBase)
-            lines.push(prefix + wrapLinePrefix + ln)
-          } else {
-            lines.push(prefix + wrapLinePrefix)
-          }
-          curLine++
-        } else {
-          ln = str.substring(rBase)
-          return wrapLinePrefix + ln
-        }
-      }
-
-      return ''
-    }
-
-    for (i = 0; i < chunks.length; i++) {
-      var chunk = chunks[i]
-
-      if (chunk === '') { continue; }
-
-      if (typeof chunk !== 'string') {
-        if (chunk.type === 'break') {
-          // This is one or more line breaks.
-          // Each entry in `breaks` is just zero or more whitespaces.
-          if (respectLineBreaks !== 'none') {
-            // Note that if `whitespace` is "collapse", we still need
-            // to collapse whitespaces in entries of `breaks`.
-            var breaks = chunk.breaks
-            var num = breaks.length - 1
-
-            if (respectLineBreaks === 's') {
-              // This is the most complex scenario. We have to check
-              // the line breaks one by one.
-              for (j = 0; j < num; j++) {
-                if (breaks[j + 1].length < respectNum) {
-                  // This line break should be stripped.
-                  if (wsCollapse) {
-                    breaks[j + 1] = ' '
-                  } else {
-                    breaks[j + 1] = breaks[j] + breaks[j + 1]
-                  }
-                } else {
-                  // This line break should be preserved.
-                  // First finish off the current line.
-                  if (wsAll) {
-                    lines[curLine] += breaks[j]
-                    curLineLength += breaks[j].length
-                  }
-                  finishOffCurLine(true)
-
-                  lines.push(prefix + preservedLinePrefix)
-                  curLine++
-                  curLineLength = start + preservedLinePrefix.length
-
-                  preservedLine = cleanLine = true
-                }
-              }
-              // We are adding to either the existing line (if no line break
-              // is qualified for preservance) or a "new" line.
-              if (!cleanLine || wsAll || (wsLine && preservedLine)) {
-                if (wsCollapse || (!cleanLine && breaks[num] === '')) {
-                  breaks[num] = ' '
-                }
-                lines[curLine] += breaks[num]
-                curLineLength += breaks[num].length
-              }
-            } else if (respectLineBreaks === 'm' && num < respectNum) {
-              // These line breaks should be stripped.
-              if (!cleanLine || wsAll || (wsLine && preservedLine)) {
-                if (wsCollapse) {
-                  chunk = ' '
-                } else {
-                  chunk = breaks.join('')
-                  if (!cleanLine && chunk === '') {
-                    chunk = ' '
-                  }
-                }
-                lines[curLine] += chunk
-                curLineLength += chunk.length
-              }
-            } else { // 'all' || ('m' && num >= respectNum)
-              // These line breaks should be preserved.
-              if (wsStrip) {
-                // Finish off the current line.
-                finishOffCurLine(true)
-
-                for (j = 0; j < num; j++) {
-                  lines.push(prefix + preservedLinePrefix)
-                  curLine++
-                }
-
-                curLineLength = start + preservedLinePrefix.length
-                preservedLine = cleanLine = true
-              } else {
-                if (wsAll || (preservedLine && cleanLine)) {
-                  lines[curLine] += breaks[0]
-                  curLineLength += breaks[0].length
-                }
-
-                for (j = 0; j < num; j++) {
-                  // Finish off the current line.
-                  finishOffCurLine(true)
-
-                  lines.push(prefix + preservedLinePrefix + breaks[j + 1])
-                  curLine++
-                  curLineLength = start + preservedLinePrefix.length + breaks[j + 1].length
-
-                  preservedLine = cleanLine = true
-                }
-              }
-            }
-          } else {
-            // These line breaks should be stripped.
-            if (!cleanLine || wsAll || (wsLine && preservedLine)) {
-              chunk = chunk.remaining
-
-              // Bug: If `wsAll` is true, `cleanLine` is false, and `chunk`
-              // is '', we insert a space to replace the line break. This
-              // space will be preserved even if we are at the end of an
-              // output line, which is wrong behavior. However, I'm not
-              // sure it's worth it to fix this edge case.
-              if (wsCollapse || (!cleanLine && chunk === '')) {
-                chunk = ' '
-              }
-              lines[curLine] += chunk
-              curLineLength += chunk.length
-            }
-          }
-        } else if (chunk.type === 'skip') {
-          // This is a skip string.
-          // Assumption: skip strings don't end with whitespaces.
-          if (curLineLength > stop) {
-            remnant = finishOffCurLine(false)
-
-            lines.push(prefix + wrapLinePrefix)
-            curLine++
-            curLineLength = start + wrapLinePrefix.length
-
-            if (remnant) {
-              lines[curLine] += remnant
-              curLineLength += remnant.length
-            }
-
-            cleanLine = true
-          }
-          lines[curLine] += chunk.value
-        }
-        continue
-      }
-
-      var chunk2
-      while (1) {
-        chunk2 = undefined
-        if (curLineLength + chunk.length > stop &&
-          curLineLength + (chunk2 = chunk.replace(tPat, '')).length > stop &&
-          chunk2 !== '' &&
-          curLineLength > start) {
-          // This line is full, add `chunk` to the next line
-          remnant = finishOffCurLine(false)
-
-          lines.push(prefix + wrapLinePrefix)
-          curLine++
-          curLineLength = start + wrapLinePrefix.length
-
-          if (remnant) {
-            lines[curLine] += remnant
-            curLineLength += remnant.length
-            cleanLine = true
-            continue
-          }
-
-          if (wsStrip || (wsLine && !(preservedLine && cleanLine))) {
-            chunk = chunk.replace(pPat, '')
-          }
-          cleanLine = false
-        } else {
-          // Add `chunk` to this line
-          if (cleanLine) {
-            if (wsStrip || (wsLine && !(preservedLine && cleanLine))) {
-              chunk = chunk.replace(pPat, '')
-              if (chunk !== '') {
-                cleanLine = false
-              }
-            } else {
-              if (nonWsPat.test(chunk)) {
-                cleanLine = false
-              }
-            }
-          }
-        }
-        break
-      }
-      if (wsAll && chunk2 && curLineLength + chunk2.length > stop) {
-        bulge = curLineLength + chunk2.length
-      }
-      lines[curLine] += chunk
-      curLineLength += chunk.length
-    }
-    // Finally, finish off the last line.
-    finishOffCurLine(true)
-    return lines.join(lineBreakStr)
-  }
-}
-
-linewrap.soft = linewrap
-
-linewrap.hard = function ( /*start, stop, params*/) {
-  var args = [].slice.call(arguments)
-  var last = args.length - 1
-  if (typeof args[last] === 'object') {
-    args[last].mode = 'hard'
-  } else {
-    args.push({ mode: 'hard' })
-  }
-  return linewrap.apply(null, args)
-}
-
-linewrap.wrap = function (text /*, start, stop, params*/) {
-  var args = [].slice.call(arguments)
-  args.shift()
-  return linewrap.apply(null, args)(text)
-}