@poe-platform/safe-js 0.1.194 → 0.1.196

package/dist/safe-js/chunks/{chunk-WRASETAY.js → chunk-KMQUDIYF.js}

@@ -739,6 +739,7 @@ function measureNode(node) {
       return 3 + node.value.length;
     case "anchor":
     case "wordBoundary":
+    case "backreference":
       return 3;
     case "characterClass": {
       let usage = 5 + node.items.length;
@@ -757,6 +758,7 @@ function measureNode(node) {
     case "group":
       return 5 + measureNode(node.body);
     case "lookahead":
+    case "lookbehind":
       return 4 + measureNode(node.body);
     case "quantifier":
       return (Object.hasOwn(node, "max") ? 6 : 5) + measureNode(node.body);
@@ -2073,6 +2075,7 @@ var RegexParser = class {
   guard;
   captureCount = 0;
   cursor = 0;
+  totalCaptureCount;
   get position() {
     return this.cursor;
   }
@@ -2129,7 +2132,7 @@ var RegexParser = class {
     if (quantifier === void 0) {
       return body;
     }
-    if (body.type === "anchor" || body.type === "wordBoundary") {
+    if (body.type === "anchor" || body.type === "wordBoundary" || body.type === "lookbehind") {
       this.fail("Invalid quantifier target", quantifierStart);
     }
     const greedy = this.peek() !== "?";
@@ -2164,7 +2167,8 @@ var RegexParser = class {
   }
   parseGroup(start) {
     let capturing = true;
-    let lookahead;
+    let assertionNegated;
+    let lookbehind = false;
     if (this.peek() === "?") {
       this.guard.allocate(Math.min(3, this.source.length - this.position));
       this.guard.work(Math.min(3, this.source.length - this.position));
@@ -2174,10 +2178,13 @@ var RegexParser = class {
         this.position += 2;
       } else if (extension.startsWith("?=") || extension.startsWith("?!")) {
         capturing = false;
-        lookahead = extension.startsWith("?!");
+        assertionNegated = extension.startsWith("?!");
         this.position += 2;
       } else if (extension.startsWith("?<=") || extension.startsWith("?<!")) {
-        this.fail("Lookbehind is not supported", start);
+        capturing = false;
+        assertionNegated = extension.startsWith("?<!");
+        lookbehind = true;
+        this.position += 3;
       } else if (extension.startsWith("?<")) {
         this.fail("Named groups are not supported", start);
       } else {
@@ -2197,9 +2204,9 @@ var RegexParser = class {
       this.fail("Unterminated group", start);
     }
     this.position += 1;
-    if (lookahead !== void 0) {
+    if (assertionNegated !== void 0) {
       this.guard.allocate(4);
-      return { type: "lookahead", negated: lookahead, body };
+      return { type: lookbehind ? "lookbehind" : "lookahead", negated: assertionNegated, body };
     }
     this.guard.allocate(5);
     return { type: "group", capturing, index, body };
@@ -2262,8 +2269,29 @@ var RegexParser = class {
       this.fail("Trailing escape", start);
     }
     const escaped = this.take();
-    if (escaped >= "1" && escaped <= "9") {
-      this.fail("Backreferences are not supported", start);
+    if (isDecimalDigit2(escaped)) {
+      if (!inCharacterClass && escaped !== "0") {
+        let end = this.position;
+        let index = Number(escaped);
+        while (isDecimalDigit2(this.source[end] ?? "")) {
+          this.guard.work(1);
+          index = index * 10 + Number(this.source[end++]);
+        }
+        this.totalCaptureCount ??= this.countAllCaptures();
+        if (index <= this.totalCaptureCount) {
+          this.position = end;
+          this.guard.allocate(3);
+          return { type: "backreference", index };
+        }
+      }
+      this.guard.allocate(4);
+      if (escaped === "8" || escaped === "9") return { type: "literal", value: escaped };
+      let code = Number(escaped);
+      const maximum = escaped <= "3" ? 3 : 2;
+      for (let digits = 1; digits < maximum && this.peek() >= "0" && this.peek() <= "7"; digits++) {
+        code = code * 8 + Number(this.take());
+      }
+      return { type: "literal", value: String.fromCharCode(code) };
     }
     if (escaped === "p" || escaped === "P") {
       this.fail("Unicode property escapes are not supported", start);
@@ -2319,6 +2347,21 @@ var RegexParser = class {
     this.position = end;
     return String.fromCharCode(Number.parseInt(digits, 16));
   }
+  countAllCaptures() {
+    let count = 0;
+    let escaped = false;
+    let characterClass = false;
+    for (let index = 0; index < this.source.length; index++) {
+      this.guard.work(1);
+      const character = this.source[index];
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === "[") characterClass = true;
+      else if (character === "]") characterClass = false;
+      else if (!characterClass && character === "(" && this.source[index + 1] !== "?") count++;
+    }
+    return count;
+  }
   parseQuantifier() {
     const character = this.peek();
     if (character === "*") {
@@ -9320,7 +9363,7 @@ function matchRegexFrom(pattern, input, startIndex) {
     return null;
   }
   for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
-    const context = { input, flags: pattern.flags, steps: 0 };
+    const context = { input, flags: pattern.flags, direction: 1, work: { steps: 0 } };
     charge(context);
     const initialState = {
       position: attempt,
@@ -9336,18 +9379,35 @@ function matchRegexFrom(pattern, input, startIndex) {
 }
 function* matchNode(node, state, context) {
   charge(context);
+  const characterIndex = context.direction === 1 ? state.position : state.position - 1;
   switch (node.type) {
     case "empty":
       yield state;
       return;
     case "literal":
-      if (charactersEqual(context.input[state.position], node.value, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
+      if (charactersEqual(context.input[characterIndex], node.value, context.flags.ignoreCase)) {
+        yield { ...state, position: state.position + context.direction };
       }
       return;
+    case "backreference": {
+      const capture = state.captures[node.index - 1];
+      if (capture === void 0) {
+        yield state;
+        return;
+      }
+      const length = capture.end - capture.start;
+      const start = context.direction === 1 ? state.position : state.position - length;
+      if (start < 0 || start + length > context.input.length) return;
+      for (let offset = 0; offset < length; offset++) {
+        charge(context);
+        if (!charactersEqual(context.input[start + offset], context.input[capture.start + offset], context.flags.ignoreCase)) return;
+      }
+      yield { ...state, position: state.position + context.direction * length };
+      return;
+    }
     case "dot":
-      if (state.position < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[state.position]))) {
-        yield { ...state, position: state.position + 1 };
+      if (characterIndex >= 0 && characterIndex < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[characterIndex]))) {
+        yield { ...state, position: state.position + context.direction };
       }
       return;
     case "anchor":
@@ -9364,9 +9424,9 @@ function* matchNode(node, state, context) {
       return;
     }
     case "characterClass": {
-      const character = context.input[state.position];
+      const character = context.input[characterIndex];
       if (character !== void 0 && matchesCharacterClass(character, node.items, node.negated, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
+        yield { ...state, position: state.position + context.direction };
       }
       return;
     }
@@ -9378,8 +9438,12 @@ function* matchNode(node, state, context) {
         yield* matchNode(alternative, cloneState(state), context);
       }
       return;
-    case "lookahead": {
-      const result = matchNode(node.body, cloneState(state), context).next();
+    case "lookahead":
+    case "lookbehind": {
+      const result = matchNode(node.body, cloneState(state), {
+        ...context,
+        direction: node.type === "lookbehind" ? -1 : 1
+      }).next();
       if (node.negated) {
         if (result.done) yield state;
       } else if (!result.done) {
@@ -9394,7 +9458,7 @@ function* matchNode(node, state, context) {
           continue;
         }
         const captures = result.captures.slice();
-        captures[node.index - 1] = { start: state.position, end: result.position };
+        captures[node.index - 1] = { start: Math.min(state.position, result.position), end: Math.max(state.position, result.position) };
         yield { position: result.position, captures };
       }
       return;
@@ -9408,7 +9472,8 @@ function* matchSequence(elements, index, state, context) {
     yield state;
     return;
   }
-  for (const result of matchNode(elements[index], state, context)) {
+  const element = elements[context.direction === 1 ? index : elements.length - 1 - index];
+  for (const result of matchNode(element, state, context)) {
     yield* matchSequence(elements, index + 1, result, context);
   }
 }
@@ -9511,13 +9576,13 @@ function clearNodeCaptures(node, captures) {
     }
     return;
   }
-  if (node.type === "quantifier" || node.type === "lookahead") {
+  if (node.type === "quantifier" || node.type === "lookahead" || node.type === "lookbehind") {
     clearNodeCaptures(node.body, captures);
   }
 }
 function charge(context) {
-  context.steps += 1;
-  allocateRegexSteps(context.steps);
+  context.work.steps += 1;
+  allocateRegexSteps(context.work.steps);
 }
 function normalizeLastIndex(lastIndex) {
   if (Number.isNaN(lastIndex) || lastIndex <= 0) {
@@ -37101,4 +37166,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-WRASETAY.js.map
+//# sourceMappingURL=chunk-KMQUDIYF.js.map