ranuts 0.4.1-alpha.2 → 0.5.0

package/dist/src/utils/behavior.js

@@ -0,0 +1,9 @@
+import { noop as n } from "./noop.js";
+var c = (t = n) => {
+  if (typeof document > "u") return n;
+  const e = (r) => t(r);
+  return document.addEventListener("click", e, !0), () => document.removeEventListener("click", e, !0);
+};
+export {
+  c as handleClick
+};

package/dist/src/utils/binary.js

@@ -0,0 +1,89 @@
+var i = (e) => {
+  const r = e instanceof Uint8Array ? e : new Uint8Array(e), t = 32768;
+  let n = "";
+  for (let a = 0; a < r.length; a += t) n += String.fromCharCode.apply(null, Array.from(r.subarray(a, a + t)));
+  return btoa(n);
+}, l = (e) => {
+  const r = e.startsWith("data:") ? e.slice(e.indexOf(",") + 1) : e, t = atob(r), n = new Uint8Array(t.length);
+  for (let a = 0; a < t.length; a++) n[a] = t.charCodeAt(a);
+  return n;
+}, h = (e) => i(e).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""), f = (e) => {
+  try {
+    const r = e.replace(/-/g, "+").replace(/_/g, "/"), t = r.padEnd(Math.ceil(r.length / 4) * 4, "=");
+    return l(t);
+  } catch {
+    return null;
+  }
+}, w = (e) => {
+  let r = 0;
+  for (const a of e) r += a.length;
+  const t = new Uint8Array(r);
+  let n = 0;
+  for (const a of e)
+    t.set(a, n), n += a.length;
+  return t;
+}, s = (e) => e.length >= 2 && e[0] === 31 && e[1] === 139, u = (e) => e.length >= 4 && e[0] === 80 && e[1] === 75 && e[2] === 3 && e[3] === 4, m = (e) => {
+  if (e.length < 8 || u(e)) return !1;
+  const r = e[0] === 239 && e[1] === 187 && e[2] === 191 ? 3 : 0, t = new TextDecoder("latin1").decode(e.subarray(r, r + 2048)).replace(/^\s+/, "");
+  return /^<(!doctype\s+html|html|head|body|table|meta|\?xml[^>]*>\s*<html)/i.test(t);
+}, p = async (e) => {
+  if (!s(e)) return e;
+  if (typeof DecompressionStream > "u") throw new Error("DecompressionStream is not available in this runtime");
+  const r = new Response(e).body.pipeThrough(new DecompressionStream("gzip"));
+  return new Uint8Array(await new Response(r).arrayBuffer());
+}, y = async (e, r) => {
+  const t = await fetch(e, r);
+  if (!t.ok) throw new Error(`Failed to fetch '${String(e)}' (${t.status} ${t.statusText})`);
+  return p(new Uint8Array(await t.arrayBuffer()));
+}, g = (e, r = [
+  "utf-8",
+  "gb18030",
+  "latin1"
+]) => {
+  if (e.length >= 3 && e[0] === 239 && e[1] === 187 && e[2] === 191) return new TextDecoder("utf-8").decode(e.subarray(3));
+  for (let t = 0; t < r.length; t++) {
+    const n = t === r.length - 1;
+    try {
+      return new TextDecoder(r[t], { fatal: !n }).decode(e);
+    } catch {
+    }
+  }
+  return new TextDecoder("latin1").decode(e);
+}, v = async (e, r, t = {}) => {
+  const n = e instanceof Blob ? e : new Blob([e], { type: t.mimeType }), a = globalThis.showSaveFilePicker;
+  if (typeof a == "function") {
+    const c = r.includes(".") ? `.${r.split(".").pop()}` : "";
+    try {
+      const o = await (await a({
+        suggestedName: r,
+        types: [{
+          description: t.description || "File",
+          accept: { [t.mimeType || n.type || "application/octet-stream"]: c ? [c] : [] }
+        }]
+      })).createWritable();
+      return await o.write(n), await o.close(), !0;
+    } catch (o) {
+      if (o?.name === "AbortError") return !1;
+    }
+  }
+  return d(n, r);
+}, d = (e, r) => {
+  const t = URL.createObjectURL(e), n = document.createElement("a");
+  return n.href = t, n.download = r, n.style.display = "none", document.body.appendChild(n), n.click(), setTimeout(() => {
+    n.remove(), URL.revokeObjectURL(t);
+  }, 100), !0;
+};
+export {
+  l as base64ToBytes,
+  f as base64UrlToBytes,
+  i as bytesToBase64,
+  h as bytesToBase64Url,
+  w as concatBytes,
+  g as decodeTextBytes,
+  y as fetchMaybeGzip,
+  p as gunzipMaybe,
+  s as isGzip,
+  m as isHtmlDocument,
+  u as isZipContainer,
+  v as saveFileToDisk
+};

