SSL RegExp.js

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// https://github.com/tc39/ecma262/pull/2418 22.2.6.4 get RegExp.prototype.flags
// https://arai-a.github.io/ecma262-compare/?pr=2418&id=sec-get-regexp.prototype.flags
// Uncloned functions with `$` prefix are allocated as extended function
// to store the original name in `SetCanonicalName`.
function $RegExpFlagsGetter() {
  // Steps 1-2.
  var R = this;
  if (!IsObject(R)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, R === null ? "null" : typeof R);
  }

  // Step 3.
  var result = "";

  // Steps 4-5.
  if (R.hasIndices) {
    result += "d";
  }

  // Steps 6-7.
  if (R.global) {
    result += "g";
  }

  // Steps 8-9.
  if (R.ignoreCase) {
    result += "i";
  }

  // Steps 10-11.
  if (R.multiline) {
    result += "m";
  }

  // Steps 12-13.
  if (R.dotAll) {
    result += "s";
  }

  // Steps 14-15.
  if (R.unicode) {
    result += "u";
  }

  // Steps 16-17.
  if (R.unicodeSets) {
    result += "v";
  }

  // Steps 18-19
  if (R.sticky) {
    result += "y";
  }

  // Step 20.
  return result;
}
SetCanonicalName($RegExpFlagsGetter, "get flags");

// ES 2017 draft 40edb3a95a475c1b251141ac681b8793129d9a6d 21.2.5.14.
function $RegExpToString() {
  // Step 1.
  var R = this;

  // Step 2.
  if (!IsObject(R)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, R === null ? "null" : typeof R);
  }

  // Step 3.
  var pattern = ToString(R.source);

  // Step 4.
  var flags = ToString(R.flags);

  // Steps 5-6.
  return "/" + pattern + "/" + flags;
}
SetCanonicalName($RegExpToString, "toString");

