httemplate/elements/xregexp-all.js

   1 (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.XRegExp = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){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[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
   2 /*!
   3  * XRegExp.build 3.1.1
   4  * <xregexp.com>
   5  * Steven Levithan (c) 2012-2016 MIT License
   6  * Inspired by Lea Verou's RegExp.create <lea.verou.me>
   7  */
   8
   9 module.exports = function(XRegExp) {
  10     'use strict';
  11
  12     var REGEX_DATA = 'xregexp';
  13     var subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g;
  14     var parts = XRegExp.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subParts], 'g');
  15
  16     /**
  17      * Strips a leading `^` and trailing unescaped `$`, if both are present.
  18      *
  19      * @param {String} pattern Pattern to process.
  20      * @returns {String} Pattern with edge anchors removed.
  21      */
  22     function deanchor(pattern) {
  23         // Allow any number of empty noncapturing groups before/after anchors, because regexes
  24         // built/generated by XRegExp sometimes include them
  25         var leadingAnchor = /^(?:\(\?:\))*\^/,
  26             trailingAnchor = /\$(?:\(\?:\))*$/;
  27
  28         if (
  29             leadingAnchor.test(pattern) &&
  30             trailingAnchor.test(pattern) &&
  31             // Ensure that the trailing `$` isn't escaped
  32             trailingAnchor.test(pattern.replace(/\\[\s\S]/g, ''))
  33         ) {
  34             return pattern.replace(leadingAnchor, '').replace(trailingAnchor, '');
  35         }
  36
  37         return pattern;
  38     }
  39
  40     /**
  41      * Converts the provided value to an XRegExp. Native RegExp flags are not preserved.
  42      *
  43      * @param {String|RegExp} value Value to convert.
  44      * @returns {RegExp} XRegExp object with XRegExp syntax applied.
  45      */
  46     function asXRegExp(value) {
  47         return XRegExp.isRegExp(value) ?
  48             (value[REGEX_DATA] && value[REGEX_DATA].captureNames ?
  49                 // Don't recompile, to preserve capture names
  50                 value :
  51                 // Recompile as XRegExp
  52                 XRegExp(value.source)
  53             ) :
  54             // Compile string as XRegExp
  55             XRegExp(value);
  56     }
  57
  58     /**
  59      * Builds regexes using named subpatterns, for readability and pattern reuse. Backreferences in
  60      * the outer pattern and provided subpatterns are automatically renumbered to work correctly.
  61      * Native flags used by provided subpatterns are ignored in favor of the `flags` argument.
  62      *
  63      * @param {String} pattern XRegExp pattern using `{{name}}` for embedded subpatterns. Allows
  64      *   `({{name}})` as shorthand for `(?<name>{{name}})`. Patterns cannot be embedded within
  65      *   character classes.
  66      * @param {Object} subs Lookup object for named subpatterns. Values can be strings or regexes. A
  67      *   leading `^` and trailing unescaped `$` are stripped from subpatterns, if both are present.
  68      * @param {String} [flags] Any combination of XRegExp flags.
  69      * @returns {RegExp} Regex with interpolated subpatterns.
  70      * @example
  71      *
  72      * var time = XRegExp.build('(?x)^ {{hours}} ({{minutes}}) $', {
  73      *   hours: XRegExp.build('{{h12}} : | {{h24}}', {
  74      *     h12: /1[0-2]|0?[1-9]/,
  75      *     h24: /2[0-3]|[01][0-9]/
  76      *   }, 'x'),
  77      *   minutes: /^[0-5][0-9]$/
  78      * });
  79      * time.test('10:59'); // -> true
  80      * XRegExp.exec('10:59', time).minutes; // -> '59'
  81      */
  82     XRegExp.build = function(pattern, subs, flags) {
  83         var inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern),
  84             data = {},
  85             numCaps = 0, // 'Caps' is short for captures
  86             numPriorCaps,
  87             numOuterCaps = 0,
  88             outerCapsMap = [0],
  89             outerCapNames,
  90             sub,
  91             p;
  92
  93         // Add flags within a leading mode modifier to the overall pattern's flags
  94         if (inlineFlags) {
  95             flags = flags || '';
  96             inlineFlags[1].replace(/./g, function(flag) {
  97                 // Don't add duplicates
  98                 flags += (flags.indexOf(flag) > -1 ? '' : flag);
  99             });
 100         }
 101
 102         for (p in subs) {
 103             if (subs.hasOwnProperty(p)) {
 104                 // Passing to XRegExp enables extended syntax and ensures independent validity,
 105                 // lest an unescaped `(`, `)`, `[`, or trailing `\` breaks the `(?:)` wrapper. For
 106                 // subpatterns provided as native regexes, it dies on octals and adds the property
 107                 // used to hold extended regex instance data, for simplicity
 108                 sub = asXRegExp(subs[p]);
 109                 data[p] = {
 110                     // Deanchoring allows embedding independently useful anchored regexes. If you
 111                     // really need to keep your anchors, double them (i.e., `^^...$$`)
 112                     pattern: deanchor(sub.source),
 113                     names: sub[REGEX_DATA].captureNames || []
 114                 };
 115             }
 116         }
 117
 118         // Passing to XRegExp dies on octals and ensures the outer pattern is independently valid;
 119         // helps keep this simple. Named captures will be put back
 120         pattern = asXRegExp(pattern);
 121         outerCapNames = pattern[REGEX_DATA].captureNames || [];
 122         pattern = pattern.source.replace(parts, function($0, $1, $2, $3, $4) {
 123             var subName = $1 || $2,
 124                 capName,
 125                 intro,
 126                 localCapIndex;
 127             // Named subpattern
 128             if (subName) {
 129                 if (!data.hasOwnProperty(subName)) {
 130                     throw new ReferenceError('Undefined property ' + $0);
 131                 }
 132                 // Named subpattern was wrapped in a capturing group
 133                 if ($1) {
 134                     capName = outerCapNames[numOuterCaps];
 135                     outerCapsMap[++numOuterCaps] = ++numCaps;
 136                     // If it's a named group, preserve the name. Otherwise, use the subpattern name
 137                     // as the capture name
 138                     intro = '(?<' + (capName || subName) + '>';
 139                 } else {
 140                     intro = '(?:';
 141                 }
 142                 numPriorCaps = numCaps;
 143                 return intro + data[subName].pattern.replace(subParts, function(match, paren, backref) {
 144                     // Capturing group
 145                     if (paren) {
 146                         capName = data[subName].names[numCaps - numPriorCaps];
 147                         ++numCaps;
 148                         // If the current capture has a name, preserve the name
 149                         if (capName) {
 150                             return '(?<' + capName + '>';
 151                         }
 152                     // Backreference
 153                     } else if (backref) {
 154                         localCapIndex = +backref - 1;
 155                         // Rewrite the backreference
 156                         return data[subName].names[localCapIndex] ?
 157                             // Need to preserve the backreference name in case using flag `n`
 158                             '\\k<' + data[subName].names[localCapIndex] + '>' :
 159                             '\\' + (+backref + numPriorCaps);
 160                     }
 161                     return match;
 162                 }) + ')';
 163             }
 164             // Capturing group
 165             if ($3) {
 166                 capName = outerCapNames[numOuterCaps];
 167                 outerCapsMap[++numOuterCaps] = ++numCaps;
 168                 // If the current capture has a name, preserve the name
 169                 if (capName) {
 170                     return '(?<' + capName + '>';
 171                 }
 172             // Backreference
 173             } else if ($4) {
 174                 localCapIndex = +$4 - 1;
 175                 // Rewrite the backreference
 176                 return outerCapNames[localCapIndex] ?
 177                     // Need to preserve the backreference name in case using flag `n`
 178                     '\\k<' + outerCapNames[localCapIndex] + '>' :
 179                     '\\' + outerCapsMap[+$4];
 180             }
 181             return $0;
 182         });
 183
 184         return XRegExp(pattern, flags);
 185     };
 186
 187 };
 188
 189 },{}],2:[function(require,module,exports){
 190 /*!
 191  * XRegExp.matchRecursive 3.1.1
 192  * <xregexp.com>
 193  * Steven Levithan (c) 2009-2016 MIT License
 194  */
 195
 196 module.exports = function(XRegExp) {
 197     'use strict';
 198
 199     /**
 200      * Returns a match detail object composed of the provided values.
 201      */
 202     function row(name, value, start, end) {
 203         return {
 204             name: name,
 205             value: value,
 206             start: start,
 207             end: end
 208         };
 209     }
 210
 211     /**
 212      * Returns an array of match strings between outermost left and right delimiters, or an array of
 213      * objects with detailed match parts and position data. An error is thrown if delimiters are
 214      * unbalanced within the data.
 215      *
 216      * @param {String} str String to search.
 217      * @param {String} left Left delimiter as an XRegExp pattern.
 218      * @param {String} right Right delimiter as an XRegExp pattern.
 219      * @param {String} [flags] Any native or XRegExp flags, used for the left and right delimiters.
 220      * @param {Object} [options] Lets you specify `valueNames` and `escapeChar` options.
 221      * @returns {Array} Array of matches, or an empty array.
 222      * @example
 223      *
 224      * // Basic usage
 225      * var str = '(t((e))s)t()(ing)';
 226      * XRegExp.matchRecursive(str, '\\(', '\\)', 'g');
 227      * // -> ['t((e))s', '', 'ing']
 228      *
 229      * // Extended information mode with valueNames
 230      * str = 'Here is <div> <div>an</div></div> example';
 231      * XRegExp.matchRecursive(str, '<div\\s*>', '</div>', 'gi', {
 232      *   valueNames: ['between', 'left', 'match', 'right']
 233      * });
 234      * // -> [
 235      * // {name: 'between', value: 'Here is ',       start: 0,  end: 8},
 236      * // {name: 'left',    value: '<div>',          start: 8,  end: 13},
 237      * // {name: 'match',   value: ' <div>an</div>', start: 13, end: 27},
 238      * // {name: 'right',   value: '</div>',         start: 27, end: 33},
 239      * // {name: 'between', value: ' example',       start: 33, end: 41}
 240      * // ]
 241      *
 242      * // Omitting unneeded parts with null valueNames, and using escapeChar
 243      * str = '...{1}.\\{{function(x,y){return {y:x}}}';
 244      * XRegExp.matchRecursive(str, '{', '}', 'g', {
 245      *   valueNames: ['literal', null, 'value', null],
 246      *   escapeChar: '\\'
 247      * });
 248      * // -> [
 249      * // {name: 'literal', value: '...',  start: 0, end: 3},
 250      * // {name: 'value',   value: '1',    start: 4, end: 5},
 251      * // {name: 'literal', value: '.\\{', start: 6, end: 9},
 252      * // {name: 'value',   value: 'function(x,y){return {y:x}}', start: 10, end: 37}
 253      * // ]
 254      *
 255      * // Sticky mode via flag y
 256      * str = '<1><<<2>>><3>4<5>';
 257      * XRegExp.matchRecursive(str, '<', '>', 'gy');
 258      * // -> ['1', '<<2>>', '3']
 259      */
 260     XRegExp.matchRecursive = function(str, left, right, flags, options) {
 261         flags = flags || '';
 262         options = options || {};
 263         var global = flags.indexOf('g') > -1,
 264             sticky = flags.indexOf('y') > -1,
 265             // Flag `y` is controlled internally
 266             basicFlags = flags.replace(/y/g, ''),
 267             escapeChar = options.escapeChar,
 268             vN = options.valueNames,
 269             output = [],
 270             openTokens = 0,
 271             delimStart = 0,
 272             delimEnd = 0,
 273             lastOuterEnd = 0,
 274             outerStart,
 275             innerStart,
 276             leftMatch,
 277             rightMatch,
 278             esc;
 279         left = XRegExp(left, basicFlags);
 280         right = XRegExp(right, basicFlags);
 281
 282         if (escapeChar) {
 283             if (escapeChar.length > 1) {
 284                 throw new Error('Cannot use more than one escape character');
 285             }
 286             escapeChar = XRegExp.escape(escapeChar);
 287             // Using `XRegExp.union` safely rewrites backreferences in `left` and `right`
 288             esc = new RegExp(
 289                 '(?:' + escapeChar + '[\\S\\s]|(?:(?!' +
 290                     XRegExp.union([left, right]).source +
 291                     ')[^' + escapeChar + '])+)+',
 292                 // Flags `gy` not needed here
 293                 flags.replace(/[^imu]+/g, '')
 294             );
 295         }
 296
 297         while (true) {
 298             // If using an escape character, advance to the delimiter's next starting position,
 299             // skipping any escaped characters in between
 300             if (escapeChar) {
 301                 delimEnd += (XRegExp.exec(str, esc, delimEnd, 'sticky') || [''])[0].length;
 302             }
 303             leftMatch = XRegExp.exec(str, left, delimEnd);
 304             rightMatch = XRegExp.exec(str, right, delimEnd);
 305             // Keep the leftmost match only
 306             if (leftMatch && rightMatch) {
 307                 if (leftMatch.index <= rightMatch.index) {
 308                     rightMatch = null;
 309                 } else {
 310                     leftMatch = null;
 311                 }
 312             }
 313             // Paths (LM: leftMatch, RM: rightMatch, OT: openTokens):
 314             // LM | RM | OT | Result
 315             // 1  | 0  | 1  | loop
 316             // 1  | 0  | 0  | loop
 317             // 0  | 1  | 1  | loop
 318             // 0  | 1  | 0  | throw
 319             // 0  | 0  | 1  | throw
 320             // 0  | 0  | 0  | break
 321             // The paths above don't include the sticky mode special case. The loop ends after the
 322             // first completed match if not `global`.
 323             if (leftMatch || rightMatch) {
 324                 delimStart = (leftMatch || rightMatch).index;
 325                 delimEnd = delimStart + (leftMatch || rightMatch)[0].length;
 326             } else if (!openTokens) {
 327                 break;
 328             }
 329             if (sticky && !openTokens && delimStart > lastOuterEnd) {
 330                 break;
 331             }
 332             if (leftMatch) {
 333                 if (!openTokens) {
 334                     outerStart = delimStart;
 335                     innerStart = delimEnd;
 336                 }
 337                 ++openTokens;
 338             } else if (rightMatch && openTokens) {
 339                 if (!--openTokens) {
 340                     if (vN) {
 341                         if (vN[0] && outerStart > lastOuterEnd) {
 342                             output.push(row(vN[0], str.slice(lastOuterEnd, outerStart), lastOuterEnd, outerStart));
 343                         }
 344                         if (vN[1]) {
 345                             output.push(row(vN[1], str.slice(outerStart, innerStart), outerStart, innerStart));
 346                         }
 347                         if (vN[2]) {
 348                             output.push(row(vN[2], str.slice(innerStart, delimStart), innerStart, delimStart));
 349                         }
 350                         if (vN[3]) {
 351                             output.push(row(vN[3], str.slice(delimStart, delimEnd), delimStart, delimEnd));
 352                         }
 353                     } else {
 354                         output.push(str.slice(innerStart, delimStart));
 355                     }
 356                     lastOuterEnd = delimEnd;
 357                     if (!global) {
 358                         break;
 359                     }
 360                 }
 361             } else {
 362                 throw new Error('Unbalanced delimiter found in string');
 363             }
 364             // If the delimiter matched an empty string, avoid an infinite loop
 365             if (delimStart === delimEnd) {
 366                 ++delimEnd;
 367             }
 368         }
 369
 370         if (global && !sticky && vN && vN[0] && str.length > lastOuterEnd) {
 371             output.push(row(vN[0], str.slice(lastOuterEnd), lastOuterEnd, str.length));
 372         }
 373
 374         return output;
 375     };
 376
 377 };
 378
 379 },{}],3:[function(require,module,exports){
 380 /*!
 381  * XRegExp Unicode Base 3.1.1
 382  * <xregexp.com>
 383  * Steven Levithan (c) 2008-2016 MIT License
 384  */
 385
 386 module.exports = function(XRegExp) {
 387     'use strict';
 388
 389     /**
 390      * Adds base support for Unicode matching:
 391      * - Adds syntax `\p{..}` for matching Unicode tokens. Tokens can be inverted using `\P{..}` or
 392      *   `\p{^..}`. Token names ignore case, spaces, hyphens, and underscores. You can omit the
 393      *   braces for token names that are a single letter (e.g. `\pL` or `PL`).
 394      * - Adds flag A (astral), which enables 21-bit Unicode support.
 395      * - Adds the `XRegExp.addUnicodeData` method used by other addons to provide character data.
 396      *
 397      * Unicode Base relies on externally provided Unicode character data. Official addons are
 398      * available to provide data for Unicode categories, scripts, blocks, and properties.
 399      *
 400      * @requires XRegExp
 401      */
 402
 403     // ==--------------------------==
 404     // Private stuff
 405     // ==--------------------------==
 406
 407     // Storage for Unicode data
 408     var unicode = {};
 409
 410     // Reuse utils
 411     var dec = XRegExp._dec;
 412     var hex = XRegExp._hex;
 413     var pad4 = XRegExp._pad4;
 414
 415     // Generates a token lookup name: lowercase, with hyphens, spaces, and underscores removed
 416     function normalize(name) {
 417         return name.replace(/[- _]+/g, '').toLowerCase();
 418     }
 419
 420     // Gets the decimal code of a literal code unit, \xHH, \uHHHH, or a backslash-escaped literal
 421     function charCode(chr) {
 422         var esc = /^\\[xu](.+)/.exec(chr);
 423         return esc ?
 424             dec(esc[1]) :
 425             chr.charCodeAt(chr.charAt(0) === '\\' ? 1 : 0);
 426     }
 427
 428     // Inverts a list of ordered BMP characters and ranges
 429     function invertBmp(range) {
 430         var output = '';
 431         var lastEnd = -1;
 432         XRegExp.forEach(
 433             range,
 434             /(\\x..|\\u....|\\?[\s\S])(?:-(\\x..|\\u....|\\?[\s\S]))?/,
 435             function(m) {
 436                 var start = charCode(m[1]);
 437                 if (start > (lastEnd + 1)) {
 438                     output += '\\u' + pad4(hex(lastEnd + 1));
 439                     if (start > (lastEnd + 2)) {
 440                         output += '-\\u' + pad4(hex(start - 1));
 441                     }
 442                 }
 443                 lastEnd = charCode(m[2] || m[1]);
 444             }
 445         );
 446         if (lastEnd < 0xFFFF) {
 447             output += '\\u' + pad4(hex(lastEnd + 1));
 448             if (lastEnd < 0xFFFE) {
 449                 output += '-\\uFFFF';
 450             }
 451         }
 452         return output;
 453     }
 454
 455     // Generates an inverted BMP range on first use
 456     function cacheInvertedBmp(slug) {
 457         var prop = 'b!';
 458         return unicode[slug][prop] || (
 459             unicode[slug][prop] = invertBmp(unicode[slug].bmp)
 460         );
 461     }
 462
 463     // Combines and optionally negates BMP and astral data
 464     function buildAstral(slug, isNegated) {
 465         var item = unicode[slug],
 466             combined = '';
 467         if (item.bmp && !item.isBmpLast) {
 468             combined = '[' + item.bmp + ']' + (item.astral ? '|' : '');
 469         }
 470         if (item.astral) {
 471             combined += item.astral;
 472         }
 473         if (item.isBmpLast && item.bmp) {
 474             combined += (item.astral ? '|' : '') + '[' + item.bmp + ']';
 475         }
 476         // Astral Unicode tokens always match a code point, never a code unit
 477         return isNegated ?
 478             '(?:(?!' + combined + ')(?:[\uD800-\uDBFF][\uDC00-\uDFFF]|[\0-\uFFFF]))' :
 479             '(?:' + combined + ')';
 480     }
 481
 482     // Builds a complete astral pattern on first use
 483     function cacheAstral(slug, isNegated) {
 484         var prop = isNegated ? 'a!' : 'a=';
 485         return unicode[slug][prop] || (
 486             unicode[slug][prop] = buildAstral(slug, isNegated)
 487         );
 488     }
 489
 490     // ==--------------------------==
 491     // Core functionality
 492     // ==--------------------------==
 493
 494     /*
 495      * Add Unicode token syntax: \p{..}, \P{..}, \p{^..}. Also add astral mode (flag A).
 496      */
 497     XRegExp.addToken(
 498         // Use `*` instead of `+` to avoid capturing `^` as the token name in `\p{^}`
 499         /\\([pP])(?:{(\^?)([^}]*)}|([A-Za-z]))/,
 500         function(match, scope, flags) {
 501             var ERR_DOUBLE_NEG = 'Invalid double negation ',
 502                 ERR_UNKNOWN_NAME = 'Unknown Unicode token ',
 503                 ERR_UNKNOWN_REF = 'Unicode token missing data ',
 504                 ERR_ASTRAL_ONLY = 'Astral mode required for Unicode token ',
 505                 ERR_ASTRAL_IN_CLASS = 'Astral mode does not support Unicode tokens within character classes',
 506                 // Negated via \P{..} or \p{^..}
 507                 isNegated = match[1] === 'P' || !!match[2],
 508                 // Switch from BMP (0-FFFF) to astral (0-10FFFF) mode via flag A
 509                 isAstralMode = flags.indexOf('A') > -1,
 510                 // Token lookup name. Check `[4]` first to avoid passing `undefined` via `\p{}`
 511                 slug = normalize(match[4] || match[3]),
 512                 // Token data object
 513                 item = unicode[slug];
 514
 515             if (match[1] === 'P' && match[2]) {
 516                 throw new SyntaxError(ERR_DOUBLE_NEG + match[0]);
 517             }
 518             if (!unicode.hasOwnProperty(slug)) {
 519                 throw new SyntaxError(ERR_UNKNOWN_NAME + match[0]);
 520             }
 521
 522             // Switch to the negated form of the referenced Unicode token
 523             if (item.inverseOf) {
 524                 slug = normalize(item.inverseOf);
 525                 if (!unicode.hasOwnProperty(slug)) {
 526                     throw new ReferenceError(ERR_UNKNOWN_REF + match[0] + ' -> ' + item.inverseOf);
 527                 }
 528                 item = unicode[slug];
 529                 isNegated = !isNegated;
 530             }
 531
 532             if (!(item.bmp || isAstralMode)) {
 533                 throw new SyntaxError(ERR_ASTRAL_ONLY + match[0]);
 534             }
 535             if (isAstralMode) {
 536                 if (scope === 'class') {
 537                     throw new SyntaxError(ERR_ASTRAL_IN_CLASS);
 538                 }
 539
 540                 return cacheAstral(slug, isNegated);
 541             }
 542
 543             return scope === 'class' ?
 544                 (isNegated ? cacheInvertedBmp(slug) : item.bmp) :
 545                 (isNegated ? '[^' : '[') + item.bmp + ']';
 546         },
 547         {
 548             scope: 'all',
 549             optionalFlags: 'A',
 550             leadChar: '\\'
 551         }
 552     );
 553
 554     /**
 555      * Adds to the list of Unicode tokens that XRegExp regexes can match via `\p` or `\P`.
 556      *
 557      * @param {Array} data Objects with named character ranges. Each object may have properties
 558      *   `name`, `alias`, `isBmpLast`, `inverseOf`, `bmp`, and `astral`. All but `name` are
 559      *   optional, although one of `bmp` or `astral` is required (unless `inverseOf` is set). If
 560      *   `astral` is absent, the `bmp` data is used for BMP and astral modes. If `bmp` is absent,
 561      *   the name errors in BMP mode but works in astral mode. If both `bmp` and `astral` are
 562      *   provided, the `bmp` data only is used in BMP mode, and the combination of `bmp` and
 563      *   `astral` data is used in astral mode. `isBmpLast` is needed when a token matches orphan
 564      *   high surrogates *and* uses surrogate pairs to match astral code points. The `bmp` and
 565      *   `astral` data should be a combination of literal characters and `\xHH` or `\uHHHH` escape
 566      *   sequences, with hyphens to create ranges. Any regex metacharacters in the data should be
 567      *   escaped, apart from range-creating hyphens. The `astral` data can additionally use
 568      *   character classes and alternation, and should use surrogate pairs to represent astral code
 569      *   points. `inverseOf` can be used to avoid duplicating character data if a Unicode token is
 570      *   defined as the exact inverse of another token.
 571      * @example
 572      *
 573      * // Basic use
 574      * XRegExp.addUnicodeData([{
 575      *   name: 'XDigit',
 576      *   alias: 'Hexadecimal',
 577      *   bmp: '0-9A-Fa-f'
 578      * }]);
 579      * XRegExp('\\p{XDigit}:\\p{Hexadecimal}+').test('0:3D'); // -> true
 580      */
 581     XRegExp.addUnicodeData = function(data) {
 582         var ERR_NO_NAME = 'Unicode token requires name',
 583             ERR_NO_DATA = 'Unicode token has no character data ',
 584             item,
 585             i;
 586
 587         for (i = 0; i < data.length; ++i) {
 588             item = data[i];
 589             if (!item.name) {
 590                 throw new Error(ERR_NO_NAME);
 591             }
 592             if (!(item.inverseOf || item.bmp || item.astral)) {
 593                 throw new Error(ERR_NO_DATA + item.name);
 594             }
 595             unicode[normalize(item.name)] = item;
 596             if (item.alias) {
 597                 unicode[normalize(item.alias)] = item;
 598             }
 599         }
 600
 601         // Reset the pattern cache used by the `XRegExp` constructor, since the same pattern and
 602         // flags might now produce different results
 603         XRegExp.cache.flush('patterns');
 604     };
 605
 606 };
 607
 608 },{}],4:[function(require,module,exports){
 609 /*!
 610  * XRegExp Unicode Blocks 3.1.1
 611  * <xregexp.com>
 612  * Steven Levithan (c) 2010-2016 MIT License
 613  * Unicode data by Mathias Bynens <mathiasbynens.be>
 614  */
 615
 616 module.exports = function(XRegExp) {
 617     'use strict';
 618
 619     /**
 620      * Adds support for all Unicode blocks. Block names use the prefix 'In'. E.g.,
 621      * `\p{InBasicLatin}`. Token names are case insensitive, and any spaces, hyphens, and
 622      * underscores are ignored.
 623      *
 624      * Uses Unicode 8.0.0.
 625      *
 626      * @requires XRegExp, Unicode Base
 627      */
 628
 629     if (!XRegExp.addUnicodeData) {
 630         throw new ReferenceError('Unicode Base must be loaded before Unicode Blocks');
 631     }
 632
 633     XRegExp.addUnicodeData([
 634         {
 635             name: 'InAegean_Numbers',
 636             astral: '\uD800[\uDD00-\uDD3F]'
 637         },
 638         {
 639             name: 'InAhom',
 640             astral: '\uD805[\uDF00-\uDF3F]'
 641         },
 642         {
 643             name: 'InAlchemical_Symbols',
 644             astral: '\uD83D[\uDF00-\uDF7F]'
 645         },
 646         {
 647             name: 'InAlphabetic_Presentation_Forms',
 648             bmp: '\uFB00-\uFB4F'
 649         },
 650         {
 651             name: 'InAnatolian_Hieroglyphs',
 652             astral: '\uD811[\uDC00-\uDE7F]'
 653         },
 654         {
 655             name: 'InAncient_Greek_Musical_Notation',
 656             astral: '\uD834[\uDE00-\uDE4F]'
 657         },
 658         {
 659             name: 'InAncient_Greek_Numbers',
 660             astral: '\uD800[\uDD40-\uDD8F]'
 661         },
 662         {
 663             name: 'InAncient_Symbols',
 664             astral: '\uD800[\uDD90-\uDDCF]'
 665         },
 666         {
 667             name: 'InArabic',
 668             bmp: '\u0600-\u06FF'
 669         },
 670         {
 671             name: 'InArabic_Extended_A',
 672             bmp: '\u08A0-\u08FF'
 673         },
 674         {
 675             name: 'InArabic_Mathematical_Alphabetic_Symbols',
 676             astral: '\uD83B[\uDE00-\uDEFF]'
 677         },
 678         {
 679             name: 'InArabic_Presentation_Forms_A',
 680             bmp: '\uFB50-\uFDFF'
 681         },
 682         {
 683             name: 'InArabic_Presentation_Forms_B',
 684             bmp: '\uFE70-\uFEFF'
 685         },
 686         {
 687             name: 'InArabic_Supplement',
 688             bmp: '\u0750-\u077F'
 689         },
 690         {
 691             name: 'InArmenian',
 692             bmp: '\u0530-\u058F'
 693         },
 694         {
 695             name: 'InArrows',
 696             bmp: '\u2190-\u21FF'
 697         },
 698         {
 699             name: 'InAvestan',
 700             astral: '\uD802[\uDF00-\uDF3F]'
 701         },
 702         {
 703             name: 'InBalinese',
 704             bmp: '\u1B00-\u1B7F'
 705         },
 706         {
 707             name: 'InBamum',
 708             bmp: '\uA6A0-\uA6FF'
 709         },
 710         {
 711             name: 'InBamum_Supplement',
 712             astral: '\uD81A[\uDC00-\uDE3F]'
 713         },
 714         {
 715             name: 'InBasic_Latin',
 716             bmp: '\0-\x7F'
 717         },
 718         {
 719             name: 'InBassa_Vah',
 720             astral: '\uD81A[\uDED0-\uDEFF]'
 721         },
 722         {
 723             name: 'InBatak',
 724             bmp: '\u1BC0-\u1BFF'
 725         },
 726         {
 727             name: 'InBengali',
 728             bmp: '\u0980-\u09FF'
 729         },
 730         {
 731             name: 'InBlock_Elements',
 732             bmp: '\u2580-\u259F'
 733         },
 734         {
 735             name: 'InBopomofo',
 736             bmp: '\u3100-\u312F'
 737         },
 738         {
 739             name: 'InBopomofo_Extended',
 740             bmp: '\u31A0-\u31BF'
 741         },
 742         {
 743             name: 'InBox_Drawing',
 744             bmp: '\u2500-\u257F'
 745         },
 746         {
 747             name: 'InBrahmi',
 748             astral: '\uD804[\uDC00-\uDC7F]'
 749         },
 750         {
 751             name: 'InBraille_Patterns',
 752             bmp: '\u2800-\u28FF'
 753         },
 754         {
 755             name: 'InBuginese',
 756             bmp: '\u1A00-\u1A1F'
 757         },
 758         {
 759             name: 'InBuhid',
 760             bmp: '\u1740-\u175F'
 761         },
 762         {
 763             name: 'InByzantine_Musical_Symbols',
 764             astral: '\uD834[\uDC00-\uDCFF]'
 765         },
 766         {
 767             name: 'InCJK_Compatibility',
 768             bmp: '\u3300-\u33FF'
 769         },
 770         {
 771             name: 'InCJK_Compatibility_Forms',
 772             bmp: '\uFE30-\uFE4F'
 773         },
 774         {
 775             name: 'InCJK_Compatibility_Ideographs',
 776             bmp: '\uF900-\uFAFF'
 777         },
 778         {
 779             name: 'InCJK_Compatibility_Ideographs_Supplement',
 780             astral: '\uD87E[\uDC00-\uDE1F]'
 781         },
 782         {
 783             name: 'InCJK_Radicals_Supplement',
 784             bmp: '\u2E80-\u2EFF'
 785         },
 786         {
 787             name: 'InCJK_Strokes',
 788             bmp: '\u31C0-\u31EF'
 789         },
 790         {
 791             name: 'InCJK_Symbols_and_Punctuation',
 792             bmp: '\u3000-\u303F'
 793         },
 794         {
 795             name: 'InCJK_Unified_Ideographs',
 796             bmp: '\u4E00-\u9FFF'
 797         },
 798         {
 799             name: 'InCJK_Unified_Ideographs_Extension_A',
 800             bmp: '\u3400-\u4DBF'
 801         },
 802         {
 803             name: 'InCJK_Unified_Ideographs_Extension_B',
 804             astral: '[\uD840-\uD868][\uDC00-\uDFFF]|\uD869[\uDC00-\uDEDF]'
 805         },
 806         {
 807             name: 'InCJK_Unified_Ideographs_Extension_C',
 808             astral: '\uD86D[\uDC00-\uDF3F]|[\uD86A-\uD86C][\uDC00-\uDFFF]|\uD869[\uDF00-\uDFFF]'
 809         },
 810         {
 811             name: 'InCJK_Unified_Ideographs_Extension_D',
 812             astral: '\uD86D[\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1F]'
 813         },
 814         {
 815             name: 'InCJK_Unified_Ideographs_Extension_E',
 816             astral: '[\uD86F-\uD872][\uDC00-\uDFFF]|\uD873[\uDC00-\uDEAF]|\uD86E[\uDC20-\uDFFF]'
 817         },
 818         {
 819             name: 'InCarian',
 820             astral: '\uD800[\uDEA0-\uDEDF]'
 821         },
 822         {
 823             name: 'InCaucasian_Albanian',
 824             astral: '\uD801[\uDD30-\uDD6F]'
 825         },
 826         {
 827             name: 'InChakma',
 828             astral: '\uD804[\uDD00-\uDD4F]'
 829         },
 830         {
 831             name: 'InCham',
 832             bmp: '\uAA00-\uAA5F'
 833         },
 834         {
 835             name: 'InCherokee',
 836             bmp: '\u13A0-\u13FF'
 837         },
 838         {
 839             name: 'InCherokee_Supplement',
 840             bmp: '\uAB70-\uABBF'
 841         },
 842         {
 843             name: 'InCombining_Diacritical_Marks',
 844             bmp: '\u0300-\u036F'
 845         },
 846         {
 847             name: 'InCombining_Diacritical_Marks_Extended',
 848             bmp: '\u1AB0-\u1AFF'
 849         },
 850         {
 851             name: 'InCombining_Diacritical_Marks_Supplement',
 852             bmp: '\u1DC0-\u1DFF'
 853         },
 854         {
 855             name: 'InCombining_Diacritical_Marks_for_Symbols',
 856             bmp: '\u20D0-\u20FF'
 857         },
 858         {
 859             name: 'InCombining_Half_Marks',
 860             bmp: '\uFE20-\uFE2F'
 861         },
 862         {
 863             name: 'InCommon_Indic_Number_Forms',
 864             bmp: '\uA830-\uA83F'
 865         },
 866         {
 867             name: 'InControl_Pictures',
 868             bmp: '\u2400-\u243F'
 869         },
 870         {
 871             name: 'InCoptic',
 872             bmp: '\u2C80-\u2CFF'
 873         },
 874         {
 875             name: 'InCoptic_Epact_Numbers',
 876             astral: '\uD800[\uDEE0-\uDEFF]'
 877         },
 878         {
 879             name: 'InCounting_Rod_Numerals',
 880             astral: '\uD834[\uDF60-\uDF7F]'
 881         },
 882         {
 883             name: 'InCuneiform',
 884             astral: '\uD808[\uDC00-\uDFFF]'
 885         },
 886         {
 887             name: 'InCuneiform_Numbers_and_Punctuation',
 888             astral: '\uD809[\uDC00-\uDC7F]'
 889         },
 890         {
 891             name: 'InCurrency_Symbols',
 892             bmp: '\u20A0-\u20CF'
 893         },
 894         {
 895             name: 'InCypriot_Syllabary',
 896             astral: '\uD802[\uDC00-\uDC3F]'
 897         },
 898         {
 899             name: 'InCyrillic',
 900             bmp: '\u0400-\u04FF'
 901         },
 902         {
 903             name: 'InCyrillic_Extended_A',
 904             bmp: '\u2DE0-\u2DFF'
 905         },
 906         {
 907             name: 'InCyrillic_Extended_B',
 908             bmp: '\uA640-\uA69F'
 909         },
 910         {
 911             name: 'InCyrillic_Supplement',
 912             bmp: '\u0500-\u052F'
 913         },
 914         {
 915             name: 'InDeseret',
 916             astral: '\uD801[\uDC00-\uDC4F]'
 917         },
 918         {
 919             name: 'InDevanagari',
 920             bmp: '\u0900-\u097F'
 921         },
 922         {
 923             name: 'InDevanagari_Extended',
 924             bmp: '\uA8E0-\uA8FF'
 925         },
 926         {
 927             name: 'InDingbats',
 928             bmp: '\u2700-\u27BF'
 929         },
 930         {
 931             name: 'InDomino_Tiles',
 932             astral: '\uD83C[\uDC30-\uDC9F]'
 933         },
 934         {
 935             name: 'InDuployan',
 936             astral: '\uD82F[\uDC00-\uDC9F]'
 937         },
 938         {
 939             name: 'InEarly_Dynastic_Cuneiform',
 940             astral: '\uD809[\uDC80-\uDD4F]'
 941         },
 942         {
 943             name: 'InEgyptian_Hieroglyphs',
 944             astral: '\uD80C[\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2F]'
 945         },
 946         {
 947             name: 'InElbasan',
 948             astral: '\uD801[\uDD00-\uDD2F]'
 949         },
 950         {
 951             name: 'InEmoticons',
 952             astral: '\uD83D[\uDE00-\uDE4F]'
 953         },
 954         {
 955             name: 'InEnclosed_Alphanumeric_Supplement',
 956             astral: '\uD83C[\uDD00-\uDDFF]'
 957         },
 958         {
 959             name: 'InEnclosed_Alphanumerics',
 960             bmp: '\u2460-\u24FF'
 961         },
 962         {
 963             name: 'InEnclosed_CJK_Letters_and_Months',
 964             bmp: '\u3200-\u32FF'
 965         },
 966         {
 967             name: 'InEnclosed_Ideographic_Supplement',
 968             astral: '\uD83C[\uDE00-\uDEFF]'
 969         },
 970         {
 971             name: 'InEthiopic',
 972             bmp: '\u1200-\u137F'
 973         },
 974         {
 975             name: 'InEthiopic_Extended',
 976             bmp: '\u2D80-\u2DDF'
 977         },
 978         {
 979             name: 'InEthiopic_Extended_A',
 980             bmp: '\uAB00-\uAB2F'
 981         },
 982         {
 983             name: 'InEthiopic_Supplement',
 984             bmp: '\u1380-\u139F'
 985         },
 986         {
 987             name: 'InGeneral_Punctuation',
 988             bmp: '\u2000-\u206F'
 989         },
 990         {
 991             name: 'InGeometric_Shapes',
 992             bmp: '\u25A0-\u25FF'
 993         },
 994         {
 995             name: 'InGeometric_Shapes_Extended',
 996             astral: '\uD83D[\uDF80-\uDFFF]'
 997         },
 998         {
 999             name: 'InGeorgian',
1000             bmp: '\u10A0-\u10FF'
1001         },
1002         {
1003             name: 'InGeorgian_Supplement',
1004             bmp: '\u2D00-\u2D2F'
1005         },
1006         {
1007             name: 'InGlagolitic',
1008             bmp: '\u2C00-\u2C5F'
1009         },
1010         {
1011             name: 'InGothic',
1012             astral: '\uD800[\uDF30-\uDF4F]'
1013         },
1014         {
1015             name: 'InGrantha',
1016             astral: '\uD804[\uDF00-\uDF7F]'
1017         },
1018         {
1019             name: 'InGreek_Extended',
1020             bmp: '\u1F00-\u1FFF'
1021         },
1022         {
1023             name: 'InGreek_and_Coptic',
1024             bmp: '\u0370-\u03FF'
1025         },
1026         {
1027             name: 'InGujarati',
1028             bmp: '\u0A80-\u0AFF'
1029         },
1030         {
1031             name: 'InGurmukhi',
1032             bmp: '\u0A00-\u0A7F'
1033         },
1034         {
1035             name: 'InHalfwidth_and_Fullwidth_Forms',
1036             bmp: '\uFF00-\uFFEF'
1037         },
1038         {
1039             name: 'InHangul_Compatibility_Jamo',
1040             bmp: '\u3130-\u318F'
1041         },
1042         {
1043             name: 'InHangul_Jamo',
1044             bmp: '\u1100-\u11FF'
1045         },
1046         {
1047             name: 'InHangul_Jamo_Extended_A',
1048             bmp: '\uA960-\uA97F'
1049         },
1050         {
1051             name: 'InHangul_Jamo_Extended_B',
1052             bmp: '\uD7B0-\uD7FF'
1053         },
1054         {
1055             name: 'InHangul_Syllables',
1056             bmp: '\uAC00-\uD7AF'
1057         },
1058         {
1059             name: 'InHanunoo',
1060             bmp: '\u1720-\u173F'
1061         },
1062         {
1063             name: 'InHatran',
1064             astral: '\uD802[\uDCE0-\uDCFF]'
1065         },
1066         {
1067             name: 'InHebrew',
1068             bmp: '\u0590-\u05FF'
1069         },
1070         {
1071             name: 'InHigh_Private_Use_Surrogates',
1072             bmp: '\uDB80-\uDBFF'
1073         },
1074         {
1075             name: 'InHigh_Surrogates',
1076             bmp: '\uD800-\uDB7F'
1077         },
1078         {
1079             name: 'InHiragana',
1080             bmp: '\u3040-\u309F'
1081         },
1082         {
1083             name: 'InIPA_Extensions',
1084             bmp: '\u0250-\u02AF'
1085         },
1086         {
1087             name: 'InIdeographic_Description_Characters',
1088             bmp: '\u2FF0-\u2FFF'
1089         },
1090         {
1091             name: 'InImperial_Aramaic',
1092             astral: '\uD802[\uDC40-\uDC5F]'
1093         },
1094         {
1095             name: 'InInscriptional_Pahlavi',
1096             astral: '\uD802[\uDF60-\uDF7F]'
1097         },
1098         {
1099             name: 'InInscriptional_Parthian',
1100             astral: '\uD802[\uDF40-\uDF5F]'
1101         },
1102         {
1103             name: 'InJavanese',
1104             bmp: '\uA980-\uA9DF'
1105         },
1106         {
1107             name: 'InKaithi',
1108             astral: '\uD804[\uDC80-\uDCCF]'
1109         },
1110         {
1111             name: 'InKana_Supplement',
1112             astral: '\uD82C[\uDC00-\uDCFF]'
1113         },
1114         {
1115             name: 'InKanbun',
1116             bmp: '\u3190-\u319F'
1117         },
1118         {
1119             name: 'InKangxi_Radicals',
1120             bmp: '\u2F00-\u2FDF'
1121         },
1122         {
1123             name: 'InKannada',
1124             bmp: '\u0C80-\u0CFF'
1125         },
1126         {
1127             name: 'InKatakana',
1128             bmp: '\u30A0-\u30FF'
1129         },
1130         {
1131             name: 'InKatakana_Phonetic_Extensions',
1132             bmp: '\u31F0-\u31FF'
1133         },
1134         {
1135             name: 'InKayah_Li',
1136             bmp: '\uA900-\uA92F'
1137         },
1138         {
1139             name: 'InKharoshthi',
1140             astral: '\uD802[\uDE00-\uDE5F]'
1141         },
1142         {
1143             name: 'InKhmer',
1144             bmp: '\u1780-\u17FF'
1145         },
1146         {
1147             name: 'InKhmer_Symbols',
1148             bmp: '\u19E0-\u19FF'
1149         },
1150         {
1151             name: 'InKhojki',
1152             astral: '\uD804[\uDE00-\uDE4F]'
1153         },
1154         {
1155             name: 'InKhudawadi',
1156             astral: '\uD804[\uDEB0-\uDEFF]'
1157         },
1158         {
1159             name: 'InLao',
1160             bmp: '\u0E80-\u0EFF'
1161         },
1162         {
1163             name: 'InLatin_Extended_Additional',
1164             bmp: '\u1E00-\u1EFF'
1165         },
1166         {
1167             name: 'InLatin_Extended_A',
1168             bmp: '\u0100-\u017F'
1169         },
1170         {
1171             name: 'InLatin_Extended_B',
1172             bmp: '\u0180-\u024F'
1173         },
1174         {
1175             name: 'InLatin_Extended_C',
1176             bmp: '\u2C60-\u2C7F'
1177         },
1178         {
1179             name: 'InLatin_Extended_D',
1180             bmp: '\uA720-\uA7FF'
1181         },
1182         {
1183             name: 'InLatin_Extended_E',
1184             bmp: '\uAB30-\uAB6F'
1185         },
1186         {
1187             name: 'InLatin_1_Supplement',
1188             bmp: '\x80-\xFF'
1189         },
1190         {
1191             name: 'InLepcha',
1192             bmp: '\u1C00-\u1C4F'
1193         },
1194         {
1195             name: 'InLetterlike_Symbols',
1196             bmp: '\u2100-\u214F'
1197         },
1198         {
1199             name: 'InLimbu',
1200             bmp: '\u1900-\u194F'
1201         },
1202         {
1203             name: 'InLinear_A',
1204             astral: '\uD801[\uDE00-\uDF7F]'
1205         },
1206         {
1207             name: 'InLinear_B_Ideograms',
1208             astral: '\uD800[\uDC80-\uDCFF]'
1209         },
1210         {
1211             name: 'InLinear_B_Syllabary',
1212             astral: '\uD800[\uDC00-\uDC7F]'
1213         },
1214         {
1215             name: 'InLisu',
1216             bmp: '\uA4D0-\uA4FF'
1217         },
1218         {
1219             name: 'InLow_Surrogates',
1220             bmp: '\uDC00-\uDFFF'
1221         },
1222         {
1223             name: 'InLycian',
1224             astral: '\uD800[\uDE80-\uDE9F]'
1225         },
1226         {
1227             name: 'InLydian',
1228             astral: '\uD802[\uDD20-\uDD3F]'
1229         },
1230         {
1231             name: 'InMahajani',
1232             astral: '\uD804[\uDD50-\uDD7F]'
1233         },
1234         {
1235             name: 'InMahjong_Tiles',
1236             astral: '\uD83C[\uDC00-\uDC2F]'
1237         },
1238         {
1239             name: 'InMalayalam',
1240             bmp: '\u0D00-\u0D7F'
1241         },
1242         {
1243             name: 'InMandaic',
1244             bmp: '\u0840-\u085F'
1245         },
1246         {
1247             name: 'InManichaean',
1248             astral: '\uD802[\uDEC0-\uDEFF]'
1249         },
1250         {
1251             name: 'InMathematical_Alphanumeric_Symbols',
1252             astral: '\uD835[\uDC00-\uDFFF]'
1253         },
1254         {
1255             name: 'InMathematical_Operators',
1256             bmp: '\u2200-\u22FF'
1257         },
1258         {
1259             name: 'InMeetei_Mayek',
1260             bmp: '\uABC0-\uABFF'
1261         },
1262         {
1263             name: 'InMeetei_Mayek_Extensions',
1264             bmp: '\uAAE0-\uAAFF'
1265         },
1266         {
1267             name: 'InMende_Kikakui',
1268             astral: '\uD83A[\uDC00-\uDCDF]'
1269         },
1270         {
1271             name: 'InMeroitic_Cursive',
1272             astral: '\uD802[\uDDA0-\uDDFF]'
1273         },
1274         {
1275             name: 'InMeroitic_Hieroglyphs',
1276             astral: '\uD802[\uDD80-\uDD9F]'
1277         },
1278         {
1279             name: 'InMiao',
1280             astral: '\uD81B[\uDF00-\uDF9F]'
1281         },
1282         {
1283             name: 'InMiscellaneous_Mathematical_Symbols_A',
1284             bmp: '\u27C0-\u27EF'
1285         },
1286         {
1287             name: 'InMiscellaneous_Mathematical_Symbols_B',
1288             bmp: '\u2980-\u29FF'
1289         },
1290         {
1291             name: 'InMiscellaneous_Symbols',
1292             bmp: '\u2600-\u26FF'
1293         },
1294         {
1295             name: 'InMiscellaneous_Symbols_and_Arrows',
1296             bmp: '\u2B00-\u2BFF'
1297         },
1298         {
1299             name: 'InMiscellaneous_Symbols_and_Pictographs',
1300             astral: '\uD83D[\uDC00-\uDDFF]|\uD83C[\uDF00-\uDFFF]'
1301         },
1302         {
1303             name: 'InMiscellaneous_Technical',
1304             bmp: '\u2300-\u23FF'
1305         },
1306         {
1307             name: 'InModi',
1308             astral: '\uD805[\uDE00-\uDE5F]'
1309         },
1310         {
1311             name: 'InModifier_Tone_Letters',
1312             bmp: '\uA700-\uA71F'
1313         },
1314         {
1315             name: 'InMongolian',
1316             bmp: '\u1800-\u18AF'
1317         },
1318         {
1319             name: 'InMro',
1320             astral: '\uD81A[\uDE40-\uDE6F]'
1321         },
1322         {
1323             name: 'InMultani',
1324             astral: '\uD804[\uDE80-\uDEAF]'
1325         },
1326         {
1327             name: 'InMusical_Symbols',
1328             astral: '\uD834[\uDD00-\uDDFF]'
1329         },
1330         {
1331             name: 'InMyanmar',
1332             bmp: '\u1000-\u109F'
1333         },
1334         {
1335             name: 'InMyanmar_Extended_A',
1336             bmp: '\uAA60-\uAA7F'
1337         },
1338         {
1339             name: 'InMyanmar_Extended_B',
1340             bmp: '\uA9E0-\uA9FF'
1341         },
1342         {
1343             name: 'InNKo',
1344             bmp: '\u07C0-\u07FF'
1345         },
1346         {
1347             name: 'InNabataean',
1348             astral: '\uD802[\uDC80-\uDCAF]'
1349         },
1350         {
1351             name: 'InNew_Tai_Lue',
1352             bmp: '\u1980-\u19DF'
1353         },
1354         {
1355             name: 'InNumber_Forms',
1356             bmp: '\u2150-\u218F'
1357         },
1358         {
1359             name: 'InOgham',
1360             bmp: '\u1680-\u169F'
1361         },
1362         {
1363             name: 'InOl_Chiki',
1364             bmp: '\u1C50-\u1C7F'
1365         },
1366         {
1367             name: 'InOld_Hungarian',
1368             astral: '\uD803[\uDC80-\uDCFF]'
1369         },
1370         {
1371             name: 'InOld_Italic',
1372             astral: '\uD800[\uDF00-\uDF2F]'
1373         },
1374         {
1375             name: 'InOld_North_Arabian',
1376             astral: '\uD802[\uDE80-\uDE9F]'
1377         },
1378         {
1379             name: 'InOld_Permic',
1380             astral: '\uD800[\uDF50-\uDF7F]'
1381         },
1382         {
1383             name: 'InOld_Persian',
1384             astral: '\uD800[\uDFA0-\uDFDF]'
1385         },
1386         {
1387             name: 'InOld_South_Arabian',
1388             astral: '\uD802[\uDE60-\uDE7F]'
1389         },
1390         {
1391             name: 'InOld_Turkic',
1392             astral: '\uD803[\uDC00-\uDC4F]'
1393         },
1394         {
1395             name: 'InOptical_Character_Recognition',
1396             bmp: '\u2440-\u245F'
1397         },
1398         {
1399             name: 'InOriya',
1400             bmp: '\u0B00-\u0B7F'
1401         },
1402         {
1403             name: 'InOrnamental_Dingbats',
1404             astral: '\uD83D[\uDE50-\uDE7F]'
1405         },
1406         {
1407             name: 'InOsmanya',
1408             astral: '\uD801[\uDC80-\uDCAF]'
1409         },
1410         {
1411             name: 'InPahawh_Hmong',
1412             astral: '\uD81A[\uDF00-\uDF8F]'
1413         },
1414         {
1415             name: 'InPalmyrene',
1416             astral: '\uD802[\uDC60-\uDC7F]'
1417         },
1418         {
1419             name: 'InPau_Cin_Hau',
1420             astral: '\uD806[\uDEC0-\uDEFF]'
1421         },
1422         {
1423             name: 'InPhags_pa',
1424             bmp: '\uA840-\uA87F'
1425         },
1426         {
1427             name: 'InPhaistos_Disc',
1428             astral: '\uD800[\uDDD0-\uDDFF]'
1429         },
1430         {
1431             name: 'InPhoenician',
1432             astral: '\uD802[\uDD00-\uDD1F]'
1433         },
1434         {
1435             name: 'InPhonetic_Extensions',
1436             bmp: '\u1D00-\u1D7F'
1437         },
1438         {
1439             name: 'InPhonetic_Extensions_Supplement',
1440             bmp: '\u1D80-\u1DBF'
1441         },
1442         {
1443             name: 'InPlaying_Cards',
1444             astral: '\uD83C[\uDCA0-\uDCFF]'
1445         },
1446         {
1447             name: 'InPrivate_Use_Area',
1448             bmp: '\uE000-\uF8FF'
1449         },
1450         {
1451             name: 'InPsalter_Pahlavi',
1452             astral: '\uD802[\uDF80-\uDFAF]'
1453         },
1454         {
1455             name: 'InRejang',
1456             bmp: '\uA930-\uA95F'
1457         },
1458         {
1459             name: 'InRumi_Numeral_Symbols',
1460             astral: '\uD803[\uDE60-\uDE7F]'
1461         },
1462         {
1463             name: 'InRunic',
1464             bmp: '\u16A0-\u16FF'
1465         },
1466         {
1467             name: 'InSamaritan',
1468             bmp: '\u0800-\u083F'
1469         },
1470         {
1471             name: 'InSaurashtra',
1472             bmp: '\uA880-\uA8DF'
1473         },
1474         {
1475             name: 'InSharada',
1476             astral: '\uD804[\uDD80-\uDDDF]'
1477         },
1478         {
1479             name: 'InShavian',
1480             astral: '\uD801[\uDC50-\uDC7F]'
1481         },
1482         {
1483             name: 'InShorthand_Format_Controls',
1484             astral: '\uD82F[\uDCA0-\uDCAF]'
1485         },
1486         {
1487             name: 'InSiddham',
1488             astral: '\uD805[\uDD80-\uDDFF]'
1489         },
1490         {
1491             name: 'InSinhala',
1492             bmp: '\u0D80-\u0DFF'
1493         },
1494         {
1495             name: 'InSinhala_Archaic_Numbers',
1496             astral: '\uD804[\uDDE0-\uDDFF]'
1497         },
1498         {
1499             name: 'InSmall_Form_Variants',
1500             bmp: '\uFE50-\uFE6F'
1501         },
1502         {
1503             name: 'InSora_Sompeng',
1504             astral: '\uD804[\uDCD0-\uDCFF]'
1505         },
1506         {
1507             name: 'InSpacing_Modifier_Letters',
1508             bmp: '\u02B0-\u02FF'
1509         },
1510         {
1511             name: 'InSpecials',
1512             bmp: '\uFFF0-\uFFFF'
1513         },
1514         {
1515             name: 'InSundanese',
1516             bmp: '\u1B80-\u1BBF'
1517         },
1518         {
1519             name: 'InSundanese_Supplement',
1520             bmp: '\u1CC0-\u1CCF'
1521         },
1522         {
1523             name: 'InSuperscripts_and_Subscripts',
1524             bmp: '\u2070-\u209F'
1525         },
1526         {
1527             name: 'InSupplemental_Arrows_A',
1528             bmp: '\u27F0-\u27FF'
1529         },
1530         {
1531             name: 'InSupplemental_Arrows_B',
1532             bmp: '\u2900-\u297F'
1533         },
1534         {
1535             name: 'InSupplemental_Arrows_C',
1536             astral: '\uD83E[\uDC00-\uDCFF]'
1537         },
1538         {
1539             name: 'InSupplemental_Mathematical_Operators',
1540             bmp: '\u2A00-\u2AFF'
1541         },
1542         {
1543             name: 'InSupplemental_Punctuation',
1544             bmp: '\u2E00-\u2E7F'
1545         },
1546         {
1547             name: 'InSupplemental_Symbols_and_Pictographs',
1548             astral: '\uD83E[\uDD00-\uDDFF]'
1549         },
1550         {
1551             name: 'InSupplementary_Private_Use_Area_A',
1552             astral: '[\uDB80-\uDBBF][\uDC00-\uDFFF]'
1553         },
1554         {
1555             name: 'InSupplementary_Private_Use_Area_B',
1556             astral: '[\uDBC0-\uDBFF][\uDC00-\uDFFF]'
1557         },
1558         {
1559             name: 'InSutton_SignWriting',
1560             astral: '\uD836[\uDC00-\uDEAF]'
1561         },
1562         {
1563             name: 'InSyloti_Nagri',
1564             bmp: '\uA800-\uA82F'
1565         },
1566         {
1567             name: 'InSyriac',
1568             bmp: '\u0700-\u074F'
1569         },
1570         {
1571             name: 'InTagalog',
1572             bmp: '\u1700-\u171F'
1573         },
1574         {
1575             name: 'InTagbanwa',
1576             bmp: '\u1760-\u177F'
1577         },
1578         {
1579             name: 'InTags',
1580             astral: '\uDB40[\uDC00-\uDC7F]'
1581         },
1582         {
1583             name: 'InTai_Le',
1584             bmp: '\u1950-\u197F'
1585         },
1586         {
1587             name: 'InTai_Tham',
1588             bmp: '\u1A20-\u1AAF'
1589         },
1590         {
1591             name: 'InTai_Viet',
1592             bmp: '\uAA80-\uAADF'
1593         },
1594         {
1595             name: 'InTai_Xuan_Jing_Symbols',
1596             astral: '\uD834[\uDF00-\uDF5F]'
1597         },
1598         {
1599             name: 'InTakri',
1600             astral: '\uD805[\uDE80-\uDECF]'
1601         },
1602         {
1603             name: 'InTamil',
1604             bmp: '\u0B80-\u0BFF'
1605         },
1606         {
1607             name: 'InTelugu',
1608             bmp: '\u0C00-\u0C7F'
1609         },
1610         {
1611             name: 'InThaana',
1612             bmp: '\u0780-\u07BF'
1613         },
1614         {
1615             name: 'InThai',
1616             bmp: '\u0E00-\u0E7F'
1617         },
1618         {
1619             name: 'InTibetan',
1620             bmp: '\u0F00-\u0FFF'
1621         },
1622         {
1623             name: 'InTifinagh',
1624             bmp: '\u2D30-\u2D7F'
1625         },
1626         {
1627             name: 'InTirhuta',
1628             astral: '\uD805[\uDC80-\uDCDF]'
1629         },
1630         {
1631             name: 'InTransport_and_Map_Symbols',
1632             astral: '\uD83D[\uDE80-\uDEFF]'
1633         },
1634         {
1635             name: 'InUgaritic',
1636             astral: '\uD800[\uDF80-\uDF9F]'
1637         },
1638         {
1639             name: 'InUnified_Canadian_Aboriginal_Syllabics',
1640             bmp: '\u1400-\u167F'
1641         },
1642         {
1643             name: 'InUnified_Canadian_Aboriginal_Syllabics_Extended',
1644             bmp: '\u18B0-\u18FF'
1645         },
1646         {
1647             name: 'InVai',
1648             bmp: '\uA500-\uA63F'
1649         },
1650         {
1651             name: 'InVariation_Selectors',
1652             bmp: '\uFE00-\uFE0F'
1653         },
1654         {
1655             name: 'InVariation_Selectors_Supplement',
1656             astral: '\uDB40[\uDD00-\uDDEF]'
1657         },
1658         {
1659             name: 'InVedic_Extensions',
1660             bmp: '\u1CD0-\u1CFF'
1661         },
1662         {
1663             name: 'InVertical_Forms',
1664             bmp: '\uFE10-\uFE1F'
1665         },
1666         {
1667             name: 'InWarang_Citi',
1668             astral: '\uD806[\uDCA0-\uDCFF]'
1669         },
1670         {
1671             name: 'InYi_Radicals',
1672             bmp: '\uA490-\uA4CF'
1673         },
1674         {
1675             name: 'InYi_Syllables',
1676             bmp: '\uA000-\uA48F'
1677         },
1678         {
1679             name: 'InYijing_Hexagram_Symbols',
1680             bmp: '\u4DC0-\u4DFF'
1681         }
1682     ]);
1683
1684 };
1685
1686 },{}],5:[function(require,module,exports){
1687 /*!
1688  * XRegExp Unicode Categories 3.1.1
1689  * <xregexp.com>
1690  * Steven Levithan (c) 2010-2016 MIT License
1691  * Unicode data by Mathias Bynens <mathiasbynens.be>
1692  */
1693
1694 module.exports = function(XRegExp) {
1695     'use strict';
1696
1697     /**
1698      * Adds support for Unicode's general categories. E.g., `\p{Lu}` or `\p{Uppercase Letter}`. See
1699      * category descriptions in UAX #44 <http://unicode.org/reports/tr44/#GC_Values_Table>. Token
1700      * names are case insensitive, and any spaces, hyphens, and underscores are ignored.
1701      *
1702      * Uses Unicode 8.0.0.
1703      *
1704      * @requires XRegExp, Unicode Base
1705      */
1706
1707     if (!XRegExp.addUnicodeData) {
1708         throw new ReferenceError('Unicode Base must be loaded before Unicode Categories');
1709     }
1710
1711     XRegExp.addUnicodeData([
1712         {
1713             name: 'C',
1714             alias: 'Other',
1715             isBmpLast: true,
1716             bmp: '\0-\x1F\x7F-\x9F\xAD\u0378\u0379\u0380-\u0383\u038B\u038D\u03A2\u0530\u0557\u0558\u0560\u0588\u058B\u058C\u0590\u05C8-\u05CF\u05EB-\u05EF\u05F5-\u0605\u061C\u061D\u06DD\u070E\u070F\u074B\u074C\u07B2-\u07BF\u07FB-\u07FF\u082E\u082F\u083F\u085C\u085D\u085F-\u089F\u08B5-\u08E2\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09FC-\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF2-\u0AF8\u0AFA-\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B55\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BFB-\u0BFF\u0C04\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C77\u0C80\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0D00\u0D04\u0D0D\u0D11\u0D3B\u0D3C\u0D45\u0D49\u0D4F-\u0D56\u0D58-\u0D5E\u0D64\u0D65\u0D76-\u0D78\u0D80\u0D81\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF5-\u0E00\u0E3B-\u0E3E\u0E5C-\u0E80\u0E83\u0E85\u0E86\u0E89\u0E8B\u0E8C\u0E8E-\u0E93\u0E98\u0EA0\u0EA4\u0EA6\u0EA8\u0EA9\u0EAC\u0EBA\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F48\u0F6D-\u0F70\u0F98\u0FBD\u0FCD\u0FDB-\u0FFF\u10C6\u10C8-\u10CC\u10CE\u10CF\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u137D-\u137F\u139A-\u139F\u13F6\u13F7\u13FE\u13FF\u169D-\u169F\u16F9-\u16FF\u170D\u1715-\u171F\u1737-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17DE\u17DF\u17EA-\u17EF\u17FA-\u17FF\u180E\u180F\u181A-\u181F\u1878-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u193F\u1941-\u1943\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19DD\u1A1C\u1A1D\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1A9F\u1AAE\u1AAF\u1ABF-\u1AFF\u1B4C-\u1B4F\u1B7D-\u1B7F\u1BF4-\u1BFB\u1C38-\u1C3A\u1C4A-\u1C4C\u1C80-\u1CBF\u1CC8-\u1CCF\u1CF7\u1CFA-\u1CFF\u1DF6-\u1DFB\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FC5\u1FD4\u1FD5\u1FDC\u1FF0\u1FF1\u1FF5\u1FFF\u200B-\u200F\u202A-\u202E\u2060-\u206F\u2072\u2073\u208F\u209D-\u209F\u20BF-\u20CF\u20F1-\u20FF\u218C-\u218F\u23FB-\u23FF\u2427-\u243F\u244B-\u245F\u2B74\u2B75\u2B96\u2B97\u2BBA-\u2BBC\u2BC9\u2BD2-\u2BEB\u2BF0-\u2BFF\u2C2F\u2C5F\u2CF4-\u2CF8\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D71-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E43-\u2E7F\u2E9A\u2EF4-\u2EFF\u2FD6-\u2FEF\u2FFC-\u2FFF\u3040\u3097\u3098\u3100-\u3104\u312E-\u3130\u318F\u31BB-\u31BF\u31E4-\u31EF\u321F\u32FF\u4DB6-\u4DBF\u9FD6-\u9FFF\uA48D-\uA48F\uA4C7-\uA4CF\uA62C-\uA63F\uA6F8-\uA6FF\uA7AE\uA7AF\uA7B8-\uA7F6\uA82C-\uA82F\uA83A-\uA83F\uA878-\uA87F\uA8C5-\uA8CD\uA8DA-\uA8DF\uA8FE\uA8FF\uA954-\uA95E\uA97D-\uA97F\uA9CE\uA9DA-\uA9DD\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A\uAA5B\uAAC3-\uAADA\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB66-\uAB6F\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBC2-\uFBD2\uFD40-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFE\uFDFF\uFE1A-\uFE1F\uFE53\uFE67\uFE6C-\uFE6F\uFE75\uFEFD-\uFF00\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFDF\uFFE7\uFFEF-\uFFFB\uFFFE\uFFFF',
1717             astral: '\uD834[\uDCF6-\uDCFF\uDD27\uDD28\uDD73-\uDD7A\uDDE9-\uDDFF\uDE46-\uDEFF\uDF57-\uDF5F\uDF72-\uDFFF]|\uD836[\uDE8C-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD83C[\uDC2C-\uDC2F\uDC94-\uDC9F\uDCAF\uDCB0\uDCC0\uDCD0\uDCF6-\uDCFF\uDD0D-\uDD0F\uDD2F\uDD6C-\uDD6F\uDD9B-\uDDE5\uDE03-\uDE0F\uDE3B-\uDE3F\uDE49-\uDE4F\uDE52-\uDEFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDE70-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|\uD81B[\uDC00-\uDEFF\uDF45-\uDF4F\uDF7F-\uDF8E\uDFA0-\uDFFF]|\uD86E[\uDC1E\uDC1F]|\uD83D[\uDD7A\uDDA4\uDED1-\uDEDF\uDEED-\uDEEF\uDEF4-\uDEFF\uDF74-\uDF7F\uDFD5-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD70-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8D-\uDD8F\uDD9C-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2F\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD869[\uDED7-\uDEFF]|\uD83B[\uDC00-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDEEF\uDEF2-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC70-\uDC7E\uDCBD\uDCC2-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD44-\uDD4F\uDD77-\uDD7F\uDDCE\uDDCF\uDDE0\uDDF5-\uDDFF\uDE12\uDE3E-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF3B\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD86D[\uDF35-\uDF3F]|[\uD807\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD81C-\uD82B\uD82D\uD82E\uD830-\uD833\uD837-\uD839\uD83F\uD874-\uD87D\uD87F-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD806[\uDC00-\uDC9F\uDCF3-\uDCFE\uDD00-\uDEBF\uDEF9-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD00-\uDE5F\uDE7F-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]|\uD805[\uDC00-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB8-\uDEBF\uDECA-\uDEFF\uDF1A-\uDF1C\uDF2C-\uDF2F\uDF40-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE34-\uDE37\uDE3B-\uDE3E\uDE48-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A\uDC9B\uDCA0-\uDFFF]|\uD82C[\uDC02-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE-\uDD0F\uDD19-\uDD7F\uDD85-\uDDBF\uDDC1-\uDFFF]|\uD873[\uDEA2-\uDFFF]'
1718         },
1719         {
1720             name: 'Cc',
1721             alias: 'Control',
1722             bmp: '\0-\x1F\x7F-\x9F'
1723         },
1724         {
1725             name: 'Cf',
1726             alias: 'Format',
1727             bmp: '\xAD\u0600-\u0605\u061C\u06DD\u070F\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB',
1728             astral: '\uDB40[\uDC01\uDC20-\uDC7F]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uD804\uDCBD'
1729         },
1730         {
1731             name: 'Cn',
1732             alias: 'Unassigned',
1733             bmp: '\u0378\u0379\u0380-\u0383\u038B\u038D\u03A2\u0530\u0557\u0558\u0560\u0588\u058B\u058C\u0590\u05C8-\u05CF\u05EB-\u05EF\u05F5-\u05FF\u061D\u070E\u074B\u074C\u07B2-\u07BF\u07FB-\u07FF\u082E\u082F\u083F\u085C\u085D\u085F-\u089F\u08B5-\u08E2\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09FC-\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF2-\u0AF8\u0AFA-\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B55\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BFB-\u0BFF\u0C04\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C77\u0C80\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0D00\u0D04\u0D0D\u0D11\u0D3B\u0D3C\u0D45\u0D49\u0D4F-\u0D56\u0D58-\u0D5E\u0D64\u0D65\u0D76-\u0D78\u0D80\u0D81\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF5-\u0E00\u0E3B-\u0E3E\u0E5C-\u0E80\u0E83\u0E85\u0E86\u0E89\u0E8B\u0E8C\u0E8E-\u0E93\u0E98\u0EA0\u0EA4\u0EA6\u0EA8\u0EA9\u0EAC\u0EBA\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F48\u0F6D-\u0F70\u0F98\u0FBD\u0FCD\u0FDB-\u0FFF\u10C6\u10C8-\u10CC\u10CE\u10CF\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u137D-\u137F\u139A-\u139F\u13F6\u13F7\u13FE\u13FF\u169D-\u169F\u16F9-\u16FF\u170D\u1715-\u171F\u1737-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17DE\u17DF\u17EA-\u17EF\u17FA-\u17FF\u180F\u181A-\u181F\u1878-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u193F\u1941-\u1943\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19DD\u1A1C\u1A1D\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1A9F\u1AAE\u1AAF\u1ABF-\u1AFF\u1B4C-\u1B4F\u1B7D-\u1B7F\u1BF4-\u1BFB\u1C38-\u1C3A\u1C4A-\u1C4C\u1C80-\u1CBF\u1CC8-\u1CCF\u1CF7\u1CFA-\u1CFF\u1DF6-\u1DFB\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FC5\u1FD4\u1FD5\u1FDC\u1FF0\u1FF1\u1FF5\u1FFF\u2065\u2072\u2073\u208F\u209D-\u209F\u20BF-\u20CF\u20F1-\u20FF\u218C-\u218F\u23FB-\u23FF\u2427-\u243F\u244B-\u245F\u2B74\u2B75\u2B96\u2B97\u2BBA-\u2BBC\u2BC9\u2BD2-\u2BEB\u2BF0-\u2BFF\u2C2F\u2C5F\u2CF4-\u2CF8\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D71-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E43-\u2E7F\u2E9A\u2EF4-\u2EFF\u2FD6-\u2FEF\u2FFC-\u2FFF\u3040\u3097\u3098\u3100-\u3104\u312E-\u3130\u318F\u31BB-\u31BF\u31E4-\u31EF\u321F\u32FF\u4DB6-\u4DBF\u9FD6-\u9FFF\uA48D-\uA48F\uA4C7-\uA4CF\uA62C-\uA63F\uA6F8-\uA6FF\uA7AE\uA7AF\uA7B8-\uA7F6\uA82C-\uA82F\uA83A-\uA83F\uA878-\uA87F\uA8C5-\uA8CD\uA8DA-\uA8DF\uA8FE\uA8FF\uA954-\uA95E\uA97D-\uA97F\uA9CE\uA9DA-\uA9DD\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A\uAA5B\uAAC3-\uAADA\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB66-\uAB6F\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBC2-\uFBD2\uFD40-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFE\uFDFF\uFE1A-\uFE1F\uFE53\uFE67\uFE6C-\uFE6F\uFE75\uFEFD\uFEFE\uFF00\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFDF\uFFE7\uFFEF-\uFFF8\uFFFE\uFFFF',
1734             astral: '\uDB40[\uDC00\uDC02-\uDC1F\uDC80-\uDCFF\uDDF0-\uDFFF]|\uD834[\uDCF6-\uDCFF\uDD27\uDD28\uDDE9-\uDDFF\uDE46-\uDEFF\uDF57-\uDF5F\uDF72-\uDFFF]|\uD83C[\uDC2C-\uDC2F\uDC94-\uDC9F\uDCAF\uDCB0\uDCC0\uDCD0\uDCF6-\uDCFF\uDD0D-\uDD0F\uDD2F\uDD6C-\uDD6F\uDD9B-\uDDE5\uDE03-\uDE0F\uDE3B-\uDE3F\uDE49-\uDE4F\uDE52-\uDEFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDE70-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|\uD81B[\uDC00-\uDEFF\uDF45-\uDF4F\uDF7F-\uDF8E\uDFA0-\uDFFF]|\uD86E[\uDC1E\uDC1F]|\uD83D[\uDD7A\uDDA4\uDED1-\uDEDF\uDEED-\uDEEF\uDEF4-\uDEFF\uDF74-\uDF7F\uDFD5-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD70-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8D-\uDD8F\uDD9C-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2F\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD869[\uDED7-\uDEFF]|\uD83B[\uDC00-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDEEF\uDEF2-\uDFFF]|[\uDBBF\uDBFF][\uDFFE\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A\uDC9B\uDCA4-\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD86D[\uDF35-\uDF3F]|[\uD807\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD81C-\uD82B\uD82D\uD82E\uD830-\uD833\uD837-\uD839\uD83F\uD874-\uD87D\uD87F-\uDB3F\uDB41-\uDB7F][\uDC00-\uDFFF]|\uD806[\uDC00-\uDC9F\uDCF3-\uDCFE\uDD00-\uDEBF\uDEF9-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD00-\uDE5F\uDE7F-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]|\uD836[\uDE8C-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD805[\uDC00-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB8-\uDEBF\uDECA-\uDEFF\uDF1A-\uDF1C\uDF2C-\uDF2F\uDF40-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE34-\uDE37\uDE3B-\uDE3E\uDE48-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC70-\uDC7E\uDCC2-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD44-\uDD4F\uDD77-\uDD7F\uDDCE\uDDCF\uDDE0\uDDF5-\uDDFF\uDE12\uDE3E-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF3B\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD82C[\uDC02-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE-\uDD0F\uDD19-\uDD7F\uDD85-\uDDBF\uDDC1-\uDFFF]|\uD873[\uDEA2-\uDFFF]'
1735         },
1736         {
1737             name: 'Co',
1738             alias: 'Private_Use',
1739             bmp: '\uE000-\uF8FF',
1740             astral: '[\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uDBBF\uDBFF][\uDC00-\uDFFD]'
1741         },
1742         {
1743             name: 'Cs',
1744             alias: 'Surrogate',
1745             bmp: '\uD800-\uDFFF'
1746         },
1747         {
1748             name: 'L',
1749             alias: 'Letter',
1750             bmp: 'A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC',
1751             astral: '\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD83A[\uDC00-\uDCC4]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD80D[\uDC00-\uDC2E]|\uD87E[\uDC00-\uDE1D]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD809[\uDC80-\uDD43]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD808[\uDC00-\uDF99]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD811[\uDC00-\uDE46]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD82C[\uDC00\uDC01]|\uD873[\uDC00-\uDEA1]'
1752         },
1753         {
1754             name: 'Ll',
1755             alias: 'Lowercase_Letter',
1756             bmp: 'a-z\xB5\xDF-\xF6\xF8-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0561-\u0587\u13F8-\u13FD\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6\u1FC7\u1FD0-\u1FD3\u1FD6\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6\u1FF7\u210A\u210E\u210F\u2113\u212F\u2134\u2139\u213C\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7B5\uA7B7\uA7FA\uAB30-\uAB5A\uAB60-\uAB65\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A',
1757             astral: '\uD803[\uDCC0-\uDCF2]|\uD835[\uDC1A-\uDC33\uDC4E-\uDC54\uDC56-\uDC67\uDC82-\uDC9B\uDCB6-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDCEA-\uDD03\uDD1E-\uDD37\uDD52-\uDD6B\uDD86-\uDD9F\uDDBA-\uDDD3\uDDEE-\uDE07\uDE22-\uDE3B\uDE56-\uDE6F\uDE8A-\uDEA5\uDEC2-\uDEDA\uDEDC-\uDEE1\uDEFC-\uDF14\uDF16-\uDF1B\uDF36-\uDF4E\uDF50-\uDF55\uDF70-\uDF88\uDF8A-\uDF8F\uDFAA-\uDFC2\uDFC4-\uDFC9\uDFCB]|\uD801[\uDC28-\uDC4F]|\uD806[\uDCC0-\uDCDF]'
1758         },
1759         {
1760             name: 'Lm',
1761             alias: 'Modifier_Letter',
1762             bmp: '\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5\u06E6\u07F4\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C\uA69D\uA717-\uA71F\uA770\uA788\uA7F8\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3\uAAF4\uAB5C-\uAB5F\uFF70\uFF9E\uFF9F',
1763             astral: '\uD81A[\uDF40-\uDF43]|\uD81B[\uDF93-\uDF9F]'
1764         },
1765         {
1766             name: 'Lo',
1767             alias: 'Other_Letter',
1768             bmp: '\xAA\xBA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05F0-\u05F2\u0620-\u063F\u0641-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E45\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10D0-\u10FA\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC',
1769             astral: '\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD83A[\uDC00-\uDCC4]|\uD803[\uDC00-\uDC48]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD80D[\uDC00-\uDC2E]|\uD87E[\uDC00-\uDE1D]|\uD81B[\uDF00-\uDF44\uDF50]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCFF\uDEC0-\uDEF8]|\uD809[\uDC80-\uDD43]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD808[\uDC00-\uDF99]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF63-\uDF77\uDF7D-\uDF8F]|\uD801[\uDC50-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD811[\uDC00-\uDE46]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD82C[\uDC00\uDC01]|\uD873[\uDC00-\uDEA1]'
1770         },
1771         {
1772             name: 'Lt',
1773             alias: 'Titlecase_Letter',
1774             bmp: '\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC'
1775         },
1776         {
1777             name: 'Lu',
1778             alias: 'Uppercase_Letter',
1779             bmp: 'A-Z\xC0-\xD6\xD8-\xDE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178\u0179\u017B\u017D\u0181\u0182\u0184\u0186\u0187\u0189-\u018B\u018E-\u0191\u0193\u0194\u0196-\u0198\u019C\u019D\u019F\u01A0\u01A2\u01A4\u01A6\u01A7\u01A9\u01AC\u01AE\u01AF\u01B1-\u01B3\u01B5\u01B7\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A\u023B\u023D\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AD\uA7B0-\uA7B4\uA7B6\uFF21-\uFF3A',
1780             astral: '\uD806[\uDCA0-\uDCBF]|\uD803[\uDC80-\uDCB2]|\uD801[\uDC00-\uDC27]|\uD835[\uDC00-\uDC19\uDC34-\uDC4D\uDC68-\uDC81\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB5\uDCD0-\uDCE9\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD38\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD6C-\uDD85\uDDA0-\uDDB9\uDDD4-\uDDED\uDE08-\uDE21\uDE3C-\uDE55\uDE70-\uDE89\uDEA8-\uDEC0\uDEE2-\uDEFA\uDF1C-\uDF34\uDF56-\uDF6E\uDF90-\uDFA8\uDFCA]'
1781         },
1782         {
1783             name: 'M',
1784             alias: 'Mark',
1785             bmp: '\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F',
1786             astral: '\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDCA-\uDDCC\uDE2C-\uDE37\uDEDF-\uDEEA\uDF00-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD82F[\uDC9D\uDC9E]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]'
1787         },
1788         {
1789             name: 'Mc',
1790             alias: 'Spacing_Mark',
1791             bmp: '\u0903\u093B\u093E-\u0940\u0949-\u094C\u094E\u094F\u0982\u0983\u09BE-\u09C0\u09C7\u09C8\u09CB\u09CC\u09D7\u0A03\u0A3E-\u0A40\u0A83\u0ABE-\u0AC0\u0AC9\u0ACB\u0ACC\u0B02\u0B03\u0B3E\u0B40\u0B47\u0B48\u0B4B\u0B4C\u0B57\u0BBE\u0BBF\u0BC1\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD7\u0C01-\u0C03\u0C41-\u0C44\u0C82\u0C83\u0CBE\u0CC0-\u0CC4\u0CC7\u0CC8\u0CCA\u0CCB\u0CD5\u0CD6\u0D02\u0D03\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D57\u0D82\u0D83\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DF2\u0DF3\u0F3E\u0F3F\u0F7F\u102B\u102C\u1031\u1038\u103B\u103C\u1056\u1057\u1062-\u1064\u1067-\u106D\u1083\u1084\u1087-\u108C\u108F\u109A-\u109C\u17B6\u17BE-\u17C5\u17C7\u17C8\u1923-\u1926\u1929-\u192B\u1930\u1931\u1933-\u1938\u1A19\u1A1A\u1A55\u1A57\u1A61\u1A63\u1A64\u1A6D-\u1A72\u1B04\u1B35\u1B3B\u1B3D-\u1B41\u1B43\u1B44\u1B82\u1BA1\u1BA6\u1BA7\u1BAA\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2\u1BF3\u1C24-\u1C2B\u1C34\u1C35\u1CE1\u1CF2\u1CF3\u302E\u302F\uA823\uA824\uA827\uA880\uA881\uA8B4-\uA8C3\uA952\uA953\uA983\uA9B4\uA9B5\uA9BA\uA9BB\uA9BD-\uA9C0\uAA2F\uAA30\uAA33\uAA34\uAA4D\uAA7B\uAA7D\uAAEB\uAAEE\uAAEF\uAAF5\uABE3\uABE4\uABE6\uABE7\uABE9\uABEA\uABEC',
1792             astral: '\uD834[\uDD65\uDD66\uDD6D-\uDD72]|\uD804[\uDC00\uDC02\uDC82\uDCB0-\uDCB2\uDCB7\uDCB8\uDD2C\uDD82\uDDB3-\uDDB5\uDDBF\uDDC0\uDE2C-\uDE2E\uDE32\uDE33\uDE35\uDEE0-\uDEE2\uDF02\uDF03\uDF3E\uDF3F\uDF41-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63]|\uD805[\uDCB0-\uDCB2\uDCB9\uDCBB-\uDCBE\uDCC1\uDDAF-\uDDB1\uDDB8-\uDDBB\uDDBE\uDE30-\uDE32\uDE3B\uDE3C\uDE3E\uDEAC\uDEAE\uDEAF\uDEB6\uDF20\uDF21\uDF26]|\uD81B[\uDF51-\uDF7E]'
1793         },
1794         {
1795             name: 'Me',
1796             alias: 'Enclosing_Mark',
1797             bmp: '\u0488\u0489\u1ABE\u20DD-\u20E0\u20E2-\u20E4\uA670-\uA672'
1798         },
1799         {
1800             name: 'Mn',
1801             alias: 'Nonspacing_Mark',
1802             bmp: '\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC\u0CCD\u0CE2\u0CE3\u0D01\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ABD\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099\u309A\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F',
1803             astral: '\uD805[\uDCB3-\uDCB8\uDCBA\uDCBF\uDCC0\uDCC2\uDCC3\uDDB2-\uDDB5\uDDBC\uDDBD\uDDBF\uDDC0\uDDDC\uDDDD\uDE33-\uDE3A\uDE3D\uDE3F\uDE40\uDEAB\uDEAD\uDEB0-\uDEB5\uDEB7\uDF1D-\uDF1F\uDF22-\uDF25\uDF27-\uDF2B]|\uD834[\uDD67-\uDD69\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC01\uDC38-\uDC46\uDC7F-\uDC81\uDCB3-\uDCB6\uDCB9\uDCBA\uDD00-\uDD02\uDD27-\uDD2B\uDD2D-\uDD34\uDD73\uDD80\uDD81\uDDB6-\uDDBE\uDDCA-\uDDCC\uDE2F-\uDE31\uDE34\uDE36\uDE37\uDEDF\uDEE3-\uDEEA\uDF00\uDF01\uDF3C\uDF40\uDF66-\uDF6C\uDF70-\uDF74]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]'
1804         },
1805         {
1806             name: 'N',
1807             alias: 'Number',
1808             bmp: '0-9\xB2\xB3\xB9\xBC-\xBE\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u09F4-\u09F9\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0B72-\u0B77\u0BE6-\u0BF2\u0C66-\u0C6F\u0C78-\u0C7E\u0CE6-\u0CEF\u0D66-\u0D75\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F33\u1040-\u1049\u1090-\u1099\u1369-\u137C\u16EE-\u16F0\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1946-\u194F\u19D0-\u19DA\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\u2070\u2074-\u2079\u2080-\u2089\u2150-\u2182\u2185-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2CFD\u3007\u3021-\u3029\u3038-\u303A\u3192-\u3195\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\uA620-\uA629\uA6E6-\uA6EF\uA830-\uA835\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19',
1809             astral: '\uD800[\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDEE1-\uDEFB\uDF20-\uDF23\uDF41\uDF4A\uDFD1-\uDFD5]|\uD801[\uDCA0-\uDCA9]|\uD803[\uDCFA-\uDCFF\uDE60-\uDE7E]|\uD835[\uDFCE-\uDFFF]|\uD83A[\uDCC7-\uDCCF]|\uD81A[\uDE60-\uDE69\uDF50-\uDF59\uDF5B-\uDF61]|\uD806[\uDCE0-\uDCF2]|\uD804[\uDC52-\uDC6F\uDCF0-\uDCF9\uDD36-\uDD3F\uDDD0-\uDDD9\uDDE1-\uDDF4\uDEF0-\uDEF9]|\uD834[\uDF60-\uDF71]|\uD83C[\uDD00-\uDD0C]|\uD809[\uDC00-\uDC6E]|\uD802[\uDC58-\uDC5F\uDC79-\uDC7F\uDCA7-\uDCAF\uDCFB-\uDCFF\uDD16-\uDD1B\uDDBC\uDDBD\uDDC0-\uDDCF\uDDD2-\uDDFF\uDE40-\uDE47\uDE7D\uDE7E\uDE9D-\uDE9F\uDEEB-\uDEEF\uDF58-\uDF5F\uDF78-\uDF7F\uDFA9-\uDFAF]|\uD805[\uDCD0-\uDCD9\uDE50-\uDE59\uDEC0-\uDEC9\uDF30-\uDF3B]'
1810         },
1811         {
1812             name: 'Nd',
1813             alias: 'Decimal_Number',
1814             bmp: '0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19',
1815             astral: '\uD801[\uDCA0-\uDCA9]|\uD835[\uDFCE-\uDFFF]|\uD805[\uDCD0-\uDCD9\uDE50-\uDE59\uDEC0-\uDEC9\uDF30-\uDF39]|\uD806[\uDCE0-\uDCE9]|\uD804[\uDC66-\uDC6F\uDCF0-\uDCF9\uDD36-\uDD3F\uDDD0-\uDDD9\uDEF0-\uDEF9]|\uD81A[\uDE60-\uDE69\uDF50-\uDF59]'
1816         },
1817         {
1818             name: 'Nl',
1819             alias: 'Letter_Number',
1820             bmp: '\u16EE-\u16F0\u2160-\u2182\u2185-\u2188\u3007\u3021-\u3029\u3038-\u303A\uA6E6-\uA6EF',
1821             astral: '\uD809[\uDC00-\uDC6E]|\uD800[\uDD40-\uDD74\uDF41\uDF4A\uDFD1-\uDFD5]'
1822         },
1823         {
1824             name: 'No',
1825             alias: 'Other_Number',
1826             bmp: '\xB2\xB3\xB9\xBC-\xBE\u09F4-\u09F9\u0B72-\u0B77\u0BF0-\u0BF2\u0C78-\u0C7E\u0D70-\u0D75\u0F2A-\u0F33\u1369-\u137C\u17F0-\u17F9\u19DA\u2070\u2074-\u2079\u2080-\u2089\u2150-\u215F\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2CFD\u3192-\u3195\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\uA830-\uA835',
1827             astral: '\uD804[\uDC52-\uDC65\uDDE1-\uDDF4]|\uD803[\uDCFA-\uDCFF\uDE60-\uDE7E]|\uD83C[\uDD00-\uDD0C]|\uD806[\uDCEA-\uDCF2]|\uD83A[\uDCC7-\uDCCF]|\uD802[\uDC58-\uDC5F\uDC79-\uDC7F\uDCA7-\uDCAF\uDCFB-\uDCFF\uDD16-\uDD1B\uDDBC\uDDBD\uDDC0-\uDDCF\uDDD2-\uDDFF\uDE40-\uDE47\uDE7D\uDE7E\uDE9D-\uDE9F\uDEEB-\uDEEF\uDF58-\uDF5F\uDF78-\uDF7F\uDFA9-\uDFAF]|\uD805[\uDF3A\uDF3B]|\uD81A[\uDF5B-\uDF61]|\uD834[\uDF60-\uDF71]|\uD800[\uDD07-\uDD33\uDD75-\uDD78\uDD8A\uDD8B\uDEE1-\uDEFB\uDF20-\uDF23]'
1828         },
1829         {
1830             name: 'P',
1831             alias: 'Punctuation',
1832             bmp: '\x21-\x23\x25-\\x2A\x2C-\x2F\x3A\x3B\\x3F\x40\\x5B-\\x5D\x5F\\x7B\x7D\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u0AF0\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E42\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65',
1833             astral: '\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD809[\uDC70-\uDC74]|\uD805[\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDF3C-\uDF3E]|\uD836[\uDE87-\uDE8B]|\uD801\uDD6F|\uD82F\uDC9F|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC9\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]'
1834         },
1835         {
1836             name: 'Pc',
1837             alias: 'Connector_Punctuation',
1838             bmp: '\x5F\u203F\u2040\u2054\uFE33\uFE34\uFE4D-\uFE4F\uFF3F'
1839         },
1840         {
1841             name: 'Pd',
1842             alias: 'Dash_Punctuation',
1843             bmp: '\\x2D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D'
1844         },
1845         {
1846             name: 'Pe',
1847             alias: 'Close_Punctuation',
1848             bmp: '\\x29\\x5D\x7D\u0F3B\u0F3D\u169C\u2046\u207E\u208E\u2309\u230B\u232A\u2769\u276B\u276D\u276F\u2771\u2773\u2775\u27C6\u27E7\u27E9\u27EB\u27ED\u27EF\u2984\u2986\u2988\u298A\u298C\u298E\u2990\u2992\u2994\u2996\u2998\u29D9\u29DB\u29FD\u2E23\u2E25\u2E27\u2E29\u3009\u300B\u300D\u300F\u3011\u3015\u3017\u3019\u301B\u301E\u301F\uFD3E\uFE18\uFE36\uFE38\uFE3A\uFE3C\uFE3E\uFE40\uFE42\uFE44\uFE48\uFE5A\uFE5C\uFE5E\uFF09\uFF3D\uFF5D\uFF60\uFF63'
1849         },
1850         {
1851             name: 'Pf',
1852             alias: 'Final_Punctuation',
1853             bmp: '\xBB\u2019\u201D\u203A\u2E03\u2E05\u2E0A\u2E0D\u2E1D\u2E21'
1854         },
1855         {
1856             name: 'Pi',
1857             alias: 'Initial_Punctuation',
1858             bmp: '\xAB\u2018\u201B\u201C\u201F\u2039\u2E02\u2E04\u2E09\u2E0C\u2E1C\u2E20'
1859         },
1860         {
1861             name: 'Po',
1862             alias: 'Other_Punctuation',
1863             bmp: '\x21-\x23\x25-\x27\\x2A\x2C\\x2E\x2F\x3A\x3B\\x3F\x40\\x5C\xA1\xA7\xB6\xB7\xBF\u037E\u0387\u055A-\u055F\u0589\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u0AF0\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u166D\u166E\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u1805\u1807-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2016\u2017\u2020-\u2027\u2030-\u2038\u203B-\u203E\u2041-\u2043\u2047-\u2051\u2053\u2055-\u205E\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00\u2E01\u2E06-\u2E08\u2E0B\u2E0E-\u2E16\u2E18\u2E19\u2E1B\u2E1E\u2E1F\u2E2A-\u2E2E\u2E30-\u2E39\u2E3C-\u2E3F\u2E41\u3001-\u3003\u303D\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFE10-\uFE16\uFE19\uFE30\uFE45\uFE46\uFE49-\uFE4C\uFE50-\uFE52\uFE54-\uFE57\uFE5F-\uFE61\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF07\uFF0A\uFF0C\uFF0E\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3C\uFF61\uFF64\uFF65',
1864             astral: '\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD809[\uDC70-\uDC74]|\uD805[\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDF3C-\uDF3E]|\uD836[\uDE87-\uDE8B]|\uD801\uDD6F|\uD82F\uDC9F|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC9\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]'
1865         },
1866         {
1867             name: 'Ps',
1868             alias: 'Open_Punctuation',
1869             bmp: '\\x28\\x5B\\x7B\u0F3A\u0F3C\u169B\u201A\u201E\u2045\u207D\u208D\u2308\u230A\u2329\u2768\u276A\u276C\u276E\u2770\u2772\u2774\u27C5\u27E6\u27E8\u27EA\u27EC\u27EE\u2983\u2985\u2987\u2989\u298B\u298D\u298F\u2991\u2993\u2995\u2997\u29D8\u29DA\u29FC\u2E22\u2E24\u2E26\u2E28\u2E42\u3008\u300A\u300C\u300E\u3010\u3014\u3016\u3018\u301A\u301D\uFD3F\uFE17\uFE35\uFE37\uFE39\uFE3B\uFE3D\uFE3F\uFE41\uFE43\uFE47\uFE59\uFE5B\uFE5D\uFF08\uFF3B\uFF5B\uFF5F\uFF62'
1870         },
1871         {
1872             name: 'S',
1873             alias: 'Symbol',
1874             bmp: '\\x24\\x2B\x3C-\x3E\\x5E\x60\\x7C\x7E\xA2-\xA6\xA8\xA9\xAC\xAE-\xB1\xB4\xB8\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u03F6\u0482\u058D-\u058F\u0606-\u0608\u060B\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u09F2\u09F3\u09FA\u09FB\u0AF1\u0B70\u0BF3-\u0BFA\u0C7F\u0D79\u0E3F\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u17DB\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u2044\u2052\u207A-\u207C\u208A-\u208C\u20A0-\u20BE\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A\u218B\u2190-\u2307\u230C-\u2328\u232B-\u23FA\u2400-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u2767\u2794-\u27C4\u27C7-\u27E5\u27F0-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2B73\u2B76-\u2B95\u2B98-\u2BB9\u2BBD-\u2BC8\u2BCA-\u2BD1\u2BEC-\u2BEF\u2CE5-\u2CEA\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u32FE\u3300-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uFB29\uFBB2-\uFBC1\uFDFC\uFDFD\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD',
1875             astral: '\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDD10-\uDD18\uDD80-\uDD84\uDDC0]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD10-\uDD2E\uDD30-\uDD6B\uDD70-\uDD9A\uDDE6-\uDE02\uDE10-\uDE3A\uDE40-\uDE48\uDE50\uDE51\uDF00-\uDFFF]|\uD83D[\uDC00-\uDD79\uDD7B-\uDDA3\uDDA5-\uDED0\uDEE0-\uDEEC\uDEF0-\uDEF3\uDF00-\uDF73\uDF80-\uDFD4]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C\uDD90-\uDD9B\uDDA0\uDDD0-\uDDFC]|\uD82F\uDC9C|\uD805\uDF3F|\uD802[\uDC77\uDC78\uDEC8]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD83B[\uDEF0\uDEF1]'
1876         },
1877         {
1878             name: 'Sc',
1879             alias: 'Currency_Symbol',
1880             bmp: '\\x24\xA2-\xA5\u058F\u060B\u09F2\u09F3\u09FB\u0AF1\u0BF9\u0E3F\u17DB\u20A0-\u20BE\uA838\uFDFC\uFE69\uFF04\uFFE0\uFFE1\uFFE5\uFFE6'
1881         },
1882         {
1883             name: 'Sk',
1884             alias: 'Modifier_Symbol',
1885             bmp: '\\x5E\x60\xA8\xAF\xB4\xB8\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u309B\u309C\uA700-\uA716\uA720\uA721\uA789\uA78A\uAB5B\uFBB2-\uFBC1\uFF3E\uFF40\uFFE3',
1886             astral: '\uD83C[\uDFFB-\uDFFF]'
1887         },
1888         {
1889             name: 'Sm',
1890             alias: 'Math_Symbol',
1891             bmp: '\\x2B\x3C-\x3E\\x7C\x7E\xAC\xB1\xD7\xF7\u03F6\u0606-\u0608\u2044\u2052\u207A-\u207C\u208A-\u208C\u2118\u2140-\u2144\u214B\u2190-\u2194\u219A\u219B\u21A0\u21A3\u21A6\u21AE\u21CE\u21CF\u21D2\u21D4\u21F4-\u22FF\u2320\u2321\u237C\u239B-\u23B3\u23DC-\u23E1\u25B7\u25C1\u25F8-\u25FF\u266F\u27C0-\u27C4\u27C7-\u27E5\u27F0-\u27FF\u2900-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2AFF\u2B30-\u2B44\u2B47-\u2B4C\uFB29\uFE62\uFE64-\uFE66\uFF0B\uFF1C-\uFF1E\uFF5C\uFF5E\uFFE2\uFFE9-\uFFEC',
1892             astral: '\uD83B[\uDEF0\uDEF1]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]'
1893         },
1894         {
1895             name: 'So',
1896             alias: 'Other_Symbol',
1897             bmp: '\xA6\xA9\xAE\xB0\u0482\u058D\u058E\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u09FA\u0B70\u0BF3-\u0BF8\u0BFA\u0C7F\u0D79\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116\u2117\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u214A\u214C\u214D\u214F\u218A\u218B\u2195-\u2199\u219C-\u219F\u21A1\u21A2\u21A4\u21A5\u21A7-\u21AD\u21AF-\u21CD\u21D0\u21D1\u21D3\u21D5-\u21F3\u2300-\u2307\u230C-\u231F\u2322-\u2328\u232B-\u237B\u237D-\u239A\u23B4-\u23DB\u23E2-\u23FA\u2400-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u25B6\u25B8-\u25C0\u25C2-\u25F7\u2600-\u266E\u2670-\u2767\u2794-\u27BF\u2800-\u28FF\u2B00-\u2B2F\u2B45\u2B46\u2B4D-\u2B73\u2B76-\u2B95\u2B98-\u2BB9\u2BBD-\u2BC8\u2BCA-\u2BD1\u2BEC-\u2BEF\u2CE5-\u2CEA\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u32FE\u3300-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA828-\uA82B\uA836\uA837\uA839\uAA77-\uAA79\uFDFD\uFFE4\uFFE8\uFFED\uFFEE\uFFFC\uFFFD',
1898             astral: '\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDD10-\uDD18\uDD80-\uDD84\uDDC0]|\uD83D[\uDC00-\uDD79\uDD7B-\uDDA3\uDDA5-\uDED0\uDEE0-\uDEEC\uDEF0-\uDEF3\uDF00-\uDF73\uDF80-\uDFD4]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD10-\uDD2E\uDD30-\uDD6B\uDD70-\uDD9A\uDDE6-\uDE02\uDE10-\uDE3A\uDE40-\uDE48\uDE50\uDE51\uDF00-\uDFFA]|\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C\uDD90-\uDD9B\uDDA0\uDDD0-\uDDFC]|\uD82F\uDC9C|\uD805\uDF3F|\uD802[\uDC77\uDC78\uDEC8]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDE00-\uDE41\uDE45\uDF00-\uDF56]'
1899         },
1900         {
1901             name: 'Z',
1902             alias: 'Separator',
1903             bmp: '\x20\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000'
1904         },
1905         {
1906             name: 'Zl',
1907             alias: 'Line_Separator',
1908             bmp: '\u2028'
1909         },
1910         {
1911             name: 'Zp',
1912             alias: 'Paragraph_Separator',
1913             bmp: '\u2029'
1914         },
1915         {
1916             name: 'Zs',
1917             alias: 'Space_Separator',
1918             bmp: '\x20\xA0\u1680\u2000-\u200A\u202F\u205F\u3000'
1919         }
1920     ]);
1921
1922 };
1923
1924 },{}],6:[function(require,module,exports){
1925 /*!
1926  * XRegExp Unicode Properties 3.1.1
1927  * <xregexp.com>
1928  * Steven Levithan (c) 2012-2016 MIT License
1929  * Unicode data by Mathias Bynens <mathiasbynens.be>
1930  */
1931
1932 module.exports = function(XRegExp) {
1933     'use strict';
1934
1935     /**
1936      * Adds properties to meet the UTS #18 Level 1 RL1.2 requirements for Unicode regex support. See
1937      * <http://unicode.org/reports/tr18/#RL1.2>. Following are definitions of these properties from
1938      * UAX #44 <http://unicode.org/reports/tr44/>:
1939      *
1940      * - Alphabetic
1941      *   Characters with the Alphabetic property. Generated from: Lowercase + Uppercase + Lt + Lm +
1942      *   Lo + Nl + Other_Alphabetic.
1943      *
1944      * - Default_Ignorable_Code_Point
1945      *   For programmatic determination of default ignorable code points. New characters that should
1946      *   be ignored in rendering (unless explicitly supported) will be assigned in these ranges,
1947      *   permitting programs to correctly handle the default rendering of such characters when not
1948      *   otherwise supported.
1949      *
1950      * - Lowercase
1951      *   Characters with the Lowercase property. Generated from: Ll + Other_Lowercase.
1952      *
1953      * - Noncharacter_Code_Point
1954      *   Code points permanently reserved for internal use.
1955      *
1956      * - Uppercase
1957      *   Characters with the Uppercase property. Generated from: Lu + Other_Uppercase.
1958      *
1959      * - White_Space
1960      *   Spaces, separator characters and other control characters which should be treated by
1961      *   programming languages as "white space" for the purpose of parsing elements.
1962      *
1963      * The properties ASCII, Any, and Assigned are also included but are not defined in UAX #44. UTS
1964      * #18 RL1.2 additionally requires support for Unicode scripts and general categories. These are
1965      * included in XRegExp's Unicode Categories and Unicode Scripts addons.
1966      *
1967      * Token names are case insensitive, and any spaces, hyphens, and underscores are ignored.
1968      *
1969      * Uses Unicode 8.0.0.
1970      *
1971      * @requires XRegExp, Unicode Base
1972      */
1973
1974     if (!XRegExp.addUnicodeData) {
1975         throw new ReferenceError('Unicode Base must be loaded before Unicode Properties');
1976     }
1977
1978     var unicodeData = [
1979         {
1980             name: 'ASCII',
1981             bmp: '\0-\x7F'
1982         },
1983         {
1984             name: 'Alphabetic',
1985             bmp: 'A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0345\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05B0-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0657\u0659-\u065F\u066E-\u06D3\u06D5-\u06DC\u06E1-\u06E8\u06ED-\u06EF\u06FA-\u06FC\u06FF\u0710-\u073F\u074D-\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0817\u081A-\u082C\u0840-\u0858\u08A0-\u08B4\u08E3-\u08E9\u08F0-\u093B\u093D-\u094C\u094E-\u0950\u0955-\u0963\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD-\u09C4\u09C7\u09C8\u09CB\u09CC\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09F0\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3E-\u0A42\u0A47\u0A48\u0A4B\u0A4C\u0A51\u0A59-\u0A5C\u0A5E\u0A70-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD-\u0AC5\u0AC7-\u0AC9\u0ACB\u0ACC\u0AD0\u0AE0-\u0AE3\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D-\u0B44\u0B47\u0B48\u0B4B\u0B4C\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD0\u0BD7\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4C\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCC\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4C\u0D4E\u0D57\u0D5F-\u0D63\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E46\u0E4D\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0ECD\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F71-\u0F81\u0F88-\u0F97\u0F99-\u0FBC\u1000-\u1036\u1038\u103B-\u103F\u1050-\u1062\u1065-\u1068\u106E-\u1086\u108E\u109C\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1713\u1720-\u1733\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17B3\u17B6-\u17C8\u17D7\u17DC\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u1938\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A1B\u1A20-\u1A5E\u1A61-\u1A74\u1AA7\u1B00-\u1B33\u1B35-\u1B43\u1B45-\u1B4B\u1B80-\u1BA9\u1BAC-\u1BAF\u1BBA-\u1BE5\u1BE7-\u1BF1\u1C00-\u1C35\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1D00-\u1DBF\u1DE7-\u1DF4\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u24B6-\u24E9\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA674-\uA67B\uA67F-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA827\uA840-\uA873\uA880-\uA8C3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA92A\uA930-\uA952\uA960-\uA97C\uA980-\uA9B2\uA9B4-\uA9BF\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA60-\uAA76\uAA7A\uAA7E-\uAABE\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF5\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC',
1986             astral: '\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD804[\uDC00-\uDC45\uDC82-\uDCB8\uDCD0-\uDCE8\uDD00-\uDD32\uDD50-\uDD72\uDD76\uDD80-\uDDBF\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE34\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEE8\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D-\uDF44\uDF47\uDF48\uDF4B\uDF4C\uDF50\uDF57\uDF5D-\uDF63]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD83A[\uDC00-\uDCC4]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF36\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD83C[\uDD30-\uDD49\uDD50-\uDD69\uDD70-\uDD89]|\uD80D[\uDC00-\uDC2E]|\uD87E[\uDC00-\uDE1D]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9E]|\uD808[\uDC00-\uDF99]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD805[\uDC80-\uDCC1\uDCC4\uDCC5\uDCC7\uDD80-\uDDB5\uDDB8-\uDDBE\uDDD8-\uDDDD\uDE00-\uDE3E\uDE40\uDE44\uDE80-\uDEB5\uDF00-\uDF19\uDF1D-\uDF2A]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD811[\uDC00-\uDE46]|\uD82C[\uDC00\uDC01]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF93-\uDF9F]|\uD873[\uDC00-\uDEA1]'
1987         },
1988         {
1989             name: 'Any',
1990             isBmpLast: true,
1991             bmp: '\0-\uFFFF',
1992             astral: '[\uD800-\uDBFF][\uDC00-\uDFFF]'
1993         },
1994         {
1995             name: 'Default_Ignorable_Code_Point',
1996             bmp: '\xAD\u034F\u061C\u115F\u1160\u17B4\u17B5\u180B-\u180E\u200B-\u200F\u202A-\u202E\u2060-\u206F\u3164\uFE00-\uFE0F\uFEFF\uFFA0\uFFF0-\uFFF8',
1997             astral: '[\uDB40-\uDB43][\uDC00-\uDFFF]|\uD834[\uDD73-\uDD7A]|\uD82F[\uDCA0-\uDCA3]'
1998         },
1999         {
2000             name: 'Lowercase',
2001             bmp: 'a-z\xAA\xB5\xBA\xDF-\xF6\xF8-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02B8\u02C0\u02C1\u02E0-\u02E4\u0345\u0371\u0373\u0377\u037A-\u037D\u0390\u03AC-\u03CE\u03D0\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0561-\u0587\u13F8-\u13FD\u1D00-\u1DBF\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6\u1FC7\u1FD0-\u1FD3\u1FD6\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6\u1FF7\u2071\u207F\u2090-\u209C\u210A\u210E\u210F\u2113\u212F\u2134\u2139\u213C\u213D\u2146-\u2149\u214E\u2170-\u217F\u2184\u24D0-\u24E9\u2C30-\u2C5E\u2C61\u2C65\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73\u2C74\u2C76-\u2C7D\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B-\uA69D\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7B5\uA7B7\uA7F8-\uA7FA\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A',
2002             astral: '\uD803[\uDCC0-\uDCF2]|\uD835[\uDC1A-\uDC33\uDC4E-\uDC54\uDC56-\uDC67\uDC82-\uDC9B\uDCB6-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDCEA-\uDD03\uDD1E-\uDD37\uDD52-\uDD6B\uDD86-\uDD9F\uDDBA-\uDDD3\uDDEE-\uDE07\uDE22-\uDE3B\uDE56-\uDE6F\uDE8A-\uDEA5\uDEC2-\uDEDA\uDEDC-\uDEE1\uDEFC-\uDF14\uDF16-\uDF1B\uDF36-\uDF4E\uDF50-\uDF55\uDF70-\uDF88\uDF8A-\uDF8F\uDFAA-\uDFC2\uDFC4-\uDFC9\uDFCB]|\uD801[\uDC28-\uDC4F]|\uD806[\uDCC0-\uDCDF]'
2003         },
2004         {
2005             name: 'Noncharacter_Code_Point',
2006             bmp: '\uFDD0-\uFDEF\uFFFE\uFFFF',
2007             astral: '[\uDB3F\uDB7F\uDBBF\uDBFF\uD83F\uD87F\uD8BF\uDAFF\uD97F\uD9BF\uD9FF\uDA3F\uD8FF\uDABF\uDA7F\uD93F][\uDFFE\uDFFF]'
2008         },
2009         {
2010             name: 'Uppercase',
2011             bmp: 'A-Z\xC0-\xD6\xD8-\xDE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178\u0179\u017B\u017D\u0181\u0182\u0184\u0186\u0187\u0189-\u018B\u018E-\u0191\u0193\u0194\u0196-\u0198\u019C\u019D\u019F\u01A0\u01A2\u01A4\u01A6\u01A7\u01A9\u01AC\u01AE\u01AF\u01B1-\u01B3\u01B5\u01B7\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A\u023B\u023D\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E\u213F\u2145\u2160-\u216F\u2183\u24B6-\u24CF\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AD\uA7B0-\uA7B4\uA7B6\uFF21-\uFF3A',
2012             astral: '\uD806[\uDCA0-\uDCBF]|\uD803[\uDC80-\uDCB2]|\uD835[\uDC00-\uDC19\uDC34-\uDC4D\uDC68-\uDC81\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB5\uDCD0-\uDCE9\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD38\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD6C-\uDD85\uDDA0-\uDDB9\uDDD4-\uDDED\uDE08-\uDE21\uDE3C-\uDE55\uDE70-\uDE89\uDEA8-\uDEC0\uDEE2-\uDEFA\uDF1C-\uDF34\uDF56-\uDF6E\uDF90-\uDFA8\uDFCA]|\uD801[\uDC00-\uDC27]|\uD83C[\uDD30-\uDD49\uDD50-\uDD69\uDD70-\uDD89]'
2013         },
2014         {
2015             name: 'White_Space',
2016             bmp: '\x09-\x0D\x20\x85\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000'
2017         }
2018     ];
2019
2020     // Add non-generated data
2021     unicodeData.push({
2022         name: 'Assigned',
2023         // Since this is defined as the inverse of Unicode category Cn (Unassigned), the Unicode
2024         // Categories addon is required to use this property
2025         inverseOf: 'Cn'
2026     });
2027
2028     XRegExp.addUnicodeData(unicodeData);
2029
2030 };
2031
2032 },{}],7:[function(require,module,exports){
2033 /*!
2034  * XRegExp Unicode Scripts 3.1.1
2035  * <xregexp.com>
2036  * Steven Levithan (c) 2010-2016 MIT License
2037  * Unicode data by Mathias Bynens <mathiasbynens.be>
2038  */
2039
2040 module.exports = function(XRegExp) {
2041     'use strict';
2042
2043     /**
2044      * Adds support for all Unicode scripts. E.g., `\p{Latin}`. Token names are case insensitive,
2045      * and any spaces, hyphens, and underscores are ignored.
2046      *
2047      * Uses Unicode 8.0.0.
2048      *
2049      * @requires XRegExp, Unicode Base
2050      */
2051
2052     if (!XRegExp.addUnicodeData) {
2053         throw new ReferenceError('Unicode Base must be loaded before Unicode Scripts');
2054     }
2055
2056     XRegExp.addUnicodeData([
2057         {
2058             name: 'Ahom',
2059             astral: '\uD805[\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF3F]'
2060         },
2061         {
2062             name: 'Anatolian_Hieroglyphs',
2063             astral: '\uD811[\uDC00-\uDE46]'
2064         },
2065         {
2066             name: 'Arabic',
2067             bmp: '\u0600-\u0604\u0606-\u060B\u060D-\u061A\u061E\u0620-\u063F\u0641-\u064A\u0656-\u066F\u0671-\u06DC\u06DE-\u06FF\u0750-\u077F\u08A0-\u08B4\u08E3-\u08FF\uFB50-\uFBC1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFD\uFE70-\uFE74\uFE76-\uFEFC',
2068             astral: '\uD803[\uDE60-\uDE7E]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB\uDEF0\uDEF1]'
2069         },
2070         {
2071             name: 'Armenian',
2072             bmp: '\u0531-\u0556\u0559-\u055F\u0561-\u0587\u058A\u058D-\u058F\uFB13-\uFB17'
2073         },
2074         {
2075             name: 'Avestan',
2076             astral: '\uD802[\uDF00-\uDF35\uDF39-\uDF3F]'
2077         },
2078         {
2079             name: 'Balinese',
2080             bmp: '\u1B00-\u1B4B\u1B50-\u1B7C'
2081         },
2082         {
2083             name: 'Bamum',
2084             bmp: '\uA6A0-\uA6F7',
2085             astral: '\uD81A[\uDC00-\uDE38]'
2086         },
2087         {
2088             name: 'Bassa_Vah',
2089             astral: '\uD81A[\uDED0-\uDEED\uDEF0-\uDEF5]'
2090         },
2091         {
2092             name: 'Batak',
2093             bmp: '\u1BC0-\u1BF3\u1BFC-\u1BFF'
2094         },
2095         {
2096             name: 'Bengali',
2097             bmp: '\u0980-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09FB'
2098         },
2099         {
2100             name: 'Bopomofo',
2101             bmp: '\u02EA\u02EB\u3105-\u312D\u31A0-\u31BA'
2102         },
2103         {
2104             name: 'Brahmi',
2105             astral: '\uD804[\uDC00-\uDC4D\uDC52-\uDC6F\uDC7F]'
2106         },
2107         {
2108             name: 'Braille',
2109             bmp: '\u2800-\u28FF'
2110         },
2111         {
2112             name: 'Buginese',
2113             bmp: '\u1A00-\u1A1B\u1A1E\u1A1F'
2114         },
2115         {
2116             name: 'Buhid',
2117             bmp: '\u1740-\u1753'
2118         },
2119         {
2120             name: 'Canadian_Aboriginal',
2121             bmp: '\u1400-\u167F\u18B0-\u18F5'
2122         },
2123         {
2124             name: 'Carian',
2125             astral: '\uD800[\uDEA0-\uDED0]'
2126         },
2127         {
2128             name: 'Caucasian_Albanian',
2129             astral: '\uD801[\uDD30-\uDD63\uDD6F]'
2130         },
2131         {
2132             name: 'Chakma',
2133             astral: '\uD804[\uDD00-\uDD34\uDD36-\uDD43]'
2134         },
2135         {
2136             name: 'Cham',
2137             bmp: '\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA5C-\uAA5F'
2138         },
2139         {
2140             name: 'Cherokee',
2141             bmp: '\u13A0-\u13F5\u13F8-\u13FD\uAB70-\uABBF'
2142         },
2143         {
2144             name: 'Common',
2145             bmp: '\0-\x40\\x5B-\x60\\x7B-\xA9\xAB-\xB9\xBB-\xBF\xD7\xF7\u02B9-\u02DF\u02E5-\u02E9\u02EC-\u02FF\u0374\u037E\u0385\u0387\u0589\u0605\u060C\u061B\u061C\u061F\u0640\u06DD\u0964\u0965\u0E3F\u0FD5-\u0FD8\u10FB\u16EB-\u16ED\u1735\u1736\u1802\u1803\u1805\u1CD3\u1CE1\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u2000-\u200B\u200E-\u2064\u2066-\u2070\u2074-\u207E\u2080-\u208E\u20A0-\u20BE\u2100-\u2125\u2127-\u2129\u212C-\u2131\u2133-\u214D\u214F-\u215F\u2189-\u218B\u2190-\u23FA\u2400-\u2426\u2440-\u244A\u2460-\u27FF\u2900-\u2B73\u2B76-\u2B95\u2B98-\u2BB9\u2BBD-\u2BC8\u2BCA-\u2BD1\u2BEC-\u2BEF\u2E00-\u2E42\u2FF0-\u2FFB\u3000-\u3004\u3006\u3008-\u3020\u3030-\u3037\u303C-\u303F\u309B\u309C\u30A0\u30FB\u30FC\u3190-\u319F\u31C0-\u31E3\u3220-\u325F\u327F-\u32CF\u3358-\u33FF\u4DC0-\u4DFF\uA700-\uA721\uA788-\uA78A\uA830-\uA839\uA92E\uA9CF\uAB5B\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE66\uFE68-\uFE6B\uFEFF\uFF01-\uFF20\uFF3B-\uFF40\uFF5B-\uFF65\uFF70\uFF9E\uFF9F\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFF9-\uFFFD',
2146             astral: '\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDD10-\uDD18\uDD80-\uDD84\uDDC0]|\uD82F[\uDCA0-\uDCA3]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDFCB\uDFCE-\uDFFF]|\uDB40[\uDC01\uDC20-\uDC7F]|\uD83D[\uDC00-\uDD79\uDD7B-\uDDA3\uDDA5-\uDED0\uDEE0-\uDEEC\uDEF0-\uDEF3\uDF00-\uDF73\uDF80-\uDFD4]|\uD800[\uDD00-\uDD02\uDD07-\uDD33\uDD37-\uDD3F\uDD90-\uDD9B\uDDD0-\uDDFC\uDEE1-\uDEFB]|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD66\uDD6A-\uDD7A\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDF00-\uDF56\uDF60-\uDF71]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD00-\uDD0C\uDD10-\uDD2E\uDD30-\uDD6B\uDD70-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE10-\uDE3A\uDE40-\uDE48\uDE50\uDE51\uDF00-\uDFFF]'
2147         },
2148         {
2149             name: 'Coptic',
2150             bmp: '\u03E2-\u03EF\u2C80-\u2CF3\u2CF9-\u2CFF'
2151         },
2152         {
2153             name: 'Cuneiform',
2154             astral: '\uD809[\uDC00-\uDC6E\uDC70-\uDC74\uDC80-\uDD43]|\uD808[\uDC00-\uDF99]'
2155         },
2156         {
2157             name: 'Cypriot',
2158             astral: '\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F]'
2159         },
2160         {
2161             name: 'Cyrillic',
2162             bmp: '\u0400-\u0484\u0487-\u052F\u1D2B\u1D78\u2DE0-\u2DFF\uA640-\uA69F\uFE2E\uFE2F'
2163         },
2164         {
2165             name: 'Deseret',
2166             astral: '\uD801[\uDC00-\uDC4F]'
2167         },
2168         {
2169             name: 'Devanagari',
2170             bmp: '\u0900-\u0950\u0953-\u0963\u0966-\u097F\uA8E0-\uA8FD'
2171         },
2172         {
2173             name: 'Duployan',
2174             astral: '\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9C-\uDC9F]'
2175         },
2176         {
2177             name: 'Egyptian_Hieroglyphs',
2178             astral: '\uD80C[\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]'
2179         },
2180         {
2181             name: 'Elbasan',
2182             astral: '\uD801[\uDD00-\uDD27]'
2183         },
2184         {
2185             name: 'Ethiopic',
2186             bmp: '\u1200-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u137C\u1380-\u1399\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E'
2187         },
2188         {
2189             name: 'Georgian',
2190             bmp: '\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u10FF\u2D00-\u2D25\u2D27\u2D2D'
2191         },
2192         {
2193             name: 'Glagolitic',
2194             bmp: '\u2C00-\u2C2E\u2C30-\u2C5E'
2195         },
2196         {
2197             name: 'Gothic',
2198             astral: '\uD800[\uDF30-\uDF4A]'
2199         },
2200         {
2201             name: 'Grantha',
2202             astral: '\uD804[\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]'
2203         },
2204         {
2205             name: 'Greek',
2206             bmp: '\u0370-\u0373\u0375-\u0377\u037A-\u037D\u037F\u0384\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03E1\u03F0-\u03FF\u1D26-\u1D2A\u1D5D-\u1D61\u1D66-\u1D6A\u1DBF\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FC4\u1FC6-\u1FD3\u1FD6-\u1FDB\u1FDD-\u1FEF\u1FF2-\u1FF4\u1FF6-\u1FFE\u2126\uAB65',
2207             astral: '\uD800[\uDD40-\uDD8C\uDDA0]|\uD834[\uDE00-\uDE45]'
2208         },
2209         {
2210             name: 'Gujarati',
2211             bmp: '\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AF1\u0AF9'
2212         },
2213         {
2214             name: 'Gurmukhi',
2215             bmp: '\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75'
2216         },
2217         {
2218             name: 'Han',
2219             bmp: '\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u3005\u3007\u3021-\u3029\u3038-\u303B\u3400-\u4DB5\u4E00-\u9FD5\uF900-\uFA6D\uFA70-\uFAD9',
2220             astral: '\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|[\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD87E[\uDC00-\uDE1D]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD873[\uDC00-\uDEA1]'
2221         },
2222         {
2223             name: 'Hangul',
2224             bmp: '\u1100-\u11FF\u302E\u302F\u3131-\u318E\u3200-\u321E\u3260-\u327E\uA960-\uA97C\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC'
2225         },
2226         {
2227             name: 'Hanunoo',
2228             bmp: '\u1720-\u1734'
2229         },
2230         {
2231             name: 'Hatran',
2232             astral: '\uD802[\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDCFF]'
2233         },
2234         {
2235             name: 'Hebrew',
2236             bmp: '\u0591-\u05C7\u05D0-\u05EA\u05F0-\u05F4\uFB1D-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFB4F'
2237         },
2238         {
2239             name: 'Hiragana',
2240             bmp: '\u3041-\u3096\u309D-\u309F',
2241             astral: '\uD82C\uDC01|\uD83C\uDE00'
2242         },
2243         {
2244             name: 'Imperial_Aramaic',
2245             astral: '\uD802[\uDC40-\uDC55\uDC57-\uDC5F]'
2246         },
2247         {
2248             name: 'Inherited',
2249             bmp: '\u0300-\u036F\u0485\u0486\u064B-\u0655\u0670\u0951\u0952\u1AB0-\u1ABE\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u200C\u200D\u20D0-\u20F0\u302A-\u302D\u3099\u309A\uFE00-\uFE0F\uFE20-\uFE2D',
2250             astral: '\uD834[\uDD67-\uDD69\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD]|\uD800[\uDDFD\uDEE0]|\uDB40[\uDD00-\uDDEF]'
2251         },
2252         {
2253             name: 'Inscriptional_Pahlavi',
2254             astral: '\uD802[\uDF60-\uDF72\uDF78-\uDF7F]'
2255         },
2256         {
2257             name: 'Inscriptional_Parthian',
2258             astral: '\uD802[\uDF40-\uDF55\uDF58-\uDF5F]'
2259         },
2260         {
2261             name: 'Javanese',
2262             bmp: '\uA980-\uA9CD\uA9D0-\uA9D9\uA9DE\uA9DF'
2263         },
2264         {
2265             name: 'Kaithi',
2266             astral: '\uD804[\uDC80-\uDCC1]'
2267         },
2268         {
2269             name: 'Kannada',
2270             bmp: '\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2'
2271         },
2272         {
2273             name: 'Katakana',
2274             bmp: '\u30A1-\u30FA\u30FD-\u30FF\u31F0-\u31FF\u32D0-\u32FE\u3300-\u3357\uFF66-\uFF6F\uFF71-\uFF9D',
2275             astral: '\uD82C\uDC00'
2276         },
2277         {
2278             name: 'Kayah_Li',
2279             bmp: '\uA900-\uA92D\uA92F'
2280         },
2281         {
2282             name: 'Kharoshthi',
2283             astral: '\uD802[\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F-\uDE47\uDE50-\uDE58]'
2284         },
2285         {
2286             name: 'Khmer',
2287             bmp: '\u1780-\u17DD\u17E0-\u17E9\u17F0-\u17F9\u19E0-\u19FF'
2288         },
2289         {
2290             name: 'Khojki',
2291             astral: '\uD804[\uDE00-\uDE11\uDE13-\uDE3D]'
2292         },
2293         {
2294             name: 'Khudawadi',
2295             astral: '\uD804[\uDEB0-\uDEEA\uDEF0-\uDEF9]'
2296         },
2297         {
2298             name: 'Lao',
2299             bmp: '\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF'
2300         },
2301         {
2302             name: 'Latin',
2303             bmp: 'A-Za-z\xAA\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02E0-\u02E4\u1D00-\u1D25\u1D2C-\u1D5C\u1D62-\u1D65\u1D6B-\u1D77\u1D79-\u1DBE\u1E00-\u1EFF\u2071\u207F\u2090-\u209C\u212A\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB64\uFB00-\uFB06\uFF21-\uFF3A\uFF41-\uFF5A'
2304         },
2305         {
2306             name: 'Lepcha',
2307             bmp: '\u1C00-\u1C37\u1C3B-\u1C49\u1C4D-\u1C4F'
2308         },
2309         {
2310             name: 'Limbu',
2311             bmp: '\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1940\u1944-\u194F'
2312         },
2313         {
2314             name: 'Linear_A',
2315             astral: '\uD801[\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]'
2316         },
2317         {
2318             name: 'Linear_B',
2319             astral: '\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA]'
2320         },
2321         {
2322             name: 'Lisu',
2323             bmp: '\uA4D0-\uA4FF'
2324         },
2325         {
2326             name: 'Lycian',
2327             astral: '\uD800[\uDE80-\uDE9C]'
2328         },
2329         {
2330             name: 'Lydian',
2331             astral: '\uD802[\uDD20-\uDD39\uDD3F]'
2332         },
2333         {
2334             name: 'Mahajani',
2335             astral: '\uD804[\uDD50-\uDD76]'
2336         },
2337         {
2338             name: 'Malayalam',
2339             bmp: '\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D75\u0D79-\u0D7F'
2340         },
2341         {
2342             name: 'Mandaic',
2343             bmp: '\u0840-\u085B\u085E'
2344         },
2345         {
2346             name: 'Manichaean',
2347             astral: '\uD802[\uDEC0-\uDEE6\uDEEB-\uDEF6]'
2348         },
2349         {
2350             name: 'Meetei_Mayek',
2351             bmp: '\uAAE0-\uAAF6\uABC0-\uABED\uABF0-\uABF9'
2352         },
2353         {
2354             name: 'Mende_Kikakui',
2355             astral: '\uD83A[\uDC00-\uDCC4\uDCC7-\uDCD6]'
2356         },
2357         {
2358             name: 'Meroitic_Cursive',
2359             astral: '\uD802[\uDDA0-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDDFF]'
2360         },
2361         {
2362             name: 'Meroitic_Hieroglyphs',
2363             astral: '\uD802[\uDD80-\uDD9F]'
2364         },
2365         {
2366             name: 'Miao',
2367             astral: '\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]'
2368         },
2369         {
2370             name: 'Modi',
2371             astral: '\uD805[\uDE00-\uDE44\uDE50-\uDE59]'
2372         },
2373         {
2374             name: 'Mongolian',
2375             bmp: '\u1800\u1801\u1804\u1806-\u180E\u1810-\u1819\u1820-\u1877\u1880-\u18AA'
2376         },
2377         {
2378             name: 'Mro',
2379             astral: '\uD81A[\uDE40-\uDE5E\uDE60-\uDE69\uDE6E\uDE6F]'
2380         },
2381         {
2382             name: 'Multani',
2383             astral: '\uD804[\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA9]'
2384         },
2385         {
2386             name: 'Myanmar',
2387             bmp: '\u1000-\u109F\uA9E0-\uA9FE\uAA60-\uAA7F'
2388         },
2389         {
2390             name: 'Nabataean',
2391             astral: '\uD802[\uDC80-\uDC9E\uDCA7-\uDCAF]'
2392         },
2393         {
2394             name: 'New_Tai_Lue',
2395             bmp: '\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u19DE\u19DF'
2396         },
2397         {
2398             name: 'Nko',
2399             bmp: '\u07C0-\u07FA'
2400         },
2401         {
2402             name: 'Ogham',
2403             bmp: '\u1680-\u169C'
2404         },
2405         {
2406             name: 'Ol_Chiki',
2407             bmp: '\u1C50-\u1C7F'
2408         },
2409         {
2410             name: 'Old_Hungarian',
2411             astral: '\uD803[\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDCFF]'
2412         },
2413         {
2414             name: 'Old_Italic',
2415             astral: '\uD800[\uDF00-\uDF23]'
2416         },
2417         {
2418             name: 'Old_North_Arabian',
2419             astral: '\uD802[\uDE80-\uDE9F]'
2420         },
2421         {
2422             name: 'Old_Permic',
2423             astral: '\uD800[\uDF50-\uDF7A]'
2424         },
2425         {
2426             name: 'Old_Persian',
2427             astral: '\uD800[\uDFA0-\uDFC3\uDFC8-\uDFD5]'
2428         },
2429         {
2430             name: 'Old_South_Arabian',
2431             astral: '\uD802[\uDE60-\uDE7F]'
2432         },
2433         {
2434             name: 'Old_Turkic',
2435             astral: '\uD803[\uDC00-\uDC48]'
2436         },
2437         {
2438             name: 'Oriya',
2439             bmp: '\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B77'
2440         },
2441         {
2442             name: 'Osmanya',
2443             astral: '\uD801[\uDC80-\uDC9D\uDCA0-\uDCA9]'
2444         },
2445         {
2446             name: 'Pahawh_Hmong',
2447             astral: '\uD81A[\uDF00-\uDF45\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]'
2448         },
2449         {
2450             name: 'Palmyrene',
2451             astral: '\uD802[\uDC60-\uDC7F]'
2452         },
2453         {
2454             name: 'Pau_Cin_Hau',
2455             astral: '\uD806[\uDEC0-\uDEF8]'
2456         },
2457         {
2458             name: 'Phags_Pa',
2459             bmp: '\uA840-\uA877'
2460         },
2461         {
2462             name: 'Phoenician',
2463             astral: '\uD802[\uDD00-\uDD1B\uDD1F]'
2464         },
2465         {
2466             name: 'Psalter_Pahlavi',
2467             astral: '\uD802[\uDF80-\uDF91\uDF99-\uDF9C\uDFA9-\uDFAF]'
2468         },
2469         {
2470             name: 'Rejang',
2471             bmp: '\uA930-\uA953\uA95F'
2472         },
2473         {
2474             name: 'Runic',
2475             bmp: '\u16A0-\u16EA\u16EE-\u16F8'
2476         },
2477         {
2478             name: 'Samaritan',
2479             bmp: '\u0800-\u082D\u0830-\u083E'
2480         },
2481         {
2482             name: 'Saurashtra',
2483             bmp: '\uA880-\uA8C4\uA8CE-\uA8D9'
2484         },
2485         {
2486             name: 'Sharada',
2487             astral: '\uD804[\uDD80-\uDDCD\uDDD0-\uDDDF]'
2488         },
2489         {
2490             name: 'Shavian',
2491             astral: '\uD801[\uDC50-\uDC7F]'
2492         },
2493         {
2494             name: 'Siddham',
2495             astral: '\uD805[\uDD80-\uDDB5\uDDB8-\uDDDD]'
2496         },
2497         {
2498             name: 'SignWriting',
2499             astral: '\uD836[\uDC00-\uDE8B\uDE9B-\uDE9F\uDEA1-\uDEAF]'
2500         },
2501         {
2502             name: 'Sinhala',
2503             bmp: '\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2-\u0DF4',
2504             astral: '\uD804[\uDDE1-\uDDF4]'
2505         },
2506         {
2507             name: 'Sora_Sompeng',
2508             astral: '\uD804[\uDCD0-\uDCE8\uDCF0-\uDCF9]'
2509         },
2510         {
2511             name: 'Sundanese',
2512             bmp: '\u1B80-\u1BBF\u1CC0-\u1CC7'
2513         },
2514         {
2515             name: 'Syloti_Nagri',
2516             bmp: '\uA800-\uA82B'
2517         },
2518         {
2519             name: 'Syriac',
2520             bmp: '\u0700-\u070D\u070F-\u074A\u074D-\u074F'
2521         },
2522         {
2523             name: 'Tagalog',
2524             bmp: '\u1700-\u170C\u170E-\u1714'
2525         },
2526         {
2527             name: 'Tagbanwa',
2528             bmp: '\u1760-\u176C\u176E-\u1770\u1772\u1773'
2529         },
2530         {
2531             name: 'Tai_Le',
2532             bmp: '\u1950-\u196D\u1970-\u1974'
2533         },
2534         {
2535             name: 'Tai_Tham',
2536             bmp: '\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA0-\u1AAD'
2537         },
2538         {
2539             name: 'Tai_Viet',
2540             bmp: '\uAA80-\uAAC2\uAADB-\uAADF'
2541         },
2542         {
2543             name: 'Takri',
2544             astral: '\uD805[\uDE80-\uDEB7\uDEC0-\uDEC9]'
2545         },
2546         {
2547             name: 'Tamil',
2548             bmp: '\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BFA'
2549         },
2550         {
2551             name: 'Telugu',
2552             bmp: '\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C78-\u0C7F'
2553         },
2554         {
2555             name: 'Thaana',
2556             bmp: '\u0780-\u07B1'
2557         },
2558         {
2559             name: 'Thai',
2560             bmp: '\u0E01-\u0E3A\u0E40-\u0E5B'
2561         },
2562         {
2563             name: 'Tibetan',
2564             bmp: '\u0F00-\u0F47\u0F49-\u0F6C\u0F71-\u0F97\u0F99-\u0FBC\u0FBE-\u0FCC\u0FCE-\u0FD4\u0FD9\u0FDA'
2565         },
2566         {
2567             name: 'Tifinagh',
2568             bmp: '\u2D30-\u2D67\u2D6F\u2D70\u2D7F'
2569         },
2570         {
2571             name: 'Tirhuta',
2572             astral: '\uD805[\uDC80-\uDCC7\uDCD0-\uDCD9]'
2573         },
2574         {
2575             name: 'Ugaritic',
2576             astral: '\uD800[\uDF80-\uDF9D\uDF9F]'
2577         },
2578         {
2579             name: 'Vai',
2580             bmp: '\uA500-\uA62B'
2581         },
2582         {
2583             name: 'Warang_Citi',
2584             astral: '\uD806[\uDCA0-\uDCF2\uDCFF]'
2585         },
2586         {
2587             name: 'Yi',
2588             bmp: '\uA000-\uA48C\uA490-\uA4C6'
2589         }
2590     ]);
2591
2592 };
2593
2594 },{}],8:[function(require,module,exports){
2595 var XRegExp = require('./xregexp');
2596
2597 require('./addons/build')(XRegExp);
2598 require('./addons/matchrecursive')(XRegExp);
2599 require('./addons/unicode-base')(XRegExp);
2600 require('./addons/unicode-blocks')(XRegExp);
2601 require('./addons/unicode-categories')(XRegExp);
2602 require('./addons/unicode-properties')(XRegExp);
2603 require('./addons/unicode-scripts')(XRegExp);
2604
2605 module.exports = XRegExp;
2606
2607 },{"./addons/build":1,"./addons/matchrecursive":2,"./addons/unicode-base":3,"./addons/unicode-blocks":4,"./addons/unicode-categories":5,"./addons/unicode-properties":6,"./addons/unicode-scripts":7,"./xregexp":9}],9:[function(require,module,exports){
2608 /*!
2609  * XRegExp 3.1.1
2610  * <xregexp.com>
2611  * Steven Levithan (c) 2007-2016 MIT License
2612  */
2613
2614 'use strict';
2615
2616 /**
2617  * XRegExp provides augmented, extensible regular expressions. You get additional regex syntax and
2618  * flags, beyond what browsers support natively. XRegExp is also a regex utility belt with tools to
2619  * make your client-side grepping simpler and more powerful, while freeing you from related
2620  * cross-browser inconsistencies.
2621  */
2622
2623 // ==--------------------------==
2624 // Private stuff
2625 // ==--------------------------==
2626
2627 // Property name used for extended regex instance data
2628 var REGEX_DATA = 'xregexp';
2629 // Optional features that can be installed and uninstalled
2630 var features = {
2631     astral: false,
2632     natives: false
2633 };
2634 // Native methods to use and restore ('native' is an ES3 reserved keyword)
2635 var nativ = {
2636     exec: RegExp.prototype.exec,
2637     test: RegExp.prototype.test,
2638     match: String.prototype.match,
2639     replace: String.prototype.replace,
2640     split: String.prototype.split
2641 };
2642 // Storage for fixed/extended native methods
2643 var fixed = {};
2644 // Storage for regexes cached by `XRegExp.cache`
2645 var regexCache = {};
2646 // Storage for pattern details cached by the `XRegExp` constructor
2647 var patternCache = {};
2648 // Storage for regex syntax tokens added internally or by `XRegExp.addToken`
2649 var tokens = [];
2650 // Token scopes
2651 var defaultScope = 'default';
2652 var classScope = 'class';
2653 // Regexes that match native regex syntax, including octals
2654 var nativeTokens = {
2655     // Any native multicharacter token in default scope, or any single character
2656     'default': /\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|\(\?(?:[:=!]|<[=!])|[?*+]\?|{\d+(?:,\d*)?}\??|[\s\S]/,
2657     // Any native multicharacter token in character class scope, or any single character
2658     'class': /\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|[\s\S]/
2659 };
2660 // Any backreference or dollar-prefixed character in replacement strings
2661 var replacementToken = /\$(?:{([\w$]+)}|(\d\d?|[\s\S]))/g;
2662 // Check for correct `exec` handling of nonparticipating capturing groups
2663 var correctExecNpcg = nativ.exec.call(/()??/, '')[1] === undefined;
2664 // Check for ES6 `flags` prop support
2665 var hasFlagsProp = /x/.flags !== undefined;
2666 // Shortcut to `Object.prototype.toString`
2667 var toString = {}.toString;
2668
2669 function hasNativeFlag(flag) {
2670     // Can't check based on the presense of properties/getters since browsers might support such
2671     // properties even when they don't support the corresponding flag in regex construction (tested
2672     // in Chrome 48, where `'unicode' in /x/` is true but trying to construct a regex with flag `u`
2673     // throws an error)
2674     var isSupported = true;
2675     try {
2676         // Can't use regex literals for testing even in a `try` because regex literals with
2677         // unsupported flags cause a compilation error in IE
2678         new RegExp('', flag);
2679     } catch (exception) {
2680         isSupported = false;
2681     }
2682     if (isSupported && flag === 'y') {
2683         // Work around Safari 9.1.1 bug
2684         return new RegExp('aa|.', 'y').test('b');
2685     }
2686     return isSupported;
2687 }
2688 // Check for ES6 `u` flag support
2689 var hasNativeU = hasNativeFlag('u');
2690 // Check for ES6 `y` flag support
2691 var hasNativeY = hasNativeFlag('y');
2692 // Tracker for known flags, including addon flags
2693 var registeredFlags = {
2694     g: true,
2695     i: true,
2696     m: true,
2697     u: hasNativeU,
2698     y: hasNativeY
2699 };
2700
2701 /**
2702  * Attaches extended data and `XRegExp.prototype` properties to a regex object.
2703  *
2704  * @param {RegExp} regex Regex to augment.
2705  * @param {Array} captureNames Array with capture names, or `null`.
2706  * @param {String} xSource XRegExp pattern used to generate `regex`, or `null` if N/A.
2707  * @param {String} xFlags XRegExp flags used to generate `regex`, or `null` if N/A.
2708  * @param {Boolean} [isInternalOnly=false] Whether the regex will be used only for internal
2709  *   operations, and never exposed to users. For internal-only regexes, we can improve perf by
2710  *   skipping some operations like attaching `XRegExp.prototype` properties.
2711  * @returns {RegExp} Augmented regex.
2712  */
2713 function augment(regex, captureNames, xSource, xFlags, isInternalOnly) {
2714     var p;
2715
2716     regex[REGEX_DATA] = {
2717         captureNames: captureNames
2718     };
2719
2720     if (isInternalOnly) {
2721         return regex;
2722     }
2723
2724     // Can't auto-inherit these since the XRegExp constructor returns a nonprimitive value
2725     if (regex.__proto__) {
2726         regex.__proto__ = XRegExp.prototype;
2727     } else {
2728         for (p in XRegExp.prototype) {
2729             // An `XRegExp.prototype.hasOwnProperty(p)` check wouldn't be worth it here, since this
2730             // is performance sensitive, and enumerable `Object.prototype` or `RegExp.prototype`
2731             // extensions exist on `regex.prototype` anyway
2732             regex[p] = XRegExp.prototype[p];
2733         }
2734     }
2735
2736     regex[REGEX_DATA].source = xSource;
2737     // Emulate the ES6 `flags` prop by ensuring flags are in alphabetical order
2738     regex[REGEX_DATA].flags = xFlags ? xFlags.split('').sort().join('') : xFlags;
2739
2740     return regex;
2741 }
2742
2743 /**
2744  * Removes any duplicate characters from the provided string.
2745  *
2746  * @param {String} str String to remove duplicate characters from.
2747  * @returns {String} String with any duplicate characters removed.
2748  */
2749 function clipDuplicates(str) {
2750     return nativ.replace.call(str, /([\s\S])(?=[\s\S]*\1)/g, '');
2751 }
2752
2753 /**
2754  * Copies a regex object while preserving extended data and augmenting with `XRegExp.prototype`
2755  * properties. The copy has a fresh `lastIndex` property (set to zero). Allows adding and removing
2756  * flags g and y while copying the regex.
2757  *
2758  * @param {RegExp} regex Regex to copy.
2759  * @param {Object} [options] Options object with optional properties:
2760  *   <li>`addG` {Boolean} Add flag g while copying the regex.
2761  *   <li>`addY` {Boolean} Add flag y while copying the regex.
2762  *   <li>`removeG` {Boolean} Remove flag g while copying the regex.
2763  *   <li>`removeY` {Boolean} Remove flag y while copying the regex.
2764  *   <li>`isInternalOnly` {Boolean} Whether the copied regex will be used only for internal
2765  *     operations, and never exposed to users. For internal-only regexes, we can improve perf by
2766  *     skipping some operations like attaching `XRegExp.prototype` properties.
2767  * @returns {RegExp} Copy of the provided regex, possibly with modified flags.
2768  */
2769 function copyRegex(regex, options) {
2770     if (!XRegExp.isRegExp(regex)) {
2771         throw new TypeError('Type RegExp expected');
2772     }
2773
2774     var xData = regex[REGEX_DATA] || {},
2775         flags = getNativeFlags(regex),
2776         flagsToAdd = '',
2777         flagsToRemove = '',
2778         xregexpSource = null,
2779         xregexpFlags = null;
2780
2781     options = options || {};
2782
2783     if (options.removeG) {flagsToRemove += 'g';}
2784     if (options.removeY) {flagsToRemove += 'y';}
2785     if (flagsToRemove) {
2786         flags = nativ.replace.call(flags, new RegExp('[' + flagsToRemove + ']+', 'g'), '');
2787     }
2788
2789     if (options.addG) {flagsToAdd += 'g';}
2790     if (options.addY) {flagsToAdd += 'y';}
2791     if (flagsToAdd) {
2792         flags = clipDuplicates(flags + flagsToAdd);
2793     }
2794
2795     if (!options.isInternalOnly) {
2796         if (xData.source !== undefined) {
2797             xregexpSource = xData.source;
2798         }
2799         // null or undefined; don't want to add to `flags` if the previous value was null, since
2800         // that indicates we're not tracking original precompilation flags
2801         if (xData.flags != null) {
2802             // Flags are only added for non-internal regexes by `XRegExp.globalize`. Flags are never
2803             // removed for non-internal regexes, so don't need to handle it
2804             xregexpFlags = flagsToAdd ? clipDuplicates(xData.flags + flagsToAdd) : xData.flags;
2805         }
2806     }
2807
2808     // Augment with `XRegExp.prototype` properties, but use the native `RegExp` constructor to avoid
2809     // searching for special tokens. That would be wrong for regexes constructed by `RegExp`, and
2810     // unnecessary for regexes constructed by `XRegExp` because the regex has already undergone the
2811     // translation to native regex syntax
2812     regex = augment(
2813         new RegExp(regex.source, flags),
2814         hasNamedCapture(regex) ? xData.captureNames.slice(0) : null,
2815         xregexpSource,
2816         xregexpFlags,
2817         options.isInternalOnly
2818     );
2819
2820     return regex;
2821 }
2822
2823 /**
2824  * Converts hexadecimal to decimal.
2825  *
2826  * @param {String} hex
2827  * @returns {Number}
2828  */
2829 function dec(hex) {
2830     return parseInt(hex, 16);
2831 }
2832
2833 /**
2834  * Returns native `RegExp` flags used by a regex object.
2835  *
2836  * @param {RegExp} regex Regex to check.
2837  * @returns {String} Native flags in use.
2838  */
2839 function getNativeFlags(regex) {
2840     return hasFlagsProp ?
2841         regex.flags :
2842         // Explicitly using `RegExp.prototype.toString` (rather than e.g. `String` or concatenation
2843         // with an empty string) allows this to continue working predictably when
2844         // `XRegExp.proptotype.toString` is overriden
2845         nativ.exec.call(/\/([a-z]*)$/i, RegExp.prototype.toString.call(regex))[1];
2846 }
2847
2848 /**
2849  * Determines whether a regex has extended instance data used to track capture names.
2850  *
2851  * @param {RegExp} regex Regex to check.
2852  * @returns {Boolean} Whether the regex uses named capture.
2853  */
2854 function hasNamedCapture(regex) {
2855     return !!(regex[REGEX_DATA] && regex[REGEX_DATA].captureNames);
2856 }
2857
2858 /**
2859  * Converts decimal to hexadecimal.
2860  *
2861  * @param {Number|String} dec
2862  * @returns {String}
2863  */
2864 function hex(dec) {
2865     return parseInt(dec, 10).toString(16);
2866 }
2867
2868 /**
2869  * Returns the first index at which a given value can be found in an array.
2870  *
2871  * @param {Array} array Array to search.
2872  * @param {*} value Value to locate in the array.
2873  * @returns {Number} Zero-based index at which the item is found, or -1.
2874  */
2875 function indexOf(array, value) {
2876     var len = array.length, i;
2877
2878     for (i = 0; i < len; ++i) {
2879         if (array[i] === value) {
2880             return i;
2881         }
2882     }
2883
2884     return -1;
2885 }
2886
2887 /**
2888  * Determines whether a value is of the specified type, by resolving its internal [[Class]].
2889  *
2890  * @param {*} value Object to check.
2891  * @param {String} type Type to check for, in TitleCase.
2892  * @returns {Boolean} Whether the object matches the type.
2893  */
2894 function isType(value, type) {
2895     return toString.call(value) === '[object ' + type + ']';
2896 }
2897
2898 /**
2899  * Checks whether the next nonignorable token after the specified position is a quantifier.
2900  *
2901  * @param {String} pattern Pattern to search within.
2902  * @param {Number} pos Index in `pattern` to search at.
2903  * @param {String} flags Flags used by the pattern.
2904  * @returns {Boolean} Whether the next token is a quantifier.
2905  */
2906 function isQuantifierNext(pattern, pos, flags) {
2907     return nativ.test.call(
2908         flags.indexOf('x') > -1 ?
2909             // Ignore any leading whitespace, line comments, and inline comments
2910             /^(?:\s|#[^#\n]*|\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/ :
2911             // Ignore any leading inline comments
2912             /^(?:\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/,
2913         pattern.slice(pos)
2914     );
2915 }
2916
2917 /**
2918  * Adds leading zeros if shorter than four characters. Used for fixed-length hexadecimal values.
2919  *
2920  * @param {String} str
2921  * @returns {String}
2922  */
2923 function pad4(str) {
2924     while (str.length < 4) {
2925         str = '0' + str;
2926     }
2927     return str;
2928 }
2929
2930 /**
2931  * Checks for flag-related errors, and strips/applies flags in a leading mode modifier. Offloads
2932  * the flag preparation logic from the `XRegExp` constructor.
2933  *
2934  * @param {String} pattern Regex pattern, possibly with a leading mode modifier.
2935  * @param {String} flags Any combination of flags.
2936  * @returns {Object} Object with properties `pattern` and `flags`.
2937  */
2938 function prepareFlags(pattern, flags) {
2939     var i;
2940
2941     // Recent browsers throw on duplicate flags, so copy this behavior for nonnative flags
2942     if (clipDuplicates(flags) !== flags) {
2943         throw new SyntaxError('Invalid duplicate regex flag ' + flags);
2944     }
2945
2946     // Strip and apply a leading mode modifier with any combination of flags except g or y
2947     pattern = nativ.replace.call(pattern, /^\(\?([\w$]+)\)/, function($0, $1) {
2948         if (nativ.test.call(/[gy]/, $1)) {
2949             throw new SyntaxError('Cannot use flag g or y in mode modifier ' + $0);
2950         }
2951         // Allow duplicate flags within the mode modifier
2952         flags = clipDuplicates(flags + $1);
2953         return '';
2954     });
2955
2956     // Throw on unknown native or nonnative flags
2957     for (i = 0; i < flags.length; ++i) {
2958         if (!registeredFlags[flags.charAt(i)]) {
2959             throw new SyntaxError('Unknown regex flag ' + flags.charAt(i));
2960         }
2961     }
2962
2963     return {
2964         pattern: pattern,
2965         flags: flags
2966     };
2967 }
2968
2969 /**
2970  * Prepares an options object from the given value.
2971  *
2972  * @param {String|Object} value Value to convert to an options object.
2973  * @returns {Object} Options object.
2974  */
2975 function prepareOptions(value) {
2976     var options = {};
2977
2978     if (isType(value, 'String')) {
2979         XRegExp.forEach(value, /[^\s,]+/, function(match) {
2980             options[match] = true;
2981         });
2982
2983         return options;
2984     }
2985
2986     return value;
2987 }
2988
2989 /**
2990  * Registers a flag so it doesn't throw an 'unknown flag' error.
2991  *
2992  * @param {String} flag Single-character flag to register.
2993  */
2994 function registerFlag(flag) {
2995     if (!/^[\w$]$/.test(flag)) {
2996         throw new Error('Flag must be a single character A-Za-z0-9_$');
2997     }
2998
2999     registeredFlags[flag] = true;
3000 }
3001
3002 /**
3003  * Runs built-in and custom regex syntax tokens in reverse insertion order at the specified
3004  * position, until a match is found.
3005  *
3006  * @param {String} pattern Original pattern from which an XRegExp object is being built.
3007  * @param {String} flags Flags being used to construct the regex.
3008  * @param {Number} pos Position to search for tokens within `pattern`.
3009  * @param {Number} scope Regex scope to apply: 'default' or 'class'.
3010  * @param {Object} context Context object to use for token handler functions.
3011  * @returns {Object} Object with properties `matchLength`, `output`, and `reparse`; or `null`.
3012  */
3013 function runTokens(pattern, flags, pos, scope, context) {
3014     var i = tokens.length,
3015         leadChar = pattern.charAt(pos),
3016         result = null,
3017         match,
3018         t;
3019
3020     // Run in reverse insertion order
3021     while (i--) {
3022         t = tokens[i];
3023         if (
3024             (t.leadChar && t.leadChar !== leadChar) ||
3025             (t.scope !== scope && t.scope !== 'all') ||
3026             (t.flag && flags.indexOf(t.flag) === -1)
3027         ) {
3028             continue;
3029         }
3030
3031         match = XRegExp.exec(pattern, t.regex, pos, 'sticky');
3032         if (match) {
3033             result = {
3034                 matchLength: match[0].length,
3035                 output: t.handler.call(context, match, scope, flags),
3036                 reparse: t.reparse
3037             };
3038             // Finished with token tests
3039             break;
3040         }
3041     }
3042
3043     return result;
3044 }
3045
3046 /**
3047  * Enables or disables implicit astral mode opt-in. When enabled, flag A is automatically added to
3048  * all new regexes created by XRegExp. This causes an error to be thrown when creating regexes if
3049  * the Unicode Base addon is not available, since flag A is registered by that addon.
3050  *
3051  * @param {Boolean} on `true` to enable; `false` to disable.
3052  */
3053 function setAstral(on) {
3054     features.astral = on;
3055 }
3056
3057 /**
3058  * Enables or disables native method overrides.
3059  *
3060  * @param {Boolean} on `true` to enable; `false` to disable.
3061  */
3062 function setNatives(on) {
3063     RegExp.prototype.exec = (on ? fixed : nativ).exec;
3064     RegExp.prototype.test = (on ? fixed : nativ).test;
3065     String.prototype.match = (on ? fixed : nativ).match;
3066     String.prototype.replace = (on ? fixed : nativ).replace;
3067     String.prototype.split = (on ? fixed : nativ).split;
3068
3069     features.natives = on;
3070 }
3071
3072 /**
3073  * Returns the object, or throws an error if it is `null` or `undefined`. This is used to follow
3074  * the ES5 abstract operation `ToObject`.
3075  *
3076  * @param {*} value Object to check and return.
3077  * @returns {*} The provided object.
3078  */
3079 function toObject(value) {
3080     // null or undefined
3081     if (value == null) {
3082         throw new TypeError('Cannot convert null or undefined to object');
3083     }
3084
3085     return value;
3086 }
3087
3088 // ==--------------------------==
3089 // Constructor
3090 // ==--------------------------==
3091
3092 /**
3093  * Creates an extended regular expression object for matching text with a pattern. Differs from a
3094  * native regular expression in that additional syntax and flags are supported. The returned object
3095  * is in fact a native `RegExp` and works with all native methods.
3096  *
3097  * @class XRegExp
3098  * @constructor
3099  * @param {String|RegExp} pattern Regex pattern string, or an existing regex object to copy.
3100  * @param {String} [flags] Any combination of flags.
3101  *   Native flags:
3102  *     <li>`g` - global
3103  *     <li>`i` - ignore case
3104  *     <li>`m` - multiline anchors
3105  *     <li>`u` - unicode (ES6)
3106  *     <li>`y` - sticky (Firefox 3+, ES6)
3107  *   Additional XRegExp flags:
3108  *     <li>`n` - explicit capture
3109  *     <li>`s` - dot matches all (aka singleline)
3110  *     <li>`x` - free-spacing and line comments (aka extended)
3111  *     <li>`A` - astral (requires the Unicode Base addon)
3112  *   Flags cannot be provided when constructing one `RegExp` from another.
3113  * @returns {RegExp} Extended regular expression object.
3114  * @example
3115  *
3116  * // With named capture and flag x
3117  * XRegExp('(?<year>  [0-9]{4} ) -?  # year  \n\
3118  *          (?<month> [0-9]{2} ) -?  # month \n\
3119  *          (?<day>   [0-9]{2} )     # day   ', 'x');
3120  *
3121  * // Providing a regex object copies it. Native regexes are recompiled using native (not XRegExp)
3122  * // syntax. Copies maintain extended data, are augmented with `XRegExp.prototype` properties, and
3123  * // have fresh `lastIndex` properties (set to zero).
3124  * XRegExp(/regex/);
3125  */
3126 function XRegExp(pattern, flags) {
3127     if (XRegExp.isRegExp(pattern)) {
3128         if (flags !== undefined) {
3129             throw new TypeError('Cannot supply flags when copying a RegExp');
3130         }
3131         return copyRegex(pattern);
3132     }
3133
3134     // Copy the argument behavior of `RegExp`
3135     pattern = pattern === undefined ? '' : String(pattern);
3136     flags = flags === undefined ? '' : String(flags);
3137
3138     if (XRegExp.isInstalled('astral') && flags.indexOf('A') === -1) {
3139         // This causes an error to be thrown if the Unicode Base addon is not available
3140         flags += 'A';
3141     }
3142
3143     if (!patternCache[pattern]) {
3144         patternCache[pattern] = {};
3145     }
3146
3147     if (!patternCache[pattern][flags]) {
3148         var context = {
3149             hasNamedCapture: false,
3150             captureNames: []
3151         };
3152         var scope = defaultScope;
3153         var output = '';
3154         var pos = 0;
3155         var result;
3156
3157         // Check for flag-related errors, and strip/apply flags in a leading mode modifier
3158         var applied = prepareFlags(pattern, flags);
3159         var appliedPattern = applied.pattern;
3160         var appliedFlags = applied.flags;
3161
3162         // Use XRegExp's tokens to translate the pattern to a native regex pattern.
3163         // `appliedPattern.length` may change on each iteration if tokens use `reparse`
3164         while (pos < appliedPattern.length) {
3165             do {
3166                 // Check for custom tokens at the current position
3167                 result = runTokens(appliedPattern, appliedFlags, pos, scope, context);
3168                 // If the matched token used the `reparse` option, splice its output into the
3169                 // pattern before running tokens again at the same position
3170                 if (result && result.reparse) {
3171                     appliedPattern = appliedPattern.slice(0, pos) +
3172                         result.output +
3173                         appliedPattern.slice(pos + result.matchLength);
3174                 }
3175             } while (result && result.reparse);
3176
3177             if (result) {
3178                 output += result.output;
3179                 pos += (result.matchLength || 1);
3180             } else {
3181                 // Get the native token at the current position
3182                 var token = XRegExp.exec(appliedPattern, nativeTokens[scope], pos, 'sticky')[0];
3183                 output += token;
3184                 pos += token.length;
3185                 if (token === '[' && scope === defaultScope) {
3186                     scope = classScope;
3187                 } else if (token === ']' && scope === classScope) {
3188                     scope = defaultScope;
3189                 }
3190             }
3191         }
3192
3193         patternCache[pattern][flags] = {
3194             // Use basic cleanup to collapse repeated empty groups like `(?:)(?:)` to `(?:)`. Empty
3195             // groups are sometimes inserted during regex transpilation in order to keep tokens
3196             // separated. However, more than one empty group in a row is never needed.
3197             pattern: nativ.replace.call(output, /(?:\(\?:\))+/g, '(?:)'),
3198             // Strip all but native flags
3199             flags: nativ.replace.call(appliedFlags, /[^gimuy]+/g, ''),
3200             // `context.captureNames` has an item for each capturing group, even if unnamed
3201             captures: context.hasNamedCapture ? context.captureNames : null
3202         };
3203     }
3204
3205     var generated = patternCache[pattern][flags];
3206     return augment(
3207         new RegExp(generated.pattern, generated.flags),
3208         generated.captures,
3209         pattern,
3210         flags
3211     );
3212 }
3213
3214 // Add `RegExp.prototype` to the prototype chain
3215 XRegExp.prototype = new RegExp();
3216
3217 // ==--------------------------==
3218 // Public properties
3219 // ==--------------------------==
3220
3221 /**
3222  * The XRegExp version number as a string containing three dot-separated parts. For example,
3223  * '2.0.0-beta-3'.
3224  *
3225  * @static
3226  * @type String
3227  */
3228 XRegExp.version = '3.1.1';
3229
3230 // ==--------------------------==
3231 // Public methods
3232 // ==--------------------------==
3233
3234 // Intentionally undocumented; used in tests and addons
3235 XRegExp._hasNativeFlag = hasNativeFlag;
3236 XRegExp._dec = dec;
3237 XRegExp._hex = hex;
3238 XRegExp._pad4 = pad4;
3239
3240 /**
3241  * Extends XRegExp syntax and allows custom flags. This is used internally and can be used to
3242  * create XRegExp addons. If more than one token can match the same string, the last added wins.
3243  *
3244  * @param {RegExp} regex Regex object that matches the new token.
3245  * @param {Function} handler Function that returns a new pattern string (using native regex syntax)
3246  *   to replace the matched token within all future XRegExp regexes. Has access to persistent
3247  *   properties of the regex being built, through `this`. Invoked with three arguments:
3248  *   <li>The match array, with named backreference properties.
3249  *   <li>The regex scope where the match was found: 'default' or 'class'.
3250  *   <li>The flags used by the regex, including any flags in a leading mode modifier.
3251  *   The handler function becomes part of the XRegExp construction process, so be careful not to
3252  *   construct XRegExps within the function or you will trigger infinite recursion.
3253  * @param {Object} [options] Options object with optional properties:
3254  *   <li>`scope` {String} Scope where the token applies: 'default', 'class', or 'all'.
3255  *   <li>`flag` {String} Single-character flag that triggers the token. This also registers the
3256  *     flag, which prevents XRegExp from throwing an 'unknown flag' error when the flag is used.
3257  *   <li>`optionalFlags` {String} Any custom flags checked for within the token `handler` that are
3258  *     not required to trigger the token. This registers the flags, to prevent XRegExp from
3259  *     throwing an 'unknown flag' error when any of the flags are used.
3260  *   <li>`reparse` {Boolean} Whether the `handler` function's output should not be treated as
3261  *     final, and instead be reparseable by other tokens (including the current token). Allows
3262  *     token chaining or deferring.
3263  *   <li>`leadChar` {String} Single character that occurs at the beginning of any successful match
3264  *     of the token (not always applicable). This doesn't change the behavior of the token unless
3265  *     you provide an erroneous value. However, providing it can increase the token's performance
3266  *     since the token can be skipped at any positions where this character doesn't appear.
3267  * @example
3268  *
3269  * // Basic usage: Add \a for the ALERT control code
3270  * XRegExp.addToken(
3271  *   /\\a/,
3272  *   function() {return '\\x07';},
3273  *   {scope: 'all'}
3274  * );
3275  * XRegExp('\\a[\\a-\\n]+').test('\x07\n\x07'); // -> true
3276  *
3277  * // Add the U (ungreedy) flag from PCRE and RE2, which reverses greedy and lazy quantifiers.
3278  * // Since `scope` is not specified, it uses 'default' (i.e., transformations apply outside of
3279  * // character classes only)
3280  * XRegExp.addToken(
3281  *   /([?*+]|{\d+(?:,\d*)?})(\??)/,
3282  *   function(match) {return match[1] + (match[2] ? '' : '?');},
3283  *   {flag: 'U'}
3284  * );
3285  * XRegExp('a+', 'U').exec('aaa')[0]; // -> 'a'
3286  * XRegExp('a+?', 'U').exec('aaa')[0]; // -> 'aaa'
3287  */
3288 XRegExp.addToken = function(regex, handler, options) {
3289     options = options || {};
3290     var optionalFlags = options.optionalFlags, i;
3291
3292     if (options.flag) {
3293         registerFlag(options.flag);
3294     }
3295
3296     if (optionalFlags) {
3297         optionalFlags = nativ.split.call(optionalFlags, '');
3298         for (i = 0; i < optionalFlags.length; ++i) {
3299             registerFlag(optionalFlags[i]);
3300         }
3301     }
3302
3303     // Add to the private list of syntax tokens
3304     tokens.push({
3305         regex: copyRegex(regex, {
3306             addG: true,
3307             addY: hasNativeY,
3308             isInternalOnly: true
3309         }),
3310         handler: handler,
3311         scope: options.scope || defaultScope,
3312         flag: options.flag,
3313         reparse: options.reparse,
3314         leadChar: options.leadChar
3315     });
3316
3317     // Reset the pattern cache used by the `XRegExp` constructor, since the same pattern and flags
3318     // might now produce different results
3319     XRegExp.cache.flush('patterns');
3320 };
3321
3322 /**
3323  * Caches and returns the result of calling `XRegExp(pattern, flags)`. On any subsequent call with
3324  * the same pattern and flag combination, the cached copy of the regex is returned.
3325  *
3326  * @param {String} pattern Regex pattern string.
3327  * @param {String} [flags] Any combination of XRegExp flags.
3328  * @returns {RegExp} Cached XRegExp object.
3329  * @example
3330  *
3331  * while (match = XRegExp.cache('.', 'gs').exec(str)) {
3332  *   // The regex is compiled once only
3333  * }
3334  */
3335 XRegExp.cache = function(pattern, flags) {
3336     if (!regexCache[pattern]) {
3337         regexCache[pattern] = {};
3338     }
3339     return regexCache[pattern][flags] || (
3340         regexCache[pattern][flags] = XRegExp(pattern, flags)
3341     );
3342 };
3343
3344 // Intentionally undocumented; used in tests
3345 XRegExp.cache.flush = function(cacheName) {
3346     if (cacheName === 'patterns') {
3347         // Flush the pattern cache used by the `XRegExp` constructor
3348         patternCache = {};
3349     } else {
3350         // Flush the regex cache populated by `XRegExp.cache`
3351         regexCache = {};
3352     }
3353 };
3354
3355 /**
3356  * Escapes any regular expression metacharacters, for use when matching literal strings. The result
3357  * can safely be used at any point within a regex that uses any flags.
3358  *
3359  * @param {String} str String to escape.
3360  * @returns {String} String with regex metacharacters escaped.
3361  * @example
3362  *
3363  * XRegExp.escape('Escaped? <.>');
3364  * // -> 'Escaped\?\ <\.>'
3365  */
3366 XRegExp.escape = function(str) {
3367     return nativ.replace.call(toObject(str), /[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
3368 };
3369
3370 /**
3371  * Executes a regex search in a specified string. Returns a match array or `null`. If the provided
3372  * regex uses named capture, named backreference properties are included on the match array.
3373  * Optional `pos` and `sticky` arguments specify the search start position, and whether the match
3374  * must start at the specified position only. The `lastIndex` property of the provided regex is not
3375  * used, but is updated for compatibility. Also fixes browser bugs compared to the native
3376  * `RegExp.prototype.exec` and can be used reliably cross-browser.
3377  *
3378  * @param {String} str String to search.
3379  * @param {RegExp} regex Regex to search with.
3380  * @param {Number} [pos=0] Zero-based index at which to start the search.
3381  * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
3382  *   only. The string `'sticky'` is accepted as an alternative to `true`.
3383  * @returns {Array} Match array with named backreference properties, or `null`.
3384  * @example
3385  *
3386  * // Basic use, with named backreference
3387  * var match = XRegExp.exec('U+2620', XRegExp('U\\+(?<hex>[0-9A-F]{4})'));
3388  * match.hex; // -> '2620'
3389  *
3390  * // With pos and sticky, in a loop
3391  * var pos = 2, result = [], match;
3392  * while (match = XRegExp.exec('<1><2><3><4>5<6>', /<(\d)>/, pos, 'sticky')) {
3393  *   result.push(match[1]);
3394  *   pos = match.index + match[0].length;
3395  * }
3396  * // result -> ['2', '3', '4']
3397  */
3398 XRegExp.exec = function(str, regex, pos, sticky) {
3399     var cacheKey = 'g',
3400         addY = false,
3401         match,
3402         r2;
3403
3404     addY = hasNativeY && !!(sticky || (regex.sticky && sticky !== false));
3405     if (addY) {
3406         cacheKey += 'y';
3407     }
3408
3409     regex[REGEX_DATA] = regex[REGEX_DATA] || {};
3410
3411     // Shares cached copies with `XRegExp.match`/`replace`
3412     r2 = regex[REGEX_DATA][cacheKey] || (
3413         regex[REGEX_DATA][cacheKey] = copyRegex(regex, {
3414             addG: true,
3415             addY: addY,
3416             removeY: sticky === false,
3417             isInternalOnly: true
3418         })
3419     );
3420
3421     r2.lastIndex = pos = pos || 0;
3422
3423     // Fixed `exec` required for `lastIndex` fix, named backreferences, etc.
3424     match = fixed.exec.call(r2, str);
3425
3426     if (sticky && match && match.index !== pos) {
3427         match = null;
3428     }
3429
3430     if (regex.global) {
3431         regex.lastIndex = match ? r2.lastIndex : 0;
3432     }
3433
3434     return match;
3435 };
3436
3437 /**
3438  * Executes a provided function once per regex match. Searches always start at the beginning of the
3439  * string and continue until the end, regardless of the state of the regex's `global` property and
3440  * initial `lastIndex`.
3441  *
3442  * @param {String} str String to search.
3443  * @param {RegExp} regex Regex to search with.
3444  * @param {Function} callback Function to execute for each match. Invoked with four arguments:
3445  *   <li>The match array, with named backreference properties.
3446  *   <li>The zero-based match index.
3447  *   <li>The string being traversed.
3448  *   <li>The regex object being used to traverse the string.
3449  * @example
3450  *
3451  * // Extracts every other digit from a string
3452  * var evens = [];
3453  * XRegExp.forEach('1a2345', /\d/, function(match, i) {
3454  *   if (i % 2) evens.push(+match[0]);
3455  * });
3456  * // evens -> [2, 4]
3457  */
3458 XRegExp.forEach = function(str, regex, callback) {
3459     var pos = 0,
3460         i = -1,
3461         match;
3462
3463     while ((match = XRegExp.exec(str, regex, pos))) {
3464         // Because `regex` is provided to `callback`, the function could use the deprecated/
3465         // nonstandard `RegExp.prototype.compile` to mutate the regex. However, since `XRegExp.exec`
3466         // doesn't use `lastIndex` to set the search position, this can't lead to an infinite loop,
3467         // at least. Actually, because of the way `XRegExp.exec` caches globalized versions of
3468         // regexes, mutating the regex will not have any effect on the iteration or matched strings,
3469         // which is a nice side effect that brings extra safety.
3470         callback(match, ++i, str, regex);
3471
3472         pos = match.index + (match[0].length || 1);
3473     }
3474 };
3475
3476 /**
3477  * Copies a regex object and adds flag `g`. The copy maintains extended data, is augmented with
3478  * `XRegExp.prototype` properties, and has a fresh `lastIndex` property (set to zero). Native
3479  * regexes are not recompiled using XRegExp syntax.
3480  *
3481  * @param {RegExp} regex Regex to globalize.
3482  * @returns {RegExp} Copy of the provided regex with flag `g` added.
3483  * @example
3484  *
3485  * var globalCopy = XRegExp.globalize(/regex/);
3486  * globalCopy.global; // -> true
3487  */
3488 XRegExp.globalize = function(regex) {
3489     return copyRegex(regex, {addG: true});
3490 };
3491
3492 /**
3493  * Installs optional features according to the specified options. Can be undone using
3494  * `XRegExp.uninstall`.
3495  *
3496  * @param {Object|String} options Options object or string.
3497  * @example
3498  *
3499  * // With an options object
3500  * XRegExp.install({
3501  *   // Enables support for astral code points in Unicode addons (implicitly sets flag A)
3502  *   astral: true,
3503  *
3504  *   // DEPRECATED: Overrides native regex methods with fixed/extended versions
3505  *   natives: true
3506  * });
3507  *
3508  * // With an options string
3509  * XRegExp.install('astral natives');
3510  */
3511 XRegExp.install = function(options) {
3512     options = prepareOptions(options);
3513
3514     if (!features.astral && options.astral) {
3515         setAstral(true);
3516     }
3517
3518     if (!features.natives && options.natives) {
3519         setNatives(true);
3520     }
3521 };
3522
3523 /**
3524  * Checks whether an individual optional feature is installed.
3525  *
3526  * @param {String} feature Name of the feature to check. One of:
3527  *   <li>`astral`
3528  *   <li>`natives`
3529  * @returns {Boolean} Whether the feature is installed.
3530  * @example
3531  *
3532  * XRegExp.isInstalled('astral');
3533  */
3534 XRegExp.isInstalled = function(feature) {
3535     return !!(features[feature]);
3536 };
3537
3538 /**
3539  * Returns `true` if an object is a regex; `false` if it isn't. This works correctly for regexes
3540  * created in another frame, when `instanceof` and `constructor` checks would fail.
3541  *
3542  * @param {*} value Object to check.
3543  * @returns {Boolean} Whether the object is a `RegExp` object.
3544  * @example
3545  *
3546  * XRegExp.isRegExp('string'); // -> false
3547  * XRegExp.isRegExp(/regex/i); // -> true
3548  * XRegExp.isRegExp(RegExp('^', 'm')); // -> true
3549  * XRegExp.isRegExp(XRegExp('(?s).')); // -> true
3550  */
3551 XRegExp.isRegExp = function(value) {
3552     return toString.call(value) === '[object RegExp]';
3553     //return isType(value, 'RegExp');
3554 };
3555
3556 /**
3557  * Returns the first matched string, or in global mode, an array containing all matched strings.
3558  * This is essentially a more convenient re-implementation of `String.prototype.match` that gives
3559  * the result types you actually want (string instead of `exec`-style array in match-first mode,
3560  * and an empty array instead of `null` when no matches are found in match-all mode). It also lets
3561  * you override flag g and ignore `lastIndex`, and fixes browser bugs.
3562  *
3563  * @param {String} str String to search.
3564  * @param {RegExp} regex Regex to search with.
3565  * @param {String} [scope='one'] Use 'one' to return the first match as a string. Use 'all' to
3566  *   return an array of all matched strings. If not explicitly specified and `regex` uses flag g,
3567  *   `scope` is 'all'.
3568  * @returns {String|Array} In match-first mode: First match as a string, or `null`. In match-all
3569  *   mode: Array of all matched strings, or an empty array.
3570  * @example
3571  *
3572  * // Match first
3573  * XRegExp.match('abc', /\w/); // -> 'a'
3574  * XRegExp.match('abc', /\w/g, 'one'); // -> 'a'
3575  * XRegExp.match('abc', /x/g, 'one'); // -> null
3576  *
3577  * // Match all
3578  * XRegExp.match('abc', /\w/g); // -> ['a', 'b', 'c']
3579  * XRegExp.match('abc', /\w/, 'all'); // -> ['a', 'b', 'c']
3580  * XRegExp.match('abc', /x/, 'all'); // -> []
3581  */
3582 XRegExp.match = function(str, regex, scope) {
3583     var global = (regex.global && scope !== 'one') || scope === 'all',
3584         cacheKey = ((global ? 'g' : '') + (regex.sticky ? 'y' : '')) || 'noGY',
3585         result,
3586         r2;
3587
3588     regex[REGEX_DATA] = regex[REGEX_DATA] || {};
3589
3590     // Shares cached copies with `XRegExp.exec`/`replace`
3591     r2 = regex[REGEX_DATA][cacheKey] || (
3592         regex[REGEX_DATA][cacheKey] = copyRegex(regex, {
3593             addG: !!global,
3594             removeG: scope === 'one',
3595             isInternalOnly: true
3596         })
3597     );
3598
3599     result = nativ.match.call(toObject(str), r2);
3600
3601     if (regex.global) {
3602         regex.lastIndex = (
3603             (scope === 'one' && result) ?
3604                 // Can't use `r2.lastIndex` since `r2` is nonglobal in this case
3605                 (result.index + result[0].length) : 0
3606         );
3607     }
3608
3609     return global ? (result || []) : (result && result[0]);
3610 };
3611
3612 /**
3613  * Retrieves the matches from searching a string using a chain of regexes that successively search
3614  * within previous matches. The provided `chain` array can contain regexes and or objects with
3615  * `regex` and `backref` properties. When a backreference is specified, the named or numbered
3616  * backreference is passed forward to the next regex or returned.
3617  *
3618  * @param {String} str String to search.
3619  * @param {Array} chain Regexes that each search for matches within preceding results.
3620  * @returns {Array} Matches by the last regex in the chain, or an empty array.
3621  * @example
3622  *
3623  * // Basic usage; matches numbers within <b> tags
3624  * XRegExp.matchChain('1 <b>2</b> 3 <b>4 a 56</b>', [
3625  *   XRegExp('(?is)<b>.*?</b>'),
3626  *   /\d+/
3627  * ]);
3628  * // -> ['2', '4', '56']
3629  *
3630  * // Passing forward and returning specific backreferences
3631  * html = '<a href="http://xregexp.com/api/">XRegExp</a>\
3632  *         <a href="http://www.google.com/">Google</a>';
3633  * XRegExp.matchChain(html, [
3634  *   {regex: /<a href="([^"]+)">/i, backref: 1},
3635  *   {regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
3636  * ]);
3637  * // -> ['xregexp.com', 'www.google.com']
3638  */
3639 XRegExp.matchChain = function(str, chain) {
3640     return (function recurseChain(values, level) {
3641         var item = chain[level].regex ? chain[level] : {regex: chain[level]};
3642         var matches = [];
3643
3644         function addMatch(match) {
3645             if (item.backref) {
3646                 // Safari 4.0.5 (but not 5.0.5+) inappropriately uses sparse arrays to hold the
3647                 // `undefined`s for backreferences to nonparticipating capturing groups. In such
3648                 // cases, a `hasOwnProperty` or `in` check on its own would inappropriately throw
3649                 // the exception, so also check if the backreference is a number that is within the
3650                 // bounds of the array.
3651                 if (!(match.hasOwnProperty(item.backref) || +item.backref < match.length)) {
3652                     throw new ReferenceError('Backreference to undefined group: ' + item.backref);
3653                 }
3654
3655                 matches.push(match[item.backref] || '');
3656             } else {
3657                 matches.push(match[0]);
3658             }
3659         }
3660
3661         for (var i = 0; i < values.length; ++i) {
3662             XRegExp.forEach(values[i], item.regex, addMatch);
3663         }
3664
3665         return ((level === chain.length - 1) || !matches.length) ?
3666             matches :
3667             recurseChain(matches, level + 1);
3668     }([str], 0));
3669 };
3670
3671 /**
3672  * Returns a new string with one or all matches of a pattern replaced. The pattern can be a string
3673  * or regex, and the replacement can be a string or a function to be called for each match. To
3674  * perform a global search and replace, use the optional `scope` argument or include flag g if using
3675  * a regex. Replacement strings can use `${n}` for named and numbered backreferences. Replacement
3676  * functions can use named backreferences via `arguments[0].name`. Also fixes browser bugs compared
3677  * to the native `String.prototype.replace` and can be used reliably cross-browser.
3678  *
3679  * @param {String} str String to search.
3680  * @param {RegExp|String} search Search pattern to be replaced.
3681  * @param {String|Function} replacement Replacement string or a function invoked to create it.
3682  *   Replacement strings can include special replacement syntax:
3683  *     <li>$$ - Inserts a literal $ character.
3684  *     <li>$&, $0 - Inserts the matched substring.
3685  *     <li>$` - Inserts the string that precedes the matched substring (left context).
3686  *     <li>$' - Inserts the string that follows the matched substring (right context).
3687  *     <li>$n, $nn - Where n/nn are digits referencing an existent capturing group, inserts
3688  *       backreference n/nn.
3689  *     <li>${n} - Where n is a name or any number of digits that reference an existent capturing
3690  *       group, inserts backreference n.
3691  *   Replacement functions are invoked with three or more arguments:
3692  *     <li>The matched substring (corresponds to $& above). Named backreferences are accessible as
3693  *       properties of this first argument.
3694  *     <li>0..n arguments, one for each backreference (corresponding to $1, $2, etc. above).
3695  *     <li>The zero-based index of the match within the total search string.
3696  *     <li>The total string being searched.
3697  * @param {String} [scope='one'] Use 'one' to replace the first match only, or 'all'. If not
3698  *   explicitly specified and using a regex with flag g, `scope` is 'all'.
3699  * @returns {String} New string with one or all matches replaced.
3700  * @example
3701  *
3702  * // Regex search, using named backreferences in replacement string
3703  * var name = XRegExp('(?<first>\\w+) (?<last>\\w+)');
3704  * XRegExp.replace('John Smith', name, '${last}, ${first}');
3705  * // -> 'Smith, John'
3706  *
3707  * // Regex search, using named backreferences in replacement function
3708  * XRegExp.replace('John Smith', name, function(match) {
3709  *   return match.last + ', ' + match.first;
3710  * });
3711  * // -> 'Smith, John'
3712  *
3713  * // String search, with replace-all
3714  * XRegExp.replace('RegExp builds RegExps', 'RegExp', 'XRegExp', 'all');
3715  * // -> 'XRegExp builds XRegExps'
3716  */
3717 XRegExp.replace = function(str, search, replacement, scope) {
3718     var isRegex = XRegExp.isRegExp(search),
3719         global = (search.global && scope !== 'one') || scope === 'all',
3720         cacheKey = ((global ? 'g' : '') + (search.sticky ? 'y' : '')) || 'noGY',
3721         s2 = search,
3722         result;
3723
3724     if (isRegex) {
3725         search[REGEX_DATA] = search[REGEX_DATA] || {};
3726
3727         // Shares cached copies with `XRegExp.exec`/`match`. Since a copy is used, `search`'s
3728         // `lastIndex` isn't updated *during* replacement iterations
3729         s2 = search[REGEX_DATA][cacheKey] || (
3730             search[REGEX_DATA][cacheKey] = copyRegex(search, {
3731                 addG: !!global,
3732                 removeG: scope === 'one',
3733                 isInternalOnly: true
3734             })
3735         );
3736     } else if (global) {
3737         s2 = new RegExp(XRegExp.escape(String(search)), 'g');
3738     }
3739
3740     // Fixed `replace` required for named backreferences, etc.
3741     result = fixed.replace.call(toObject(str), s2, replacement);
3742
3743     if (isRegex && search.global) {
3744         // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
3745         search.lastIndex = 0;
3746     }
3747
3748     return result;
3749 };
3750
3751 /**
3752  * Performs batch processing of string replacements. Used like `XRegExp.replace`, but accepts an
3753  * array of replacement details. Later replacements operate on the output of earlier replacements.
3754  * Replacement details are accepted as an array with a regex or string to search for, the
3755  * replacement string or function, and an optional scope of 'one' or 'all'. Uses the XRegExp
3756  * replacement text syntax, which supports named backreference properties via `${name}`.
3757  *
3758  * @param {String} str String to search.
3759  * @param {Array} replacements Array of replacement detail arrays.
3760  * @returns {String} New string with all replacements.
3761  * @example
3762  *
3763  * str = XRegExp.replaceEach(str, [
3764  *   [XRegExp('(?<name>a)'), 'z${name}'],
3765  *   [/b/gi, 'y'],
3766  *   [/c/g, 'x', 'one'], // scope 'one' overrides /g
3767  *   [/d/, 'w', 'all'],  // scope 'all' overrides lack of /g
3768  *   ['e', 'v', 'all'],  // scope 'all' allows replace-all for strings
3769  *   [/f/g, function($0) {
3770  *     return $0.toUpperCase();
3771  *   }]
3772  * ]);
3773  */
3774 XRegExp.replaceEach = function(str, replacements) {
3775     var i, r;
3776
3777     for (i = 0; i < replacements.length; ++i) {
3778         r = replacements[i];
3779         str = XRegExp.replace(str, r[0], r[1], r[2]);
3780     }
3781
3782     return str;
3783 };
3784
3785 /**
3786  * Splits a string into an array of strings using a regex or string separator. Matches of the
3787  * separator are not included in the result array. However, if `separator` is a regex that contains
3788  * capturing groups, backreferences are spliced into the result each time `separator` is matched.
3789  * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
3790  * cross-browser.
3791  *
3792  * @param {String} str String to split.
3793  * @param {RegExp|String} separator Regex or string to use for separating the string.
3794  * @param {Number} [limit] Maximum number of items to include in the result array.
3795  * @returns {Array} Array of substrings.
3796  * @example
3797  *
3798  * // Basic use
3799  * XRegExp.split('a b c', ' ');
3800  * // -> ['a', 'b', 'c']
3801  *
3802  * // With limit
3803  * XRegExp.split('a b c', ' ', 2);
3804  * // -> ['a', 'b']
3805  *
3806  * // Backreferences in result array
3807  * XRegExp.split('..word1..', /([a-z]+)(\d+)/i);
3808  * // -> ['..', 'word', '1', '..']
3809  */
3810 XRegExp.split = function(str, separator, limit) {
3811     return fixed.split.call(toObject(str), separator, limit);
3812 };
3813
3814 /**
3815  * Executes a regex search in a specified string. Returns `true` or `false`. Optional `pos` and
3816  * `sticky` arguments specify the search start position, and whether the match must start at the
3817  * specified position only. The `lastIndex` property of the provided regex is not used, but is
3818  * updated for compatibility. Also fixes browser bugs compared to the native
3819  * `RegExp.prototype.test` and can be used reliably cross-browser.
3820  *
3821  * @param {String} str String to search.
3822  * @param {RegExp} regex Regex to search with.
3823  * @param {Number} [pos=0] Zero-based index at which to start the search.
3824  * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
3825  *   only. The string `'sticky'` is accepted as an alternative to `true`.
3826  * @returns {Boolean} Whether the regex matched the provided value.
3827  * @example
3828  *
3829  * // Basic use
3830  * XRegExp.test('abc', /c/); // -> true
3831  *
3832  * // With pos and sticky
3833  * XRegExp.test('abc', /c/, 0, 'sticky'); // -> false
3834  * XRegExp.test('abc', /c/, 2, 'sticky'); // -> true
3835  */
3836 XRegExp.test = function(str, regex, pos, sticky) {
3837     // Do this the easy way :-)
3838     return !!XRegExp.exec(str, regex, pos, sticky);
3839 };
3840
3841 /**
3842  * Uninstalls optional features according to the specified options. All optional features start out
3843  * uninstalled, so this is used to undo the actions of `XRegExp.install`.
3844  *
3845  * @param {Object|String} options Options object or string.
3846  * @example
3847  *
3848  * // With an options object
3849  * XRegExp.uninstall({
3850  *   // Disables support for astral code points in Unicode addons
3851  *   astral: true,
3852  *
3853  *   // DEPRECATED: Restores native regex methods
3854  *   natives: true
3855  * });
3856  *
3857  * // With an options string
3858  * XRegExp.uninstall('astral natives');
3859  */
3860 XRegExp.uninstall = function(options) {
3861     options = prepareOptions(options);
3862
3863     if (features.astral && options.astral) {
3864         setAstral(false);
3865     }
3866
3867     if (features.natives && options.natives) {
3868         setNatives(false);
3869     }
3870 };
3871
3872 /**
3873  * Returns an XRegExp object that is the union of the given patterns. Patterns can be provided as
3874  * regex objects or strings. Metacharacters are escaped in patterns provided as strings.
3875  * Backreferences in provided regex objects are automatically renumbered to work correctly within
3876  * the larger combined pattern. Native flags used by provided regexes are ignored in favor of the
3877  * `flags` argument.
3878  *
3879  * @param {Array} patterns Regexes and strings to combine.
3880  * @param {String} [flags] Any combination of XRegExp flags.
3881  * @returns {RegExp} Union of the provided regexes and strings.
3882  * @example
3883  *
3884  * XRegExp.union(['a+b*c', /(dogs)\1/, /(cats)\1/], 'i');
3885  * // -> /a\+b\*c|(dogs)\1|(cats)\2/i
3886  */
3887 XRegExp.union = function(patterns, flags) {
3888     var numCaptures = 0;
3889     var numPriorCaptures;
3890     var captureNames;
3891
3892     function rewrite(match, paren, backref) {
3893         var name = captureNames[numCaptures - numPriorCaptures];
3894
3895         // Capturing group
3896         if (paren) {
3897             ++numCaptures;
3898             // If the current capture has a name, preserve the name
3899             if (name) {
3900                 return '(?<' + name + '>';
3901             }
3902         // Backreference
3903         } else if (backref) {
3904             // Rewrite the backreference
3905             return '\\' + (+backref + numPriorCaptures);
3906         }
3907
3908         return match;
3909     }
3910
3911     if (!(isType(patterns, 'Array') && patterns.length)) {
3912         throw new TypeError('Must provide a nonempty array of patterns to merge');
3913     }
3914
3915     var parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g;
3916     var output = [];
3917     var pattern;
3918     for (var i = 0; i < patterns.length; ++i) {
3919         pattern = patterns[i];
3920
3921         if (XRegExp.isRegExp(pattern)) {
3922             numPriorCaptures = numCaptures;
3923             captureNames = (pattern[REGEX_DATA] && pattern[REGEX_DATA].captureNames) || [];
3924
3925             // Rewrite backreferences. Passing to XRegExp dies on octals and ensures patterns are
3926             // independently valid; helps keep this simple. Named captures are put back
3927             output.push(nativ.replace.call(XRegExp(pattern.source).source, parts, rewrite));
3928         } else {
3929             output.push(XRegExp.escape(pattern));
3930         }
3931     }
3932
3933     return XRegExp(output.join('|'), flags);
3934 };
3935
3936 // ==--------------------------==
3937 // Fixed/extended native methods
3938 // ==--------------------------==
3939
3940 /**
3941  * Adds named capture support (with backreferences returned as `result.name`), and fixes browser
3942  * bugs in the native `RegExp.prototype.exec`. Calling `XRegExp.install('natives')` uses this to
3943  * override the native method. Use via `XRegExp.exec` without overriding natives.
3944  *
3945  * @param {String} str String to search.
3946  * @returns {Array} Match array with named backreference properties, or `null`.
3947  */
3948 fixed.exec = function(str) {
3949     var origLastIndex = this.lastIndex,
3950         match = nativ.exec.apply(this, arguments),
3951         name,
3952         r2,
3953         i;
3954
3955     if (match) {
3956         // Fix browsers whose `exec` methods don't return `undefined` for nonparticipating capturing
3957         // groups. This fixes IE 5.5-8, but not IE 9's quirks mode or emulation of older IEs. IE 9
3958         // in standards mode follows the spec.
3959         if (!correctExecNpcg && match.length > 1 && indexOf(match, '') > -1) {
3960             r2 = copyRegex(this, {
3961                 removeG: true,
3962                 isInternalOnly: true
3963             });
3964             // Using `str.slice(match.index)` rather than `match[0]` in case lookahead allowed
3965             // matching due to characters outside the match
3966             nativ.replace.call(String(str).slice(match.index), r2, function() {
3967                 var len = arguments.length, i;
3968                 // Skip index 0 and the last 2
3969                 for (i = 1; i < len - 2; ++i) {
3970                     if (arguments[i] === undefined) {
3971                         match[i] = undefined;
3972                     }
3973                 }
3974             });
3975         }
3976
3977         // Attach named capture properties
3978         if (this[REGEX_DATA] && this[REGEX_DATA].captureNames) {
3979             // Skip index 0
3980             for (i = 1; i < match.length; ++i) {
3981                 name = this[REGEX_DATA].captureNames[i - 1];
3982                 if (name) {
3983                     match[name] = match[i];
3984                 }
3985             }
3986         }
3987
3988         // Fix browsers that increment `lastIndex` after zero-length matches
3989         if (this.global && !match[0].length && (this.lastIndex > match.index)) {
3990             this.lastIndex = match.index;
3991         }
3992     }
3993
3994     if (!this.global) {
3995         // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
3996         this.lastIndex = origLastIndex;
3997     }
3998
3999     return match;
4000 };
4001
4002 /**
4003  * Fixes browser bugs in the native `RegExp.prototype.test`. Calling `XRegExp.install('natives')`
4004  * uses this to override the native method.
4005  *
4006  * @param {String} str String to search.
4007  * @returns {Boolean} Whether the regex matched the provided value.
4008  */
4009 fixed.test = function(str) {
4010     // Do this the easy way :-)
4011     return !!fixed.exec.call(this, str);
4012 };
4013
4014 /**
4015  * Adds named capture support (with backreferences returned as `result.name`), and fixes browser
4016  * bugs in the native `String.prototype.match`. Calling `XRegExp.install('natives')` uses this to
4017  * override the native method.
4018  *
4019  * @param {RegExp|*} regex Regex to search with. If not a regex object, it is passed to `RegExp`.
4020  * @returns {Array} If `regex` uses flag g, an array of match strings or `null`. Without flag g,
4021  *   the result of calling `regex.exec(this)`.
4022  */
4023 fixed.match = function(regex) {
4024     var result;
4025
4026     if (!XRegExp.isRegExp(regex)) {
4027         // Use the native `RegExp` rather than `XRegExp`
4028         regex = new RegExp(regex);
4029     } else if (regex.global) {
4030         result = nativ.match.apply(this, arguments);
4031         // Fixes IE bug
4032         regex.lastIndex = 0;
4033
4034         return result;
4035     }
4036
4037     return fixed.exec.call(regex, toObject(this));
4038 };
4039
4040 /**
4041  * Adds support for `${n}` tokens for named and numbered backreferences in replacement text, and
4042  * provides named backreferences to replacement functions as `arguments[0].name`. Also fixes browser
4043  * bugs in replacement text syntax when performing a replacement using a nonregex search value, and
4044  * the value of a replacement regex's `lastIndex` property during replacement iterations and upon
4045  * completion. Calling `XRegExp.install('natives')` uses this to override the native method. Note
4046  * that this doesn't support SpiderMonkey's proprietary third (`flags`) argument. Use via
4047  * `XRegExp.replace` without overriding natives.
4048  *
4049  * @param {RegExp|String} search Search pattern to be replaced.
4050  * @param {String|Function} replacement Replacement string or a function invoked to create it.
4051  * @returns {String} New string with one or all matches replaced.
4052  */
4053 fixed.replace = function(search, replacement) {
4054     var isRegex = XRegExp.isRegExp(search),
4055         origLastIndex,
4056         captureNames,
4057         result;
4058
4059     if (isRegex) {
4060         if (search[REGEX_DATA]) {
4061             captureNames = search[REGEX_DATA].captureNames;
4062         }
4063         // Only needed if `search` is nonglobal
4064         origLastIndex = search.lastIndex;
4065     } else {
4066         search += ''; // Type-convert
4067     }
4068
4069     // Don't use `typeof`; some older browsers return 'function' for regex objects
4070     if (isType(replacement, 'Function')) {
4071         // Stringifying `this` fixes a bug in IE < 9 where the last argument in replacement
4072         // functions isn't type-converted to a string
4073         result = nativ.replace.call(String(this), search, function() {
4074             var args = arguments, i;
4075             if (captureNames) {
4076                 // Change the `arguments[0]` string primitive to a `String` object that can store
4077                 // properties. This really does need to use `String` as a constructor
4078                 args[0] = new String(args[0]);
4079                 // Store named backreferences on the first argument
4080                 for (i = 0; i < captureNames.length; ++i) {
4081                     if (captureNames[i]) {
4082                         args[0][captureNames[i]] = args[i + 1];
4083                     }
4084                 }
4085             }
4086             // Update `lastIndex` before calling `replacement`. Fixes IE, Chrome, Firefox, Safari
4087             // bug (last tested IE 9, Chrome 17, Firefox 11, Safari 5.1)
4088             if (isRegex && search.global) {
4089                 search.lastIndex = args[args.length - 2] + args[0].length;
4090             }
4091             // ES6 specs the context for replacement functions as `undefined`
4092             return replacement.apply(undefined, args);
4093         });
4094     } else {
4095         // Ensure that the last value of `args` will be a string when given nonstring `this`,
4096         // while still throwing on null or undefined context
4097         result = nativ.replace.call(this == null ? this : String(this), search, function() {
4098             // Keep this function's `arguments` available through closure
4099             var args = arguments;
4100             return nativ.replace.call(String(replacement), replacementToken, function($0, $1, $2) {
4101                 var n;
4102                 // Named or numbered backreference with curly braces
4103                 if ($1) {
4104                     // XRegExp behavior for `${n}`:
4105                     // 1. Backreference to numbered capture, if `n` is an integer. Use `0` for the
4106                     //    entire match. Any number of leading zeros may be used.
4107                     // 2. Backreference to named capture `n`, if it exists and is not an integer
4108                     //    overridden by numbered capture. In practice, this does not overlap with
4109                     //    numbered capture since XRegExp does not allow named capture to use a bare
4110                     //    integer as the name.
4111                     // 3. If the name or number does not refer to an existing capturing group, it's
4112                     //    an error.
4113                     n = +$1; // Type-convert; drop leading zeros
4114                     if (n <= args.length - 3) {
4115                         return args[n] || '';
4116                     }
4117                     // Groups with the same name is an error, else would need `lastIndexOf`
4118                     n = captureNames ? indexOf(captureNames, $1) : -1;
4119                     if (n < 0) {
4120                         throw new SyntaxError('Backreference to undefined group ' + $0);
4121                     }
4122                     return args[n + 1] || '';
4123                 }
4124                 // Else, special variable or numbered backreference without curly braces
4125                 if ($2 === '$') { // $$
4126                     return '$';
4127                 }
4128                 if ($2 === '&' || +$2 === 0) { // $&, $0 (not followed by 1-9), $00
4129                     return args[0];
4130                 }
4131                 if ($2 === '`') { // $` (left context)
4132                     return args[args.length - 1].slice(0, args[args.length - 2]);
4133                 }
4134                 if ($2 === "'") { // $' (right context)
4135                     return args[args.length - 1].slice(args[args.length - 2] + args[0].length);
4136                 }
4137                 // Else, numbered backreference without curly braces
4138                 $2 = +$2; // Type-convert; drop leading zero
4139                 // XRegExp behavior for `$n` and `$nn`:
4140                 // - Backrefs end after 1 or 2 digits. Use `${..}` for more digits.
4141                 // - `$1` is an error if no capturing groups.
4142                 // - `$10` is an error if less than 10 capturing groups. Use `${1}0` instead.
4143                 // - `$01` is `$1` if at least one capturing group, else it's an error.
4144                 // - `$0` (not followed by 1-9) and `$00` are the entire match.
4145                 // Native behavior, for comparison:
4146                 // - Backrefs end after 1 or 2 digits. Cannot reference capturing group 100+.
4147                 // - `$1` is a literal `$1` if no capturing groups.
4148                 // - `$10` is `$1` followed by a literal `0` if less than 10 capturing groups.
4149                 // - `$01` is `$1` if at least one capturing group, else it's a literal `$01`.
4150                 // - `$0` is a literal `$0`.
4151                 if (!isNaN($2)) {
4152                     if ($2 > args.length - 3) {
4153                         throw new SyntaxError('Backreference to undefined group ' + $0);
4154                     }
4155                     return args[$2] || '';
4156                 }
4157                 // `$` followed by an unsupported char is an error, unlike native JS
4158                 throw new SyntaxError('Invalid token ' + $0);
4159             });
4160         });
4161     }
4162
4163     if (isRegex) {
4164         if (search.global) {
4165             // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
4166             search.lastIndex = 0;
4167         } else {
4168             // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
4169             search.lastIndex = origLastIndex;
4170         }
4171     }
4172
4173     return result;
4174 };
4175
4176 /**
4177  * Fixes browser bugs in the native `String.prototype.split`. Calling `XRegExp.install('natives')`
4178  * uses this to override the native method. Use via `XRegExp.split` without overriding natives.
4179  *
4180  * @param {RegExp|String} separator Regex or string to use for separating the string.
4181  * @param {Number} [limit] Maximum number of items to include in the result array.
4182  * @returns {Array} Array of substrings.
4183  */
4184 fixed.split = function(separator, limit) {
4185     if (!XRegExp.isRegExp(separator)) {
4186         // Browsers handle nonregex split correctly, so use the faster native method
4187         return nativ.split.apply(this, arguments);
4188     }
4189
4190     var str = String(this),
4191         output = [],
4192         origLastIndex = separator.lastIndex,
4193         lastLastIndex = 0,
4194         lastLength;
4195
4196     // Values for `limit`, per the spec:
4197     // If undefined: pow(2,32) - 1
4198     // If 0, Infinity, or NaN: 0
4199     // If positive number: limit = floor(limit); if (limit >= pow(2,32)) limit -= pow(2,32);
4200     // If negative number: pow(2,32) - floor(abs(limit))
4201     // If other: Type-convert, then use the above rules
4202     // This line fails in very strange ways for some values of `limit` in Opera 10.5-10.63, unless
4203     // Opera Dragonfly is open (go figure). It works in at least Opera 9.5-10.1 and 11+
4204     limit = (limit === undefined ? -1 : limit) >>> 0;
4205
4206     XRegExp.forEach(str, separator, function(match) {
4207         // This condition is not the same as `if (match[0].length)`
4208         if ((match.index + match[0].length) > lastLastIndex) {
4209             output.push(str.slice(lastLastIndex, match.index));
4210             if (match.length > 1 && match.index < str.length) {
4211                 Array.prototype.push.apply(output, match.slice(1));
4212             }
4213             lastLength = match[0].length;
4214             lastLastIndex = match.index + lastLength;
4215         }
4216     });
4217
4218     if (lastLastIndex === str.length) {
4219         if (!nativ.test.call(separator, '') || lastLength) {
4220             output.push('');
4221         }
4222     } else {
4223         output.push(str.slice(lastLastIndex));
4224     }
4225
4226     separator.lastIndex = origLastIndex;
4227     return output.length > limit ? output.slice(0, limit) : output;
4228 };
4229
4230 // ==--------------------------==
4231 // Built-in syntax/flag tokens
4232 // ==--------------------------==
4233
4234 /*
4235  * Letter escapes that natively match literal characters: `\a`, `\A`, etc. These should be
4236  * SyntaxErrors but are allowed in web reality. XRegExp makes them errors for cross-browser
4237  * consistency and to reserve their syntax, but lets them be superseded by addons.
4238  */
4239 XRegExp.addToken(
4240     /\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4}|{[\dA-Fa-f]+})|x(?![\dA-Fa-f]{2}))/,
4241     function(match, scope) {
4242         // \B is allowed in default scope only
4243         if (match[1] === 'B' && scope === defaultScope) {
4244             return match[0];
4245         }
4246         throw new SyntaxError('Invalid escape ' + match[0]);
4247     },
4248     {
4249         scope: 'all',
4250         leadChar: '\\'
4251     }
4252 );
4253
4254 /*
4255  * Unicode code point escape with curly braces: `\u{N..}`. `N..` is any one or more digit
4256  * hexadecimal number from 0-10FFFF, and can include leading zeros. Requires the native ES6 `u` flag
4257  * to support code points greater than U+FFFF. Avoids converting code points above U+FFFF to
4258  * surrogate pairs (which could be done without flag `u`), since that could lead to broken behavior
4259  * if you follow a `\u{N..}` token that references a code point above U+FFFF with a quantifier, or
4260  * if you use the same in a character class.
4261  */
4262 XRegExp.addToken(
4263     /\\u{([\dA-Fa-f]+)}/,
4264     function(match, scope, flags) {
4265         var code = dec(match[1]);
4266         if (code > 0x10FFFF) {
4267             throw new SyntaxError('Invalid Unicode code point ' + match[0]);
4268         }
4269         if (code <= 0xFFFF) {
4270             // Converting to \uNNNN avoids needing to escape the literal character and keep it
4271             // separate from preceding tokens
4272             return '\\u' + pad4(hex(code));
4273         }
4274         // If `code` is between 0xFFFF and 0x10FFFF, require and defer to native handling
4275         if (hasNativeU && flags.indexOf('u') > -1) {
4276             return match[0];
4277         }
4278         throw new SyntaxError('Cannot use Unicode code point above \\u{FFFF} without flag u');
4279     },
4280     {
4281         scope: 'all',
4282         leadChar: '\\'
4283     }
4284 );
4285
4286 /*
4287  * Empty character class: `[]` or `[^]`. This fixes a critical cross-browser syntax inconsistency.
4288  * Unless this is standardized (per the ES spec), regex syntax can't be accurately parsed because
4289  * character class endings can't be determined.
4290  */
4291 XRegExp.addToken(
4292     /\[(\^?)]/,
4293     function(match) {
4294         // For cross-browser compatibility with ES3, convert [] to \b\B and [^] to [\s\S].
4295         // (?!) should work like \b\B, but is unreliable in some versions of Firefox
4296         return match[1] ? '[\\s\\S]' : '\\b\\B';
4297     },
4298     {leadChar: '['}
4299 );
4300
4301 /*
4302  * Comment pattern: `(?# )`. Inline comments are an alternative to the line comments allowed in
4303  * free-spacing mode (flag x).
4304  */
4305 XRegExp.addToken(
4306     /\(\?#[^)]*\)/,
4307     function(match, scope, flags) {
4308         // Keep tokens separated unless the following token is a quantifier. This avoids e.g.
4309         // inadvertedly changing `\1(?#)1` to `\11`.
4310         return isQuantifierNext(match.input, match.index + match[0].length, flags) ?
4311             '' : '(?:)';
4312     },
4313     {leadChar: '('}
4314 );
4315
4316 /*
4317  * Whitespace and line comments, in free-spacing mode (aka extended mode, flag x) only.
4318  */
4319 XRegExp.addToken(
4320     /\s+|#[^\n]*\n?/,
4321     function(match, scope, flags) {
4322         // Keep tokens separated unless the following token is a quantifier. This avoids e.g.
4323         // inadvertedly changing `\1 1` to `\11`.
4324         return isQuantifierNext(match.input, match.index + match[0].length, flags) ?
4325             '' : '(?:)';
4326     },
4327     {flag: 'x'}
4328 );
4329
4330 /*
4331  * Dot, in dotall mode (aka singleline mode, flag s) only.
4332  */
4333 XRegExp.addToken(
4334     /\./,
4335     function() {
4336         return '[\\s\\S]';
4337     },
4338     {
4339         flag: 's',
4340         leadChar: '.'
4341     }
4342 );
4343
4344 /*
4345  * Named backreference: `\k<name>`. Backreference names can use the characters A-Z, a-z, 0-9, _,
4346  * and $ only. Also allows numbered backreferences as `\k<n>`.
4347  */
4348 XRegExp.addToken(
4349     /\\k<([\w$]+)>/,
4350     function(match) {
4351         // Groups with the same name is an error, else would need `lastIndexOf`
4352         var index = isNaN(match[1]) ? (indexOf(this.captureNames, match[1]) + 1) : +match[1],
4353             endIndex = match.index + match[0].length;
4354         if (!index || index > this.captureNames.length) {
4355             throw new SyntaxError('Backreference to undefined group ' + match[0]);
4356         }
4357         // Keep backreferences separate from subsequent literal numbers. This avoids e.g.
4358         // inadvertedly changing `(?<n>)\k<n>1` to `()\11`.
4359         return '\\' + index + (
4360             endIndex === match.input.length || isNaN(match.input.charAt(endIndex)) ?
4361                 '' : '(?:)'
4362         );
4363     },
4364     {leadChar: '\\'}
4365 );
4366
4367 /*
4368  * Numbered backreference or octal, plus any following digits: `\0`, `\11`, etc. Octals except `\0`
4369  * not followed by 0-9 and backreferences to unopened capture groups throw an error. Other matches
4370  * are returned unaltered. IE < 9 doesn't support backreferences above `\99` in regex syntax.
4371  */
4372 XRegExp.addToken(
4373     /\\(\d+)/,
4374     function(match, scope) {
4375         if (
4376             !(
4377                 scope === defaultScope &&
4378                 /^[1-9]/.test(match[1]) &&
4379                 +match[1] <= this.captureNames.length
4380             ) &&
4381             match[1] !== '0'
4382         ) {
4383             throw new SyntaxError('Cannot use octal escape or backreference to undefined group ' +
4384                 match[0]);
4385         }
4386         return match[0];
4387     },
4388     {
4389         scope: 'all',
4390         leadChar: '\\'
4391     }
4392 );
4393
4394 /*
4395  * Named capturing group; match the opening delimiter only: `(?<name>`. Capture names can use the
4396  * characters A-Z, a-z, 0-9, _, and $ only. Names can't be integers. Supports Python-style
4397  * `(?P<name>` as an alternate syntax to avoid issues in some older versions of Opera which natively
4398  * supported the Python-style syntax. Otherwise, XRegExp might treat numbered backreferences to
4399  * Python-style named capture as octals.
4400  */
4401 XRegExp.addToken(
4402     /\(\?P?<([\w$]+)>/,
4403     function(match) {
4404         // Disallow bare integers as names because named backreferences are added to match arrays
4405         // and therefore numeric properties may lead to incorrect lookups
4406         if (!isNaN(match[1])) {
4407             throw new SyntaxError('Cannot use integer as capture name ' + match[0]);
4408         }
4409         if (match[1] === 'length' || match[1] === '__proto__') {
4410             throw new SyntaxError('Cannot use reserved word as capture name ' + match[0]);
4411         }
4412         if (indexOf(this.captureNames, match[1]) > -1) {
4413             throw new SyntaxError('Cannot use same name for multiple groups ' + match[0]);
4414         }
4415         this.captureNames.push(match[1]);
4416         this.hasNamedCapture = true;
4417         return '(';
4418     },
4419     {leadChar: '('}
4420 );
4421
4422 /*
4423  * Capturing group; match the opening parenthesis only. Required for support of named capturing
4424  * groups. Also adds explicit capture mode (flag n).
4425  */
4426 XRegExp.addToken(
4427     /\((?!\?)/,
4428     function(match, scope, flags) {
4429         if (flags.indexOf('n') > -1) {
4430             return '(?:';
4431         }
4432         this.captureNames.push(null);
4433         return '(';
4434     },
4435     {
4436         optionalFlags: 'n',
4437         leadChar: '('
4438     }
4439 );
4440
4441 module.exports = XRegExp;
4442
4443 },{}]},{},[8])(8)
4444 });