prepack/lib/intrinsics/ecma262/RegExp.js

Execute a JS bundle, serialize global state and side effects to a snapshot that can be quickly restored.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = _default;

var _index = require("../../values/index.js");

var _is = require("../../methods/is.js");

var _get = require("../../methods/get.js");

var _abstract = require("../../methods/abstract.js");

var _regexp = require("../../methods/regexp.js");

var _invariant = _interopRequireDefault(require("../../invariant.js"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Copyright (c) 2017-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

/*  strict-local */
function _default(realm) {
  let func = new _index.NativeFunctionValue(realm, "RegExp", "RegExp", 2, (context, [pattern, flags], argCount, NewTarget) => {
    // 1. Let patternIsRegExp be ? IsRegExp(pattern).
    let patternIsRegExp = (0, _is.IsRegExp)(realm, pattern);
    let newTarget; // 2. If NewTarget is not undefined, let newTarget be NewTarget.

    if (NewTarget) {
      newTarget = NewTarget;
    } else {
      // 3. Else,
      // a. Let newTarget be the active function object.
      newTarget = func; // b. If patternIsRegExp is true and flags is undefined, then

      if (patternIsRegExp && flags instanceof _index.UndefinedValue) {
        (0, _invariant.default)(pattern instanceof _index.ObjectValue); // i. Let patternConstructor be ? Get(pattern, "constructor").

        let patternConstructor = (0, _get.Get)(realm, pattern, "constructor"); // ii. If SameValue(newTarget, patternConstructor) is true, return pattern.

        if ((0, _abstract.SameValuePartial)(realm, newTarget, patternConstructor)) {
          return pattern;
        }
      }
    }

    let P, F; // 4. If Type(pattern) is Object and pattern has a [[RegExpMatcher]] internal slot, then

    if (pattern instanceof _index.ObjectValue && pattern.$RegExpMatcher) {
      // a. Let P be the value of pattern's [[OriginalSource]] internal slot.
      (0, _invariant.default)(typeof pattern.$OriginalSource === "string");
      P = new _index.StringValue(realm, pattern.$OriginalSource); // b. If flags is undefined, let F be the value of pattern's [[OriginalFlags]] internal slot.

      if (flags instanceof _index.UndefinedValue) {
        (0, _invariant.default)(typeof pattern.$OriginalFlags === "string");
        F = new _index.StringValue(realm, pattern.$OriginalFlags);
      } else {
        // c. Else, let F be flags.
        F = flags.throwIfNotConcrete();
      }
    } else if (patternIsRegExp) {
      // 5. Else if patternIsRegExp is true, then
      (0, _invariant.default)(pattern instanceof _index.ObjectValue); // a. Let P be ? Get(pattern, "source").

      P = (0, _get.Get)(realm, pattern, "source"); // b. If flags is undefined, then

      if (flags instanceof _index.UndefinedValue) {
        // i. Let F be ? Get(pattern, "flags").
        F = (0, _get.Get)(realm, pattern, "flags");
      } else {
        // c. Else, let F be flags.
        F = flags.throwIfNotConcrete();
      }
    } else {
      // 6. Else,
      // a. Let P be pattern.
      P = pattern.throwIfNotConcrete(); // b. Let F be flags.

      F = flags.throwIfNotConcrete();
    } // 7. Let O be ? RegExpAlloc(newTarget).


    let O = (0, _regexp.RegExpAlloc)(realm, newTarget); // 8. Return ? RegExpInitialize(O, P, F).

    return (0, _regexp.RegExpInitialize)(realm, O, P, F);
  }); // ECMA262 21.2.4.2

  func.defineNativeGetter(realm.intrinsics.SymbolSpecies, context => {
    // 1. Return the this value
    return context;
  });
  return func;
}
//# sourceMappingURL=RegExp.js.map