// ES 2016 draft Mar 25, 2016 21.2.5.2.3.
function AdvanceStringIndex(S, index) {
  // Step 1.
  assert(typeof S === "string", "Expected string as 1st argument");

  // Step 2.
  assert(
    index >= 0 && index <= MAX_NUMERIC_INDEX,
    "Expected integer as 2nd argument"
  );

  // Step 3 (skipped).

  // Step 4 (skipped).

  // Steps 5-11.
  var supplementary = (
    index < S.length &&
    callFunction(std_String_codePointAt, S, index) > 0xffff
  );
  return index + 1 + supplementary;
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.8 RegExp.prototype [ @@match ] ( string )
function RegExpMatch(string) {
  // Step 1.
  var rx = this;

  // Step 2.
  if (!IsObject(rx)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, rx === null ? "null" : typeof rx);
  }

  // Step 3.
  var S = ToString(string);

  // Optimized paths for simple cases.
  if (IsOptimizableRegExpObject(rx)) {
    // Step 4.
    var flags = UnsafeGetInt32FromReservedSlot(rx, REGEXP_FLAGS_SLOT);
    var global = !!(flags & REGEXP_GLOBAL_FLAG);

    if (global) {
      // Step 6.a.
      var fullUnicode = !!(flags & REGEXP_ANY_UNICODE_MASK);

      // Steps 6.b-e.
      return RegExpGlobalMatchOpt(rx, S, fullUnicode);
    }

    // Step 5.
    return RegExpBuiltinExec(rx, S);
  }

  // Stes 4-6
  return RegExpMatchSlowPath(rx, S);
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.8 RegExp.prototype [ @@match ] ( string )
// Steps 4-6
function RegExpMatchSlowPath(rx, S) {
  // Step 4.
  var flags = ToString(rx.flags);

  // Step 5.
  if (!callFunction(std_String_includes, flags, "g")) {
    return RegExpExec(rx, S);
  }

  // Step 6.a.
  var fullUnicode = callFunction(std_String_includes, flags, "u") || callFunction(std_String_includes, flags, "v");

  // Step 6.b.
  rx.lastIndex = 0;

  // Step 6.c.
  var A = [];

  // Step 6.d.
  var n = 0;

  // Step 6.e.
  while (true) {
    // Step 6.e.i.
    var result = RegExpExec(rx, S);

    // Step 6.e.ii.
    if (result === null) {
      return n === 0 ? null : A;
    }

    // Step 6.e.iii.1.
    var matchStr = ToString(result[0]);

    // Step 6.e.iii.2.
    DefineDataProperty(A, n, matchStr);

    // Step 6.e.iii.3.
    if (matchStr === "") {
      var lastIndex = ToLength(rx.lastIndex);
      rx.lastIndex = fullUnicode
        ? AdvanceStringIndex(S, lastIndex)
        : lastIndex + 1;
    }

    // Step 6.e.iii.4.
    n++;
  }
}

// ES 2017 draft rev 6859bb9ccaea9c6ede81d71e5320e3833b92cb3e 21.2.5.6.
// Steps 6.b-e.
// Optimized path for @@match with global flag.
function RegExpGlobalMatchOpt(rx, S, fullUnicode) {
  // Step 6.b.
  var lastIndex = 0;
  rx.lastIndex = 0;

  // Step 6.c.
  var A = [];

  // Step 6.d.
  var n = 0;

  var lengthS = S.length;

  // Step 6.e.
  while (true) {
    // Step 6.e.i.
    var position = RegExpSearcher(rx, S, lastIndex);

    // Step 6.e.ii.
    if (position === -1) {
      return n === 0 ? null : A;
    }

    lastIndex = RegExpSearcherLastLimit(S);

    // Step 6.e.iii.1.
    var matchStr = Substring(S, position, lastIndex - position);

    // Step 6.e.iii.2.
    DefineDataProperty(A, n, matchStr);

    // Step 6.e.iii.4.
    if (matchStr === "") {
      lastIndex = fullUnicode
        ? AdvanceStringIndex(S, lastIndex)
        : lastIndex + 1;
      if (lastIndex > lengthS) {
        return A;
      }
    }

    // Step 6.e.iii.5.
    n++;
  }
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.11 RegExp.prototype [ @@replace ] ( string, replaceValue )
function RegExpReplace(string, replaceValue) {
  // Step 1.
  var rx = this;

  // Step 2.
  if (!IsObject(rx)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, rx === null ? "null" : typeof rx);
  }

  // Step 3.
  var S = ToString(string);

  // Step 4.
  var lengthS = S.length;

  // Step 5.
  var functionalReplace = IsCallable(replaceValue);

  // Step 6.
  var firstDollarIndex = -1;
  if (!functionalReplace) {
    // Step 6.a.
    replaceValue = ToString(replaceValue);

    // Skip if replaceValue is an empty string or a single character.
    // A single character string may contain "$", but that cannot be a
    // substitution.
    if (replaceValue.length > 1) {
      firstDollarIndex = GetFirstDollarIndex(replaceValue);
    }
  }

  // Optimized paths.
  if (IsOptimizableRegExpObject(rx)) {
    // Step 7.
    var flags = UnsafeGetInt32FromReservedSlot(rx, REGEXP_FLAGS_SLOT);

    // Step 9.
    var global = !!(flags & REGEXP_GLOBAL_FLAG);

    // Steps 9-17.
    if (global) {
      if (functionalReplace) {
        // For large strings check if the replacer function is
        // applicable for the elem-base optimization.
        if (lengthS > 5000) {
          var elemBase = GetElemBaseForLambda(replaceValue);
          if (IsObject(elemBase)) {
            return RegExpGlobalReplaceOptElemBase(
              rx,
              S,
              lengthS,
              replaceValue,
              flags,
              elemBase
            );
          }
        }
        return RegExpGlobalReplaceOptFunc(rx, S, lengthS, replaceValue, flags);
      }
      if (firstDollarIndex !== -1) {
        return RegExpGlobalReplaceOptSubst(
          rx,
          S,
          lengthS,
          replaceValue,
          flags,
          firstDollarIndex
        );
      }
      return RegExpGlobalReplaceOptSimple(rx, S, lengthS, replaceValue, flags);
    }

    if (functionalReplace) {
      return RegExpLocalReplaceOptFunc(rx, S, lengthS, replaceValue);
    }
    if (firstDollarIndex !== -1) {
      return RegExpLocalReplaceOptSubst(
        rx,
        S,
        lengthS,
        replaceValue,
        firstDollarIndex
      );
    }
    return RegExpLocalReplaceOptSimple(rx, S, lengthS, replaceValue);
  }

  // Steps 7-17.
  return RegExpReplaceSlowPath(
    rx,
    S,
    lengthS,
    replaceValue,
    functionalReplace,
    firstDollarIndex
  );
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.11 RegExp.prototype [ @@replace ] ( string, replaceValue )
// Steps 7-17.
// Slow path for @@replace.
function RegExpReplaceSlowPath(
  rx,
  S,
  lengthS,
  replaceValue,
  functionalReplace,
  firstDollarIndex
) {
  // Step 7.
  var flags = ToString(rx.flags);

  // Step 8.
  var global = callFunction(std_String_includes, flags, "g");

  // Step 9.
  var fullUnicode = false;
  if (global) {
    // Step 9.a.
    fullUnicode = callFunction(std_String_includes, flags, "u") || callFunction(std_String_includes, flags, "v");

    // Step 9.b.
    rx.lastIndex = 0;
  }

  // Step 10.
  var results = new_List();
  var nResults = 0;

  // Steps 11-12.
  while (true) {
    // Step 12.a.
    var result = RegExpExec(rx, S);

    // Step 12.b.
    if (result === null) {
      break;
    }

    // Step 12.c.i.
    DefineDataProperty(results, nResults++, result);

    // Step 12.c.ii.
    if (!global) {
      break;
    }

    // Step 12.c.iii.1.
    var matchStr = ToString(result[0]);

    // Step 12.c.iii.2.
    if (matchStr === "") {
      var lastIndex = ToLength(rx.lastIndex);
      rx.lastIndex = fullUnicode
        ? AdvanceStringIndex(S, lastIndex)
        : lastIndex + 1;
    }
  }

  // Step 13.
  var accumulatedResult = "";

  // Step 14.
  var nextSourcePosition = 0;

  // Step 15.
  for (var i = 0; i < nResults; i++) {
    result = results[i];

    // Steps 15.a-b.
    var nCaptures = std_Math_max(ToLength(result.length) - 1, 0);

    // Step 15.c.
    var matched = ToString(result[0]);

    // Step 15.d.
    var matchLength = matched.length;

    // Steps 15.e-f.
    var position = std_Math_max(
      std_Math_min(ToInteger(result.index), lengthS),
      0
    );

    var replacement;
    if (functionalReplace || firstDollarIndex !== -1) {
      // Steps 15.g-l.
      replacement = RegExpGetComplexReplacement(
        result,
        matched,
        S,
        position,
        nCaptures,
        replaceValue,
        functionalReplace,
        firstDollarIndex
      );
    } else {
      // Steps 15.g, 15.i, 15.i.iv.
      // We don't need captures array, but ToString is visible to script.
      for (var n = 1; n <= nCaptures; n++) {
        // Steps 15.i.i-ii.
        var capN = result[n];

        // Step 15.i.ii.
        if (capN !== undefined) {
          ToString(capN);
        }
      }

      // Steps 15.j, 15.l.i.
      // We don't need namedCaptures, but ToObject is visible to script.
      var namedCaptures = result.groups;
      if (namedCaptures !== undefined) {
        ToObject(namedCaptures);
      }

      // Step 15.l.ii.
      replacement = replaceValue;
    }

    // Step 15.m.
    if (position >= nextSourcePosition) {
      // Step 15.m.ii.
      accumulatedResult +=
        Substring(S, nextSourcePosition, position - nextSourcePosition) +
        replacement;

      // Step 15.m.iii.
      nextSourcePosition = position + matchLength;
    }
  }

  // Step 16.
  if (nextSourcePosition >= lengthS) {
    return accumulatedResult;
  }

  // Step 17.
  return (
    accumulatedResult +
    Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
  );
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.11 RegExp.prototype [ @@replace ] ( string, replaceValue )
// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
// Steps 15.g-l.
// Calculates functional/substitution replacement from match result.
// Used in the following functions:
//   * RegExpReplaceSlowPath
function RegExpGetComplexReplacement(
  result,
  matched,
  S,
  position,
  nCaptures,
  replaceValue,
  functionalReplace,
  firstDollarIndex
) {
  // Step 15.g.
  var captures = new_List();
  var capturesLength = 0;

  // Step 15.k.i (reordered).
  DefineDataProperty(captures, capturesLength++, matched);

  // String substitutions can only reference $1 through $99. Keep getting and
  // stringifying all captures because those operations are observable.
  var storedCaptures = functionalReplace
    ? nCaptures
    : std_Math_min(nCaptures, REGEXP_MAX_SUBSTITUTION_CAPTURES);

  // Steps 15.h, 15.i, 15.i.v.
  for (var n = 1; n <= nCaptures; n++) {
    // Step 15.i.i.
    var capN = result[n];

    // Step 15.i.ii.
    if (capN !== undefined) {
      capN = ToString(capN);
    }

    // Step 15.i.iii.
    if (n <= storedCaptures) {
      DefineDataProperty(captures, capturesLength++, capN);
    }
  }

  // Step 15.j.
  var namedCaptures = result.groups;

  // Step 15.k.
  if (functionalReplace) {
    // For `nCaptures` <= 4 case, call `replaceValue` directly, otherwise
    // use `std_Function_apply` with all arguments stored in `captures`.
    if (namedCaptures === undefined) {
      switch (nCaptures) {
        case 0:
          return ToString(
            callContentFunction(
              replaceValue,
              undefined,
              SPREAD(captures, 1),
              position,
              S
            )
          );
        case 1:
          return ToString(
            callContentFunction(
              replaceValue,
              undefined,
              SPREAD(captures, 2),
              position,
              S
            )
          );
        case 2:
          return ToString(
            callContentFunction(
              replaceValue,
              undefined,
              SPREAD(captures, 3),
              position,
              S
            )
          );
        case 3:
          return ToString(
            callContentFunction(
              replaceValue,
              undefined,
              SPREAD(captures, 4),
              position,
              S
            )
          );
        case 4:
          return ToString(
            callContentFunction(
              replaceValue,
              undefined,
              SPREAD(captures, 5),
              position,
              S
            )
          );
      }
    }

    // Steps 15.k.ii-vi.
    DefineDataProperty(captures, capturesLength++, position);
    DefineDataProperty(captures, capturesLength++, S);
    if (namedCaptures !== undefined) {
      DefineDataProperty(captures, capturesLength++, namedCaptures);
    }
    return ToString(
      callFunction(std_Function_apply, replaceValue, undefined, captures)
    );
  }

  // Step 15.l.
  if (namedCaptures !== undefined) {
    namedCaptures = ToObject(namedCaptures);
  }
  return RegExpGetSubstitution(
    captures,
    S,
    position,
    replaceValue,
    firstDollarIndex,
    namedCaptures
  );
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.11 RegExp.prototype [ @@replace ] ( string, replaceValue )
// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
// Steps 15.g-k.
// Calculates functional replacement from match result.
// Used in the following functions:
//   * RegExpGlobalReplaceOptFunc
//   * RegExpGlobalReplaceOptElemBase
//   * RegExpLocalReplaceOptFunc
function RegExpGetFunctionalReplacement(result, S, position, replaceValue) {
  // For `nCaptures` <= 4 case, call `replaceValue` directly, otherwise
  // use `std_Function_apply` with all arguments stored in `captures`.
  assert(result.length >= 1, "RegExpMatcher doesn't return an empty array");
  var nCaptures = result.length - 1;

  // Step 15.j (reordered)
  var namedCaptures = result.groups;

  if (namedCaptures === undefined) {
    switch (nCaptures) {
      case 0:
        return ToString(
          callContentFunction(
            replaceValue,
            undefined,
            SPREAD(result, 1),
            position,
            S
          )
        );
      case 1:
        return ToString(
          callContentFunction(
            replaceValue,
            undefined,
            SPREAD(result, 2),
            position,
            S
          )
        );
      case 2:
        return ToString(
          callContentFunction(
            replaceValue,
            undefined,
            SPREAD(result, 3),
            position,
            S
          )
        );
      case 3:
        return ToString(
          callContentFunction(
            replaceValue,
            undefined,
            SPREAD(result, 4),
            position,
            S
          )
        );
      case 4:
        return ToString(
          callContentFunction(
            replaceValue,
            undefined,
            SPREAD(result, 5),
            position,
            S
          )
        );
    }
  }

  // Steps 15.g-i, 15.k.i-ii.
  var captures = new_List();
  for (var n = 0; n <= nCaptures; n++) {
    assert(
      typeof result[n] === "string" || result[n] === undefined,
      "RegExpMatcher returns only strings and undefined"
    );
    DefineDataProperty(captures, n, result[n]);
  }

  // Step 15.k.iii.
  DefineDataProperty(captures, nCaptures + 1, position);
  DefineDataProperty(captures, nCaptures + 2, S);

  // Step 15.k.iv.
  if (namedCaptures !== undefined) {
    DefineDataProperty(captures, nCaptures + 3, namedCaptures);
  }

  // Steps 15.k.v-vi.
  return ToString(
    callFunction(std_Function_apply, replaceValue, undefined, captures)
  );
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.11 RegExp.prototype [ @@replace ] ( string, replaceValue )
// Steps 9.b-17.
// Optimized path for @@replace with the following conditions:
//   * global flag is true
//   * replaceValue is a string without "$"
function RegExpGlobalReplaceOptSimple(rx, S, lengthS, replaceValue, flags) {
  // Step 9.a.
  var fullUnicode = !!(flags & REGEXP_ANY_UNICODE_MASK);

  // Step 9.b.
  var lastIndex = 0;
  rx.lastIndex = 0;

  // Step 13 (reordered).
  var accumulatedResult = "";

  // Step 14 (reordered).
  var nextSourcePosition = 0;

  // Step 12.
  while (true) {
    // Step 12.a.
    var position = RegExpSearcher(rx, S, lastIndex);

    // Step 12.b.
    if (position === -1) {
      break;
    }

    lastIndex = RegExpSearcherLastLimit(S);

    // Step 15.m.ii.
    accumulatedResult +=
      Substring(S, nextSourcePosition, position - nextSourcePosition) +
      replaceValue;

    // Step 15.m.iii.
    nextSourcePosition = lastIndex;

    // Step 12.c.iii.2.
    if (lastIndex === position) {
      lastIndex = fullUnicode
        ? AdvanceStringIndex(S, lastIndex)
        : lastIndex + 1;
      if (lastIndex > lengthS) {
        break;
      }
    }
  }

  // Step 16.
  if (nextSourcePosition >= lengthS) {
    return accumulatedResult;
  }

  // Step 17.
  return (
    accumulatedResult +
    Substring(S, nextSourcePosition, lengthS - nextSourcePosition)
  );
}

// ES2023 draft rev 2c78e6f6b5bc6bfbf79dd8a12a9593e5b57afcd2
// 22.2.5.11 RegExp.prototype [ @@replace ] ( string, replaceValue )
// Steps 7-17.
// Optimized path for @@replace.

// Conditions:
//   * global flag is true
//   * replaceValue is a function
#define FUNC_NAME RegExpGlobalReplaceOptFunc
#define FUNCTIONAL
#include "RegExpGlobalReplaceOpt.h.js"
#undef FUNCTIONAL
#undef FUNC_NAME
/* global RegExpGlobalReplaceOptFunc */

// Conditions:
//   * global flag is true
//   * replaceValue is a function that returns element of an object
#define FUNC_NAME RegExpGlobalReplaceOptElemBase
#define ELEMBASE
#include "RegExpGlobalReplaceOpt.h.js"
#undef ELEMBASE
#undef FUNC_NAME
/* global RegExpGlobalReplaceOptElemBase */

// Conditions:
//   * global flag is true
//   * replaceValue is a string with "$"
#define FUNC_NAME RegExpGlobalReplaceOptSubst
#define SUBSTITUTION
#include "RegExpGlobalReplaceOpt.h.js"
#undef SUBSTITUTION
#undef FUNC_NAME
/* global RegExpGlobalReplaceOptSubst */

// Conditions:
//   * global flag is false
//   * replaceValue is a string without "$"
#define FUNC_NAME RegExpLocalReplaceOptSimple
#define SIMPLE
#include "RegExpLocalReplaceOpt.h.js"
#undef SIMPLE
#undef FUNC_NAME
/* global RegExpLocalReplaceOptSimple */

// Conditions:
//   * global flag is false
//   * replaceValue is a function
#define FUNC_NAME RegExpLocalReplaceOptFunc
#define FUNCTIONAL
#include "RegExpLocalReplaceOpt.h.js"
#undef FUNCTIONAL
#undef FUNC_NAME
/* global RegExpLocalReplaceOptFunc */

// Conditions:
//   * global flag is false
//   * replaceValue is a string with "$"
#define FUNC_NAME RegExpLocalReplaceOptSubst
#define SUBSTITUTION
#include "RegExpLocalReplaceOpt.h.js"
#undef SUBSTITUTION
#undef FUNC_NAME
/* global RegExpLocalReplaceOptSubst */

// ES2017 draft rev 6390c2f1b34b309895d31d8c0512eac8660a0210
// 21.2.5.9 RegExp.prototype [ @@search ] ( string )
function RegExpSearch(string) {
  // Step 1.
  var rx = this;

  // Step 2.
  if (!IsObject(rx)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, rx === null ? "null" : typeof rx);
  }

  // Step 3.
  var S = ToString(string);

  // Step 4.
  var previousLastIndex = rx.lastIndex;

  // Step 5.
  var lastIndexIsZero = SameValue(previousLastIndex, 0);
  if (!lastIndexIsZero) {
    rx.lastIndex = 0;
  }

  if (IsOptimizableRegExpObject(rx) && S.length < 0x7fff) {
    // Step 6.
    var result = RegExpSearcher(rx, S, 0);

    // We need to consider two cases:
    //
    // 1. Neither global nor sticky is set:
    // RegExpBuiltinExec doesn't modify lastIndex for local RegExps, that
    // means |SameValue(rx.lastIndex, 0)| is true after calling exec. The
    // comparison in steps 7-8 |SameValue(rx.lastIndex, previousLastIndex)|
    // is therefore equal to the already computed |lastIndexIsZero| value.
    //
    // 2. Global or sticky flag is set.
    // RegExpBuiltinExec will always update lastIndex and we need to
    // restore the property to its original value.

    // Steps 7-8.
    if (!lastIndexIsZero) {
      rx.lastIndex = previousLastIndex;
    } else {
      var flags = UnsafeGetInt32FromReservedSlot(rx, REGEXP_FLAGS_SLOT);
      if (flags & (REGEXP_GLOBAL_FLAG | REGEXP_STICKY_FLAG)) {
        rx.lastIndex = previousLastIndex;
      }
    }

    // Steps 9-10.
    return result;
  }

  return RegExpSearchSlowPath(rx, S, previousLastIndex);
}

// ES2017 draft rev 6390c2f1b34b309895d31d8c0512eac8660a0210
// 21.2.5.9 RegExp.prototype [ @@search ] ( string )
// Steps 6-10.
function RegExpSearchSlowPath(rx, S, previousLastIndex) {
  // Step 6.
  var result = RegExpExec(rx, S);

  // Step 7.
  var currentLastIndex = rx.lastIndex;

  // Step 8.
  if (!SameValue(currentLastIndex, previousLastIndex)) {
    rx.lastIndex = previousLastIndex;
  }

  // Step 9.
  if (result === null) {
    return -1;
  }

  // Step 10.
  return result.index;
}

// ES 2017 draft 6859bb9ccaea9c6ede81d71e5320e3833b92cb3e 21.2.5.11.
function RegExpSplit(string, limit) {
  // Step 1.
  var rx = this;

  // Step 2.
  if (!IsObject(rx)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, rx === null ? "null" : typeof rx);
  }

  // Step 3.
  var S = ToString(string);

  // Step 4.
  var builtinCtor = GetBuiltinConstructor("RegExp");
  var C = SpeciesConstructor(rx, builtinCtor);

  var optimizable =
    IsOptimizableRegExpObject(rx) &&
    C === builtinCtor &&
    (limit === undefined || typeof limit === "number");

  var flags, unicodeMatching, splitter;
  if (optimizable) {
    // Step 5.
    flags = UnsafeGetInt32FromReservedSlot(rx, REGEXP_FLAGS_SLOT);
    #ifdef NIGHTLY_BUILD
    assert(!!(flags & REGEXP_LEGACY_FEATURES_ENABLED_FLAG),
           "Legacy features must be enabled in optimized path");
    #endif
    // Steps 6-7.
    unicodeMatching = !!(flags & REGEXP_ANY_UNICODE_MASK);

    // Steps 8-10.
    // If split operation is optimizable, perform non-sticky match.
    if (flags & REGEXP_STICKY_FLAG) {
      var source = UnsafeGetStringFromReservedSlot(rx, REGEXP_SOURCE_SLOT);
      var newFlags = flags & ~(REGEXP_STICKY_FLAG | REGEXP_LEGACY_FEATURES_ENABLED_FLAG);
      splitter = RegExpConstructRaw(source, newFlags, true);
    } else {
      splitter = rx;
    }
  } else {
    // Step 5.
    flags = ToString(rx.flags);

    // Steps 6-7.
    unicodeMatching = callFunction(std_String_includes, flags, "u") || callFunction(std_String_includes, flags, "v");

    // Steps 8-9.
    var newFlags;
    if (callFunction(std_String_includes, flags, "y")) {
      newFlags = flags;
    } else {
      newFlags = flags + "y";
    }

    // Step 10.
    splitter = constructContentFunction(C, C, rx, newFlags);
  }

  // Step 11.
  var A = [];

  // Step 12.
  var lengthA = 0;

  // Step 13.
  var lim;
  if (limit === undefined) {
    lim = MAX_UINT32;
  } else {
    lim = limit >>> 0;
  }

  // Step 15.
  var p = 0;

  // Step 16.
  if (lim === 0) {
    return A;
  }

  // Step 14 (reordered).
  var size = S.length;

  // Step 17.
  if (size === 0) {
    // Step 17.a-b.
    if (optimizable) {
      if (RegExpSearcher(splitter, S, 0) !== -1) {
        return A;
      }
    } else {
      if (RegExpExec(splitter, S) !== null) {
        return A;
      }
    }

    // Step 17.d.
    DefineDataProperty(A, 0, S);

    // Step 17.e.
    return A;
  }

  // Step 18.
  var q = p;

  var optimizableNoCaptures = optimizable && !RegExpHasCaptureGroups(splitter, S);

  // Step 19.
  while (q < size) {
    var e, z;
    if (optimizableNoCaptures) {
      // If there are no capturing groups, avoid allocating the match result
      // object |z| (we set it to null). This is the only difference between
      // this branch and the |if (optimizable)| case below.

      // Step 19.a (skipped).
      // splitter.lastIndex is not used.

      // Steps 19.b-c.
      q = RegExpSearcher(splitter, S, q);
      if (q === -1 || q >= size) {
        break;
      }

      // Step 19.d.i.
      e = RegExpSearcherLastLimit(S);
      z = null;
    } else if (optimizable) {
      // Step 19.a (skipped).
      // splitter.lastIndex is not used.

      // Step 19.b.
      z = RegExpMatcher(splitter, S, q);

      // Step 19.c.
      if (z === null) {
        break;
      }

      // splitter.lastIndex is not updated.
      q = z.index;
      if (q >= size) {
        break;
      }

      // Step 19.d.i.
      e = q + z[0].length;
    } else {
      // Step 19.a.
      splitter.lastIndex = q;

      // Step 19.b.
      z = RegExpExec(splitter, S);

      // Step 19.c.
      if (z === null) {
        q = unicodeMatching ? AdvanceStringIndex(S, q) : q + 1;
        continue;
      }

      // Step 19.d.i.
      e = ToLength(splitter.lastIndex);
    }

    // Step 19.d.iii.
    if (e === p) {
      q = unicodeMatching ? AdvanceStringIndex(S, q) : q + 1;
      continue;
    }

    // Steps 19.d.iv.1-3.
    DefineDataProperty(A, lengthA, Substring(S, p, q - p));

    // Step 19.d.iv.4.
    lengthA++;

    // Step 19.d.iv.5.
    if (lengthA === lim) {
      return A;
    }

    // Step 19.d.iv.6.
    p = e;

    if (z !== null) {
      // Steps 19.d.iv.7-8.
      var numberOfCaptures = std_Math_max(ToLength(z.length) - 1, 0);

      // Step 19.d.iv.9.
      var i = 1;

      // Step 19.d.iv.10.
      while (i <= numberOfCaptures) {
        // Steps 19.d.iv.10.a-b.
        DefineDataProperty(A, lengthA, z[i]);

        // Step 19.d.iv.10.c.
        i++;

        // Step 19.d.iv.10.d.
        lengthA++;

        // Step 19.d.iv.10.e.
        if (lengthA === lim) {
          return A;
        }
      }
    }

    // Step 19.d.iv.11.
    q = p;
  }

  // Steps 20-22.
  if (p >= size) {
    DefineDataProperty(A, lengthA, "");
  } else {
    DefineDataProperty(A, lengthA, Substring(S, p, size - p));
  }

  // Step 23.
  return A;
}

// ES6 21.2.5.2.
// NOTE: This is not RegExpExec (21.2.5.2.1).
function RegExp_prototype_Exec(string) {
  // Steps 1-3.
  var R = this;
  if (!IsObject(R) || !IsRegExpObject(R)) {
    return callFunction(
      CallRegExpMethodIfWrapped,
      R,
      string,
      "RegExp_prototype_Exec"
    );
  }

  // Steps 4-5.
  var S = ToString(string);

  // Step 6.
  return RegExpBuiltinExec(R, S);
}

// ES6 21.2.5.13.
function RegExpTest(string) {
  // Steps 1-2.
  var R = this;
  if (!IsObject(R)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, R === null ? "null" : typeof R);
  }

  // Steps 3-4.
  var S = ToString(string);

  // Steps 5-6.
  return RegExpExecForTest(R, S);
}

// ES 2016 draft Mar 25, 2016 21.2.4.2.
function $RegExpSpecies() {
  // Step 1.
  return this;
}
SetCanonicalName($RegExpSpecies, "get [Symbol.species]");

// String.prototype.matchAll proposal.
//
// RegExp.prototype [ @@matchAll ] ( string )
function RegExpMatchAll(string) {
  // Step 1.
  var rx = this;

  // Step 2.
  if (!IsObject(rx)) {
    ThrowTypeError(JSMSG_OBJECT_REQUIRED, rx === null ? "null" : typeof rx);
  }

  // Step 3.
  var str = ToString(string);

  // Step 4.
  var builtinCtor = GetBuiltinConstructor("RegExp");
  var C = SpeciesConstructor(rx, builtinCtor);

  var source, flags, matcher, lastIndex;
  if (IsOptimizableRegExpObject(rx) && C === builtinCtor) {
    // Step 5, 9-12.
    source = UnsafeGetStringFromReservedSlot(rx, REGEXP_SOURCE_SLOT);
    flags = UnsafeGetInt32FromReservedSlot(rx, REGEXP_FLAGS_SLOT);
    #ifdef NIGHTLY_BUILD
    assert(!!(flags & REGEXP_LEGACY_FEATURES_ENABLED_FLAG),
    "Legacy features must be enabled in optimized path");
    #endif

    // Step 6.
    matcher = rx;

    // Step 7.
    lastIndex = ToLength(rx.lastIndex);

    // Step 8 (not applicable for the optimized path).
  } else {
    // Step 5.
    source = "";
    flags = ToString(rx.flags);

    // Step 6.
    matcher = constructContentFunction(C, C, rx, flags);

    // Steps 7-8.
    matcher.lastIndex = ToLength(rx.lastIndex);

    // Steps 9-12.
    flags =
      (callFunction(std_String_includes, flags, "g") ? REGEXP_GLOBAL_FLAG : 0) |
      (callFunction(std_String_includes, flags, "u") ? REGEXP_UNICODE_FLAG : 0) |
      (callFunction(std_String_includes, flags, "v") ? REGEXP_UNICODESETS_FLAG : 0);
    
    // Take the non-optimized path.
    lastIndex = REGEXP_STRING_ITERATOR_LASTINDEX_SLOW;
  }

  // Step 13.
  return CreateRegExpStringIterator(matcher, str, source, flags, lastIndex);
}

// String.prototype.matchAll proposal.
//
// CreateRegExpStringIterator ( R, S, global, fullUnicode )
function CreateRegExpStringIterator(regexp, string, source, flags, lastIndex) {
  // Step 1.
  assert(typeof string === "string", "|string| is a string value");

  // Steps 2-3.
  assert(typeof flags === "number", "|flags| is a number value");

  assert(typeof source === "string", "|source| is a string value");
  assert(typeof lastIndex === "number", "|lastIndex| is a number value");

  // Steps 4-9.
  var iterator = NewRegExpStringIterator();
  UnsafeSetReservedSlot(iterator, REGEXP_STRING_ITERATOR_REGEXP_SLOT, regexp);
  UnsafeSetReservedSlot(iterator, REGEXP_STRING_ITERATOR_STRING_SLOT, string);
  UnsafeSetReservedSlot(iterator, REGEXP_STRING_ITERATOR_SOURCE_SLOT, source);
  UnsafeSetReservedSlot(iterator, REGEXP_STRING_ITERATOR_FLAGS_SLOT, flags | 0);
  UnsafeSetReservedSlot(
    iterator,
    REGEXP_STRING_ITERATOR_LASTINDEX_SLOT,
    lastIndex
  );

  // Step 10.
  return iterator;
}

// String.prototype.matchAll proposal.
//
// %RegExpStringIteratorPrototype%.next ( )
function RegExpStringIteratorNext() {
  // Steps 1-3.
  var obj = this;
  if (!IsObject(obj) || (obj = GuardToRegExpStringIterator(obj)) === null) {
    return callFunction(
      CallRegExpStringIteratorMethodIfWrapped,
      this,
      "RegExpStringIteratorNext"
    );
  }

  var result = { value: undefined, done: false };

  // Step 4.
  var lastIndex = UnsafeGetReservedSlot(
    obj,
    REGEXP_STRING_ITERATOR_LASTINDEX_SLOT
  );
  if (lastIndex === REGEXP_STRING_ITERATOR_LASTINDEX_DONE) {
    result.done = true;
    return result;
  }

  // Step 5.
  var regexp = UnsafeGetObjectFromReservedSlot(
    obj,
    REGEXP_STRING_ITERATOR_REGEXP_SLOT
  );

  // Step 6.
  var string = UnsafeGetStringFromReservedSlot(
    obj,
    REGEXP_STRING_ITERATOR_STRING_SLOT
  );

  // Steps 7-8.
  var flags = UnsafeGetInt32FromReservedSlot(
    obj,
    REGEXP_STRING_ITERATOR_FLAGS_SLOT
  );
  var global = !!(flags & REGEXP_GLOBAL_FLAG);
  var fullUnicode = !!(flags & REGEXP_ANY_UNICODE_MASK);

  if (lastIndex >= 0) {
    assert(IsRegExpObject(regexp), "|regexp| is a RegExp object");

    var source = UnsafeGetStringFromReservedSlot(
      obj,
      REGEXP_STRING_ITERATOR_SOURCE_SLOT
    );
    if (
      IsRegExpPrototypeOptimizable() &&
      UnsafeGetStringFromReservedSlot(regexp, REGEXP_SOURCE_SLOT) === source &&
      UnsafeGetInt32FromReservedSlot(regexp, REGEXP_FLAGS_SLOT) === flags
    ) {
      // Step 9 (Inlined RegExpBuiltinExec).
      var globalOrSticky = !!(
        flags &
        (REGEXP_GLOBAL_FLAG | REGEXP_STICKY_FLAG)
      );
      if (!globalOrSticky) {
        lastIndex = 0;
      }

      var match =
        lastIndex <= string.length
          ? RegExpMatcher(regexp, string, lastIndex)
          : null;

      // Step 10.
      if (match === null) {
        // Step 10.a.
        UnsafeSetReservedSlot(
          obj,
          REGEXP_STRING_ITERATOR_LASTINDEX_SLOT,
          REGEXP_STRING_ITERATOR_LASTINDEX_DONE
        );

        // Step 10.b.
        result.done = true;
        return result;
      }

      // Step 11.a.
      if (global) {
        // Step 11.a.i.
        var matchLength = match[0].length;
        lastIndex = match.index + matchLength;

        // Step 11.a.ii.
        if (matchLength === 0) {
          // Steps 11.a.ii.1-3.
          lastIndex = fullUnicode
            ? AdvanceStringIndex(string, lastIndex)
            : lastIndex + 1;
        }

        UnsafeSetReservedSlot(
          obj,
          REGEXP_STRING_ITERATOR_LASTINDEX_SLOT,
          lastIndex
        );
      } else {
        // Step 11.b.i.
        UnsafeSetReservedSlot(
          obj,
          REGEXP_STRING_ITERATOR_LASTINDEX_SLOT,
          REGEXP_STRING_ITERATOR_LASTINDEX_DONE
        );
      }

      // Steps 11.a.iii and 11.b.ii.
      result.value = match;
      return result;
    }

    // Reify the RegExp object.
    var newFlags = flags & ~REGEXP_LEGACY_FEATURES_ENABLED_FLAG;
    regexp = RegExpConstructRaw(source, newFlags, true);
    regexp.lastIndex = lastIndex;
    UnsafeSetReservedSlot(obj, REGEXP_STRING_ITERATOR_REGEXP_SLOT, regexp);

    // Mark the iterator as no longer optimizable.
    UnsafeSetReservedSlot(
      obj,
      REGEXP_STRING_ITERATOR_LASTINDEX_SLOT,
      REGEXP_STRING_ITERATOR_LASTINDEX_SLOW
    );
  }

  // Step 9.
  var match = RegExpExec(regexp, string);

  // Step 10.
  if (match === null) {
    // Step 10.a.
    UnsafeSetReservedSlot(
      obj,
      REGEXP_STRING_ITERATOR_LASTINDEX_SLOT,
      REGEXP_STRING_ITERATOR_LASTINDEX_DONE
    );

    // Step 10.b.
    result.done = true;
    return result;
  }

  // Step 11.a.
  if (global) {
    // Step 11.a.i.
    var matchStr = ToString(match[0]);

    // Step 11.a.ii.
    if (matchStr.length === 0) {
      // Step 11.a.ii.1.
      var thisIndex = ToLength(regexp.lastIndex);

      // Step 11.a.ii.2.
      var nextIndex = fullUnicode
        ? AdvanceStringIndex(string, thisIndex)
        : thisIndex + 1;

      // Step 11.a.ii.3.
      regexp.lastIndex = nextIndex;
    }
  } else {
    // Step 11.b.i.
    UnsafeSetReservedSlot(
      obj,
      REGEXP_STRING_ITERATOR_LASTINDEX_SLOT,
      REGEXP_STRING_ITERATOR_LASTINDEX_DONE
    );
  }

  // Steps 11.a.iii and 11.b.ii.
  result.value = match;
  return result;
}

// ES2020 draft rev e97c95d064750fb949b6778584702dd658cf5624
// 7.2.8 IsRegExp ( argument )
function IsRegExp(argument) {
  // Step 1.
  if (!IsObject(argument)) {
    return false;
  }

  // Step 2.
  var matcher = argument[GetBuiltinSymbol("match")];

  // Step 3.
  if (matcher !== undefined) {
    return !!matcher;
  }

  // Steps 4-5.
  return IsPossiblyWrappedRegExpObject(argument);
}