.config/coc/extensions/node_modules/coc-prettier/node_modules/core-js/modules/es.regexp.constructor.js

   1 var DESCRIPTORS = require('../internals/descriptors');
   2 var global = require('../internals/global');
   3 var uncurryThis = require('../internals/function-uncurry-this');
   4 var isForced = require('../internals/is-forced');
   5 var inheritIfRequired = require('../internals/inherit-if-required');
   6 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
   7 var defineProperty = require('../internals/object-define-property').f;
   8 var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
   9 var isPrototypeOf = require('../internals/object-is-prototype-of');
  10 var isRegExp = require('../internals/is-regexp');
  11 var toString = require('../internals/to-string');
  12 var regExpFlags = require('../internals/regexp-flags');
  13 var stickyHelpers = require('../internals/regexp-sticky-helpers');
  14 var redefine = require('../internals/redefine');
  15 var fails = require('../internals/fails');
  16 var hasOwn = require('../internals/has-own-property');
  17 var enforceInternalState = require('../internals/internal-state').enforce;
  18 var setSpecies = require('../internals/set-species');
  19 var wellKnownSymbol = require('../internals/well-known-symbol');
  20 var UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');
  21 var UNSUPPORTED_NCG = require('../internals/regexp-unsupported-ncg');
  22
  23 var MATCH = wellKnownSymbol('match');
  24 var NativeRegExp = global.RegExp;
  25 var RegExpPrototype = NativeRegExp.prototype;
  26 var SyntaxError = global.SyntaxError;
  27 var getFlags = uncurryThis(regExpFlags);
  28 var exec = uncurryThis(RegExpPrototype.exec);
  29 var charAt = uncurryThis(''.charAt);
  30 var replace = uncurryThis(''.replace);
  31 var stringIndexOf = uncurryThis(''.indexOf);
  32 var stringSlice = uncurryThis(''.slice);
  33 // TODO: Use only propper RegExpIdentifierName
  34 var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/;
  35 var re1 = /a/g;
  36 var re2 = /a/g;
  37
  38 // "new" should create a new object, old webkit bug
  39 var CORRECT_NEW = new NativeRegExp(re1) !== re1;
  40
  41 var MISSED_STICKY = stickyHelpers.MISSED_STICKY;
  42 var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
  43
  44 var BASE_FORCED = DESCRIPTORS &&
  45   (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || fails(function () {
  46     re2[MATCH] = false;
  47     // RegExp constructor can alter flags and IsRegExp works correct with @@match
  48     return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';
  49   }));
  50
  51 var handleDotAll = function (string) {
  52   var length = string.length;
  53   var index = 0;
  54   var result = '';
  55   var brackets = false;
  56   var chr;
  57   for (; index <= length; index++) {
  58     chr = charAt(string, index);
  59     if (chr === '\\') {
  60       result += chr + charAt(string, ++index);
  61       continue;
  62     }
  63     if (!brackets && chr === '.') {
  64       result += '[\\s\\S]';
  65     } else {
  66       if (chr === '[') {
  67         brackets = true;
  68       } else if (chr === ']') {
  69         brackets = false;
  70       } result += chr;
  71     }
  72   } return result;
  73 };
  74
  75 var handleNCG = function (string) {
  76   var length = string.length;
  77   var index = 0;
  78   var result = '';
  79   var named = [];
  80   var names = {};
  81   var brackets = false;
  82   var ncg = false;
  83   var groupid = 0;
  84   var groupname = '';
  85   var chr;
  86   for (; index <= length; index++) {
  87     chr = charAt(string, index);
  88     if (chr === '\\') {
  89       chr = chr + charAt(string, ++index);
  90     } else if (chr === ']') {
  91       brackets = false;
  92     } else if (!brackets) switch (true) {
  93       case chr === '[':
  94         brackets = true;
  95         break;
  96       case chr === '(':
  97         if (exec(IS_NCG, stringSlice(string, index + 1))) {
  98           index += 2;
  99           ncg = true;
 100         }
 101         result += chr;
 102         groupid++;
 103         continue;
 104       case chr === '>' && ncg:
 105         if (groupname === '' || hasOwn(names, groupname)) {
 106           throw new SyntaxError('Invalid capture group name');
 107         }
 108         names[groupname] = true;
 109         named[named.length] = [groupname, groupid];
 110         ncg = false;
 111         groupname = '';
 112         continue;
 113     }
 114     if (ncg) groupname += chr;
 115     else result += chr;
 116   } return [result, named];
 117 };
 118
 119 // `RegExp` constructor
 120 // https://tc39.es/ecma262/#sec-regexp-constructor
 121 if (isForced('RegExp', BASE_FORCED)) {
 122   var RegExpWrapper = function RegExp(pattern, flags) {
 123     var thisIsRegExp = isPrototypeOf(RegExpPrototype, this);
 124     var patternIsRegExp = isRegExp(pattern);
 125     var flagsAreUndefined = flags === undefined;
 126     var groups = [];
 127     var rawPattern = pattern;
 128     var rawFlags, dotAll, sticky, handled, result, state;
 129
 130     if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) {
 131       return pattern;
 132     }
 133
 134     if (patternIsRegExp || isPrototypeOf(RegExpPrototype, pattern)) {
 135       pattern = pattern.source;
 136       if (flagsAreUndefined) flags = 'flags' in rawPattern ? rawPattern.flags : getFlags(rawPattern);
 137     }
 138
 139     pattern = pattern === undefined ? '' : toString(pattern);
 140     flags = flags === undefined ? '' : toString(flags);
 141     rawPattern = pattern;
 142
 143     if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) {
 144       dotAll = !!flags && stringIndexOf(flags, 's') > -1;
 145       if (dotAll) flags = replace(flags, /s/g, '');
 146     }
 147
 148     rawFlags = flags;
 149
 150     if (MISSED_STICKY && 'sticky' in re1) {
 151       sticky = !!flags && stringIndexOf(flags, 'y') > -1;
 152       if (sticky && UNSUPPORTED_Y) flags = replace(flags, /y/g, '');
 153     }
 154
 155     if (UNSUPPORTED_NCG) {
 156       handled = handleNCG(pattern);
 157       pattern = handled[0];
 158       groups = handled[1];
 159     }
 160
 161     result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype, RegExpWrapper);
 162
 163     if (dotAll || sticky || groups.length) {
 164       state = enforceInternalState(result);
 165       if (dotAll) {
 166         state.dotAll = true;
 167         state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);
 168       }
 169       if (sticky) state.sticky = true;
 170       if (groups.length) state.groups = groups;
 171     }
 172
 173     if (pattern !== rawPattern) try {
 174       // fails in old engines, but we have no alternatives for unsupported regex syntax
 175       createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);
 176     } catch (error) { /* empty */ }
 177
 178     return result;
 179   };
 180
 181   var proxy = function (key) {
 182     key in RegExpWrapper || defineProperty(RegExpWrapper, key, {
 183       configurable: true,
 184       get: function () { return NativeRegExp[key]; },
 185       set: function (it) { NativeRegExp[key] = it; }
 186     });
 187   };
 188
 189   for (var keys = getOwnPropertyNames(NativeRegExp), index = 0; keys.length > index;) {
 190     proxy(keys[index++]);
 191   }
 192
 193   RegExpPrototype.constructor = RegExpWrapper;
 194   RegExpWrapper.prototype = RegExpPrototype;
 195   redefine(global, 'RegExp', RegExpWrapper);
 196 }
 197
 198 // https://tc39.es/ecma262/#sec-get-regexp-@@species
 199 setSpecies('RegExp');