iframe-link 1.0.0

package/dist/index.cjs

@@ -0,0 +1,994 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+
+// node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
+var require_ms = __commonJS({
+  "node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports, module2) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module2.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(exports, module2) {
+    "use strict";
+    function setup(env) {
+      createDebug2.debug = createDebug2;
+      createDebug2.default = createDebug2;
+      createDebug2.coerce = coerce;
+      createDebug2.disable = disable;
+      createDebug2.enable = enable;
+      createDebug2.enabled = enabled;
+      createDebug2.humanize = require_ms();
+      createDebug2.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug2[key] = env[key];
+      });
+      createDebug2.names = [];
+      createDebug2.skips = [];
+      createDebug2.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug2.colors[Math.abs(hash) % createDebug2.colors.length];
+      }
+      createDebug2.selectColor = selectColor;
+      function createDebug2(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug2.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug2.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug2.formatArgs.call(self, args);
+          const logFn = self.log || createDebug2.log;
+          logFn.apply(self, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug2.useColors();
+        debug.color = createDebug2.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug2.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug2.namespaces) {
+              namespacesCache = createDebug2.namespaces;
+              enabledCache = createDebug2.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug2.init === "function") {
+          createDebug2.init(debug);
+        }
+        return debug;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug2(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug2.save(namespaces);
+        createDebug2.namespaces = namespaces;
+        createDebug2.names = [];
+        createDebug2.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug2.skips.push(ns.slice(1));
+          } else {
+            createDebug2.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug2.names,
+          ...createDebug2.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug2.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug2.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug2.names) {
+          if (matchesTemplate(name, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug2.enable(createDebug2.load());
+      return createDebug2;
+    }
+    module2.exports = setup;
+  }
+});
+
+// node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js"(exports, module2) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module2.exports = require_common()(exports);
+    var { formatters } = module2.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_ALLOWED_ORIGIN: () => DEFAULT_ALLOWED_ORIGIN,
+  SDK_MESSAGE_TYPES: () => SDK_MESSAGE_TYPES,
+  connectToIframe: () => connectToIframe,
+  connectToParent: () => connectToParent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var SDK_MESSAGE_TYPES = ["READY", "ACK", "CALL", "RESULT", "EVENT"];
+var DEFAULT_ALLOWED_ORIGIN = /^https:\/\/oa\.example\.com$/;
+
+// src/utils.ts
+var import_debug = __toESM(require_browser(), 1);
+var NAMESPACE = "iframe-link";
+var log = {
+  bridge: (0, import_debug.default)(`${NAMESPACE}:bridge`),
+  channel: (0, import_debug.default)(`${NAMESPACE}:channel`),
+  rpc: (0, import_debug.default)(`${NAMESPACE}:rpc`),
+  event: (0, import_debug.default)(`${NAMESPACE}:event`),
+  utils: (0, import_debug.default)(`${NAMESPACE}:utils`)
+};
+function enableDebug() {
+  import_debug.default.enable(`${NAMESPACE}:*`);
+}
+function isTrustedOrigin(origin, allowed) {
+  const result = allowed.some((pattern) => {
+    if (pattern === "*") return true;
+    if (pattern instanceof RegExp) {
+      const matcher = pattern.global || pattern.sticky ? new RegExp(pattern.source, pattern.flags) : pattern;
+      return matcher.test(origin);
+    }
+    return pattern === origin;
+  });
+  log.utils("isTrustedOrigin: %s -> %s %O", origin, result ? "\u2713" : "\u2717", allowed.map((p) => p.toString()));
+  return result;
+}
+function uuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return Date.now().toString(36) + "-" + Math.random().toString(36).slice(2);
+}
+var RPC = class {
+  constructor(messenger, methods) {
+    this.messenger = messenger;
+    this.methods = methods;
+    this.destroyed = false;
+    this.pending = /* @__PURE__ */ new Map();
+    log.rpc("\u521B\u5EFA RPC \u7BA1\u7406\u5668, methods: %O", Object.keys(methods));
+  }
+  call(name, params) {
+    if (this.destroyed) return Promise.reject(new Error("Destroyed"));
+    return new Promise((resolve, reject) => {
+      const id = uuid();
+      log.rpc("\u53D1\u8D77\u8C03\u7528: %s, id=%s, params=%O", name, id, params);
+      this.pending.set(id, { resolve, reject });
+      try {
+        this.messenger.send({ type: "CALL", id, method: name, params });
+      } catch (error) {
+        this.pending.delete(id);
+        reject(error);
+      }
+    });
+  }
+  execute(id, name, params) {
+    return __async(this, null, function* () {
+      log.rpc("\u6267\u884C\u65B9\u6CD5: %s, id=%s, params=%O", name, id, params);
+      if (!Object.prototype.hasOwnProperty.call(this.methods, name)) {
+        log.rpc("\u65B9\u6CD5\u4E0D\u5B58\u5728: %s", name);
+        this.messenger.send({ type: "RESULT", id, error: `Method not found: ${name}` });
+        return;
+      }
+      try {
+        const result = yield this.methods[name](params);
+        log.rpc("\u2713 \u65B9\u6CD5\u6267\u884C\u6210\u529F: %s, result=%O", name, result);
+        this.messenger.send({ type: "RESULT", id, result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log.rpc("\u2717 \u65B9\u6CD5\u6267\u884C\u5931\u8D25: %s, error=%s", name, message);
+        this.messenger.send({ type: "RESULT", id, error: message });
+      }
+    });
+  }
+  resolve(id, result, error) {
+    const p = this.pending.get(id);
+    if (!p) {
+      log.rpc("\u672A\u627E\u5230\u5F85\u5904\u7406\u7684\u8C03\u7528: %s", id);
+      return;
+    }
+    this.pending.delete(id);
+    if (error !== void 0) {
+      log.rpc("\u8C03\u7528\u8FD4\u56DE\u9519\u8BEF: id=%s, error=%s", id, error);
+      p.reject(new Error(error));
+    } else {
+      log.rpc("\u8C03\u7528\u8FD4\u56DE\u6210\u529F: id=%s, result=%O", id, result);
+      p.resolve(result);
+    }
+  }
+  cleanup() {
+    this.destroyed = true;
+    log.rpc("\u6E05\u7406 RPC, pending=%d", this.pending.size);
+    this.pending.forEach(({ reject }) => reject(new Error("Destroyed")));
+    this.pending.clear();
+  }
+};
+function createRPC(messenger, methods) {
+  return new RPC(messenger, methods);
+}
+function createEvent(messenger) {
+  const handlers = /* @__PURE__ */ new Map();
+  return {
+    on: (type, fn) => {
+      if (!handlers.has(type)) handlers.set(type, /* @__PURE__ */ new Set());
+      handlers.get(type).add(fn);
+      log.event("\u8BA2\u9605\u4E8B\u4EF6: %s, handlers=%d", type, handlers.get(type).size);
+    },
+    off: (type, fn) => {
+      var _a;
+      (_a = handlers.get(type)) == null ? void 0 : _a.delete(fn);
+      log.event("\u53D6\u6D88\u8BA2\u9605: %s", type);
+    },
+    emit: (type, data) => {
+      log.event("\u53D1\u9001\u4E8B\u4EF6: %s, data=%O", type, data);
+      messenger.send({ type: "EVENT", eventType: type, data });
+    },
+    dispatch: (type, data) => {
+      const set = handlers.get(type);
+      const count = set ? set.size : 0;
+      log.event("\u5206\u53D1\u4E8B\u4EF6: %s, handlers=%d, data=%O", type, count, data);
+      if (set) set.forEach((fn) => fn(data));
+    },
+    cleanup: () => {
+      log.event("\u6E05\u7406\u4E8B\u4EF6\u7CFB\u7EDF");
+      handlers.clear();
+    }
+  };
+}
+
+// src/channelBridge.ts
+function isValidMessage(data) {
+  const valid = data && typeof data === "object" && (data.type || data.action);
+  if (!valid && data) {
+    log.bridge("\u65E0\u6548\u6D88\u606F\u683C\u5F0F: %O", data);
+  }
+  return valid;
+}
+function cleanMessage(message) {
+  return JSON.parse(JSON.stringify(message));
+}
+function createMessenger(options) {
+  return options.isChild ? createChildMessenger(options.allowedOrigins) : createParentMessenger(options.iframe, options.origin);
+}
+function createParentMessenger(iframe, childOrigin) {
+  let onMessage;
+  let destroyed = false;
+  log.bridge("[Parent] \u521B\u5EFA\u901A\u4FE1\u5668, origin=%s, iframe=%s", childOrigin, (iframe == null ? void 0 : iframe.id) || (iframe == null ? void 0 : iframe.src));
+  const handleMessageEvent = (event) => {
+    log.bridge(
+      "[Parent] \u6536\u5230\u6D88\u606F: origin=%s, expected=%s, sourceMatch=%s, data=%O",
+      event.origin,
+      childOrigin,
+      event.source === iframe.contentWindow,
+      event.data
+    );
+    if (destroyed || !onMessage) {
+      log.bridge("[Parent] \u8DF3\u8FC7: destroyed=%s, hasHandler=%s", destroyed, !!onMessage);
+      return;
+    }
+    if (event.origin !== childOrigin) {
+      log.bridge("[Parent] origin \u4E0D\u5339\u914D: %s !== %s", event.origin, childOrigin);
+      return;
+    }
+    if (event.source !== iframe.contentWindow) {
+      log.bridge("[Parent] source \u4E0D\u662F\u76EE\u6807 iframe");
+      return;
+    }
+    if (!isValidMessage(event.data)) {
+      return;
+    }
+    log.bridge("[Parent] \u2713 \u6D88\u606F\u9A8C\u8BC1\u901A\u8FC7: %O", event.data);
+    onMessage(event.data);
+  };
+  const send = (message) => {
+    log.bridge("[Parent] \u53D1\u9001: %O -> %s", message, childOrigin);
+    if (destroyed) return;
+    if (!iframe.contentWindow) throw new Error("Iframe not available");
+    try {
+      iframe.contentWindow.postMessage(cleanMessage(message), childOrigin);
+      log.bridge("[Parent] \u2713 \u5DF2\u53D1\u9001: %s", message.type);
+    } catch (e) {
+      log.bridge("[Parent] \u2717 \u53D1\u9001\u5F02\u5E38: %O", e);
+      throw e;
+    }
+  };
+  return {
+    isChild: false,
+    init: (handler) => {
+      log.bridge("[Parent] \u5F00\u59CB\u76D1\u542C message \u4E8B\u4EF6");
+      onMessage = handler;
+      window.addEventListener("message", handleMessageEvent);
+    },
+    send,
+    destroy: () => {
+      log.bridge("[Parent] \u9500\u6BC1\u901A\u4FE1\u5668");
+      if (destroyed) return;
+      window.removeEventListener("message", handleMessageEvent);
+      onMessage = void 0;
+      destroyed = true;
+    }
+  };
+}
+function createChildMessenger(allowedOrigins) {
+  let onMessage;
+  let destroyed = false;
+  let parentOrigin;
+  log.bridge(
+    "[Child] \u521B\u5EFA\u901A\u4FE1\u5668, allowed=%O, inIframe=%s, origin=%s",
+    allowedOrigins.map((o) => o.toString()),
+    window !== window.parent,
+    window.location.origin
+  );
+  const handleMessageEvent = (event) => {
+    log.bridge(
+      "[Child] \u6536\u5230\u6D88\u606F: origin=%s, parentOrigin=%s, data=%O",
+      event.origin,
+      parentOrigin,
+      event.data
+    );
+    if (destroyed || !onMessage) {
+      log.bridge("[Child] \u8DF3\u8FC7: destroyed=%s, hasHandler=%s", destroyed, !!onMessage);
+      return;
+    }
+    if (event.source !== window.parent) {
+      log.bridge("[Child] source \u4E0D\u662F\u7236\u7A97\u53E3");
+      return;
+    }
+    const trusted = isTrustedOrigin(event.origin, allowedOrigins);
+    if (!trusted) {
+      log.bridge("[Child] origin \u4E0D\u53EF\u4FE1: %s", event.origin);
+      return;
+    }
+    if (!isValidMessage(event.data)) {
+      return;
+    }
+    if (!parentOrigin) {
+      parentOrigin = event.origin;
+      log.bridge("[Child] \u8BB0\u5F55\u7236\u7A97\u53E3 origin: %s", parentOrigin);
+    }
+    log.bridge("[Child] \u2713 \u6D88\u606F\u9A8C\u8BC1\u901A\u8FC7: %O", event.data);
+    onMessage(event.data);
+  };
+  const send = (message) => {
+    if (message.type !== "READY" && !parentOrigin) return;
+    const targetOrigin = message.type === "READY" ? "*" : parentOrigin;
+    log.bridge("[Child] \u53D1\u9001: %O -> %s", message, targetOrigin);
+    if (destroyed || !window.parent) {
+      log.bridge("[Child] \u53D1\u9001\u5931\u8D25: destroyed=%s, hasParent=%s", destroyed, window.parent !== window);
+      return;
+    }
+    try {
+      window.parent.postMessage(cleanMessage(message), targetOrigin);
+      log.bridge("[Child] \u2713 \u5DF2\u53D1\u9001: %s", message.type);
+    } catch (e) {
+      log.bridge("[Child] \u2717 \u53D1\u9001\u5F02\u5E38: %O", e);
+      throw e;
+    }
+  };
+  return {
+    isChild: true,
+    init: (handler) => {
+      log.bridge("[Child] \u5F00\u59CB\u76D1\u542C message \u4E8B\u4EF6");
+      onMessage = handler;
+      window.addEventListener("message", handleMessageEvent);
+    },
+    send,
+    destroy: () => {
+      log.bridge("[Child] \u9500\u6BC1\u901A\u4FE1\u5668");
+      if (destroyed) return;
+      window.removeEventListener("message", handleMessageEvent);
+      onMessage = void 0;
+      destroyed = true;
+    }
+  };
+}
+
+// src/channelConnect.ts
+function isSDKMessage(message) {
+  return message && typeof message === "object" && "type" in message && SDK_MESSAGE_TYPES.includes(message.type);
+}
+function isNativeMessage(message) {
+  return message && typeof message === "object" && "action" in message && !isSDKMessage(message) && !("success" in message);
+}
+function createChannel(options) {
+  const { messenger, methods = {}, debug = false } = options;
+  const role = messenger.isChild ? "Child" : "Parent";
+  if (debug) {
+    enableDebug();
+  }
+  log.channel("[%s] \u521B\u5EFA\u901A\u4FE1\u901A\u9053, methods=%O", role, Object.keys(methods));
+  const rpc = createRPC(messenger, methods);
+  const event = createEvent(messenger);
+  let resolveHandshake;
+  const handshakePromise = new Promise((resolve) => {
+    resolveHandshake = resolve;
+  });
+  messenger.init(handleMessage);
+  log.channel("[%s] \u6D88\u606F\u76D1\u542C\u5DF2\u521D\u59CB\u5316", role);
+  const RETRY_INTERVAL = 1e3;
+  const MAX_RETRIES = 5;
+  let retryCount = 0;
+  let retryTimer = null;
+  if (messenger.isChild) {
+    const sendReady = () => {
+      retryCount++;
+      log.channel("[%s] \u53D1\u9001 READY (%d/%d)", role, retryCount, MAX_RETRIES);
+      messenger.send({ type: "READY" });
+      if (retryCount >= MAX_RETRIES) {
+        if (retryTimer) {
+          clearInterval(retryTimer);
+          retryTimer = null;
+        }
+        log.channel("[%s] \u2717 \u63E1\u624B\u8D85\u65F6\uFF0C\u5DF2\u91CD\u8BD5 %d \u6B21", role, MAX_RETRIES);
+      }
+    };
+    sendReady();
+    retryTimer = setInterval(sendReady, RETRY_INTERVAL);
+  } else {
+    log.channel("[%s] \u7B49\u5F85\u5B50\u5E94\u7528 READY", role);
+  }
+  function createNativeResponse(action, requestId, result, error) {
+    return {
+      type: "__NATIVE_RESPONSE__",
+      action,
+      requestId,
+      success: error === void 0,
+      result,
+      error
+    };
+  }
+  function handleMessage(message) {
+    log.channel("[%s] handleMessage: %O", role, message);
+    if (isSDKMessage(message)) {
+      handleSDKMessage(message);
+    } else if (isNativeMessage(message)) {
+      handleNativeMessage(message).catch((error) => {
+        log.channel("[%s] Native \u54CD\u5E94\u53D1\u9001\u5931\u8D25: %O", role, error);
+      });
+    } else {
+      log.channel("[%s] \u672A\u77E5\u6D88\u606F\u7C7B\u578B\uFF0C\u5FFD\u7565", role);
+    }
+  }
+  function handleSDKMessage(message) {
+    log.channel("[%s] SDK \u6D88\u606F: %s %O", role, message.type, message);
+    switch (message.type) {
+      case "READY":
+        if (!messenger.isChild) {
+          log.channel("[%s] \u6536\u5230 READY\uFF0C\u56DE\u590D ACK", role);
+          messenger.send({ type: "ACK" });
+          finishHandshake();
+        }
+        break;
+      case "ACK":
+        if (messenger.isChild) {
+          log.channel("[%s] \u6536\u5230 ACK\uFF0C\u63E1\u624B\u5B8C\u6210", role);
+          finishHandshake();
+        }
+        break;
+      case "CALL":
+        log.channel("[%s] RPC \u8C03\u7528: %s", role, message.method);
+        rpc.execute(message.id, message.method, message.params).catch((error) => {
+          log.channel("[%s] RPC \u54CD\u5E94\u53D1\u9001\u5931\u8D25: %O", role, error);
+        });
+        break;
+      case "RESULT":
+        log.channel("[%s] RPC \u7ED3\u679C: id=%s", role, message.id);
+        rpc.resolve(message.id, message.result, message.error);
+        break;
+      case "EVENT":
+        log.channel("[%s] \u4E8B\u4EF6: %s", role, message.eventType);
+        event.dispatch(message.eventType, message.data);
+        break;
+    }
+  }
+  function handleNativeMessage(message) {
+    return __async(this, null, function* () {
+      const { action, data, requestId } = message;
+      log.channel("[%s] Native \u6D88\u606F: %s", role, action);
+      if (!Object.prototype.hasOwnProperty.call(methods, action)) {
+        messenger.send(
+          createNativeResponse(
+            action,
+            requestId,
+            void 0,
+            `Method not found: ${action}`
+          )
+        );
+        return;
+      }
+      try {
+        const result = yield methods[action](data);
+        messenger.send(createNativeResponse(action, requestId, result));
+      } catch (e) {
+        const error = e instanceof Error ? e.message : String(e);
+        messenger.send(
+          createNativeResponse(action, requestId, void 0, error)
+        );
+      }
+    });
+  }
+  function finishHandshake() {
+    if (!resolveHandshake) {
+      log.channel("[%s] finishHandshake: \u5DF2\u5B8C\u6210\uFF0C\u5FFD\u7565", role);
+      return;
+    }
+    if (retryTimer) {
+      clearInterval(retryTimer);
+      retryTimer = null;
+    }
+    log.channel("[%s] \u2713 \u63E1\u624B\u5B8C\u6210 (\u7B2C %d \u6B21\u5C1D\u8BD5)", role, retryCount);
+    const remote = new Proxy(
+      {},
+      {
+        get: (_, name) => {
+          if (name === "then" || name === "catch" || name === "finally") {
+            return void 0;
+          }
+          return typeof name === "string" ? (params) => rpc.call(name, params) : void 0;
+        }
+      }
+    );
+    resolveHandshake(remote);
+    resolveHandshake = void 0;
+  }
+  return {
+    promise: handshakePromise,
+    on: event.on,
+    off: event.off,
+    emit: event.emit,
+    destroy: () => {
+      log.channel("[%s] \u9500\u6BC1\u901A\u9053", role);
+      if (retryTimer) {
+        clearInterval(retryTimer);
+        retryTimer = null;
+      }
+      rpc.cleanup();
+      event.cleanup();
+      messenger.destroy();
+    }
+  };
+}
+function connectToIframe(options) {
+  const { iframe, origin, methods, debug } = options;
+  log.channel("connectToIframe: iframe=%s, origin=%s, debug=%s", iframe, origin, debug);
+  const el = typeof iframe === "string" ? document.querySelector(iframe) : iframe;
+  if (!el) {
+    log.channel("\u2717 Iframe \u672A\u627E\u5230: %s", iframe);
+    throw new Error("Iframe not found");
+  }
+  if (!origin) {
+    log.channel("\u2717 Origin \u7F3A\u5931");
+    throw new Error("Origin is required");
+  }
+  log.channel("\u521B\u5EFA\u7236\u5E94\u7528\u901A\u9053: origin=%s, src=%s", origin, el.src);
+  const messenger = createMessenger({ isChild: false, iframe: el, origin });
+  return createChannel({ messenger, methods, debug });
+}
+function connectToParent(options = {}) {
+  const { allowedOrigins = [DEFAULT_ALLOWED_ORIGIN], methods, debug } = options;
+  log.channel("connectToParent: allowed=%O, debug=%s", allowedOrigins.map((o) => o.toString()), debug);
+  const messenger = createMessenger({ isChild: true, allowedOrigins });
+  return createChannel({ messenger, methods, debug });
+}
+//# sourceMappingURL=index.cjs.map