package/dist/src/utils/bom.d.ts

@@ -4,28 +4,34 @@
  * @return {*}
  */
 export declare const getCookie: (objName: string) => string;
-export interface RequestUrlToArraybufferOption {
-    responseType: XMLHttpRequestResponseType;
+export interface RequestUrlToArraybufferOption<T extends XMLHttpRequestResponseType = XMLHttpRequestResponseType> {
+    responseType: T;
     method: string;
     withCredentials: boolean;
     headers: Record<string, string>;
     body: string;
-    onProgress?: Function;
+    onProgress?: (event: ProgressEvent) => void;
 }
-export interface requestUrlToArraybufferReturn extends BaseReturn {
-    data: Blob;
+export interface requestUrlToArraybufferReturn<T = ArrayBuffer> extends BaseReturn {
+    data: T;
 }
+type RequestUrlResponse<T extends XMLHttpRequestResponseType> = T extends '' | 'arraybuffer' ? ArrayBuffer : T extends 'blob' ? Blob : T extends 'text' ? string : T extends 'document' ? Document | null : unknown;
 export interface BaseReturn {
     success: boolean;
     message?: string;
 }
 /**
- * @description: Fetch a URL as an ArrayBuffer
+ * @description: Fetch a URL as an ArrayBuffer by default, or as the requested XHR response type
+ * An empty responseType also uses ArrayBuffer. JSON responses require validation before use.
  * @param {string} src
  * @param {RequestUrlToArraybufferOption} options
  * @return {*}
  */
-export declare const requestUrlToBuffer: (src: string, options: Partial<RequestUrlToArraybufferOption>) => Promise<requestUrlToArraybufferReturn>;
+export declare function requestUrlToBuffer(src: string, options?: Partial<RequestUrlToArraybufferOption<'' | 'arraybuffer'>>): Promise<requestUrlToArraybufferReturn>;
+export declare function requestUrlToBuffer<T extends XMLHttpRequestResponseType>(src: string, options: Partial<RequestUrlToArraybufferOption<T>> & {
+    responseType: T;
+}): Promise<requestUrlToArraybufferReturn<RequestUrlResponse<T>>>;
+export declare function requestUrlToBuffer<T extends XMLHttpRequestResponseType>(src: string, options: Partial<RequestUrlToArraybufferOption<T>>): Promise<requestUrlToArraybufferReturn<RequestUrlResponse<T | 'arraybuffer'>>>;
 export interface Context {
     backingStorePixelRatio: number;
     webkitBackingStorePixelRatio: number;
@@ -39,7 +45,7 @@ export interface Context {
  * @return {*}
  */
 export declare const getPixelRatio: (context: CanvasRenderingContext2D & Partial<Context>) => number;
-export declare const createObjectURL: (src: Blob | ArrayBuffer | Response) => Promise<string>;
+export declare const createObjectURL: (src: string | Blob | ArrayBuffer | Response) => Promise<string>;
 /**
  * @description: Frames per millisecond; multiply by 1000 for frames per second
  * @return {*}
@@ -112,10 +118,26 @@ interface ClientRatio {
  * Get the viewport size across browsers
  */
 export declare const getWindow: () => ClientRatio;
+/**
+ * The subset of the Network Information API's `NetworkInformation` object that browsers
+ * actually ship. It is not in TypeScript's DOM lib because the spec is not standardised.
+ */
+export interface NetworkInformation extends EventTarget {
+    /** 'slow-2g' | '2g' | '3g' | '4g' */
+    effectiveType?: string;
+    /** Estimated downlink bandwidth in Mbps */
+    downlink?: number;
+    /** Estimated round-trip time in milliseconds */
+    rtt?: number;
+    /** Whether the user has asked for reduced data usage */
+    saveData?: boolean;
+    /** 'wifi' | 'cellular' | 'ethernet' | … where the platform exposes it */
+    type?: string;
+}
 /**
  * @description: Current network status: type, throughput, and whether the connection changed
  */
-export declare const connection: () => number | undefined;
+export declare const connection: () => NetworkInformation | undefined;
 /**
  * Encode a URL to a percent-encoded form, excluding already-encoded sequences.
  *

package/dist/src/utils/bom.js

@@ -0,0 +1,165 @@
+import { performanceTime as f } from "./time.js";
+var v = (t) => {
+  const e = document.cookie.split("; ");
+  for (let i = 0; i < e.length; i++) {
+    const n = e[i].split("=");
+    if (n[0] === t) return decodeURIComponent(n[1]);
+  }
+  return "";
+};
+function x(t, e = {}) {
+  return new Promise(function(i, n) {
+    const r = new XMLHttpRequest();
+    r.open(e.method || "GET", t, !0), r.responseType = e.responseType || "arraybuffer", r.onload = function() {
+      r.status === 200 ? i({
+        success: !0,
+        data: r.response,
+        message: ""
+      }) : n({
+        success: !1,
+        data: r.status,
+        message: `The request status is${r.status}`
+      });
+    }, r.onerror = function(o) {
+      n({
+        success: !1,
+        data: o,
+        message: ""
+      });
+    }, r.onprogress = (o) => {
+      e.onProgress && e.onProgress(o);
+    }, r.withCredentials = e.withCredentials || !1, e.headers && Object.keys(e.headers).forEach(function(o) {
+      e.headers?.[o] && r.setRequestHeader(o, e.headers[o]);
+    }), r.send(e.body);
+  });
+}
+var y = (t) => {
+  const e = t.backingStorePixelRatio || t.webkitBackingStorePixelRatio || t.mozBackingStorePixelRatio || t.msBackingStorePixelRatio || t.oBackingStorePixelRatio || 1;
+  return ((typeof window > "u" ? 1 : window.devicePixelRatio) || 1) / e;
+}, F = async (t) => {
+  if (typeof t == "string") return t;
+  if (t instanceof Blob) return URL.createObjectURL(t);
+  if (t instanceof ArrayBuffer) return URL.createObjectURL(new Blob([t]));
+  if (t instanceof Response) {
+    const e = await t.blob();
+    return URL.createObjectURL(e);
+  } else return t;
+}, P = (t = 10) => {
+  const e = [];
+  let i = 0, n;
+  return new Promise((r) => {
+    const o = () => {
+      const a = f(), s = a - i;
+      i !== 0 && e.push(s), i = a, e.length > t && (r(1 / (e.reduce((u, c) => u + c) / t)), cancelAnimationFrame(n)), n = requestAnimationFrame(o);
+    };
+    e.length <= t && (n = requestAnimationFrame(o));
+  });
+}, d = (t) => {
+  const e = t ?? (typeof window > "u" ? "" : window.location.href), i = e.indexOf("?");
+  if (i === -1) return "";
+  const n = e.slice(i + 1), r = n.indexOf("#");
+  return r === -1 ? n : n.slice(0, r);
+}, l = (t) => {
+  const e = {}, i = d(t);
+  if (!i) return e;
+  for (const n of i.split("&")) {
+    if (!n) continue;
+    const r = n.indexOf("="), o = r === -1 ? n : n.slice(0, r), a = r === -1 ? "" : n.slice(r + 1);
+    if (o)
+      try {
+        e[decodeURIComponent(o.replace(/\+/g, " "))] = decodeURIComponent(a.replace(/\+/g, " "));
+      } catch {
+        e[o] = a;
+      }
+  }
+  return e;
+}, U = (t, e) => {
+  const i = l(e)[t];
+  if (i === void 0) return !1;
+  const n = i.toLowerCase();
+  return n === "" || n === "1" || n === "true";
+}, A = () => {
+  if (typeof window > "u") return !1;
+  try {
+    return window.parent !== window;
+  } catch {
+    return !0;
+  }
+};
+function O(t, e = {}) {
+  let i = t;
+  i.indexOf("//") === 0 && (i = i.replace("//", "https://"));
+  const n = new URL(i);
+  return e && Object.keys(e).forEach((r) => {
+    e[r] && n.searchParams.set(r, e[r]);
+  }), n.href;
+}
+function b(t) {
+  if (typeof window < "u") {
+    const e = new RegExp(`(^| )${t}(?:=([^;]*))?(;|$)`).exec(document.cookie);
+    if (e && e[2]) return e[2];
+  }
+  return "";
+}
+var E = () => typeof window < "u" ? {
+  width: window.innerWidth,
+  height: window.innerHeight
+} : {
+  width: 0,
+  height: 0
+}, C = () => {
+  if (typeof window < "u") return window.navigator.connection;
+}, g = /(?:[^\x21\x25\x26-\x3B\x3D\x3F-\x5B\x5D\x5F\x7E]|%(?:[^\da-f]|[\da-f][^\da-f]|$))+/gi, w = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g, m = "$1�$2";
+function S(t) {
+  return String(t).replace(w, m).replace(g, encodeURI);
+}
+var h = (t) => new Promise((e, i) => {
+  const n = new Image(), r = (/* @__PURE__ */ new Date()).getTime();
+  n.src = t || `https://github.com/favicon.ico?d=${r}`, n.onload = () => {
+    e((/* @__PURE__ */ new Date()).getTime() - r);
+  }, n.onerror = (o) => {
+    i(o);
+  };
+}), R = (t, ...e) => (i) => new Promise((n, r) => {
+  setTimeout(async () => {
+    try {
+      n(await t(...e));
+    } catch (o) {
+      r(o);
+    }
+  }, i);
+}), D = async (t) => {
+  const { url: e, duration: i = 3e3, count: n = 5 } = t;
+  let r = 0, o = 0;
+  const a = [];
+  for (let s = 0; s < n; s++) {
+    const u = await R(h, e)(i);
+    a.push(u);
+  }
+  return r = Math.max(...a) - Math.min(...a), o = a.reduce((s, u) => s + u) / a.length, {
+    ping: o,
+    jitter: r
+  };
+}, L = () => {
+  if (!(typeof navigator > "u"))
+    return navigator.vendor && navigator.vendor.indexOf("Apple") > -1 && navigator.userAgent && !navigator.userAgent.includes("CriOS") && !navigator.userAgent.includes("FxiOS");
+};
+export {
+  O as appendUrl,
+  C as connection,
+  F as createObjectURL,
+  R as durationHandler,
+  S as encodeUrl,
+  l as getAllQueryString,
+  v as getCookie,
+  b as getCookieByName,
+  P as getFrame,
+  y as getPixelRatio,
+  E as getWindow,
+  h as imageRequest,
+  A as isInIframe,
+  L as isSafari,
+  D as networkSpeed,
+  U as queryFlag,
+  x as requestUrlToBuffer
+};

package/dist/src/utils/bridge.js

@@ -0,0 +1,310 @@
+import { getRandomString as p } from "./str.js";
+import { isFunction as w } from "./func.js";
+var b = 12e4, m = "__ranuts_bridge__", v = "default", R = class {
+  bridges = /* @__PURE__ */ new Set();
+  attachedWindow = null;
+  handleMessage = (e) => {
+    for (const t of Array.from(this.bridges)) t.receive(e);
+  };
+  add(e) {
+    this.bridges.add(e), typeof window < "u" && this.attachedWindow !== window && (window.addEventListener("message", this.handleMessage), this.attachedWindow = window);
+  }
+  remove(e) {
+    this.bridges.delete(e), this.bridges.size === 0 && this.attachedWindow && (this.attachedWindow.removeEventListener("message", this.handleMessage), this.attachedWindow = null);
+  }
+}, y = new R(), M = class {
+  targetWindow;
+  targetOrigin;
+  messageHandlers;
+  pendingRequests;
+  channel;
+  senderId;
+  available;
+  constructor(e, t = "*", r = v) {
+    if (this.targetOrigin = t, this.channel = r, this.senderId = p(12), this.messageHandlers = /* @__PURE__ */ new Map(), this.pendingRequests = /* @__PURE__ */ new Map(), this.available = typeof window < "u", !this.available) {
+      this.targetWindow = void 0;
+      return;
+    }
+    this.targetWindow = e ?? window, y.add(this);
+  }
+  post(e, t) {
+    const r = {
+      ...t,
+      __bridge: m,
+      channel: this.channel,
+      senderId: this.senderId
+    };
+    e.postMessage(r, this.targetOrigin);
+  }
+  receive = (e) => {
+    if (!this.available || this.targetOrigin !== "*" && e.origin !== this.targetOrigin || e.source && e.source !== this.targetWindow) return;
+    const t = e.data;
+    if (!t || typeof t != "object" || t.__bridge !== "__ranuts_bridge__" || (t.channel ?? "default") !== this.channel) return;
+    const { type: r, payload: a, id: s, isResponse: n, isError: o, senderId: c } = t;
+    if (n && s) {
+      const g = this.pendingRequests.get(s);
+      g && (o ? g.reject(new Error(typeof a == "string" ? a : "Bridge request failed")) : g.resolve(a), this.pendingRequests.delete(s));
+      return;
+    }
+    if (c && c === this.senderId || typeof r != "string" || !this.messageHandlers.has(r)) return;
+    const i = this.messageHandlers.get(r);
+    if (w(i)) {
+      const g = e.source ?? this.targetWindow;
+      Promise.resolve(i(a)).then((l) => {
+        s && this.post(g, {
+          type: r,
+          payload: l,
+          id: s,
+          isResponse: !0
+        });
+      }).catch((l) => {
+        s && this.post(g, {
+          type: r,
+          payload: l instanceof Error ? l.message : String(l),
+          id: s,
+          isResponse: !0,
+          isError: !0
+        });
+      });
+    }
+  };
+  on = (e, t) => {
+    this.messageHandlers.set(e, t);
+  };
+  off = (e) => {
+    this.messageHandlers.delete(e);
+  };
+  send = async (e, t) => {
+    if (!this.available) return Promise.reject(/* @__PURE__ */ new Error("PostMessageBridge is unavailable outside a browser environment"));
+    const r = p(10);
+    return new Promise((a, s) => {
+      const n = setTimeout(() => {
+        this.pendingRequests.has(r) && (this.pendingRequests.delete(r), s(/* @__PURE__ */ new Error("Request timeout")));
+      }, b), o = (i) => {
+        clearTimeout(n), a(i);
+      }, c = (i) => {
+        clearTimeout(n), s(i);
+      };
+      this.pendingRequests.set(r, {
+        resolve: o,
+        reject: c
+      });
+      try {
+        this.post(this.targetWindow, {
+          type: e,
+          payload: t,
+          id: r
+        });
+      } catch (i) {
+        this.pendingRequests.delete(r), c(i instanceof Error ? i : /* @__PURE__ */ new Error("Failed to post message"));
+      }
+    });
+  };
+  broadcast = (e) => {
+    if (this.available)
+      try {
+        this.post(this.targetWindow, {
+          type: e.type,
+          payload: e.payload
+        });
+      } catch {
+      }
+  };
+  destroy = () => {
+    y.remove(this), this.messageHandlers.clear(), this.pendingRequests.forEach((e) => {
+      e.reject(/* @__PURE__ */ new Error("Bridge destroyed"));
+    }), this.pendingRequests.clear();
+  };
+}, B = class f {
+  static instance;
+  bridges = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    return f.instance || (f.instance = new f()), f.instance;
+  }
+  connectClient = ({ id: t, targetOrigin: r, targetWindow: a, channel: s }) => {
+    const n = new M(a, r, s);
+    if (t || (t = p(10)), this.bridges.has(t)) throw new Error(`Bridge ${t} already exists`);
+    return this.bridges.set(t, n), {
+      bridge: n,
+      id: t
+    };
+  };
+  getClient = (t) => this.bridges.get(t);
+  removeClient = (t) => {
+    const r = this.bridges.get(t);
+    r && (r.destroy(), this.bridges.delete(t));
+  };
+  removeAllClient = () => {
+    this.bridges.forEach((t) => {
+      t.destroy();
+    }), this.bridges.clear();
+  };
+  broadcast = (t) => {
+    this.bridges.forEach((r) => {
+      r.broadcast(t);
+    });
+  };
+  sendTo = (t, r, a) => {
+    const s = this.getClient(t);
+    return s ? s.send(r, a) : Promise.reject(/* @__PURE__ */ new Error(`Bridge ${t} not found`));
+  };
+}, u = B.getInstance(), T = {
+  connect: ({ id: e, targetWindow: t, targetOrigin: r, channel: a }) => u.connectClient({
+    id: e,
+    targetWindow: t,
+    targetOrigin: r,
+    channel: a
+  }),
+  remove: (e) => {
+    e && u.removeClient(e);
+  },
+  removeAll: () => {
+    u.removeAllClient();
+  },
+  broadcast: (e) => u.broadcast(e),
+  call: ({ id: e, type: t, payload: r }) => u.sendTo(e, t, r),
+  broadcastToAll: (e) => {
+    if (typeof window > "u") return;
+    const t = {
+      __bridge: m,
+      channel: v,
+      type: e.type,
+      payload: e.payload
+    };
+    return window.postMessage(t, "*");
+  }
+}, P = (e) => {
+  const t = new Map(Object.entries(e).filter((s) => w(s[1]))), r = async (s) => {
+    const n = s.data;
+    if (!n || typeof n != "object" || n.__bridge !== "__ranuts_bridge__") return;
+    const { type: o, payload: c, id: i } = n, g = n.channel ?? "default";
+    if (typeof o != "string" || !t.has(o)) return;
+    const l = t.get(o);
+    if (!l) return;
+    const h = (d) => {
+      i && s.source?.postMessage({
+        __bridge: m,
+        channel: g,
+        type: o,
+        id: i,
+        isResponse: !0,
+        ...d
+      }, { targetOrigin: s.origin });
+    };
+    try {
+      h({ payload: await l(c) });
+    } catch (d) {
+      h({
+        payload: d instanceof Error ? d.message : String(d),
+        isError: !0
+      });
+    }
+  };
+  return window.removeEventListener("message", r), window.addEventListener("message", r), { destroy: () => {
+    window.removeEventListener("message", r);
+  } };
+}, j = { init: P }, E = "__ranuts_port_init__", _ = (e) => {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), a = (s) => {
+    const n = s.data;
+    if (!n || typeof n != "object" || typeof n.type != "string") return;
+    const { type: o, payload: c, id: i, isResponse: g, isError: l } = n;
+    if (g && i) {
+      const d = r.get(i);
+      d && (l ? d.reject(new Error(typeof c == "string" ? c : "Bridge request failed")) : d.resolve(c), r.delete(i));
+      return;
+    }
+    if (!t.has(o)) return;
+    const h = t.get(o);
+    w(h) && Promise.resolve(h(c)).then((d) => {
+      i && e.postMessage({
+        type: o,
+        payload: d,
+        id: i,
+        isResponse: !0
+      });
+    }).catch((d) => {
+      i && e.postMessage({
+        type: o,
+        payload: d instanceof Error ? d.message : String(d),
+        id: i,
+        isResponse: !0,
+        isError: !0
+      });
+    });
+  };
+  return e.addEventListener("message", a), e.start(), {
+    on: (s, n) => {
+      t.set(s, n);
+    },
+    off: (s) => {
+      t.delete(s);
+    },
+    send: (s, n) => {
+      const o = p(10);
+      return new Promise((c, i) => {
+        const g = setTimeout(() => {
+          r.has(o) && (r.delete(o), i(/* @__PURE__ */ new Error("Request timeout")));
+        }, b), l = (d) => {
+          clearTimeout(g), c(d);
+        }, h = (d) => {
+          clearTimeout(g), i(d);
+        };
+        r.set(o, {
+          resolve: l,
+          reject: h
+        });
+        try {
+          e.postMessage({
+            type: s,
+            payload: n,
+            id: o
+          });
+        } catch (d) {
+          r.delete(o), h(d instanceof Error ? d : /* @__PURE__ */ new Error("Failed to post message"));
+        }
+      });
+    },
+    broadcast: (s) => {
+      try {
+        e.postMessage({
+          type: s.type,
+          payload: s.payload
+        });
+      } catch {
+      }
+    },
+    destroy: () => {
+      e.removeEventListener("message", a), t.clear(), r.forEach((s) => s.reject(/* @__PURE__ */ new Error("Bridge destroyed"))), r.clear(), e.close();
+    }
+  };
+}, I = ({ targetWindow: e, targetOrigin: t = "*", name: r = "default" }) => {
+  const a = new MessageChannel();
+  return e.postMessage({
+    [E]: !0,
+    name: r
+  }, t, [a.port2]), _(a.port1);
+}, L = ({ targetOrigin: e = "*", name: t = "default" } = {}) => typeof window > "u" ? Promise.reject(/* @__PURE__ */ new Error("acceptPortBridge is unavailable outside a browser environment")) : new Promise((r) => {
+  const a = (s) => {
+    if (e !== "*" && s.origin !== e) return;
+    const n = s.data;
+    if (!n || typeof n != "object" || n[E] !== !0 || n.name !== t) return;
+    const o = s.ports?.[0];
+    o && (window.removeEventListener("message", a), r(_(o)));
+  };
+  window.addEventListener("message", a);
+});
+export {
+  m as BRIDGE_MARKER,
+  B as BridgeManager,
+  T as Client,
+  v as DEFAULT_CHANNEL,
+  j as Platform,
+  M as PostMessageBridge,
+  L as acceptPortBridge,
+  u as bridgeManager,
+  _ as createPortBridge,
+  P as initPlatform,
+  I as openPortBridge
+};