{"version":3,"sources":["webpack:///./node_modules/regenerate/regenerate.js"],"names":["_typeof2","_interopRequireDefault","root","freeExports","default","exports","freeModule","module","freeGlobal","global","window","ERRORS","HIGH_SURROGATE_MIN","HIGH_SURROGATE_MAX","LOW_SURROGATE_MIN","LOW_SURROGATE_MAX","regexNull","object","hasOwnProperty","forEach","array","callback","index","length","toString","isArray","value","call","isNumber","pad","number","totalCharacters","string","String","slice","hex","Number","toUpperCase","dataRemove","data","codePoint","start","end","splice","dataRemoveRange","rangeStart","rangeEnd","Error","dataAdd","lastIndex","RangeError","push","dataAddData","dataA","dataB","dataAddRange","dataRemoveData","added","dataContains","dataIsEmpty","dataIsSingleton","dataToArray","result","floor","Math","highSurrogate","parseInt","lowSurrogate","stringFromCharCode","fromCharCode","codePointToString","codePointToStringUnicode","symbolToCodePoint","symbol","second","first","charCodeAt","createBMPCharacterClasses","optimizeByLowSurrogates","surrogateMappings","innerIndex","mapping","lowSurrogates","lowSurrogateStart","lowSurrogateEnd","otherMapping","otherLowSurrogates","otherLowSurrogateStart","otherLowSurrogateEnd","surrogateSet","startHigh","startLow","endHigh","endLow","endsWithHighestLowSurrogate","complete","nextMapping","highSurrogates","nextHighSurrogates","nextLowSurrogates","tmpLow","addLow","optimizeSurrogateMappings","createCharacterClassesFromData","bmpOnly","hasUnicodeFlag","createUnicodeCharacterClasses","parts","loneHighSurrogates","loneLowSurrogates","bmp","astral","splitAtBMP","hasLoneHighSurrogates","hasLoneLowSurrogates","surrogateMapping","join","createSurrogateCharacterClasses","regenerate","arguments","this","add","version","proto","prototype","destination","source","key","extend","$this","item","remove","startCodePoint","endCodePoint","argument","codePoints","tmp","max","isStart","previous","dataFromCodePoints","dataIntersection","set","options","replace","flags","pattern","indexOf","RegExp","toArray","valueOf","nodeType"],"mappings":"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","file":"js/vendors~application~9f7cc33a-7e725a2bc0cfe466d2cf.chunk.js","sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _typeof2 = _interopRequireDefault(require(\"@babel/runtime/helpers/typeof\"));\n\n/*! https://mths.be/regenerate v1.4.2 by @mathias | MIT license */\n;\n\n(function (root) {\n  // Detect free variables `exports`.\n  var freeExports = (typeof exports === \"undefined\" ? \"undefined\" : (0, _typeof2.default)(exports)) == 'object' && exports; // Detect free variable `module`.\n\n  var freeModule = (typeof module === \"undefined\" ? \"undefined\" : (0, _typeof2.default)(module)) == 'object' && module && module.exports == freeExports && module; // Detect free variable `global`, from Node.js/io.js or Browserified code,\n  // and use it as `root`.\n\n  var freeGlobal = (typeof global === \"undefined\" ? \"undefined\" : (0, _typeof2.default)(global)) == 'object' && global;\n\n  if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n    root = freeGlobal;\n  }\n  /*--------------------------------------------------------------------------*/\n\n\n  var ERRORS = {\n    'rangeOrder': \"A range\\u2019s `stop` value must be greater than or equal \" + 'to the `start` value.',\n    'codePointRange': 'Invalid code point value. Code points range from ' + 'U+000000 to U+10FFFF.'\n  }; // https://mathiasbynens.be/notes/javascript-encoding#surrogate-pairs\n\n  var HIGH_SURROGATE_MIN = 0xD800;\n  var HIGH_SURROGATE_MAX = 0xDBFF;\n  var LOW_SURROGATE_MIN = 0xDC00;\n  var LOW_SURROGATE_MAX = 0xDFFF; // In Regenerate output, `\\0` is never preceded by `\\` because we sort by\n  // code point value, so let’s keep this regular expression simple.\n\n  var regexNull = /\\\\x00([^0123456789]|$)/g;\n  var object = {};\n  var hasOwnProperty = object.hasOwnProperty;\n\n  var extend = function extend(destination, source) {\n    var key;\n\n    for (key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        destination[key] = source[key];\n      }\n    }\n\n    return destination;\n  };\n\n  var forEach = function forEach(array, callback) {\n    var index = -1;\n    var length = array.length;\n\n    while (++index < length) {\n      callback(array[index], index);\n    }\n  };\n\n  var toString = object.toString;\n\n  var isArray = function isArray(value) {\n    return toString.call(value) == '[object Array]';\n  };\n\n  var isNumber = function isNumber(value) {\n    return typeof value == 'number' || toString.call(value) == '[object Number]';\n  }; // This assumes that `number` is a positive integer that `toString()`s nicely\n  // (which is the case for all code point values).\n\n\n  var zeroes = '0000';\n\n  var pad = function pad(number, totalCharacters) {\n    var string = String(number);\n    return string.length < totalCharacters ? (zeroes + string).slice(-totalCharacters) : string;\n  };\n\n  var hex = function hex(number) {\n    return Number(number).toString(16).toUpperCase();\n  };\n\n  var slice = [].slice;\n  /*--------------------------------------------------------------------------*/\n\n  var dataFromCodePoints = function dataFromCodePoints(codePoints) {\n    var index = -1;\n    var length = codePoints.length;\n    var max = length - 1;\n    var result = [];\n    var isStart = true;\n    var tmp;\n    var previous = 0;\n\n    while (++index < length) {\n      tmp = codePoints[index];\n\n      if (isStart) {\n        result.push(tmp);\n        previous = tmp;\n        isStart = false;\n      } else {\n        if (tmp == previous + 1) {\n          if (index != max) {\n            previous = tmp;\n            continue;\n          } else {\n            isStart = true;\n            result.push(tmp + 1);\n          }\n        } else {\n          // End the previous range and start a new one.\n          result.push(previous + 1, tmp);\n          previous = tmp;\n        }\n      }\n    }\n\n    if (!isStart) {\n      result.push(tmp + 1);\n    }\n\n    return result;\n  };\n\n  var dataRemove = function dataRemove(data, codePoint) {\n    // Iterate over the data per `(start, end)` pair.\n    var index = 0;\n    var start;\n    var end;\n    var length = data.length;\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1];\n\n      if (codePoint >= start && codePoint < end) {\n        // Modify this pair.\n        if (codePoint == start) {\n          if (end == start + 1) {\n            // Just remove `start` and `end`.\n            data.splice(index, 2);\n            return data;\n          } else {\n            // Just replace `start` with a new value.\n            data[index] = codePoint + 1;\n            return data;\n          }\n        } else if (codePoint == end - 1) {\n          // Just replace `end` with a new value.\n          data[index + 1] = codePoint;\n          return data;\n        } else {\n          // Replace `[start, end]` with `[startA, endA, startB, endB]`.\n          data.splice(index, 2, start, codePoint, codePoint + 1, end);\n          return data;\n        }\n      }\n\n      index += 2;\n    }\n\n    return data;\n  };\n\n  var dataRemoveRange = function dataRemoveRange(data, rangeStart, rangeEnd) {\n    if (rangeEnd < rangeStart) {\n      throw Error(ERRORS.rangeOrder);\n    } // Iterate over the data per `(start, end)` pair.\n\n\n    var index = 0;\n    var start;\n    var end;\n\n    while (index < data.length) {\n      start = data[index];\n      end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive.\n      // Exit as soon as no more matching pairs can be found.\n\n      if (start > rangeEnd) {\n        return data;\n      } // Check if this range pair is equal to, or forms a subset of, the range\n      // to be removed.\n      // E.g. we have `[0, 11, 40, 51]` and want to remove 0-10 → `[40, 51]`.\n      // E.g. we have `[40, 51]` and want to remove 0-100 → `[]`.\n\n\n      if (rangeStart <= start && rangeEnd >= end) {\n        // Remove this pair.\n        data.splice(index, 2);\n        continue;\n      } // Check if both `rangeStart` and `rangeEnd` are within the bounds of\n      // this pair.\n      // E.g. we have `[0, 11]` and want to remove 4-6 → `[0, 4, 7, 11]`.\n\n\n      if (rangeStart >= start && rangeEnd < end) {\n        if (rangeStart == start) {\n          // Replace `[start, end]` with `[startB, endB]`.\n          data[index] = rangeEnd + 1;\n          data[index + 1] = end + 1;\n          return data;\n        } // Replace `[start, end]` with `[startA, endA, startB, endB]`.\n\n\n        data.splice(index, 2, start, rangeStart, rangeEnd + 1, end + 1);\n        return data;\n      } // Check if only `rangeStart` is within the bounds of this pair.\n      // E.g. we have `[0, 11]` and want to remove 4-20 → `[0, 4]`.\n\n\n      if (rangeStart >= start && rangeStart <= end) {\n        // Replace `end` with `rangeStart`.\n        data[index + 1] = rangeStart; // Note: we cannot `return` just yet, in case any following pairs still\n        // contain matching code points.\n        // E.g. we have `[0, 11, 14, 31]` and want to remove 4-20\n        // → `[0, 4, 21, 31]`.\n      } // Check if only `rangeEnd` is within the bounds of this pair.\n      // E.g. we have `[14, 31]` and want to remove 4-20 → `[21, 31]`.\n      else if (rangeEnd >= start && rangeEnd <= end) {\n        // Just replace `start`.\n        data[index] = rangeEnd + 1;\n        return data;\n      }\n\n      index += 2;\n    }\n\n    return data;\n  };\n\n  var dataAdd = function dataAdd(data, codePoint) {\n    // Iterate over the data per `(start, end)` pair.\n    var index = 0;\n    var start;\n    var end;\n    var lastIndex = null;\n    var length = data.length;\n\n    if (codePoint < 0x0 || codePoint > 0x10FFFF) {\n      throw RangeError(ERRORS.codePointRange);\n    }\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1]; // Check if the code point is already in the set.\n\n      if (codePoint >= start && codePoint < end) {\n        return data;\n      }\n\n      if (codePoint == start - 1) {\n        // Just replace `start` with a new value.\n        data[index] = codePoint;\n        return data;\n      } // At this point, if `start` is `greater` than `codePoint`, insert a new\n      // `[start, end]` pair before the current pair, or after the current pair\n      // if there is a known `lastIndex`.\n\n\n      if (start > codePoint) {\n        data.splice(lastIndex != null ? lastIndex + 2 : 0, 0, codePoint, codePoint + 1);\n        return data;\n      }\n\n      if (codePoint == end) {\n        // Check if adding this code point causes two separate ranges to become\n        // a single range, e.g. `dataAdd([0, 4, 5, 10], 4)` → `[0, 10]`.\n        if (codePoint + 1 == data[index + 2]) {\n          data.splice(index, 4, start, data[index + 3]);\n          return data;\n        } // Else, just replace `end` with a new value.\n\n\n        data[index + 1] = codePoint + 1;\n        return data;\n      }\n\n      lastIndex = index;\n      index += 2;\n    } // The loop has finished; add the new pair to the end of the data set.\n\n\n    data.push(codePoint, codePoint + 1);\n    return data;\n  };\n\n  var dataAddData = function dataAddData(dataA, dataB) {\n    // Iterate over the data per `(start, end)` pair.\n    var index = 0;\n    var start;\n    var end;\n    var data = dataA.slice();\n    var length = dataB.length;\n\n    while (index < length) {\n      start = dataB[index];\n      end = dataB[index + 1] - 1;\n\n      if (start == end) {\n        data = dataAdd(data, start);\n      } else {\n        data = dataAddRange(data, start, end);\n      }\n\n      index += 2;\n    }\n\n    return data;\n  };\n\n  var dataRemoveData = function dataRemoveData(dataA, dataB) {\n    // Iterate over the data per `(start, end)` pair.\n    var index = 0;\n    var start;\n    var end;\n    var data = dataA.slice();\n    var length = dataB.length;\n\n    while (index < length) {\n      start = dataB[index];\n      end = dataB[index + 1] - 1;\n\n      if (start == end) {\n        data = dataRemove(data, start);\n      } else {\n        data = dataRemoveRange(data, start, end);\n      }\n\n      index += 2;\n    }\n\n    return data;\n  };\n\n  var dataAddRange = function dataAddRange(data, rangeStart, rangeEnd) {\n    if (rangeEnd < rangeStart) {\n      throw Error(ERRORS.rangeOrder);\n    }\n\n    if (rangeStart < 0x0 || rangeStart > 0x10FFFF || rangeEnd < 0x0 || rangeEnd > 0x10FFFF) {\n      throw RangeError(ERRORS.codePointRange);\n    } // Iterate over the data per `(start, end)` pair.\n\n\n    var index = 0;\n    var start;\n    var end;\n    var added = false;\n    var length = data.length;\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1];\n\n      if (added) {\n        // The range has already been added to the set; at this point, we just\n        // need to get rid of the following ranges in case they overlap.\n        // Check if this range can be combined with the previous range.\n        if (start == rangeEnd + 1) {\n          data.splice(index - 1, 2);\n          return data;\n        } // Exit as soon as no more possibly overlapping pairs can be found.\n\n\n        if (start > rangeEnd) {\n          return data;\n        } // E.g. `[0, 11, 12, 16]` and we’ve added 5-15, so we now have\n        // `[0, 16, 12, 16]`. Remove the `12,16` part, as it lies within the\n        // `0,16` range that was previously added.\n\n\n        if (start >= rangeStart && start <= rangeEnd) {\n          // `start` lies within the range that was previously added.\n          if (end > rangeStart && end - 1 <= rangeEnd) {\n            // `end` lies within the range that was previously added as well,\n            // so remove this pair.\n            data.splice(index, 2);\n            index -= 2; // Note: we cannot `return` just yet, as there may still be other\n            // overlapping pairs.\n          } else {\n            // `start` lies within the range that was previously added, but\n            // `end` doesn’t. E.g. `[0, 11, 12, 31]` and we’ve added 5-15, so\n            // now we have `[0, 16, 12, 31]`. This must be written as `[0, 31]`.\n            // Remove the previously added `end` and the current `start`.\n            data.splice(index - 1, 2);\n            index -= 2;\n          } // Note: we cannot return yet.\n\n        }\n      } else if (start == rangeEnd + 1 || start == rangeEnd) {\n        data[index] = rangeStart;\n        return data;\n      } // Check if a new pair must be inserted *before* the current one.\n      else if (start > rangeEnd) {\n        data.splice(index, 0, rangeStart, rangeEnd + 1);\n        return data;\n      } else if (rangeStart >= start && rangeStart < end && rangeEnd + 1 <= end) {\n        // The new range lies entirely within an existing range pair. No action\n        // needed.\n        return data;\n      } else if ( // E.g. `[0, 11]` and you add 5-15 → `[0, 16]`.\n      rangeStart >= start && rangeStart < end || // E.g. `[0, 3]` and you add 3-6 → `[0, 7]`.\n      end == rangeStart) {\n        // Replace `end` with the new value.\n        data[index + 1] = rangeEnd + 1; // Make sure the next range pair doesn’t overlap, e.g. `[0, 11, 12, 14]`\n        // and you add 5-15 → `[0, 16]`, i.e. remove the `12,14` part.\n\n        added = true; // Note: we cannot `return` just yet.\n      } else if (rangeStart <= start && rangeEnd + 1 >= end) {\n        // The new range is a superset of the old range.\n        data[index] = rangeStart;\n        data[index + 1] = rangeEnd + 1;\n        added = true;\n      }\n\n      index += 2;\n    } // The loop has finished without doing anything; add the new pair to the end\n    // of the data set.\n\n\n    if (!added) {\n      data.push(rangeStart, rangeEnd + 1);\n    }\n\n    return data;\n  };\n\n  var dataContains = function dataContains(data, codePoint) {\n    var index = 0;\n    var length = data.length; // Exit early if `codePoint` is not within `data`’s overall range.\n\n    var start = data[index];\n    var end = data[length - 1];\n\n    if (length >= 2) {\n      if (codePoint < start || codePoint > end) {\n        return false;\n      }\n    } // Iterate over the data per `(start, end)` pair.\n\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1];\n\n      if (codePoint >= start && codePoint < end) {\n        return true;\n      }\n\n      index += 2;\n    }\n\n    return false;\n  };\n\n  var dataIntersection = function dataIntersection(data, codePoints) {\n    var index = 0;\n    var length = codePoints.length;\n    var codePoint;\n    var result = [];\n\n    while (index < length) {\n      codePoint = codePoints[index];\n\n      if (dataContains(data, codePoint)) {\n        result.push(codePoint);\n      }\n\n      ++index;\n    }\n\n    return dataFromCodePoints(result);\n  };\n\n  var dataIsEmpty = function dataIsEmpty(data) {\n    return !data.length;\n  };\n\n  var dataIsSingleton = function dataIsSingleton(data) {\n    // Check if the set only represents a single code point.\n    return data.length == 2 && data[0] + 1 == data[1];\n  };\n\n  var dataToArray = function dataToArray(data) {\n    // Iterate over the data per `(start, end)` pair.\n    var index = 0;\n    var start;\n    var end;\n    var result = [];\n    var length = data.length;\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1];\n\n      while (start < end) {\n        result.push(start);\n        ++start;\n      }\n\n      index += 2;\n    }\n\n    return result;\n  };\n  /*--------------------------------------------------------------------------*/\n  // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n\n\n  var floor = Math.floor;\n\n  var highSurrogate = function highSurrogate(codePoint) {\n    return parseInt(floor((codePoint - 0x10000) / 0x400) + HIGH_SURROGATE_MIN, 10);\n  };\n\n  var lowSurrogate = function lowSurrogate(codePoint) {\n    return parseInt((codePoint - 0x10000) % 0x400 + LOW_SURROGATE_MIN, 10);\n  };\n\n  var stringFromCharCode = String.fromCharCode;\n\n  var codePointToString = function codePointToString(codePoint) {\n    var string; // https://mathiasbynens.be/notes/javascript-escapes#single\n    // Note: the `\\b` escape sequence for U+0008 BACKSPACE in strings has a\n    // different meaning in regular expressions (word boundary), so it cannot\n    // be used here.\n\n    if (codePoint == 0x09) {\n      string = '\\\\t';\n    } // Note: IE < 9 treats `'\\v'` as `'v'`, so avoid using it.\n    // else if (codePoint == 0x0B) {\n    // \tstring = '\\\\v';\n    // }\n    else if (codePoint == 0x0A) {\n      string = '\\\\n';\n    } else if (codePoint == 0x0C) {\n      string = '\\\\f';\n    } else if (codePoint == 0x0D) {\n      string = '\\\\r';\n    } else if (codePoint == 0x2D) {\n      // https://mathiasbynens.be/notes/javascript-escapes#hexadecimal\n      // Note: `-` (U+002D HYPHEN-MINUS) is escaped in this way rather\n      // than by backslash-escaping, in case the output is used outside\n      // of a character class in a `u` RegExp. /\\-/u throws, but\n      // /\\x2D/u is fine.\n      string = '\\\\x2D';\n    } else if (codePoint == 0x5C) {\n      string = '\\\\\\\\';\n    } else if (codePoint == 0x24 || codePoint >= 0x28 && codePoint <= 0x2B || codePoint == 0x2E || codePoint == 0x2F || codePoint == 0x3F || codePoint >= 0x5B && codePoint <= 0x5E || codePoint >= 0x7B && codePoint <= 0x7D) {\n      // The code point maps to an unsafe printable ASCII character;\n      // backslash-escape it. Here’s the list of those symbols:\n      //\n      //     $()*+./?[\\]^{|}\n      //\n      // This matches SyntaxCharacters as well as `/` (U+002F SOLIDUS).\n      // https://tc39.github.io/ecma262/#prod-SyntaxCharacter\n      string = '\\\\' + stringFromCharCode(codePoint);\n    } else if (codePoint >= 0x20 && codePoint <= 0x7E) {\n      // The code point maps to one of these printable ASCII symbols\n      // (including the space character):\n      //\n      //      !\"#%&',/0123456789:;<=>@ABCDEFGHIJKLMNO\n      //     PQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz~\n      //\n      // These can safely be used directly.\n      string = stringFromCharCode(codePoint);\n    } else if (codePoint <= 0xFF) {\n      string = '\\\\x' + pad(hex(codePoint), 2);\n    } else {\n      // `codePoint <= 0xFFFF` holds true.\n      // https://mathiasbynens.be/notes/javascript-escapes#unicode\n      string = \"\\\\u\" + pad(hex(codePoint), 4);\n    } // There’s no need to account for astral symbols / surrogate pairs here,\n    // since `codePointToString` is private and only used for BMP code points.\n    // But if that’s what you need, just add an `else` block with this code:\n    //\n    //     string = '\\\\u' + pad(hex(highSurrogate(codePoint)), 4)\n    //     \t+ '\\\\u' + pad(hex(lowSurrogate(codePoint)), 4);\n\n\n    return string;\n  };\n\n  var codePointToStringUnicode = function codePointToStringUnicode(codePoint) {\n    if (codePoint <= 0xFFFF) {\n      return codePointToString(codePoint);\n    }\n\n    return \"\\\\u{\" + codePoint.toString(16).toUpperCase() + '}';\n  };\n\n  var symbolToCodePoint = function symbolToCodePoint(symbol) {\n    var length = symbol.length;\n    var first = symbol.charCodeAt(0);\n    var second;\n\n    if (first >= HIGH_SURROGATE_MIN && first <= HIGH_SURROGATE_MAX && length > 1 // There is a next code unit.\n    ) {\n      // `first` is a high surrogate, and there is a next character. Assume\n      // it’s a low surrogate (else it’s invalid usage of Regenerate anyway).\n      second = symbol.charCodeAt(1); // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n\n      return (first - HIGH_SURROGATE_MIN) * 0x400 + second - LOW_SURROGATE_MIN + 0x10000;\n    }\n\n    return first;\n  };\n\n  var createBMPCharacterClasses = function createBMPCharacterClasses(data) {\n    // Iterate over the data per `(start, end)` pair.\n    var result = '';\n    var index = 0;\n    var start;\n    var end;\n    var length = data.length;\n\n    if (dataIsSingleton(data)) {\n      return codePointToString(data[0]);\n    }\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive.\n\n      if (start == end) {\n        result += codePointToString(start);\n      } else if (start + 1 == end) {\n        result += codePointToString(start) + codePointToString(end);\n      } else {\n        result += codePointToString(start) + '-' + codePointToString(end);\n      }\n\n      index += 2;\n    }\n\n    return '[' + result + ']';\n  };\n\n  var createUnicodeCharacterClasses = function createUnicodeCharacterClasses(data) {\n    // Iterate over the data per `(start, end)` pair.\n    var result = '';\n    var index = 0;\n    var start;\n    var end;\n    var length = data.length;\n\n    if (dataIsSingleton(data)) {\n      return codePointToStringUnicode(data[0]);\n    }\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive.\n\n      if (start == end) {\n        result += codePointToStringUnicode(start);\n      } else if (start + 1 == end) {\n        result += codePointToStringUnicode(start) + codePointToStringUnicode(end);\n      } else {\n        result += codePointToStringUnicode(start) + '-' + codePointToStringUnicode(end);\n      }\n\n      index += 2;\n    }\n\n    return '[' + result + ']';\n  };\n\n  var splitAtBMP = function splitAtBMP(data) {\n    // Iterate over the data per `(start, end)` pair.\n    var loneHighSurrogates = [];\n    var loneLowSurrogates = [];\n    var bmp = [];\n    var astral = [];\n    var index = 0;\n    var start;\n    var end;\n    var length = data.length;\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive.\n\n      if (start < HIGH_SURROGATE_MIN) {\n        // The range starts and ends before the high surrogate range.\n        // E.g. (0, 0x10).\n        if (end < HIGH_SURROGATE_MIN) {\n          bmp.push(start, end + 1);\n        } // The range starts before the high surrogate range and ends within it.\n        // E.g. (0, 0xD855).\n\n\n        if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {\n          bmp.push(start, HIGH_SURROGATE_MIN);\n          loneHighSurrogates.push(HIGH_SURROGATE_MIN, end + 1);\n        } // The range starts before the high surrogate range and ends in the low\n        // surrogate range. E.g. (0, 0xDCFF).\n\n\n        if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {\n          bmp.push(start, HIGH_SURROGATE_MIN);\n          loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);\n          loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);\n        } // The range starts before the high surrogate range and ends after the\n        // low surrogate range. E.g. (0, 0x10FFFF).\n\n\n        if (end > LOW_SURROGATE_MAX) {\n          bmp.push(start, HIGH_SURROGATE_MIN);\n          loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);\n          loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);\n\n          if (end <= 0xFFFF) {\n            bmp.push(LOW_SURROGATE_MAX + 1, end + 1);\n          } else {\n            bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);\n            astral.push(0xFFFF + 1, end + 1);\n          }\n        }\n      } else if (start >= HIGH_SURROGATE_MIN && start <= HIGH_SURROGATE_MAX) {\n        // The range starts and ends in the high surrogate range.\n        // E.g. (0xD855, 0xD866).\n        if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {\n          loneHighSurrogates.push(start, end + 1);\n        } // The range starts in the high surrogate range and ends in the low\n        // surrogate range. E.g. (0xD855, 0xDCFF).\n\n\n        if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {\n          loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);\n          loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);\n        } // The range starts in the high surrogate range and ends after the low\n        // surrogate range. E.g. (0xD855, 0x10FFFF).\n\n\n        if (end > LOW_SURROGATE_MAX) {\n          loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);\n          loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);\n\n          if (end <= 0xFFFF) {\n            bmp.push(LOW_SURROGATE_MAX + 1, end + 1);\n          } else {\n            bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);\n            astral.push(0xFFFF + 1, end + 1);\n          }\n        }\n      } else if (start >= LOW_SURROGATE_MIN && start <= LOW_SURROGATE_MAX) {\n        // The range starts and ends in the low surrogate range.\n        // E.g. (0xDCFF, 0xDDFF).\n        if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {\n          loneLowSurrogates.push(start, end + 1);\n        } // The range starts in the low surrogate range and ends after the low\n        // surrogate range. E.g. (0xDCFF, 0x10FFFF).\n\n\n        if (end > LOW_SURROGATE_MAX) {\n          loneLowSurrogates.push(start, LOW_SURROGATE_MAX + 1);\n\n          if (end <= 0xFFFF) {\n            bmp.push(LOW_SURROGATE_MAX + 1, end + 1);\n          } else {\n            bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);\n            astral.push(0xFFFF + 1, end + 1);\n          }\n        }\n      } else if (start > LOW_SURROGATE_MAX && start <= 0xFFFF) {\n        // The range starts and ends after the low surrogate range.\n        // E.g. (0xFFAA, 0x10FFFF).\n        if (end <= 0xFFFF) {\n          bmp.push(start, end + 1);\n        } else {\n          bmp.push(start, 0xFFFF + 1);\n          astral.push(0xFFFF + 1, end + 1);\n        }\n      } else {\n        // The range starts and ends in the astral range.\n        astral.push(start, end + 1);\n      }\n\n      index += 2;\n    }\n\n    return {\n      'loneHighSurrogates': loneHighSurrogates,\n      'loneLowSurrogates': loneLowSurrogates,\n      'bmp': bmp,\n      'astral': astral\n    };\n  };\n\n  var optimizeSurrogateMappings = function optimizeSurrogateMappings(surrogateMappings) {\n    var result = [];\n    var tmpLow = [];\n    var addLow = false;\n    var mapping;\n    var nextMapping;\n    var highSurrogates;\n    var lowSurrogates;\n    var nextHighSurrogates;\n    var nextLowSurrogates;\n    var index = -1;\n    var length = surrogateMappings.length;\n\n    while (++index < length) {\n      mapping = surrogateMappings[index];\n      nextMapping = surrogateMappings[index + 1];\n\n      if (!nextMapping) {\n        result.push(mapping);\n        continue;\n      }\n\n      highSurrogates = mapping[0];\n      lowSurrogates = mapping[1];\n      nextHighSurrogates = nextMapping[0];\n      nextLowSurrogates = nextMapping[1]; // Check for identical high surrogate ranges.\n\n      tmpLow = lowSurrogates;\n\n      while (nextHighSurrogates && highSurrogates[0] == nextHighSurrogates[0] && highSurrogates[1] == nextHighSurrogates[1]) {\n        // Merge with the next item.\n        if (dataIsSingleton(nextLowSurrogates)) {\n          tmpLow = dataAdd(tmpLow, nextLowSurrogates[0]);\n        } else {\n          tmpLow = dataAddRange(tmpLow, nextLowSurrogates[0], nextLowSurrogates[1] - 1);\n        }\n\n        ++index;\n        mapping = surrogateMappings[index];\n        highSurrogates = mapping[0];\n        lowSurrogates = mapping[1];\n        nextMapping = surrogateMappings[index + 1];\n        nextHighSurrogates = nextMapping && nextMapping[0];\n        nextLowSurrogates = nextMapping && nextMapping[1];\n        addLow = true;\n      }\n\n      result.push([highSurrogates, addLow ? tmpLow : lowSurrogates]);\n      addLow = false;\n    }\n\n    return optimizeByLowSurrogates(result);\n  };\n\n  var optimizeByLowSurrogates = function optimizeByLowSurrogates(surrogateMappings) {\n    if (surrogateMappings.length == 1) {\n      return surrogateMappings;\n    }\n\n    var index = -1;\n    var innerIndex = -1;\n\n    while (++index < surrogateMappings.length) {\n      var mapping = surrogateMappings[index];\n      var lowSurrogates = mapping[1];\n      var lowSurrogateStart = lowSurrogates[0];\n      var lowSurrogateEnd = lowSurrogates[1];\n      innerIndex = index; // Note: the loop starts at the next index.\n\n      while (++innerIndex < surrogateMappings.length) {\n        var otherMapping = surrogateMappings[innerIndex];\n        var otherLowSurrogates = otherMapping[1];\n        var otherLowSurrogateStart = otherLowSurrogates[0];\n        var otherLowSurrogateEnd = otherLowSurrogates[1];\n\n        if (lowSurrogateStart == otherLowSurrogateStart && lowSurrogateEnd == otherLowSurrogateEnd && otherLowSurrogates.length === 2) {\n          // Add the code points in the other item to this one.\n          if (dataIsSingleton(otherMapping[0])) {\n            mapping[0] = dataAdd(mapping[0], otherMapping[0][0]);\n          } else {\n            mapping[0] = dataAddRange(mapping[0], otherMapping[0][0], otherMapping[0][1] - 1);\n          } // Remove the other, now redundant, item.\n\n\n          surrogateMappings.splice(innerIndex, 1);\n          --innerIndex;\n        }\n      }\n    }\n\n    return surrogateMappings;\n  };\n\n  var surrogateSet = function surrogateSet(data) {\n    // Exit early if `data` is an empty set.\n    if (!data.length) {\n      return [];\n    } // Iterate over the data per `(start, end)` pair.\n\n\n    var index = 0;\n    var start;\n    var end;\n    var startHigh;\n    var startLow;\n    var endHigh;\n    var endLow;\n    var surrogateMappings = [];\n    var length = data.length;\n\n    while (index < length) {\n      start = data[index];\n      end = data[index + 1] - 1;\n      startHigh = highSurrogate(start);\n      startLow = lowSurrogate(start);\n      endHigh = highSurrogate(end);\n      endLow = lowSurrogate(end);\n      var startsWithLowestLowSurrogate = startLow == LOW_SURROGATE_MIN;\n      var endsWithHighestLowSurrogate = endLow == LOW_SURROGATE_MAX;\n      var complete = false; // Append the previous high-surrogate-to-low-surrogate mappings.\n      // Step 1: `(startHigh, startLow)` to `(startHigh, LOW_SURROGATE_MAX)`.\n\n      if (startHigh == endHigh || startsWithLowestLowSurrogate && endsWithHighestLowSurrogate) {\n        surrogateMappings.push([[startHigh, endHigh + 1], [startLow, endLow + 1]]);\n        complete = true;\n      } else {\n        surrogateMappings.push([[startHigh, startHigh + 1], [startLow, LOW_SURROGATE_MAX + 1]]);\n      } // Step 2: `(startHigh + 1, LOW_SURROGATE_MIN)` to\n      // `(endHigh - 1, LOW_SURROGATE_MAX)`.\n\n\n      if (!complete && startHigh + 1 < endHigh) {\n        if (endsWithHighestLowSurrogate) {\n          // Combine step 2 and step 3.\n          surrogateMappings.push([[startHigh + 1, endHigh + 1], [LOW_SURROGATE_MIN, endLow + 1]]);\n          complete = true;\n        } else {\n          surrogateMappings.push([[startHigh + 1, endHigh], [LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1]]);\n        }\n      } // Step 3. `(endHigh, LOW_SURROGATE_MIN)` to `(endHigh, endLow)`.\n\n\n      if (!complete) {\n        surrogateMappings.push([[endHigh, endHigh + 1], [LOW_SURROGATE_MIN, endLow + 1]]);\n      }\n\n      index += 2;\n    } // The format of `surrogateMappings` is as follows:\n    //\n    //     [ surrogateMapping1, surrogateMapping2 ]\n    //\n    // i.e.:\n    //\n    //     [\n    //       [ highSurrogates1, lowSurrogates1 ],\n    //       [ highSurrogates2, lowSurrogates2 ]\n    //     ]\n\n\n    return optimizeSurrogateMappings(surrogateMappings);\n  };\n\n  var createSurrogateCharacterClasses = function createSurrogateCharacterClasses(surrogateMappings) {\n    var result = [];\n    forEach(surrogateMappings, function (surrogateMapping) {\n      var highSurrogates = surrogateMapping[0];\n      var lowSurrogates = surrogateMapping[1];\n      result.push(createBMPCharacterClasses(highSurrogates) + createBMPCharacterClasses(lowSurrogates));\n    });\n    return result.join('|');\n  };\n\n  var createCharacterClassesFromData = function createCharacterClassesFromData(data, bmpOnly, hasUnicodeFlag) {\n    if (hasUnicodeFlag) {\n      return createUnicodeCharacterClasses(data);\n    }\n\n    var result = [];\n    var parts = splitAtBMP(data);\n    var loneHighSurrogates = parts.loneHighSurrogates;\n    var loneLowSurrogates = parts.loneLowSurrogates;\n    var bmp = parts.bmp;\n    var astral = parts.astral;\n    var hasLoneHighSurrogates = !dataIsEmpty(loneHighSurrogates);\n    var hasLoneLowSurrogates = !dataIsEmpty(loneLowSurrogates);\n    var surrogateMappings = surrogateSet(astral);\n\n    if (bmpOnly) {\n      bmp = dataAddData(bmp, loneHighSurrogates);\n      hasLoneHighSurrogates = false;\n      bmp = dataAddData(bmp, loneLowSurrogates);\n      hasLoneLowSurrogates = false;\n    }\n\n    if (!dataIsEmpty(bmp)) {\n      // The data set contains BMP code points that are not high surrogates\n      // needed for astral code points in the set.\n      result.push(createBMPCharacterClasses(bmp));\n    }\n\n    if (surrogateMappings.length) {\n      // The data set contains astral code points; append character classes\n      // based on their surrogate pairs.\n      result.push(createSurrogateCharacterClasses(surrogateMappings));\n    } // https://gist.github.com/mathiasbynens/bbe7f870208abcfec860\n\n\n    if (hasLoneHighSurrogates) {\n      result.push(createBMPCharacterClasses(loneHighSurrogates) + // Make sure the high surrogates aren’t part of a surrogate pair.\n      \"(?![\\\\uDC00-\\\\uDFFF])\");\n    }\n\n    if (hasLoneLowSurrogates) {\n      result.push( // It is not possible to accurately assert the low surrogates aren’t\n      // part of a surrogate pair, since JavaScript regular expressions do\n      // not support lookbehind.\n      \"(?:[^\\\\uD800-\\\\uDBFF]|^)\" + createBMPCharacterClasses(loneLowSurrogates));\n    }\n\n    return result.join('|');\n  };\n  /*--------------------------------------------------------------------------*/\n  // `regenerate` can be used as a constructor (and new methods can be added to\n  // its prototype) but also as a regular function, the latter of which is the\n  // documented and most common usage. For that reason, it’s not capitalized.\n\n\n  var regenerate = function regenerate(value) {\n    if (arguments.length > 1) {\n      value = slice.call(arguments);\n    }\n\n    if (this instanceof regenerate) {\n      this.data = [];\n      return value ? this.add(value) : this;\n    }\n\n    return new regenerate().add(value);\n  };\n\n  regenerate.version = '1.4.2';\n  var proto = regenerate.prototype;\n  extend(proto, {\n    'add': function add(value) {\n      var $this = this;\n\n      if (value == null) {\n        return $this;\n      }\n\n      if (value instanceof regenerate) {\n        // Allow passing other Regenerate instances.\n        $this.data = dataAddData($this.data, value.data);\n        return $this;\n      }\n\n      if (arguments.length > 1) {\n        value = slice.call(arguments);\n      }\n\n      if (isArray(value)) {\n        forEach(value, function (item) {\n          $this.add(item);\n        });\n        return $this;\n      }\n\n      $this.data = dataAdd($this.data, isNumber(value) ? value : symbolToCodePoint(value));\n      return $this;\n    },\n    'remove': function remove(value) {\n      var $this = this;\n\n      if (value == null) {\n        return $this;\n      }\n\n      if (value instanceof regenerate) {\n        // Allow passing other Regenerate instances.\n        $this.data = dataRemoveData($this.data, value.data);\n        return $this;\n      }\n\n      if (arguments.length > 1) {\n        value = slice.call(arguments);\n      }\n\n      if (isArray(value)) {\n        forEach(value, function (item) {\n          $this.remove(item);\n        });\n        return $this;\n      }\n\n      $this.data = dataRemove($this.data, isNumber(value) ? value : symbolToCodePoint(value));\n      return $this;\n    },\n    'addRange': function addRange(start, end) {\n      var $this = this;\n      $this.data = dataAddRange($this.data, isNumber(start) ? start : symbolToCodePoint(start), isNumber(end) ? end : symbolToCodePoint(end));\n      return $this;\n    },\n    'removeRange': function removeRange(start, end) {\n      var $this = this;\n      var startCodePoint = isNumber(start) ? start : symbolToCodePoint(start);\n      var endCodePoint = isNumber(end) ? end : symbolToCodePoint(end);\n      $this.data = dataRemoveRange($this.data, startCodePoint, endCodePoint);\n      return $this;\n    },\n    'intersection': function intersection(argument) {\n      var $this = this; // Allow passing other Regenerate instances.\n      // TODO: Optimize this by writing and using `dataIntersectionData()`.\n\n      var array = argument instanceof regenerate ? dataToArray(argument.data) : argument;\n      $this.data = dataIntersection($this.data, array);\n      return $this;\n    },\n    'contains': function contains(codePoint) {\n      return dataContains(this.data, isNumber(codePoint) ? codePoint : symbolToCodePoint(codePoint));\n    },\n    'clone': function clone() {\n      var set = new regenerate();\n      set.data = this.data.slice(0);\n      return set;\n    },\n    'toString': function toString(options) {\n      var result = createCharacterClassesFromData(this.data, options ? options.bmpOnly : false, options ? options.hasUnicodeFlag : false);\n\n      if (!result) {\n        // For an empty set, return something that can be inserted `/here/` to\n        // form a valid regular expression. Avoid `(?:)` since that matches the\n        // empty string.\n        return '[]';\n      } // Use `\\0` instead of `\\x00` where possible.\n\n\n      return result.replace(regexNull, '\\\\0$1');\n    },\n    'toRegExp': function toRegExp(flags) {\n      var pattern = this.toString(flags && flags.indexOf('u') != -1 ? {\n        'hasUnicodeFlag': true\n      } : null);\n      return RegExp(pattern, flags || '');\n    },\n    'valueOf': function valueOf() {\n      // Note: `valueOf` is aliased as `toArray`.\n      return dataToArray(this.data);\n    }\n  });\n  proto.toArray = proto.valueOf; // Some AMD build optimizers, like r.js, check for specific condition patterns\n  // like the following:\n\n  if (typeof define == 'function' && (0, _typeof2.default)(define.amd) == 'object' && define.amd) {\n    define(function () {\n      return regenerate;\n    });\n  } else if (freeExports && !freeExports.nodeType) {\n    if (freeModule) {\n      // in Node.js, io.js, or RingoJS v0.8.0+\n      freeModule.exports = regenerate;\n    } else {\n      // in Narwhal or RingoJS v0.7.0-\n      freeExports.regenerate = regenerate;\n    }\n  } else {\n    // in Rhino or a web browser\n    root.regenerate = regenerate;\n  }\n})(void 0);"],"sourceRoot":""}