poe-code 13.0.2 → 13.0.3

package/dist/index.js

@@ -138898,14 +138898,6 @@ function enterRunningState(object) {
     runningObjects.delete(object);
   };
 }
-function enterCollectionCallback(object) {
-  const leaveRunning = enterRunningState(object);
-  lockedCollections.add(object);
-  return () => {
-    lockedCollections.delete(object);
-    leaveRunning();
-  };
-}
 function assertCollectionMutable(object) {
   if (lockedCollections.has(object)) {
     throw new SandboxError("reentry");
@@ -143669,7 +143661,7 @@ async function callArrayMethod(value, methodName, args, options, stack = []) {
   if (isCallbackArrayMethod(methodName)) {
     let callbackState = activeArrayCallbacks.get(value);
     if (callbackState === void 0) {
-      callbackState = { depth: 0, leave: enterCollectionCallback(value) };
+      callbackState = { depth: 0, leave: enterRunningState(value) };
       activeArrayCallbacks.set(value, callbackState);
     }
     callbackState.depth += 1;
@@ -143920,42 +143912,63 @@ function getRequiredCallback(methodName, value) {
 async function mapArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   const result = new Array(length);
-  for (let index = 0; index < length; index += 1) {
-    if (!(index in value)) {
-      continue;
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      result[index] = await callArrayCallback(
+        callback,
+        value[index],
+        index,
+        value,
+        options,
+        stack,
+        thisValue
+      );
     }
-    result[index] = await callArrayCallback(
-      callback,
-      value[index],
-      index,
-      value,
-      options,
-      stack,
-      thisValue
-    );
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
   }
-  return result;
 }
 async function filterArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   const result = [];
-  for (let index = 0; index < length; index += 1) {
-    if (!(index in value)) {
-      continue;
-    }
-    if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
-      result.push(value[index]);
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      const entry = value[index];
+      if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+        result.push(entry);
+      }
     }
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
   }
-  return result;
 }
 async function findInArray(value, callback, options, stack, thisValue) {
-  const index = await findIndexInArray(value, callback, options, stack, thisValue);
-  return index < 0 ? void 0 : value[index];
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    const entry = index in value ? value[index] : void 0;
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return entry;
+    }
+  }
+  return void 0;
 }
 async function findIndexInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     const entry = index in value ? value[index] : void 0;
     if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
       return index;
