(function e(t,n,r){function s(o,u){if(!n){if(!t){var a=typeof require==“function”&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(“Cannot find module '”o“'”);throw f.code=“MODULE_NOT_FOUND”,f}var l=n={exports:{}};t[0].call(l.exports,function(e){var n=t[1];return s(n?n:e)},l,l.exports,e,t,n,r)}return n.exports}var i=typeof require==“function”&&require;for(var o=0;o);return s})({1:[function(require,module,exports){ (function (process){ module.exports = minimatch minimatch.Minimatch = Minimatch

var isWindows = false if (typeof process !== 'undefined' && process.platform === 'win32')

isWindows = true

var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}

, expand = require("brace-expansion")

// any single thing other than /
// don't need to escape / when using new RegExp()
, qmark = "[^/]"

// * => any number of characters
, star = qmark + "*?"

// ** when dots are allowed.  Anything goes, except .. and .
// not (^ or / followed by one or two dots followed by $ or /),
// followed by anything, any number of times.
, twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?"

// not a ^ or / followed by a dot,
// followed by anything, any number of times.
, twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?"

// characters that need to be escaped in RegExp.
, reSpecials = charSet("().*{}+?[]^$\\!")

// “abc” -> { a:true, b:true, c:true } function charSet (s) {

return s.split("").reduce(function (set, c) {
  set[c] = true
  return set
}, {})

}

// normalizes slashes. var slashSplit = //+/

minimatch.filter = filter function filter (pattern, options) {

options = options || {}
return function (p, i, list) {
  return minimatch(p, pattern, options)
}

}

function ext (a, b) {

a = a || {}
b = b || {}
var t = {}
Object.keys(b).forEach(function (k) {
  t[k] = b[k]
})
Object.keys(a).forEach(function (k) {
  t[k] = a[k]
})
return t

}

minimatch.defaults = function (def) {

if (!def || !Object.keys(def).length) return minimatch

var orig = minimatch

var m = function minimatch (p, pattern, options) {
  return orig.minimatch(p, pattern, ext(def, options))
}

m.Minimatch = function Minimatch (pattern, options) {
  return new orig.Minimatch(pattern, ext(def, options))
}

return m

}

Minimatch.defaults = function (def) {

if (!def || !Object.keys(def).length) return Minimatch
return minimatch.defaults(def).Minimatch

}

function minimatch (p, pattern, options) {

if (typeof pattern !== "string") {
  throw new TypeError("glob pattern string required")
}

if (!options) options = {}

// shortcut: comments match nothing.
if (!options.nocomment && pattern.charAt(0) === "#") {
  return false
}

// "" only matches ""
if (pattern.trim() === "") return p === ""

return new Minimatch(pattern, options).match(p)

}

function Minimatch (pattern, options) {

if (!(this instanceof Minimatch)) {
  return new Minimatch(pattern, options)
}

if (typeof pattern !== "string") {
  throw new TypeError("glob pattern string required")
}

if (!options) options = {}
pattern = pattern.trim()

// windows support: need to use /, not \
if (isWindows)
  pattern = pattern.split("\\").join("/")

this.options = options
this.set = []
this.pattern = pattern
this.regexp = null
this.negate = false
this.comment = false
this.empty = false

// make the set of regexps etc.
this.make()

}

Minimatch.prototype.debug = function() {}

Minimatch.prototype.make = make function make () {

// don't do it more than once.
if (this._made) return

var pattern = this.pattern
var options = this.options

// empty patterns and comments match nothing.
if (!options.nocomment && pattern.charAt(0) === "#") {
  this.comment = true
  return
}
if (!pattern) {
  this.empty = true
  return
}

// step 1: figure out negation, etc.
this.parseNegate()

// step 2: expand braces
var set = this.globSet = this.braceExpand()

if (options.debug) this.debug = console.error

this.debug(this.pattern, set)

// step 3: now we have a set, so turn each one into a series of path-portion
// matching patterns.
// These will be regexps, except in the case of "**", which is
// set to the GLOBSTAR object for globstar behavior,
// and will not contain any / characters
set = this.globParts = set.map(function (s) {
  return s.split(slashSplit)
})

this.debug(this.pattern, set)

// glob --> regexps
set = set.map(function (s, si, set) {
  return s.map(this.parse, this)
}, this)

this.debug(this.pattern, set)

// filter out everything that didn't compile properly.
set = set.filter(function (s) {
  return -1 === s.indexOf(false)
})

this.debug(this.pattern, set)

this.set = set

}

Minimatch.prototype.parseNegate = parseNegate function parseNegate () {

var pattern = this.pattern
  , negate = false
  , options = this.options
  , negateOffset = 0

if (options.nonegate) return

for ( var i = 0, l = pattern.length
    ; i < l && pattern.charAt(i) === "!"
    ; i ++) {
  negate = !negate
  negateOffset ++
}

if (negateOffset) this.pattern = pattern.substr(negateOffset)
this.negate = negate

}

// Brace expansion: // a{b,c}d -> abd acd // a{b,}c -> abc ac // a{0..3}d -> a0d a1d a2d a3d // a{b,c{d,e}f}g -> abg acdfg acefg // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg // // Invalid sets are not expanded. // a{2..}b -> a{2..}b // a{b}c -> a{b}c minimatch.braceExpand = function (pattern, options) {

return braceExpand(pattern, options)

}

Minimatch.prototype.braceExpand = braceExpand

function braceExpand (pattern, options) {

if (!options) {
  if (this instanceof Minimatch)
    options = this.options
  else
    options = {}
}

pattern = typeof pattern === "undefined"
  ? this.pattern : pattern

if (typeof pattern === "undefined") {
  throw new Error("undefined pattern")
}

if (options.nobrace ||
    !pattern.match(/\{.*\}/)) {
  // shortcut. no need to expand.
  return [pattern]
}

return expand(pattern)

}

// parse a component of the expanded set. // At this point, no pattern may contain “/” in it // so we're going to return a 2d array, where each entry is the full // pattern, split on '/', and then turned into a regular expression. // A regexp is made at the end which joins each array with an // escaped /, and another full one which joins each regexp with |. // // Following the lead of Bash 4.1, note that “**” only has special meaning // when it is the only thing in a path portion. Otherwise, any series // of * is equivalent to a single *. Globstar behavior is enabled by // default, and can be disabled by setting options.noglobstar. Minimatch.prototype.parse = parse var SUBPARSE = {} function parse (pattern, isSub) {

var options = this.options

// shortcuts
if (!options.noglobstar && pattern === "**") return GLOBSTAR
if (pattern === "") return ""

var re = ""
  , hasMagic = !!options.nocase
  , escaping = false
  // ? => one single character
  , patternListStack = []
  , plType
  , stateChar
  , inClass = false
  , reClassStart = -1
  , classStart = -1
  // . and .. never match anything that doesn't start with .,
  // even when options.dot is set.
  , patternStart = pattern.charAt(0) === "." ? "" // anything
    // not (start or / followed by . or .. followed by / or end)
    : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))"
    : "(?!\\.)"
  , self = this

function clearStateChar () {
  if (stateChar) {
    // we had some state-tracking character
    // that wasn't consumed by this pass.
    switch (stateChar) {
      case "*":
        re += star
        hasMagic = true
        break
      case "?":
        re += qmark
        hasMagic = true
        break
      default:
        re += "\\"+stateChar
        break
    }
    self.debug('clearStateChar %j %j', stateChar, re)
    stateChar = false
  }
}

for ( var i = 0, len = pattern.length, c
    ; (i < len) && (c = pattern.charAt(i))
    ; i ++ ) {

  this.debug("%s\t%s %s %j", pattern, i, re, c)

  // skip over any that are escaped.
  if (escaping && reSpecials[c]) {
    re += "\\" + c
    escaping = false
    continue
  }

  SWITCH: switch (c) {
    case "/":
      // completely not allowed, even escaped.
      // Should already be path-split by now.
      return false

    case "\\":
      clearStateChar()
      escaping = true
      continue

    // the various stateChar values
    // for the "extglob" stuff.
    case "?":
    case "*":
    case "+":
    case "@":
    case "!":
      this.debug("%s\t%s %s %j <-- stateChar", pattern, i, re, c)

      // all of those are literals inside a class, except that
      // the glob [!a] means [^a] in regexp
      if (inClass) {
        this.debug('  in class')
        if (c === "!" && i === classStart + 1) c = "^"
        re += c
        continue
      }

      // if we already have a stateChar, then it means
      // that there was something like ** or +? in there.
      // Handle the stateChar, then proceed with this one.
      self.debug('call clearStateChar %j', stateChar)
      clearStateChar()
      stateChar = c
      // if extglob is disabled, then +(asdf|foo) isn't a thing.
      // just clear the statechar *now*, rather than even diving into
      // the patternList stuff.
      if (options.noext) clearStateChar()
      continue

    case "(":
      if (inClass) {
        re += "("
        continue
      }

      if (!stateChar) {
        re += "\\("
        continue
      }

      plType = stateChar
      patternListStack.push({ type: plType
                            , start: i - 1
                            , reStart: re.length })
      // negation is (?:(?!js)[^/]*)
      re += stateChar === "!" ? "(?:(?!" : "(?:"
      this.debug('plType %j %j', stateChar, re)
      stateChar = false
      continue

    case ")":
      if (inClass || !patternListStack.length) {
        re += "\\)"
        continue
      }

      clearStateChar()
      hasMagic = true
      re += ")"
      plType = patternListStack.pop().type
      // negation is (?:(?!js)[^/]*)
      // The others are (?:<pattern>)<type>
      switch (plType) {
        case "!":
          re += "[^/]*?)"
          break
        case "?":
        case "+":
        case "*": re += plType
        case "@": break // the default anyway
      }
      continue

    case "|":
      if (inClass || !patternListStack.length || escaping) {
        re += "\\|"
        escaping = false
        continue
      }

      clearStateChar()
      re += "|"
      continue

    // these are mostly the same in regexp and glob
    case "[":
      // swallow any state-tracking char before the [
      clearStateChar()

      if (inClass) {
        re += "\\" + c
        continue
      }

      inClass = true
      classStart = i
      reClassStart = re.length
      re += c
      continue

    case "]":
      //  a right bracket shall lose its special
      //  meaning and represent itself in
      //  a bracket expression if it occurs
      //  first in the list.  -- POSIX.2 2.8.3.2
      if (i === classStart + 1 || !inClass) {
        re += "\\" + c
        escaping = false
        continue
      }

      // finish up the class.
      hasMagic = true
      inClass = false
      re += c
      continue

    default:
      // swallow any state char that wasn't consumed
      clearStateChar()

      if (escaping) {
        // no need
        escaping = false
      } else if (reSpecials[c]
                 && !(c === "^" && inClass)) {
        re += "\\"
      }

      re += c

  } // switch
} // for

// handle the case where we left a class open.
// "[abc" is valid, equivalent to "\[abc"
if (inClass) {
  // split where the last [ was, and escape it
  // this is a huge pita.  We now have to re-walk
  // the contents of the would-be class to re-translate
  // any characters that were passed through as-is
  var cs = pattern.substr(classStart + 1)
    , sp = this.parse(cs, SUBPARSE)
  re = re.substr(0, reClassStart) + "\\[" + sp[0]
  hasMagic = hasMagic || sp[1]
}

// handle the case where we had a +( thing at the *end*
// of the pattern.
// each pattern list stack adds 3 chars, and we need to go through
// and escape any | chars that were passed through as-is for the regexp.
// Go through and escape them, taking care not to double-escape any
// | chars that were already escaped.
var pl
while (pl = patternListStack.pop()) {
  var tail = re.slice(pl.reStart + 3)
  // maybe some even number of \, then maybe 1 \, followed by a |
  tail = tail.replace(/((?:\\{2})*)(\\?)\|/g, function (_, $1, $2) {
    if (!$2) {
      // the | isn't already escaped, so escape it.
      $2 = "\\"
    }

    // need to escape all those slashes *again*, without escaping the
    // one that we need for escaping the | character.  As it works out,
    // escaping an even number of slashes can be done by simply repeating
    // it exactly after itself.  That's why this trick works.
    //
    // I am sorry that you have to see this.
    return $1 + $1 + $2 + "|"
  })

  this.debug("tail=%j\n   %s", tail, tail)
  var t = pl.type === "*" ? star
        : pl.type === "?" ? qmark
        : "\\" + pl.type

  hasMagic = true
  re = re.slice(0, pl.reStart)
     + t + "\\("
     + tail
}

// handle trailing things that only matter at the very end.
clearStateChar()
if (escaping) {
  // trailing \\
  re += "\\\\"
}

// only need to apply the nodot start if the re starts with
// something that could conceivably capture a dot
var addPatternStart = false
switch (re.charAt(0)) {
  case ".":
  case "[":
  case "(": addPatternStart = true
}

// if the re is not "" at this point, then we need to make sure
// it doesn't match against an empty path part.
// Otherwise a/* will match a/, which it should not.
if (re !== "" && hasMagic) re = "(?=.)" + re

if (addPatternStart) re = patternStart + re

// parsing just a piece of a larger pattern.
if (isSub === SUBPARSE) {
  return [ re, hasMagic ]
}

// skip the regexp for non-magical patterns
// unescape anything in it, though, so that it'll be
// an exact match against a file etc.
if (!hasMagic) {
  return globUnescape(pattern)
}

var flags = options.nocase ? "i" : ""
  , regExp = new RegExp("^" + re + "$", flags)

regExp._glob = pattern
regExp._src = re

return regExp

}

