@ant-design/agentic-ui 2.0.10 → 2.0.13

package/dist/Utils/proxySandbox/ProxySandbox.js

@@ -0,0 +1,1061 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/Utils/proxySandbox/ProxySandbox.ts
+var DANGEROUS_GLOBALS = [
+  "eval",
+  "Function",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "global",
+  "globalThis",
+  "self",
+  "parent",
+  "top",
+  "frames",
+  "location",
+  "history",
+  "navigator",
+  "screen",
+  "localStorage",
+  "sessionStorage",
+  "indexedDB",
+  "WebSocket",
+  "XMLHttpRequest",
+  "fetch",
+  "Request",
+  "Response",
+  "Headers",
+  "URL",
+  "URLSearchParams",
+  "Blob",
+  "File",
+  "FileReader",
+  "FormData",
+  "Worker",
+  "SharedWorker",
+  "ServiceWorker",
+  "MessageChannel",
+  "MessagePort",
+  "BroadcastChannel",
+  "WebRTC",
+  "MediaStream",
+  "process",
+  "require",
+  "module",
+  "exports",
+  "Buffer",
+  "global",
+  "setImmediate",
+  "clearImmediate",
+  "setInterval",
+  "clearInterval",
+  "setTimeout",
+  "clearTimeout",
+  "queueMicrotask",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "requestIdleCallback",
+  "cancelIdleCallback",
+  "crypto",
+  "SubtleCrypto",
+  "performance",
+  "PerformanceObserver",
+  "IntersectionObserver",
+  "MutationObserver",
+  "ResizeObserver",
+  "AbortController",
+  "AbortSignal",
+  "EventSource",
+  "CloseEvent",
+  "CustomEvent",
+  "ErrorEvent",
+  "Event",
+  "EventTarget",
+  "MessageEvent",
+  "ProgressEvent",
+  "PromiseRejectionEvent",
+  "alert",
+  "confirm",
+  "prompt",
+  "open",
+  "close",
+  "print",
+  "focus",
+  "blur",
+  "getSelection",
+  "getComputedStyle",
+  "matchMedia",
+  "moveBy",
+  "moveTo",
+  "resizeBy",
+  "resizeTo",
+  "scroll",
+  "scrollBy",
+  "scrollTo",
+  "stop",
+  "Notification",
+  "webkitNotifications",
+  "external",
+  "chrome",
+  "safari",
+  "opera",
+  "moz"
+];
+var SAFE_GLOBALS = [
+  "console",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "Math",
+  "Date",
+  "JSON",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  "String",
+  "Number",
+  "Boolean",
+  "Array",
+  "Object",
+  "RegExp",
+  "Error",
+  "TypeError",
+  "ReferenceError",
+  "SyntaxError"
+];
+var ProxySandbox = class {
+  constructor(config = {}) {
+    this.isActive = false;
+    this.timeoutId = null;
+    this.startTime = 0;
+    var _a, _b, _c, _d;
+    this.config = {
+      allowedGlobals: config.allowedGlobals || SAFE_GLOBALS,
+      forbiddenGlobals: config.forbiddenGlobals || DANGEROUS_GLOBALS,
+      allowConsole: (_a = config.allowConsole) != null ? _a : true,
+      allowTimers: (_b = config.allowTimers) != null ? _b : true,
+      timeout: config.timeout || 5e3,
+      strictMode: (_c = config.strictMode) != null ? _c : true,
+      customGlobals: config.customGlobals || {},
+      allowDOM: (_d = config.allowDOM) != null ? _d : false,
+      maxMemoryUsage: config.maxMemoryUsage || 10 * 1024 * 1024
+      // 10MB
+    };
+    this.sandboxGlobal = this.createSandboxGlobal();
+    this.globalProxy = this.createGlobalProxy();
+  }
+  /**
+   * 创建安全的 document 代理对象
+   * 允许访问 document 但限制敏感操作
+   */
+  createSafeDocument() {
+    const safeDocument = {};
+    safeDocument.title = "Sandbox Document";
+    safeDocument.readyState = "complete";
+    safeDocument.documentURI = "about:blank";
+    safeDocument.URL = "about:blank";
+    safeDocument.domain = "";
+    safeDocument.origin = "null";
+    safeDocument.doctype = null;
+    safeDocument.documentElement = null;
+    safeDocument.body = null;
+    safeDocument.head = null;
+    Object.defineProperty(safeDocument, "cookie", {
+      get: () => "",
+      set: () => {
+      },
+      // 静默忽略设置
+      enumerable: true,
+      configurable: false
+    });
+    safeDocument.getElementById = () => null;
+    safeDocument.getElementsByClassName = () => [];
+    safeDocument.getElementsByTagName = () => [];
+    safeDocument.getElementsByName = () => [];
+    safeDocument.querySelector = () => null;
+    safeDocument.querySelectorAll = () => [];
+    safeDocument.createElement = (tagName) => ({
+      tagName: tagName.toUpperCase(),
+      id: "",
+      className: "",
+      innerHTML: "",
+      textContent: "",
+      setAttribute: () => {
+      },
+      getAttribute: () => null,
+      removeAttribute: () => {
+      },
+      appendChild: () => {
+      },
+      removeChild: () => {
+      },
+      addEventListener: () => {
+      },
+      removeEventListener: () => {
+      }
+    });
+    safeDocument.createTextNode = (data) => ({
+      nodeType: 3,
+      textContent: data,
+      data
+    });
+    safeDocument.createDocumentFragment = () => ({
+      nodeType: 11,
+      appendChild: () => {
+      },
+      querySelector: () => null,
+      querySelectorAll: () => []
+    });
+    return new Proxy(safeDocument, {
+      get: (target, prop, receiver) => {
+        const propStr = String(prop);
+        const dangerousDocumentProps = [
+          "location",
+          "defaultView",
+          "parentWindow",
+          "implementation",
+          "documentURI",
+          "execCommand",
+          "write",
+          "writeln",
+          "open",
+          "close",
+          "evaluate",
+          "createRange",
+          "getSelection",
+          "elementsFromPoint",
+          "elementFromPoint",
+          "hasFocus",
+          "hidden",
+          "visibilityState"
+        ];
+        if (dangerousDocumentProps.includes(propStr)) {
+          return void 0;
+        }
+        if (propStr in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        return void 0;
+      },
+      set: (target, prop, value, receiver) => {
+        const propStr = String(prop);
+        const readOnlyProps = [
+          "title",
+          "readyState",
+          "documentURI",
+          "URL",
+          "domain",
+          "origin"
+        ];
+        if (readOnlyProps.includes(propStr)) {
+          return false;
+        }
+        return Reflect.set(target, prop, value, receiver);
+      },
+      has: (target, prop) => {
+        const propStr = String(prop);
+        const dangerousDocumentProps = [
+          "location",
+          "defaultView",
+          "parentWindow",
+          "implementation",
+          "execCommand",
+          "write",
+          "writeln",
+          "open",
+          "close"
+        ];
+        if (dangerousDocumentProps.includes(propStr)) {
+          return false;
+        }
+        return Reflect.has(target, prop);
+      }
+    });
+  }
+  /**
+   * 创建安全的 window 代理对象
+   * 允许访问 window 但限制敏感信息
+   */
+  createSafeWindow(safeDocument) {
+    const sensitiveProperties = [
+      "cookie",
+      "localStorage",
+      "sessionStorage",
+      "indexedDB",
+      "location",
+      "history",
+      "navigator",
+      "parent",
+      "top",
+      "frames",
+      "opener",
+      "external",
+      "chrome",
+      "safari",
+      "opera",
+      "moz"
+    ];
+    const safeWindow = {};
+    if (typeof window !== "undefined") {
+      safeWindow.innerWidth = 1024;
+      safeWindow.innerHeight = 768;
+      safeWindow.outerWidth = 1024;
+      safeWindow.outerHeight = 768;
+      safeWindow.devicePixelRatio = 1;
+      safeWindow.screen = {
+        width: 1920,
+        height: 1080,
+        availWidth: 1920,
+        availHeight: 1040,
+        colorDepth: 24,
+        pixelDepth: 24
+      };
+    }
+    safeWindow.Array = Array;
+    safeWindow.Object = Object;
+    safeWindow.String = String;
+    safeWindow.Number = Number;
+    safeWindow.Boolean = Boolean;
+    safeWindow.Date = Date;
+    safeWindow.Math = Math;
+    safeWindow.JSON = JSON;
+    safeWindow.RegExp = RegExp;
+    safeWindow.Error = Error;
+    safeWindow.TypeError = TypeError;
+    safeWindow.ReferenceError = ReferenceError;
+    safeWindow.SyntaxError = SyntaxError;
+    safeWindow.parseInt = parseInt;
+    safeWindow.parseFloat = parseFloat;
+    safeWindow.isNaN = isNaN;
+    safeWindow.isFinite = isFinite;
+    safeWindow.encodeURIComponent = encodeURIComponent;
+    safeWindow.decodeURIComponent = decodeURIComponent;
+    safeWindow.encodeURI = encodeURI;
+    safeWindow.decodeURI = decodeURI;
+    safeWindow.document = safeDocument || this.createSafeDocument();
+    if (this.config.allowConsole) {
+      safeWindow.console = {
+        log: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        info: console.info.bind(console),
+        debug: console.debug.bind(console)
+      };
+    }
+    return new Proxy(safeWindow, {
+      get: (target, prop, receiver) => {
+        const propStr = String(prop);
+        if (sensitiveProperties.includes(propStr)) {
+          switch (propStr) {
+            case "cookie":
+              return "";
+            case "localStorage":
+            case "sessionStorage":
+              return {
+                length: 0,
+                getItem: () => null,
+                setItem: () => {
+                },
+                removeItem: () => {
+                },
+                clear: () => {
+                },
+                key: () => null
+              };
+            case "location":
+              return {
+                href: "about:blank",
+                origin: "null",
+                protocol: "about:",
+                host: "",
+                hostname: "",
+                port: "",
+                pathname: "blank",
+                search: "",
+                hash: ""
+              };
+            case "navigator":
+              return {
+                userAgent: "Sandbox/1.0",
+                language: "en-US",
+                languages: ["en-US"],
+                platform: "Sandbox",
+                cookieEnabled: false,
+                onLine: true
+              };
+            default:
+              return void 0;
+          }
+        }
+        if (propStr in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        return void 0;
+      },
+      set: (target, prop, value, receiver) => {
+        const propStr = String(prop);
+        if (sensitiveProperties.includes(propStr)) {
+          return false;
+        }
+        return Reflect.set(target, prop, value, receiver);
+      },
+      has: (target, prop) => {
+        const propStr = String(prop);
+        if (sensitiveProperties.includes(propStr)) {
+          return false;
+        }
+        return Reflect.has(target, prop);
+      },
+      ownKeys: (target) => {
+        const allKeys = Reflect.ownKeys(target);
+        return allKeys.filter(
+          (key) => !sensitiveProperties.includes(String(key))
+        );
+      },
+      getOwnPropertyDescriptor: (target, prop) => {
+        const propStr = String(prop);
+        if (sensitiveProperties.includes(propStr)) {
+          return void 0;
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    });
+  }
+  /**
+   * 创建安全的沙箱全局对象
+   */
+  createSandboxGlobal() {
+    const sandboxGlobal = {};
+    for (const globalName of this.config.allowedGlobals) {
+      if (globalName in globalThis) {
+        sandboxGlobal[globalName] = globalThis[globalName];
+      }
+    }
+    Object.assign(sandboxGlobal, this.config.customGlobals);
+    const safeDocument = this.createSafeDocument();
+    const safeWindow = this.createSafeWindow(safeDocument);
+    sandboxGlobal.window = safeWindow;
+    sandboxGlobal.document = safeDocument;
+    if (this.config.allowConsole) {
+      sandboxGlobal.console = this.createSafeConsole();
+    }
+    if (this.config.allowTimers) {
+      sandboxGlobal.setTimeout = this.createSafeTimeout();
+      sandboxGlobal.setInterval = this.createSafeInterval();
+      sandboxGlobal.clearTimeout = clearTimeout;
+      sandboxGlobal.clearInterval = clearInterval;
+    }
+    sandboxGlobal.__checkInstructions = () => {
+    };
+    return sandboxGlobal;
+  }
+  /**
+   * 创建安全的 console 对象
+   */
+  createSafeConsole() {
+    return {
+      log: (...args) => console.log("[Sandbox]", ...args),
+      warn: (...args) => console.warn("[Sandbox]", ...args),
+      error: (...args) => console.error("[Sandbox]", ...args),
+      info: (...args) => console.info("[Sandbox]", ...args),
+      debug: (...args) => console.debug("[Sandbox]", ...args)
+    };
+  }
+  /**
+   * 创建安全的 setTimeout
+   */
+  createSafeTimeout() {
+    return (callback, delay, ...args) => {
+      if (typeof callback !== "function") {
+        throw new TypeError("Callback must be a function");
+      }
+      const safeCallback = () => {
+        try {
+          callback.apply(null, args);
+        } catch (error) {
+          console.error("[Sandbox] Timer callback error:", error);
+        }
+      };
+      return setTimeout(safeCallback, Math.min(delay, 1e3));
+    };
+  }
+  /**
+   * 创建安全的 setInterval
+   */
+  createSafeInterval() {
+    return (callback, delay, ...args) => {
+      if (typeof callback !== "function") {
+        throw new TypeError("Callback must be a function");
+      }
+      const safeCallback = () => {
+        try {
+          callback.apply(null, args);
+        } catch (error) {
+          console.error("[Sandbox] Interval callback error:", error);
+        }
+      };
+      return setInterval(safeCallback, Math.max(delay, 100));
+    };
+  }
+  /**
+   * 创建全局对象的 Proxy
+   */
+  createGlobalProxy() {
+    return new Proxy(this.sandboxGlobal, {
+      get: (target, prop, receiver) => {
+        const propStr = String(prop);
+        if (this.config.forbiddenGlobals.includes(propStr)) {
+          throw new ReferenceError(
+            `Access to '${propStr}' is not allowed in sandbox`
+          );
+        }
+        if (propStr === "__checkInstructions") {
+          return Reflect.get(target, prop, receiver);
+        }
+        if (this.config.allowedGlobals.includes(propStr)) {
+          if (propStr in target) {
+            return Reflect.get(target, prop, receiver);
+          }
+          if (propStr === "window" || propStr === "global" || propStr === "globalThis") {
+            return receiver;
+          }
+        }
+        if (propStr in this.config.customGlobals) {
+          return Reflect.get(target, prop, receiver);
+        }
+        return void 0;
+      },
+      set: (target, prop, value, receiver) => {
+        const propStr = String(prop);
+        if (this.config.forbiddenGlobals.includes(propStr)) {
+          throw new ReferenceError(
+            `Setting '${propStr}' is not allowed in sandbox`
+          );
+        }
+        return Reflect.set(target, prop, value, receiver);
+      },
+      has: (target, prop) => {
+        const propStr = String(prop);
+        if (this.config.forbiddenGlobals.includes(propStr)) {
+          return false;
+        }
+        return this.config.allowedGlobals.includes(propStr) || Reflect.has(target, prop);
+      },
+      ownKeys: (target) => {
+        const allKeys = Reflect.ownKeys(target);
+        return allKeys.filter(
+          (key) => !this.config.forbiddenGlobals.includes(String(key))
+        );
+      },
+      getOwnPropertyDescriptor: (target, prop) => {
+        const propStr = String(prop);
+        if (this.config.forbiddenGlobals.includes(propStr)) {
+          return void 0;
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    });
+  }
+  /**
+   * 在沙箱中执行代码
+   */
+  execute(code, injectedParams) {
+    return __async(this, null, function* () {
+      this.startTime = performance.now();
+      this.isActive = true;
+      let result;
+      let error;
+      let success = false;
+      try {
+        if (typeof Worker !== "undefined" && typeof URL !== "undefined") {
+          result = yield this.executeWithWorker(code, injectedParams);
+        } else {
+          if (this.isObviousInfiniteLoop(code)) {
+            result = yield this.executeWithInstructionLimit(code, injectedParams);
+          } else {
+            result = yield this.executeWithTimeout(code, injectedParams);
+          }
+        }
+        success = true;
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        success = false;
+      } finally {
+        this.cleanup();
+      }
+      const executionTime = performance.now() - this.startTime;
+      return {
+        result,
+        success,
+        error,
+        executionTime,
+        memoryUsage: this.getMemoryUsage()
+      };
+    });
+  }
+  /**
+   * 检查是否是明显的死循环
+   */
+  isObviousInfiniteLoop(code) {
+    const infiniteLoopPatterns = [
+      /while\s*\(\s*true\s*\)/,
+      /for\s*\(\s*;\s*;\s*\)/,
+      /while\s*\(\s*1\s*\)/,
+      /while\s*\(\s*!false\s*\)/
+    ];
+    return infiniteLoopPatterns.some((pattern) => pattern.test(code));
+  }
+  /**
+   * 带超时的普通执行
+   */
+  executeWithTimeout(code, injectedParams) {
+    return __async(this, null, function* () {
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(
+            new Error(`Code execution timeout after ${this.config.timeout}ms`)
+          );
+        }, this.config.timeout);
+        try {
+          const result = this.executeCode(code, injectedParams);
+          clearTimeout(timeoutId);
+          resolve(result);
+        } catch (error) {
+          clearTimeout(timeoutId);
+          reject(error);
+        }
+      });
+    });
+  }
+  /**
+   * 使用指令计数限制执行时间
+   */
+  executeWithInstructionLimit(code, injectedParams) {
+    return __async(this, null, function* () {
+      return new Promise((resolve, reject) => {
+        const maxInstructions = 1e6;
+        let instructionCount = 0;
+        const startTime = performance.now();
+        const instrumentedCode = this.instrumentCode(code);
+        const originalGlobal = this.sandboxGlobal.__checkInstructions;
+        this.sandboxGlobal.__checkInstructions = () => {
+          instructionCount++;
+          const elapsed = performance.now() - startTime;
+          if (elapsed > this.config.timeout) {
+            throw new Error(
+              `Code execution timeout after ${this.config.timeout}ms`
+            );
+          }
+          if (instructionCount > maxInstructions && elapsed < 10) {
+            throw new Error(`Code execution exceeded maximum instruction limit`);
+          }
+        };
+        try {
+          const result = this.executeCode(instrumentedCode, injectedParams);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        } finally {
+          if (originalGlobal) {
+            this.sandboxGlobal.__checkInstructions = originalGlobal;
+          } else {
+            delete this.sandboxGlobal.__checkInstructions;
+          }
+        }
+      });
+    });
+  }
+  /**
+   * 在代码中注入指令计数器
+   */
+  instrumentCode(code) {
+    let instrumented = code;
+    instrumented = instrumented.replace(
+      /(\bfor\s*\([^)]*\)\s*\{)/g,
+      "$1\n  __checkInstructions();"
+    );
+    instrumented = instrumented.replace(
+      /(\bwhile\s*\([^)]*\)\s*\{)/g,
+      "$1\n  __checkInstructions();"
+    );
+    instrumented = instrumented.replace(
+      /(\bdo\s*\{)/g,
+      "$1\n  __checkInstructions();"
+    );
+    return `__checkInstructions();
+${instrumented}`;
+  }
+  /**
+   * 使用 Worker 执行代码以实现真正的超时控制
+   */
+  executeWithWorker(code, injectedParams) {
+    return new Promise((resolve, reject) => {
+      let serializableParams = {};
+      if (injectedParams) {
+        try {
+          for (const [key, value] of Object.entries(injectedParams)) {
+            try {
+              JSON.stringify(value);
+              serializableParams[key] = value;
+            } catch (e) {
+              console.warn(`无法序列化注入参数 "${key}"，回退到同步执行`);
+              this.executeCode(code, injectedParams).then(resolve).catch(reject);
+              return;
+            }
+          }
+        } catch (error) {
+          console.warn("注入参数序列化检查失败，回退到同步执行");
+          try {
+            const result = this.executeCode(code, injectedParams);
+            resolve(result);
+          } catch (syncError) {
+            reject(syncError);
+          }
+          return;
+        }
+      }
+      const workerCode = `
+        self.onmessage = function(e) {
+          const { code, config, injectedParams } = e.data;
+          
+          try {
+            // 创建安全的执行环境
+            const safeGlobals = {
+              Math, Date, JSON, parseInt, parseFloat, isNaN, isFinite,
+              encodeURIComponent, decodeURIComponent, encodeURI, decodeURI,
+              String, Number, Boolean, Array, Object, RegExp,
+              Error, TypeError, ReferenceError, SyntaxError
+            };
+            
+            // 添加自定义全局变量
+            Object.assign(safeGlobals, config.customGlobals || {});
+            
+            // 添加注入的参数
+            Object.assign(safeGlobals, injectedParams || {});
+            
+            // 添加 console（如果允许）
+            if (config.allowConsole) {
+              safeGlobals.console = {
+                log: (...args) => self.postMessage({ type: 'log', data: args }),
+                warn: (...args) => self.postMessage({ type: 'warn', data: args }),
+                error: (...args) => self.postMessage({ type: 'error', data: args }),
+                info: (...args) => self.postMessage({ type: 'info', data: args }),
+                debug: (...args) => self.postMessage({ type: 'debug', data: args })
+              };
+            }
+            
+            // 创建执行函数
+            const wrappedCode = config.strictMode ? "'use strict';\\n" + code : code;
+            const func = new Function(...Object.keys(safeGlobals), 'return (function() { ' + wrappedCode + ' })()');
+            
+            // 执行代码
+            const result = func(...Object.values(safeGlobals));
+            
+            self.postMessage({ type: 'result', data: result });
+          } catch (error) {
+            self.postMessage({ type: 'error', data: { message: error.message, stack: error.stack } });
+          }
+        };
+      `;
+      const blob = new Blob([workerCode], { type: "application/javascript" });
+      const workerUrl = URL.createObjectURL(blob);
+      let worker;
+      let timeoutId;
+      try {
+        worker = new Worker(workerUrl);
+        timeoutId = window.setTimeout(() => {
+          if (worker) {
+            worker.terminate();
+          }
+          URL.revokeObjectURL(workerUrl);
+          reject(
+            new Error(`Code execution timeout after ${this.config.timeout}ms`)
+          );
+        }, this.config.timeout);
+        worker.onmessage = (e) => {
+          const { type, data } = e.data;
+          if (type === "result") {
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            if (worker)
+              worker.terminate();
+            URL.revokeObjectURL(workerUrl);
+            resolve(data);
+          } else if (type === "error") {
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            if (worker)
+              worker.terminate();
+            URL.revokeObjectURL(workerUrl);
+            reject(new Error(data.message));
+          } else if (type === "log" || type === "warn" || type === "error" || type === "info" || type === "debug") {
+            if (this.config.allowConsole) {
+              const consoleMethod = console[type];
+              if (typeof consoleMethod === "function") {
+                consoleMethod("[Sandbox]", ...data);
+              }
+            }
+          }
+        };
+        worker.onerror = (error) => {
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          if (worker)
+            worker.terminate();
+          URL.revokeObjectURL(workerUrl);
+          reject(new Error(`Worker error: ${error.message}`));
+        };
+        worker.postMessage({
+          code,
+          config: this.config,
+          injectedParams: serializableParams
+        });
+      } catch (error) {
+        if (timeoutId)
+          clearTimeout(timeoutId);
+        if (worker)
+          worker.terminate();
+        URL.revokeObjectURL(workerUrl);
+        try {
+          const result = this.executeCode(code, injectedParams);
+          resolve(result);
+        } catch (syncError) {
+          reject(syncError);
+        }
+      }
+    });
+  }
+  /**
+   * 执行代码的核心方法（同步版本）
+   */
+  executeCode(code, injectedParams) {
+    const wrappedCode = this.config.strictMode ? `'use strict';
+${code}` : code;
+    this.validateCode(wrappedCode);
+    const allGlobals = __spreadValues(__spreadValues(__spreadValues({}, this.sandboxGlobal), this.config.customGlobals), injectedParams || {});
+    const allowedKeys = Object.keys(allGlobals);
+    const allowedValues = allowedKeys.map((key) => allGlobals[key]);
+    const funcCode = `
+      return (function(${allowedKeys.join(", ")}) {
+        ${wrappedCode}
+      })(${allowedKeys.map((_, index) => `arguments[${index}]`).join(", ")});
+    `;
+    try {
+      const func = new Function(funcCode);
+      return func.apply(null, allowedValues);
+    } catch (error) {
+      if (error instanceof ReferenceError) {
+        const match = error.message.match(/(\w+) is not defined/);
+        if (match) {
+          const varName = match[1];
+          if (this.config.forbiddenGlobals.includes(varName)) {
+            throw new ReferenceError(
+              `Access to '${varName}' is not allowed in sandbox`
+            );
+          }
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * 验证代码安全性
+   */
+  validateCode(code) {
+    const dangerousPatterns = [
+      /\beval\s*\(/,
+      /\bFunction\s*\(/,
+      /new\s+Function\s*\(/,
+      /\.constructor/,
+      // 直接检查 .constructor 访问
+      /\.__proto__/,
+      /\.prototype\./,
+      /\bglobal\s*[.[]/,
+      /\bself\s*[.[]/,
+      /\bprocess\s*[.[]/,
+      /\brequire\s*\(/,
+      /\bimport\s*\(/,
+      /\bimportScripts\s*\(/
+    ];
+    const globalThisPatterns = [
+      /\bglobalThis\s*\.\s*[a-zA-Z_$]/,
+      // globalThis.someProperty
+      /\bglobalThis\s*\[/,
+      // globalThis[someIndex]
+      /=\s*globalThis\b/,
+      // = globalThis
+      /\breturn\s+globalThis\b/
+      // return globalThis
+    ];
+    for (const pattern of globalThisPatterns) {
+      if (pattern.test(code)) {
+        throw new Error(
+          "Code contains dangerous pattern: globalThis property access"
+        );
+      }
+    }
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(code)) {
+        throw new Error(`Code contains dangerous pattern: ${pattern.source}`);
+      }
+    }
+    const criticalForbiddenGlobals = [
+      "eval",
+      "Function",
+      "constructor",
+      "__proto__",
+      "global",
+      "self",
+      "process",
+      "require",
+      "module",
+      "exports",
+      "Buffer",
+      "XMLHttpRequest",
+      "fetch",
+      "WebSocket",
+      "Worker",
+      "SharedArrayBuffer",
+      "Atomics",
+      "WebAssembly"
+    ];
+    for (const forbiddenGlobal of criticalForbiddenGlobals) {
+      const patterns = [
+        new RegExp(`\\b${forbiddenGlobal}\\s*\\(`, "g"),
+        // 函数调用
+        new RegExp(`\\b${forbiddenGlobal}\\s*\\.`, "g"),
+        // 属性访问
+        new RegExp(`\\b${forbiddenGlobal}\\s*\\[`, "g"),
+        // 索引访问
+        new RegExp(`\\breturn\\s+${forbiddenGlobal}\\b`, "g"),
+        // 直接返回
+        new RegExp(`=\\s*${forbiddenGlobal}\\b`, "g")
+        // 赋值
+      ];
+      for (const pattern of patterns) {
+        if (pattern.test(code)) {
+          throw new ReferenceError(
+            `Access to '${forbiddenGlobal}' is not allowed in sandbox`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 获取内存使用情况
+   */
+  getMemoryUsage() {
+    if ("memory" in performance) {
+      return performance.memory.usedJSHeapSize;
+    }
+    return 0;
+  }
+  /**
+   * 清理资源
+   */
+  cleanup() {
+    this.isActive = false;
+    if (this.timeoutId !== null) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+  /**
+   * 销毁沙箱
+   */
+  destroy() {
+    this.cleanup();
+    Object.keys(this.sandboxGlobal).forEach((key) => {
+      delete this.sandboxGlobal[key];
+    });
+  }
+  /**
+   * 检查沙箱是否处于活动状态
+   */
+  isRunning() {
+    return this.isActive;
+  }
+  /**
+   * 添加自定义全局变量
+   */
+  addGlobal(name, value) {
+    if (this.config.forbiddenGlobals.includes(name)) {
+      throw new Error(`Cannot add forbidden global: ${name}`);
+    }
+    this.sandboxGlobal[name] = value;
+    this.config.customGlobals[name] = value;
+  }
+  /**
+   * 移除自定义全局变量
+   */
+  removeGlobal(name) {
+    delete this.sandboxGlobal[name];
+    delete this.config.customGlobals[name];
+  }
+  /**
+   * 获取沙箱配置
+   */
+  getConfig() {
+    return __spreadValues({}, this.config);
+  }
+};
+function createSandbox(config) {
+  return new ProxySandbox(config);
+}
+function runInSandbox(code, config, injectedParams) {
+  return __async(this, null, function* () {
+    const sandbox = createSandbox(config);
+    try {
+      return yield sandbox.execute(code, injectedParams);
+    } finally {
+      sandbox.destroy();
+    }
+  });
+}
+export {
+  ProxySandbox,
+  createSandbox,
+  runInSandbox
+};