@@ -143966,6 +143979,7 @@ async function findIndexInArray(value, callback, options, stack, thisValue) {
 async function findLastInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = length - 1; index >= 0; index -= 1) {
+    options.budget.visitNode();
     const entry = index in value ? value[index] : void 0;
     if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
       return entry;
@@ -143976,6 +143990,7 @@ async function findLastInArray(value, callback, options, stack, thisValue) {
 async function findLastIndexInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = length - 1; index >= 0; index -= 1) {
+    options.budget.visitNode();
     const entry = index in value ? value[index] : void 0;
     if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
       return index;
@@ -143986,6 +144001,7 @@ async function findLastIndexInArray(value, callback, options, stack, thisValue)
 async function someInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     if (!(index in value)) {
       continue;
     }
@@ -143998,6 +144014,7 @@ async function someInArray(value, callback, options, stack, thisValue) {
 async function everyInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     if (!(index in value)) {
       continue;
     }
@@ -144009,10 +144026,10 @@ async function everyInArray(value, callback, options, stack, thisValue) {
 }
 async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
   const length = value.length;
-  const start = findNextDefinedIndex(value, 0, 1, length);
   if (hasInitialValue) {
-    return reduceFromLeft(value, callback, initialValue, start, length, options, stack);
+    return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
   }
+  const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
   if (start < 0) {
     throw new TypeError("Reduce of empty array with no initial value.");
   }
@@ -144020,10 +144037,10 @@ async function reduceArray(value, callback, hasInitialValue, initialValue, optio
 }
 async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
   const length = value.length;
-  const start = findNextDefinedIndex(value, length - 1, -1, length);
   if (hasInitialValue) {
-    return reduceFromRight(value, callback, initialValue, start, length, options, stack);
+    return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
   }
+  const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
   if (start < 0) {
     throw new TypeError("Reduce of empty array with no initial value.");
   }
@@ -144031,27 +144048,42 @@ async function reduceRightArray(value, callback, hasInitialValue, initialValue,
 }
 async function reduceFromLeft(value, callback, accumulator, startIndex, length, options, stack) {
   let current = accumulator;
-  for (let index = startIndex; index < length; index += 1) {
-    if (!(index in value)) {
-      continue;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+  try {
+    for (let index = startIndex; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      current = await options.callClosure(callback, [current, value[index], index, value], stack);
     }
-    current = await options.callClosure(callback, [current, value[index], index, value], stack);
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
   }
-  return current;
 }
 async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
   let current = accumulator;
-  for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
-    if (!(index in value)) {
-      continue;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+  try {
+    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      current = await options.callClosure(callback, [current, value[index], index, value], stack);
     }
-    current = await options.callClosure(callback, [current, value[index], index, value], stack);
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
   }
-  return current;
 }
 async function forEachArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     if (!(index in value)) {
       continue;
     }
@@ -144061,33 +144093,40 @@ async function forEachArray(value, callback, options, stack, thisValue) {
 async function flatMapArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   const result = [];
-  for (let index = 0; index < length; index += 1) {
-    if (!(index in value)) {
-      continue;
-    }
-    const mapped = await callArrayCallback(
-      callback,
-      value[index],
-      index,
-      value,
-      options,
-      stack,
-      thisValue
-    );
-    if (Array.isArray(mapped)) {
-      for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
-        if (!(mappedIndex in mapped)) {
-          continue;
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      const mapped = await callArrayCallback(
+        callback,
+        value[index],
+        index,
+        value,
+        options,
+        stack,
+        thisValue
+      );
+      if (Array.isArray(mapped)) {
+        for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
+          options.budget.visitNode();
+          if (!(mappedIndex in mapped)) {
+            continue;
+          }
+          result.push(mapped[mappedIndex]);
+          options.budget.allocateArrayLength(result.length);
         }
-        result.push(mapped[mappedIndex]);
-        options.budget.allocateArrayLength(result.length);
+        continue;
       }
-      continue;
+      result.push(mapped);
+      options.budget.allocateArrayLength(result.length);
     }
-    result.push(mapped);
-    options.budget.allocateArrayLength(result.length);
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
   }
-  return result;
 }
 function flattenArray(value, depth, budget) {
   const result = [];
@@ -144109,47 +144148,59 @@ function appendFlattenedEntries(value, depth, result, budget) {
   }
 }
 async function sortArray(value, comparator, options, stack) {
+  const length = value.length;
   const definedValues = [];
   let undefinedCount = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    if (!(index in value)) {
-      continue;
+  let currentEntry;
+  options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      const entry = value[index];
+      if (entry === void 0) {
+        undefinedCount += 1;
+        continue;
+      }
+      definedValues.push(entry);
     }
-    const entry = value[index];
-    if (entry === void 0) {
-      undefinedCount += 1;
-      continue;
+    for (let index = 1; index < definedValues.length; index += 1) {
+      currentEntry = definedValues[index];
+      let cursor2 = index - 1;
+      while (cursor2 >= 0 && await compareEntries(definedValues[cursor2], currentEntry, comparator, options, stack) > 0) {
+        definedValues[cursor2 + 1] = definedValues[cursor2];
+        cursor2 -= 1;
+      }
+      definedValues[cursor2 + 1] = currentEntry;
     }
-    definedValues.push(entry);
-  }
-  for (let index = 1; index < definedValues.length; index += 1) {
-    const entry = definedValues[index];
-    let cursor2 = index - 1;
-    while (cursor2 >= 0 && await compareEntries(definedValues[cursor2], entry, comparator, options, stack) > 0) {
-      definedValues[cursor2 + 1] = definedValues[cursor2];
-      cursor2 -= 1;
+    currentEntry = void 0;
+    for (let index = 0; index < definedValues.length; index += 1) {
+      value[index] = definedValues[index];
     }
-    definedValues[cursor2 + 1] = entry;
-  }
-  for (let index = 0; index < definedValues.length; index += 1) {
-    value[index] = definedValues[index];
-  }
-  for (let index = 0; index < undefinedCount; index += 1) {
-    value[definedValues.length + index] = void 0;
-  }
-  for (let index = definedValues.length + undefinedCount; index < value.length; index += 1) {
-    delete value[index];
+    for (let index = 0; index < undefinedCount; index += 1) {
+      value[definedValues.length + index] = void 0;
+    }
+    for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
+      options.budget.visitNode();
+      delete value[index];
+    }
+  } finally {
+    options.budget.setRetainedValues(definedValues, void 0);
   }
 }
 async function compareEntries(left, right, comparator, options, stack) {
+  options.budget.visitNode();
   const result = Number(await options.callClosure(comparator, [left, right], stack));
   return Number.isNaN(result) ? 0 : result;
 }
 async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {
   return options.callClosure(callback, [value, index, array], stack, thisValue);
 }
-function findNextDefinedIndex(value, startIndex, direction, length) {
+function findNextDefinedIndex(value, startIndex, direction, length, budget) {
   for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
+    budget.visitNode();
     if (index in value) {
       return index;
     }
@@ -156554,7 +156605,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "13.0.2",
+      version: "13.0.3",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",