poe-code 11.0.3 → 11.0.5

package/dist/index.js

@@ -138743,12 +138743,10 @@ function getSandboxIterator(value) {
     return syncIterator(value[Symbol.iterator]());
   }
   if (isSandboxMap(value)) {
-    return syncIterator(
-      Array.from(value.entries, ([key3, entry]) => [key3, entry])[Symbol.iterator]()
-    );
+    return collectionIterator(value.entries);
   }
   if (isSandboxSet(value)) {
-    return syncIterator(value.values[Symbol.iterator]());
+    return collectionIterator(value.values);
   }
   if (typeof value !== "object" && typeof value !== "function" || value === null) {
     return void 0;
@@ -138759,6 +138757,29 @@ function getSandboxIterator(value) {
   }
   return syncIterator(Reflect.apply(iteratorMethod, value, []));
 }
+function collectionIterator(collection) {
+  let iterator = collection[Symbol.iterator]();
+  let exhausted = false;
+  return {
+    ...syncIterator({
+      next: () => {
+        if (exhausted) return { done: true, value: void 0 };
+        const result = iterator.next();
+        exhausted = result.done === true;
+        return result;
+      }
+    }),
+    snapshotIndex: () => {
+      if (exhausted) return collection.size;
+      let remaining = 0;
+      while (!iterator.next().done) remaining += 1;
+      const index = collection.size - remaining;
+      iterator = collection[Symbol.iterator]();
+      for (let skipped = 0; skipped < index; skipped += 1) iterator.next();
+      return index;
+    }
+  };
+}
 function generatorIterator(generator) {
   const invoke2 = async (method, value) => {
     const leaveRunning = enterRunningState(generator);
@@ -144253,7 +144274,7 @@ async function replaceRegex(value, regex, replacement, replaceAll2, budget, call
   let copiedThrough = 0;
   for (const match of matches) {
     result += value.slice(copiedThrough, match.index);
-    result += typeof replacement === "string" ? expandReplacement(replacement, match.text, match.captures) : String(
+    result += typeof replacement === "string" ? expandReplacement(replacement, match.text, match.captures, value, match.index) : String(
       await callClosure(replacement, [match.text, ...match.captures, match.index, value])
     );
     copiedThrough = match.index + match.text.length;
@@ -144261,12 +144282,45 @@ async function replaceRegex(value, regex, replacement, replaceAll2, budget, call
   result += value.slice(copiedThrough);
   return budget.allocateString(result);
 }
-function expandReplacement(replacement, match, captures) {
-  return replacement.replace(/\$([$&]|[1-9][0-9]?)/g, (token, part) => {
-    if (part === "$") return "$";
-    if (part === "&") return match;
-    return captures[Number(part) - 1] ?? token;
-  });
+function expandReplacement(replacement, match, captures, input, matchIndex) {
+  let result = "";
+  for (let index = 0; index < replacement.length; index += 1) {
+    const character2 = replacement.charAt(index);
+    if (character2 !== "$") {
+      result += character2;
+      continue;
+    }
+    const token = replacement.charAt(index + 1);
+    if (token === "$") {
+      result += "$";
+    } else if (token === "&") {
+      result += match;
+    } else if (token === "`") {
+      result += input.slice(0, matchIndex);
+    } else if (token === "'") {
+      result += input.slice(matchIndex + match.length);
+    } else if (token >= "0" && token <= "9") {
+      let captureIndex = Number(token);
+      const nextDigit = replacement.charAt(index + 2);
+      if (nextDigit >= "0" && nextDigit <= "9") {
+        const twoDigitIndex = Number(token + nextDigit);
+        if (twoDigitIndex > 0 && twoDigitIndex <= captures.length) {
+          captureIndex = twoDigitIndex;
+          index += 1;
+        }
+      }
+      if (captureIndex === 0 || captureIndex > captures.length) {
+        result += "$";
+        continue;
+      }
+      result += captures[captureIndex - 1] ?? "";
+    } else {
+      result += "$";
+      continue;
+    }
+    index += 1;
+  }
+  return result;
 }
 async function replaceWithClosure(value, searchValue, replacer, replaceAll2, budget, callClosure) {
   const offsets = findReplacementOffsets(value, searchValue, replaceAll2);
@@ -145339,19 +145393,35 @@ async function evaluateVariableDeclaration(node, context) {
     value: void 0
   };
 }
-function isRestorableBindingValue(value) {
-  if (Array.isArray(value)) {
-    return value.every(isRestorableBindingValue);
-  }
+function isRestorableBindingValue(value, seen = /* @__PURE__ */ new WeakSet()) {
   if (typeof value !== "object" || value === null) {
     return true;
   }
+  if (seen.has(value)) return true;
+  seen.add(value);
+  if (isSandboxMap(value)) {
+    for (const [key3, entry] of value.entries) {
+      if (!isRestorableBindingValue(key3, seen) || !isRestorableBindingValue(entry, seen)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isSandboxSet(value)) {
+    for (const entry of value.values) {
+      if (!isRestorableBindingValue(entry, seen)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every((entry) => isRestorableBindingValue(entry, seen));
+  }
   if (Object.hasOwn(value, "kind")) {
     return !["fn", "generator", "map", "promise", "regex", "set"].includes(
       String(value.kind)
     );
   }
-  return Object.values(value).every(isRestorableBindingValue);
+  return Object.values(value).every((entry) => isRestorableBindingValue(entry, seen));
 }
 function predeclareDeclarationBindings(node, scope) {
   for (const name of getDeclarationBindingNames2(node)) {
@@ -145565,13 +145635,24 @@ async function evaluateIfStatement(node, context) {
   return evaluateNode2(branch, context);
 }
 async function evaluateForOfStatement(node, context) {
+  const restoredIteration = context.restoredLoopIterations.get(node.nodeId ?? -1);
+  let restoredEntry;
+  if (typeof restoredIteration === "object" && typeof restoredIteration.values[0] === "string") {
+    const restored = context.scope.consumeRestoredBinding(restoredIteration.values[0]);
+    if (restored.found && Array.isArray(restored.value)) {
+      restoredEntry = { done: false, value: restored.value[1] };
+      if (isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0])) {
+        return evaluateForOfIterator(node, restored.value[0], context, restoredEntry);
+      }
+    }
+  }
   const iterable = await evaluateNode2(node.right, context);
   if (iterable.kind !== "normal") {
     return iterable;
   }
   const values = snapshotableIterationValues(iterable.value);
   if (values === void 0) {
-    return evaluateForOfIterator(node, iterable.value, context);
+    return evaluateForOfIterator(node, iterable.value, context, restoredEntry);
   }
   const restoredIndex = consumeRestoredLoopIterationIndex(node, context);
   for (let index = restoredIndex; index < values.length; index += 1) {
@@ -145607,7 +145688,7 @@ async function evaluateForOfStatement(node, context) {
     value: void 0
   };
 }
-async function evaluateForOfIterator(node, value, context) {
+async function evaluateForOfIterator(node, value, context, restoredEntry) {
   const iterator = getSandboxIterator(value);
   if (iterator === void 0) {
     throw new TypeError(`${String(value)} is not a supported iterable`);
@@ -145624,7 +145705,8 @@ async function evaluateForOfIterator(node, value, context) {
     }
   }
   while (true) {
-    const iteration = await iterator.next();
+    const iteration = restoredEntry ?? await iterator.next();
+    restoredEntry = void 0;
     if (typeof iteration !== "object" || iteration === null) {
       throw new TypeError("Iterator result must be an object.");
     }
@@ -145632,7 +145714,15 @@ async function evaluateForOfIterator(node, value, context) {
       context.activeLoopIterations.delete(nodeId);
       return normalEmptyResult();
     }
-    context.activeLoopIterations.set(nodeId, index);
+    context.activeLoopIterations.set(
+      nodeId,
+      iterator.snapshotIndex === void 0 ? index : {
+        get index() {
+          return iterator.snapshotIndex();
+        },
+        values: [value, iteration.value]
+      }
+    );
     const scope = context.scope.child();
     const binding = await bindForOfLoopVariable(node.left, iteration.value, scope, context);
     if (!binding.ok) {
@@ -145871,10 +145961,21 @@ function createLoopIterationContext(context, scope) {
   return {
     ...context,
     scope,
-    snapshot: (currentScope) => ({
-      ...currentScope.snapshot(),
-      ...context.activeLoopIterations.size === 0 ? {} : { loopIterations: Object.fromEntries(context.activeLoopIterations) }
-    })
+    snapshot: (currentScope) => {
+      const snapshot2 = currentScope.snapshot();
+      if (context.activeLoopIterations.size === 0) return snapshot2;
+      snapshot2.loopIterations = {};
+      for (const [nodeId, iteration] of context.activeLoopIterations) {
+        if (typeof iteration !== "number" && (isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]))) {
+          const bindingName = `#for-of:${nodeId}`;
+          snapshot2.bindings[bindingName] = iteration.values;
+          snapshot2.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
+        } else {
+          snapshot2.loopIterations[nodeId] = iteration;
+        }
+      }
+      return snapshot2;
+    }
   };
 }
 function consumeRestoredLoopIteration(node, context) {
@@ -145894,12 +145995,6 @@ function snapshotableIterationValues(value) {
   if (Array.isArray(value)) {
     return value;
   }
-  if (isSandboxMap(value)) {
-    return Array.from(value.entries, ([key3, entry]) => [key3, entry]);
-  }
-  if (isSandboxSet(value)) {
-    return Array.from(value.values);
-  }
   return void 0;
 }
 function isMatchingBreak(result, labels) {
@@ -155459,7 +155554,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "11.0.3",
+      version: "11.0.5",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",