You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					51 lines
				
				2.2 KiB
			
		
		
			
		
	
	
					51 lines
				
				2.2 KiB
			| 
								 
											3 years ago
										 
									 | 
							
								var _typeof = require("./typeof.js")["default"];
							 | 
						||
| 
								 | 
							
								var setPrototypeOf = require("./setPrototypeOf.js");
							 | 
						||
| 
								 | 
							
								var inherits = require("./inherits.js");
							 | 
						||
| 
								 | 
							
								function _wrapRegExp() {
							 | 
						||
| 
								 | 
							
								  module.exports = _wrapRegExp = function _wrapRegExp(re, groups) {
							 | 
						||
| 
								 | 
							
								    return new BabelRegExp(re, void 0, groups);
							 | 
						||
| 
								 | 
							
								  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
							 | 
						||
| 
								 | 
							
								  var _super = RegExp.prototype,
							 | 
						||
| 
								 | 
							
								    _groups = new WeakMap();
							 | 
						||
| 
								 | 
							
								  function BabelRegExp(re, flags, groups) {
							 | 
						||
| 
								 | 
							
								    var _this = new RegExp(re, flags);
							 | 
						||
| 
								 | 
							
								    return _groups.set(_this, groups || _groups.get(re)), setPrototypeOf(_this, BabelRegExp.prototype);
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								  function buildGroups(result, re) {
							 | 
						||
| 
								 | 
							
								    var g = _groups.get(re);
							 | 
						||
| 
								 | 
							
								    return Object.keys(g).reduce(function (groups, name) {
							 | 
						||
| 
								 | 
							
								      var i = g[name];
							 | 
						||
| 
								 | 
							
								      if ("number" == typeof i) groups[name] = result[i];else {
							 | 
						||
| 
								 | 
							
								        for (var k = 0; void 0 === result[i[k]] && k + 1 < i.length;) k++;
							 | 
						||
| 
								 | 
							
								        groups[name] = result[i[k]];
							 | 
						||
| 
								 | 
							
								      }
							 | 
						||
| 
								 | 
							
								      return groups;
							 | 
						||
| 
								 | 
							
								    }, Object.create(null));
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								  return inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) {
							 | 
						||
| 
								 | 
							
								    var result = _super.exec.call(this, str);
							 | 
						||
| 
								 | 
							
								    if (result) {
							 | 
						||
| 
								 | 
							
								      result.groups = buildGroups(result, this);
							 | 
						||
| 
								 | 
							
								      var indices = result.indices;
							 | 
						||
| 
								 | 
							
								      indices && (indices.groups = buildGroups(indices, this));
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								    return result;
							 | 
						||
| 
								 | 
							
								  }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
							 | 
						||
| 
								 | 
							
								    if ("string" == typeof substitution) {
							 | 
						||
| 
								 | 
							
								      var groups = _groups.get(this);
							 | 
						||
| 
								 | 
							
								      return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
							 | 
						||
| 
								 | 
							
								        var group = groups[name];
							 | 
						||
| 
								 | 
							
								        return "$" + (Array.isArray(group) ? group.join("$") : group);
							 | 
						||
| 
								 | 
							
								      }));
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								    if ("function" == typeof substitution) {
							 | 
						||
| 
								 | 
							
								      var _this = this;
							 | 
						||
| 
								 | 
							
								      return _super[Symbol.replace].call(this, str, function () {
							 | 
						||
| 
								 | 
							
								        var args = arguments;
							 | 
						||
| 
								 | 
							
								        return "object" != _typeof(args[args.length - 1]) && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args);
							 | 
						||
| 
								 | 
							
								      });
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								    return _super[Symbol.replace].call(this, str, substitution);
							 | 
						||
| 
								 | 
							
								  }, _wrapRegExp.apply(this, arguments);
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								module.exports = _wrapRegExp, module.exports.__esModule = true, module.exports["default"] = module.exports;
							 |