minimatch.makeRe = function (pattern, options) {

return new Minimatch(pattern, options || {}).makeRe()

}

Minimatch.prototype.makeRe = makeRe function makeRe () {

if (this.regexp || this.regexp === false) return this.regexp

// at this point, this.set is a 2d array of partial
// pattern strings, or "**".
//
// It's better to use .match().  This function shouldn't
// be used, really, but it's pretty convenient sometimes,
// when you just want to work with a regex.
var set = this.set

if (!set.length) return this.regexp = false
var options = this.options

var twoStar = options.noglobstar ? star
    : options.dot ? twoStarDot
    : twoStarNoDot
  , flags = options.nocase ? "i" : ""

var re = set.map(function (pattern) {
  return pattern.map(function (p) {
    return (p === GLOBSTAR) ? twoStar
         : (typeof p === "string") ? regExpEscape(p)
         : p._src
  }).join("\\\/")
}).join("|")

// must match entire pattern
// ending in a * or ** will make it less strict.
re = "^(?:" + re + ")$"

// can match anything, as long as it's not this.
if (this.negate) re = "^(?!" + re + ").*$"

try {
  return this.regexp = new RegExp(re, flags)
} catch (ex) {
  return this.regexp = false
}

}

minimatch.match = function (list, pattern, options) {

options = options || {}
var mm = new Minimatch(pattern, options)
list = list.filter(function (f) {
  return mm.match(f)
})
if (mm.options.nonull && !list.length) {
  list.push(pattern)
}
return list

}

