@ai-ecoverse/slicc-kernel 1.162.0 → 1.163.0

package/dist/node-driver-worker.js

@@ -1420,6 +1420,123 @@ async function hostDriver(start, load) {
 import { isBuiltin, registerHooks } from "node:module";
 import { types } from "node:util";
 
+// src/node-stack.ts
+import { createRequire } from "node:module";
+var apply = Reflect.apply;
+var push = Array.prototype.push;
+var startsWith = String.prototype.startsWith;
+var slice = String.prototype.slice;
+var lastIndexOf = String.prototype.lastIndexOf;
+var indexOf2 = String.prototype.indexOf;
+var setHas = Set.prototype.has;
+var setAdd = Set.prototype.add;
+function internals() {
+  try {
+    const load = createRequire(import.meta.url);
+    const errors = load("internal/errors");
+    const set = errors.setInternalPrepareStackTrace;
+    let fallback = errors.defaultPrepareStackTrace;
+    if (process.sourceMapsEnabled) {
+      fallback = load("internal/source_map/prepare_stack_trace").prepareStackTraceWithSourceMaps;
+    }
+    if (typeof set !== "function" || typeof fallback !== "function") return void 0;
+    return {
+      setInternalPrepareStackTrace: set,
+      fallback
+    };
+  } catch {
+    return void 0;
+  }
+}
+function ownSite() {
+  const saved = Object.getOwnPropertyDescriptor(Error, "prepareStackTrace");
+  try {
+    Object.defineProperty(Error, "prepareStackTrace", {
+      value: (_, sites) => sites[0],
+      configurable: true,
+      writable: true
+    });
+    return new Error().stack;
+  } finally {
+    delete Error.prepareStackTrace;
+    Object.defineProperties(Error, saved ? { prepareStackTrace: saved } : {});
+  }
+}
+var self = ownSite();
+var proto = Object.getPrototypeOf(self);
+var fileOf = proto.getFileName;
+var hashOf = proto.getScriptHash;
+var isEval = proto.isEval;
+var originOf = proto.getEvalOrigin;
+var ownHash = apply(hashOf, self, []);
+var programHashes = /* @__PURE__ */ new Set();
+var programNames = /* @__PURE__ */ new Set();
+function programName(name) {
+  return apply(startsWith, name, ["data:"]) === true || apply(setHas, programNames, [name]) === true;
+}
+function rootOrigin(origin) {
+  let at = origin;
+  while (apply(startsWith, at, ["eval at "]) === true) {
+    const open = apply(indexOf2, at, [" ("]);
+    if (open < 0) return "";
+    let depth = 1;
+    let i = open + 2;
+    for (; i < at.length && depth > 0; i++) {
+      const c = at[i];
+      if (c === "(") depth++;
+      else if (c === ")") depth--;
+    }
+    if (depth !== 0) return "";
+    at = apply(slice, at, [open + 2, i - 1]);
+  }
+  let end = at.length;
+  for (let n = 0; n < 2; n++) {
+    const colon = apply(lastIndexOf, at, [":", end - 1]);
+    if (colon <= 0) break;
+    end = colon;
+  }
+  return apply(slice, at, [0, end]);
+}
+function keptFrame(site) {
+  const hash = apply(hashOf, site, []);
+  if (hash === ownHash) return false;
+  if (apply(isEval, site, []) === true) {
+    const origin = apply(originOf, site, []);
+    return typeof origin === "string" && programName(rootOrigin(origin));
+  }
+  const file = apply(fileOf, site, []);
+  if (typeof file !== "string") return true;
+  if (apply(setHas, programHashes, [hash]) === true) return true;
+  return apply(startsWith, file, ["node:"]) === true || programName(file);
+}
+function keptFrames(trace) {
+  const out = [];
+  for (let i = 0; i < trace.length; i++) {
+    const site = trace[i];
+    if (keptFrame(site)) apply(push, out, [site]);
+  }
+  return out;
+}
+var formatter = null;
+var formatting = false;
+function stackDispatcher(fallback) {
+  return (error, trace) => {
+    const fn = formatter;
+    if (fn === null || formatting) return apply(fallback, void 0, [error, trace]);
+    formatting = true;
+    try {
+      const out = apply(fn, void 0, [error, keptFrames(trace)]);
+      if (typeof out === "string") return out;
+    } catch {
+    } finally {
+      formatting = false;
+    }
+    return apply(fallback, void 0, [error, trace]);
+  };
+}
+var found = internals();
+if (found) found.setInternalPrepareStackTrace(stackDispatcher(found.fallback));
+
 // src/process/js/lockdown.ts
 var BLOCKED_GLOBALS = [
   "XMLHttpRequest",