Minimatch.prototype.match = match function match (f, partial) {

this.debug("match", f, this.pattern)
// short-circuit in the case of busted things.
// comments, etc.
if (this.comment) return false
if (this.empty) return f === ""

if (f === "/" && partial) return true

var options = this.options

// windows: need to use /, not \
if (isWindows)
  f = f.split("\\").join("/")

// treat the test path as a set of pathparts.
f = f.split(slashSplit)
this.debug(this.pattern, "split", f)

// just ONE of the pattern sets in this.set needs to match
// in order for it to be valid.  If negating, then just one
// match means that we have failed.
// Either way, return on the first hit.

var set = this.set
this.debug(this.pattern, "set", set)

// Find the basename of the path by looking for the last non-empty segment
var filename;
for (var i = f.length - 1; i >= 0; i--) {
  filename = f[i]
  if (filename) break
}

for (var i = 0, l = set.length; i < l; i ++) {
  var pattern = set[i], file = f
  if (options.matchBase && pattern.length === 1) {
    file = [filename]
  }
  var hit = this.matchOne(file, pattern, partial)
  if (hit) {
    if (options.flipNegate) return true
    return !this.negate
  }
}

// didn't get any hits.  this is success if it's a negative
// pattern, failure otherwise.
if (options.flipNegate) return false
return this.negate

}

// set partial to true to test if, for example, // “/a/b” matches the start of “//b//d” // Partial means, if you run out of file before you run // out of pattern, then that's fine, as long as all // the parts match. Minimatch.prototype.matchOne = function (file, pattern, partial) {

var options = this.options

this.debug("matchOne",
            { "this": this
            , file: file
            , pattern: pattern })

this.debug("matchOne", file.length, pattern.length)

for ( var fi = 0
        , pi = 0
        , fl = file.length
        , pl = pattern.length
    ; (fi < fl) && (pi < pl)
    ; fi ++, pi ++ ) {

  this.debug("matchOne loop")
  var p = pattern[pi]
    , f = file[fi]

  this.debug(pattern, p, f)

  // should be impossible.
  // some invalid regexp stuff in the set.
  if (p === false) return false

  if (p === GLOBSTAR) {
    this.debug('GLOBSTAR', [pattern, p, f])

    // "**"
    // a/**/b/**/c would match the following:
    // a/b/x/y/z/c
    // a/x/y/z/b/c
    // a/b/x/b/x/c
    // a/b/c
    // To do this, take the rest of the pattern after
    // the **, and see if it would match the file remainder.
    // If so, return success.
    // If not, the ** "swallows" a segment, and try again.
    // This is recursively awful.
    //
    // a/**/b/**/c matching a/b/x/y/z/c
    // - a matches a
    // - doublestar
    //   - matchOne(b/x/y/z/c, b/**/c)
    //     - b matches b
    //     - doublestar
    //       - matchOne(x/y/z/c, c) -> no
    //       - matchOne(y/z/c, c) -> no
    //       - matchOne(z/c, c) -> no
    //       - matchOne(c, c) yes, hit
    var fr = fi
      , pr = pi + 1
    if (pr === pl) {
      this.debug('** at the end')
      // a ** at the end will just swallow the rest.
      // We have found a match.
      // however, it will not swallow /.x, unless
      // options.dot is set.
      // . and .. are *never* matched by **, for explosively
      // exponential reasons.
      for ( ; fi < fl; fi ++) {
        if (file[fi] === "." || file[fi] === ".." ||
            (!options.dot && file[fi].charAt(0) === ".")) return false
      }
      return true
    }

    // ok, let's see if we can swallow whatever we can.
    WHILE: while (fr < fl) {
      var swallowee = file[fr]

      this.debug('\nglobstar while',
                  file, fr, pattern, pr, swallowee)

      // XXX remove this slice.  Just pass the start index.
      if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
        this.debug('globstar found match!', fr, fl, swallowee)
        // found a match.
        return true
      } else {
        // can't swallow "." or ".." ever.
        // can only swallow ".foo" when explicitly asked.
        if (swallowee === "." || swallowee === ".." ||
            (!options.dot && swallowee.charAt(0) === ".")) {
          this.debug("dot detected!", file, fr, pattern, pr)
          break WHILE
        }

        // ** swallows a segment, and continue.
        this.debug('globstar swallow a segment, and continue')
        fr ++
      }
    }
    // no match was found.
    // However, in partial mode, we can't say this is necessarily over.
    // If there's more *pattern* left, then
    if (partial) {
      // ran out of file
      this.debug("\n>>> no match, partial?", file, fr, pattern, pr)
      if (fr === fl) return true
    }
    return false
  }

  // something other than **
  // non-magic patterns just have to match exactly
  // patterns with magic have been turned into regexps.
  var hit
  if (typeof p === "string") {
    if (options.nocase) {
      hit = f.toLowerCase() === p.toLowerCase()
    } else {
      hit = f === p
    }
    this.debug("string match", p, f, hit)
  } else {
    hit = f.match(p)
    this.debug("pattern match", p, f, hit)
  }

  if (!hit) return false
}

// Note: ending in / means that we'll get a final ""
// at the end of the pattern.  This can only match a
// corresponding "" at the end of the file.
// If the file ends in /, then it can only match a
// a pattern that ends in /, unless the pattern just
// doesn't have any more for it. But, a/b/ should *not*
// match "a/b/*", even though "" matches against the
// [^/]*? pattern, except in partial mode, where it might
// simply not be reached yet.
// However, a/b/ should still satisfy a/*

// now either we fell off the end of the pattern, or we're done.
if (fi === fl && pi === pl) {
  // ran out of pattern and filename at the same time.
  // an exact hit!
  return true
} else if (fi === fl) {
  // ran out of file, but still had pattern left.
  // this is ok if we're doing the match as part of
  // a glob fs traversal.
  return partial
} else if (pi === pl) {
  // ran out of pattern, still have file left.
  // this is only acceptable if we're on the very last
  // empty segment of a file with a trailing slash.
  // a/* should match a/b/
  var emptyFileEnd = (fi === fl - 1) && (file[fi] === "")
  return emptyFileEnd
}

// should be unreachable.
throw new Error("wtf?")

}

// replace stuff like * with * function globUnescape (s) {

return s.replace(/\\(.)/g, "$1")

}

function regExpEscape (s) {

return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")

}

}).call(this,require('_process')) },{“_process”:5,“brace-expansion”:2}],2:[function(require,module,exports){ var concatMap = require('concat-map'); var balanced = require('balanced-match');

module.exports = expandTop;

var escSlash = '0SLASH'+Math.random()+'0'; var escOpen = '0OPEN'+Math.random()+'0'; var escClose = '0CLOSE'+Math.random()+'0'; var escComma = '0COMMA'+Math.random()+'0'; var escPeriod = '0PERIOD'+Math.random()+'0';

function numeric(str) {

return parseInt(str, 10) == str
  ? parseInt(str, 10)
  : str.charCodeAt(0);

}

function escapeBraces(str) {

return str.split('\\\\').join(escSlash)
          .split('\\{').join(escOpen)
          .split('\\}').join(escClose)
          .split('\\,').join(escComma)
          .split('\\.').join(escPeriod);

}

function unescapeBraces(str) {

return str.split(escSlash).join('\\')
          .split(escOpen).join('{')
          .split(escClose).join('}')
          .split(escComma).join(',')
          .split(escPeriod).join('.');

}

// Basically just str.split(“,”), but handling cases // where we have nested braced sections, which should be // treated as individual members, like {a,{b,c},d} function parseCommaParts(str) {

if (!str)
  return [''];

var parts = [];
var m = balanced('{', '}', str);

if (!m)
  return str.split(',');

var pre = m.pre;
var body = m.body;
var post = m.post;
var p = pre.split(',');

p[p.length-1] += '{' + body + '}';
var postParts = parseCommaParts(post);
if (post.length) {
  p[p.length-1] += postParts.shift();
  p.push.apply(p, postParts);
}

parts.push.apply(parts, p);

return parts;

}

function expandTop(str) {

if (!str)
  return [];

var expansions = expand(escapeBraces(str));
return expansions.filter(identity).map(unescapeBraces);

}

function identity(e) {

return e;

}

function embrace(str) {

return '{' + str + '}';

} function isPadded(el) {

return /^-?0\d/.test(el);

}

function lte(i, y) {

return i <= y;

} function gte(i, y) {

return i >= y;

}

function expand(str) {

var expansions = [];

var m = balanced('{', '}', str);
if (!m || /\$$/.test(m.pre)) return [str];

var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
var isSequence = isNumericSequence || isAlphaSequence;
var isOptions = /^(.*,)+(.+)?$/.test(m.body);
if (!isSequence && !isOptions) {
  // {a},b}
  if (m.post.match(/,.*}/)) {
    str = m.pre + '{' + m.body + escClose + m.post;
    return expand(str);
  }
  return [str];
}

var n;
if (isSequence) {
  n = m.body.split(/\.\./);
} else {
  n = parseCommaParts(m.body);
  if (n.length === 1) {
    // x{{a,b}}y ==> x{a}y x{b}y
    n = expand(n[0]).map(embrace);
    if (n.length === 1) {
      var post = m.post.length
        ? expand(m.post)
        : [''];
      return post.map(function(p) {
        return m.pre + n[0] + p;
      });
    }
  }
}

// at this point, n is the parts, and we know it's not a comma set
// with a single entry.

// no need to expand pre, since it is guaranteed to be free of brace-sets
var pre = m.pre;
var post = m.post.length
  ? expand(m.post)
  : [''];

var N;

if (isSequence) {
  var x = numeric(n[0]);
  var y = numeric(n[1]);
  var width = Math.max(n[0].length, n[1].length)
  var incr = n.length == 3
    ? Math.abs(numeric(n[2]))
    : 1;
  var test = lte;
  var reverse = y < x;
  if (reverse) {
    incr *= -1;
    test = gte;
  }
  var pad = n.some(isPadded);

  N = [];

  for (var i = x; test(i, y); i += incr) {
    var c;
    if (isAlphaSequence) {
      c = String.fromCharCode(i);
      if (c === '\\')
        c = '';
    } else {
      c = String(i);
      if (pad) {
        var need = width - c.length;
        if (need > 0) {
          var z = new Array(need + 1).join('0');
          if (i < 0)
            c = '-' + z + c.slice(1);
          else
            c = z + c;
        }
      }
    }
    N.push(c);
  }
} else {
  N = concatMap(n, function(el) { return expand(el) });
}

for (var j = 0; j < N.length; j++) {
  for (var k = 0; k < post.length; k++) {
    expansions.push([pre, N[j], post[k]].join(''))
  }
}

return expansions;

}

},{“balanced-match”:3,“concat-map”:4}],3:[function(require,module,exports){ module.exports = balanced; function balanced(a, b, str) {

var bal = 0;
var m = {};
var ended = false;

for (var i = 0; i < str.length; i++) {
  if (a == str.substr(i, a.length)) {
    if (!('start' in m)) m.start = i;
    bal++;
  }
  else if (b == str.substr(i, b.length) && 'start' in m) {
    ended = true;
    bal--;
    if (!bal) {
      m.end = i;
      m.pre = str.substr(0, m.start);
      m.body = (m.end - m.start > 1)
        ? str.substring(m.start + a.length, m.end)
        : '';
      m.post = str.slice(m.end + b.length);
      return m;
    }
  }
}

// if we opened more than we closed, find the one we closed
if (bal && ended) {
  var start = m.start + a.length;
  m = balanced(a, b, str.substr(start));
  if (m) {
    m.start += start;
    m.end += start;
    m.pre = str.slice(0, start) + m.pre;
  }
  return m;
}

}

},{}],4:[function(require,module,exports){ module.exports = function (xs, fn) {

var res = [];
for (var i = 0; i < xs.length; i++) {
    var x = fn(xs[i], i);
    if (Array.isArray(x)) res.push.apply(res, x);
    else res.push(x);
}
return res;

};

},{}],5:[function(require,module,exports){ // shim for using process in browser

var process = module.exports = {};

process.nextTick = (function () {

var canSetImmediate = typeof window !== 'undefined'
&& window.setImmediate;
var canMutationObserver = typeof window !== 'undefined'
&& window.MutationObserver;
var canPost = typeof window !== 'undefined'
&& window.postMessage && window.addEventListener
;

if (canSetImmediate) {
    return function (f) { return window.setImmediate(f) };
}

var queue = [];

if (canMutationObserver) {
    var hiddenDiv = document.createElement("div");
    var observer = new MutationObserver(function () {
        var queueList = queue.slice();
        queue.length = 0;
        queueList.forEach(function (fn) {
            fn();
        });
    });

    observer.observe(hiddenDiv, { attributes: true });

    return function nextTick(fn) {
        if (!queue.length) {
            hiddenDiv.setAttribute('yes', 'no');
        }
        queue.push(fn);
    };
}

if (canPost) {
    window.addEventListener('message', function (ev) {
        var source = ev.source;
        if ((source === window || source === null) && ev.data === 'process-tick') {
            ev.stopPropagation();
            if (queue.length > 0) {
                var fn = queue.shift();
                fn();
            }
        }
    }, true);

    return function nextTick(fn) {
        queue.push(fn);
        window.postMessage('process-tick', '*');
    };
}

return function nextTick(fn) {
    setTimeout(fn, 0);
};

})();

process.title = 'browser'; process.browser = true; process.env = {}; process.argv = [];

function noop() {}

process.on = noop; process.addListener = noop; process.once = noop; process.off = noop; process.removeListener = noop; process.removeAllListeners = noop; process.emit = noop;

process.binding = function (name) {

throw new Error('process.binding is not supported');

};

// TODO(shtylman) process.cwd = function () { return '/' }; process.chdir = function (dir) {

throw new Error('process.chdir is not supported');

};

},{}]},{},[1]);