forgeframe 1.0.0

package/dist/forgeframe.js

@@ -0,0 +1,2419 @@
+const h = {
+  /** String prop type */
+  STRING: "string",
+  /** Object prop type */
+  OBJECT: "object",
+  /** Function prop type - serialized for cross-domain calls */
+  FUNCTION: "function",
+  /** Boolean prop type */
+  BOOLEAN: "boolean",
+  /** Number prop type */
+  NUMBER: "number",
+  /** Array prop type */
+  ARRAY: "array"
+}, f = {
+  /** Render component in an iframe */
+  IFRAME: "iframe",
+  /** Render component in a popup window */
+  POPUP: "popup"
+}, p = {
+  /** Emitted when rendering starts */
+  RENDER: "render",
+  /** Emitted when component is fully rendered and initialized */
+  RENDERED: "rendered",
+  /** Emitted when prerender (loading) phase starts */
+  PRERENDER: "prerender",
+  /** Emitted when prerender phase completes */
+  PRERENDERED: "prerendered",
+  /** Emitted when component becomes visible */
+  DISPLAY: "display",
+  /** Emitted when an error occurs */
+  ERROR: "error",
+  /** Emitted when component is closing */
+  CLOSE: "close",
+  /** Emitted when component is destroyed */
+  DESTROY: "destroy",
+  /** Emitted when props are updated */
+  PROPS: "props",
+  /** Emitted when component is resized */
+  RESIZE: "resize",
+  /** Emitted when component receives focus */
+  FOCUS: "focus"
+}, I = {
+  /** Default JSON serialization */
+  JSON: "json",
+  /** Base64 encoding for binary or large data */
+  BASE64: "base64",
+  /** Dot notation for nested objects (e.g., "a.b.c=value") */
+  DOTIFY: "dotify"
+}, T = {
+  /** Request message expecting a response */
+  REQUEST: "request",
+  /** Response to a previous request */
+  RESPONSE: "response"
+}, l = {
+  /** Child initialization complete */
+  INIT: "forgeframe_init",
+  /** Props update from parent to child */
+  PROPS: "forgeframe_props",
+  /** Close request from child */
+  CLOSE: "forgeframe_close",
+  /** Resize request from child */
+  RESIZE: "forgeframe_resize",
+  /** Focus request from child */
+  FOCUS: "forgeframe_focus",
+  /** Show request from child */
+  SHOW: "forgeframe_show",
+  /** Hide request from child */
+  HIDE: "forgeframe_hide",
+  /** Error report from child */
+  ERROR: "forgeframe_error",
+  /** Data export from child to parent */
+  EXPORT: "forgeframe_export",
+  /** Cross-domain function call */
+  CALL: "forgeframe_call",
+  /** Parent export from child context */
+  PARENT_EXPORT: "forgeframe_parent_export",
+  /** Get sibling components request */
+  GET_SIBLINGS: "forgeframe_get_siblings"
+}, N = "__forgeframe__", re = "1.0.0";
+class ne {
+  /**
+   * Internal storage for event listeners mapped by event name.
+   * @internal
+   */
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Subscribes a handler to a specific event.
+   *
+   * @typeParam T - The type of data expected by the event handler
+   * @param event - The name of the event to subscribe to
+   * @param handler - The callback function to invoke when the event is emitted
+   * @returns A function that, when called, unsubscribes the handler from the event
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = emitter.on<{ userId: string }>('login', (data) => {
+   *   console.log('User logged in:', data.userId);
+   * });
+   * ```
+   *
+   * @public
+   */
+  on(e, r) {
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(r), () => this.off(e, r);
+  }
+  /**
+   * Subscribes a handler to an event that will automatically unsubscribe after the first invocation.
+   *
+   * @typeParam T - The type of data expected by the event handler
+   * @param event - The name of the event to subscribe to
+   * @param handler - The callback function to invoke once when the event is emitted
+   * @returns A function that, when called, unsubscribes the handler before it fires
+   *
+   * @remarks
+   * This is useful for one-time event handling, such as waiting for an initialization
+   * event or a single response.
+   *
+   * @example
+   * ```typescript
+   * emitter.once('ready', () => {
+   *   console.log('Component is ready!');
+   * });
+   * ```
+   *
+   * @public
+   */
+  once(e, r) {
+    const n = (i) => (this.off(e, n), r(i));
+    return this.on(e, n);
+  }
+  /**
+   * Emits an event, invoking all registered handlers with the provided data.
+   *
+   * @typeParam T - The type of data to pass to event handlers
+   * @param event - The name of the event to emit
+   * @param data - Optional data to pass to all registered handlers
+   *
+   * @remarks
+   * Handlers are invoked synchronously in the order they were registered.
+   * If a handler throws an error, it is caught and logged to the console,
+   * allowing subsequent handlers to still execute.
+   *
+   * @example
+   * ```typescript
+   * emitter.emit('userAction', { action: 'click', target: 'button' });
+   * ```
+   *
+   * @public
+   */
+  emit(e, r) {
+    const n = this.listeners.get(e);
+    if (n)
+      for (const i of n)
+        try {
+          const s = i(r);
+          s && typeof s == "object" && "catch" in s && typeof s.catch == "function" && s.catch((o) => {
+            console.error(`Error in async event handler for "${e}":`, o);
+          });
+        } catch (s) {
+          console.error(`Error in event handler for "${e}":`, s);
+        }
+  }
+  /**
+   * Unsubscribes a handler from an event, or removes all handlers for the event.
+   *
+   * @param event - The name of the event to unsubscribe from
+   * @param handler - The specific handler to remove. If not provided, all handlers for the event are removed.
+   *
+   * @remarks
+   * When a specific handler is removed and it was the last handler for that event,
+   * the event entry is cleaned up from the internal map.
+   *
+   * @example
+   * ```typescript
+   * // Remove a specific handler
+   * emitter.off('message', myHandler);
+   *
+   * // Remove all handlers for an event
+   * emitter.off('message');
+   * ```
+   *
+   * @public
+   */
+  off(e, r) {
+    if (!r) {
+      this.listeners.delete(e);
+      return;
+    }
+    const n = this.listeners.get(e);
+    n && (n.delete(r), n.size === 0 && this.listeners.delete(e));
+  }
+  /**
+   * Removes all event listeners from the emitter.
+   *
+   * @remarks
+   * This method is typically called during component cleanup or disposal
+   * to ensure no memory leaks from lingering event subscriptions.
+   *
+   * @example
+   * ```typescript
+   * // Clean up all listeners when component is destroyed
+   * emitter.removeAllListeners();
+   * ```
+   *
+   * @public
+   */
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+  /**
+   * Returns the number of listeners registered for a specific event.
+   *
+   * @param event - The name of the event to check
+   * @returns The number of handlers currently subscribed to the event
+   *
+   * @remarks
+   * This method is primarily useful for debugging and testing purposes
+   * to verify that subscriptions are being properly managed.
+   *
+   * @example
+   * ```typescript
+   * console.log(`Active listeners: ${emitter.listenerCount('message')}`);
+   * ```
+   *
+   * @public
+   */
+  listenerCount(e) {
+    return this.listeners.get(e)?.size ?? 0;
+  }
+}
+function we() {
+  const t = Date.now().toString(36), e = Math.random().toString(36).slice(2, 11);
+  return `${t}_${e}`;
+}
+function v() {
+  return Math.random().toString(36).slice(2, 11);
+}
+class Ee {
+  /**
+   * Array of registered cleanup tasks awaiting execution.
+   * @internal
+   */
+  tasks = [];
+  /**
+   * Flag indicating whether cleanup has already been performed.
+   * @internal
+   */
+  cleaned = !1;
+  /**
+   * Registers a cleanup task to be executed when {@link cleanup} is called.
+   *
+   * @param task - The cleanup function to register
+   *
+   * @remarks
+   * If cleanup has already been performed, the task is executed immediately
+   * rather than being registered. This ensures late-registered tasks are
+   * still handled appropriately.
+   *
+   * @example
+   * ```typescript
+   * cleanup.register(() => {
+   *   eventEmitter.removeAllListeners();
+   * });
+   *
+   * cleanup.register(async () => {
+   *   await database.close();
+   * });
+   * ```
+   *
+   * @public
+   */
+  register(e) {
+    if (this.cleaned) {
+      try {
+        e();
+      } catch (r) {
+        console.error("Error in cleanup task:", r);
+      }
+      return;
+    }
+    this.tasks.push(e);
+  }
+  /**
+   * Executes all registered cleanup tasks in LIFO order.
+   *
+   * @returns A Promise that resolves when all cleanup tasks have completed
+   *
+   * @remarks
+   * Tasks are executed in reverse order of registration (LIFO pattern).
+   * Each task is awaited individually, and errors are caught and logged
+   * to prevent one failing task from blocking subsequent cleanup operations.
+   * Calling this method multiple times has no effect after the first call.
+   *
+   * @example
+   * ```typescript
+   * // In a component's destroy lifecycle
+   * async destroy() {
+   *   await this.cleanupManager.cleanup();
+   * }
+   * ```
+   *
+   * @public
+   */
+  async cleanup() {
+    if (this.cleaned) return;
+    this.cleaned = !0;
+    const e = this.tasks.reverse();
+    this.tasks = [];
+    for (const r of e)
+      try {
+        await r();
+      } catch (n) {
+        console.error("Error in cleanup task:", n);
+      }
+  }
+  /**
+   * Checks whether cleanup has already been performed.
+   *
+   * @returns `true` if {@link cleanup} has been called, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * if (!cleanupManager.isCleaned()) {
+   *   // Safe to register more tasks
+   *   cleanupManager.register(myTask);
+   * }
+   * ```
+   *
+   * @public
+   */
+  isCleaned() {
+    return this.cleaned;
+  }
+  /**
+   * Resets the manager to its initial state, allowing it to be reused.
+   *
+   * @remarks
+   * This method clears all registered tasks and resets the cleaned flag.
+   * It is primarily intended for testing scenarios or cases where the
+   * manager needs to be reused after cleanup.
+   *
+   * @example
+   * ```typescript
+   * // In a test teardown
+   * afterEach(() => {
+   *   cleanupManager.reset();
+   * });
+   * ```
+   *
+   * @public
+   */
+  reset() {
+    this.tasks = [], this.cleaned = !1;
+  }
+}
+function ie() {
+  let t, e;
+  return { promise: new Promise((n, i) => {
+    t = n, e = i;
+  }), resolve: t, reject: e };
+}
+function Ce(t, e, r = "Operation timed out") {
+  return new Promise((n, i) => {
+    const s = setTimeout(() => {
+      i(new Error(`${r} (${e}ms)`));
+    }, e);
+    t.then((o) => {
+      clearTimeout(s), n(o);
+    }).catch((o) => {
+      clearTimeout(s), i(o);
+    });
+  });
+}
+const A = "forgeframe:";
+function F(t) {
+  return A + JSON.stringify(t);
+}
+function Pe(t) {
+  if (typeof t != "string" || !t.startsWith(A)) return null;
+  try {
+    const e = t.slice(A.length), r = JSON.parse(e);
+    return !r.id || !r.type || !r.name || !r.source ? null : r;
+  } catch {
+    return null;
+  }
+}
+function X(t, e, r, n) {
+  return {
+    id: t,
+    type: T.REQUEST,
+    name: e,
+    data: r,
+    source: n
+  };
+}
+function Re(t, e, r, n) {
+  return {
+    id: t,
+    type: T.RESPONSE,
+    name: "response",
+    data: e,
+    source: r,
+    error: n ? {
+      message: n.message,
+      stack: n.stack
+    } : void 0
+  };
+}
+class se {
+  /**
+   * Creates a new Messenger instance.
+   *
+   * @param uid - Unique identifier for this messenger
+   * @param win - The window to listen for messages on
+   * @param domain - The origin domain of this messenger
+   * @param trustedDomains - Optional domains to trust for incoming messages
+   */
+  constructor(e, r = window, n = window.location.origin, i) {
+    this.uid = e, this.win = r, this.domain = n, this.allowedOrigins.add(n), i && this.addTrustedDomain(i), this.setupListener();
+  }
+  /** @internal */
+  pending = /* @__PURE__ */ new Map();
+  /** @internal */
+  handlers = /* @__PURE__ */ new Map();
+  /** @internal */
+  listener = null;
+  /** @internal */
+  destroyed = !1;
+  /** @internal */
+  allowedOrigins = /* @__PURE__ */ new Set();
+  /** @internal */
+  allowedOriginPatterns = [];
+  /**
+   * Adds a trusted domain that can send messages to this messenger.
+   *
+   * @param domain - Domain pattern to trust (string, RegExp, or array)
+   */
+  addTrustedDomain(e) {
+    if (Array.isArray(e))
+      for (const r of e)
+        this.allowedOrigins.add(r);
+    else e instanceof RegExp ? this.allowedOriginPatterns.push(e) : this.allowedOrigins.add(e);
+  }
+  /**
+   * Checks if an origin is trusted.
+   *
+   * @param origin - The origin to check
+   * @returns True if the origin is trusted
+   * @internal
+   */
+  isOriginTrusted(e) {
+    if (this.allowedOrigins.has(e))
+      return !0;
+    for (const r of this.allowedOriginPatterns)
+      if (r.test(e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Sends a message and waits for a response.
+   *
+   * @typeParam T - The data type being sent
+   * @typeParam R - The expected response type
+   * @param targetWin - The target window to send to
+   * @param targetDomain - The target origin domain
+   * @param name - The message name/type
+   * @param data - Optional data payload
+   * @param timeout - Timeout in milliseconds (default: 10000)
+   * @returns Promise resolving to the response data
+   * @throws Error if messenger is destroyed or timeout occurs
+   */
+  async send(e, r, n, i, s = 1e4) {
+    if (this.destroyed)
+      throw new Error("Messenger has been destroyed");
+    const o = v(), a = X(o, n, i, {
+      uid: this.uid,
+      domain: this.domain
+    }), c = ie(), d = setTimeout(() => {
+      this.pending.delete(o), c.reject(new Error(`Message "${n}" timed out after ${s}ms`));
+    }, s);
+    this.pending.set(o, {
+      deferred: c,
+      timeout: d
+    });
+    try {
+      e.postMessage(F(a), r);
+    } catch (u) {
+      throw this.pending.delete(o), clearTimeout(d), u;
+    }
+    return c.promise;
+  }
+  /**
+   * Sends a one-way message without waiting for a response.
+   *
+   * @typeParam T - The data type being sent
+   * @param targetWin - The target window to send to
+   * @param targetDomain - The target origin domain
+   * @param name - The message name/type
+   * @param data - Optional data payload
+   * @throws Error if messenger is destroyed
+   */
+  post(e, r, n, i) {
+    if (this.destroyed)
+      throw new Error("Messenger has been destroyed");
+    const s = v(), o = X(s, n, i, {
+      uid: this.uid,
+      domain: this.domain
+    });
+    e.postMessage(F(o), r);
+  }
+  /**
+   * Registers a handler for incoming messages of a specific type.
+   *
+   * @typeParam T - The expected data type of incoming messages
+   * @typeParam R - The return type of the handler
+   * @param name - The message name/type to handle
+   * @param handler - The handler function
+   * @returns Function to unregister the handler
+   */
+  on(e, r) {
+    return this.handlers.set(e, r), () => this.handlers.delete(e);
+  }
+  /**
+   * Sets up the postMessage event listener.
+   * @internal
+   */
+  setupListener() {
+    this.listener = (e) => {
+      if (e.source === this.win || !this.isOriginTrusted(e.origin))
+        return;
+      const r = Pe(e.data);
+      r && this.handleMessage(r, e.source, e.origin);
+    }, this.win.addEventListener("message", this.listener);
+  }
+  /**
+   * Processes a received message.
+   * @internal
+   */
+  async handleMessage(e, r, n) {
+    if (e.type === T.RESPONSE) {
+      const i = this.pending.get(e.id);
+      if (i)
+        if (this.pending.delete(e.id), clearTimeout(i.timeout), e.error) {
+          const s = new Error(e.error.message);
+          s.stack = e.error.stack, i.deferred.reject(s);
+        } else
+          i.deferred.resolve(e.data);
+      return;
+    }
+    if (e.type === T.REQUEST) {
+      const i = this.handlers.get(e.name);
+      if (!i)
+        return;
+      let s, o;
+      try {
+        s = await i(e.data, e.source);
+      } catch (c) {
+        o = c instanceof Error ? c : new Error(String(c));
+      }
+      const a = Re(
+        e.id,
+        s,
+        { uid: this.uid, domain: this.domain },
+        o
+      );
+      try {
+        r.postMessage(F(a), n);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Cleans up the messenger and releases resources.
+   *
+   * @remarks
+   * Removes the message listener, rejects all pending requests,
+   * and clears all handlers.
+   */
+  destroy() {
+    if (!this.destroyed) {
+      this.destroyed = !0, this.listener && (this.win.removeEventListener("message", this.listener), this.listener = null);
+      for (const e of this.pending.values())
+        clearTimeout(e.timeout), e.deferred.reject(new Error("Messenger destroyed"));
+      this.pending.clear(), this.handlers.clear();
+    }
+  }
+  /**
+   * Checks if the messenger has been destroyed.
+   *
+   * @returns True if destroy() has been called
+   */
+  isDestroyed() {
+    return this.destroyed;
+  }
+}
+const J = 500;
+class $ {
+  /**
+   * Creates a new FunctionBridge instance.
+   *
+   * @param messenger - The messenger to use for cross-domain calls
+   */
+  constructor(e) {
+    this.messenger = e, this.setupCallHandler();
+  }
+  /** @internal */
+  localFunctions = /* @__PURE__ */ new Map();
+  /** @internal */
+  remoteFunctions = /* @__PURE__ */ new Map();
+  /**
+   * Tracks function IDs from the current serialization batch.
+   * Used for cleanup of stale references when props are updated.
+   * @internal
+   */
+  currentBatchIds = /* @__PURE__ */ new Set();
+  /**
+   * Serializes a local function to a transferable reference.
+   *
+   * @param fn - The function to serialize
+   * @param name - Optional name for debugging
+   * @returns A function reference that can be sent across domains
+   */
+  serialize(e, r) {
+    if (this.localFunctions.size >= J) {
+      const i = this.localFunctions.keys().next().value;
+      i && this.localFunctions.delete(i);
+    }
+    const n = v();
+    return this.localFunctions.set(n, e), this.currentBatchIds.add(n), {
+      __type__: "function",
+      __id__: n,
+      __name__: r || e.name || "anonymous"
+    };
+  }
+  /**
+   * Deserializes a function reference to a callable wrapper.
+   *
+   * @remarks
+   * The returned function, when called, will invoke the original function
+   * in the remote window via postMessage and return the result.
+   *
+   * @param ref - The function reference to deserialize
+   * @param targetWin - The window containing the original function
+   * @param targetDomain - The origin of the target window
+   * @returns A callable wrapper function
+   */
+  deserialize(e, r, n) {
+    const i = `${e.__id__}`, s = this.remoteFunctions.get(i);
+    if (s) return s;
+    if (this.remoteFunctions.size >= J) {
+      const a = this.remoteFunctions.keys().next().value;
+      a && this.remoteFunctions.delete(a);
+    }
+    const o = async (...a) => this.messenger.send(r, n, l.CALL, {
+      id: e.__id__,
+      args: a
+    });
+    return Object.defineProperty(o, "name", {
+      value: e.__name__,
+      configurable: !0
+    }), this.remoteFunctions.set(i, o), o;
+  }
+  /**
+   * Type guard to check if a value is a function reference.
+   *
+   * @param value - The value to check
+   * @returns True if the value is a FunctionRef
+   */
+  static isFunctionRef(e) {
+    return typeof e == "object" && e !== null && e.__type__ === "function" && typeof e.__id__ == "string";
+  }
+  /**
+   * Sets up the handler for incoming function call messages.
+   * @internal
+   */
+  setupCallHandler() {
+    this.messenger.on(
+      l.CALL,
+      async ({ id: e, args: r }) => {
+        const n = this.localFunctions.get(e);
+        if (!n)
+          throw new Error(`Function with id "${e}" not found`);
+        return n(...r);
+      }
+    );
+  }
+  /**
+   * Removes a local function reference.
+   *
+   * @param id - The function reference ID to remove
+   */
+  removeLocal(e) {
+    this.localFunctions.delete(e);
+  }
+  /**
+   * Starts a new serialization batch.
+   *
+   * @remarks
+   * Call this before serializing a new set of props. After serialization,
+   * call {@link finishBatch} to clean up functions from previous batches.
+   *
+   * @example
+   * ```typescript
+   * bridge.startBatch();
+   * const serialized = serializeFunctions(props, bridge);
+   * bridge.finishBatch();
+   * ```
+   */
+  startBatch() {
+    this.currentBatchIds.clear();
+  }
+  /**
+   * Finishes the current batch and removes functions not in this batch.
+   *
+   * @remarks
+   * This cleans up function references from previous prop updates that
+   * are no longer needed, preventing memory leaks.
+   *
+   * @param keepPrevious - If true, keeps previous batch functions (default: false)
+   */
+  finishBatch(e = !1) {
+    if (e) {
+      this.currentBatchIds.clear();
+      return;
+    }
+    for (const r of this.localFunctions.keys())
+      this.currentBatchIds.has(r) || this.localFunctions.delete(r);
+    this.currentBatchIds.clear();
+  }
+  /**
+   * Clears all remote function references.
+   *
+   * @remarks
+   * Call this when the remote window is no longer accessible
+   * (e.g., closed or navigated away).
+   */
+  clearRemote() {
+    this.remoteFunctions.clear();
+  }
+  /**
+   * Returns the current number of registered local functions.
+   * Useful for debugging and monitoring.
+   */
+  get localFunctionCount() {
+    return this.localFunctions.size;
+  }
+  /**
+   * Returns the current number of cached remote functions.
+   * Useful for debugging and monitoring.
+   */
+  get remoteFunctionCount() {
+    return this.remoteFunctions.size;
+  }
+  /**
+   * Cleans up all function references.
+   */
+  destroy() {
+    this.localFunctions.clear(), this.remoteFunctions.clear(), this.currentBatchIds.clear();
+  }
+}
+function k(t, e, r = /* @__PURE__ */ new WeakSet()) {
+  if (typeof t == "function")
+    return e.serialize(t);
+  if (Array.isArray(t)) {
+    if (r.has(t))
+      throw new Error("Circular reference detected in props - arrays cannot contain circular references");
+    return r.add(t), t.map((n) => k(n, e, r));
+  }
+  if (typeof t == "object" && t !== null) {
+    if (r.has(t))
+      throw new Error("Circular reference detected in props - objects cannot contain circular references");
+    r.add(t);
+    const n = {};
+    for (const [i, s] of Object.entries(t))
+      n[i] = k(s, e, r);
+    return n;
+  }
+  return t;
+}
+function z(t, e, r, n, i = /* @__PURE__ */ new WeakSet()) {
+  if ($.isFunctionRef(t))
+    return e.deserialize(t, r, n);
+  if (Array.isArray(t)) {
+    if (i.has(t))
+      throw new Error("Circular reference detected in serialized props");
+    return i.add(t), t.map(
+      (s) => z(s, e, r, n, i)
+    );
+  }
+  if (typeof t == "object" && t !== null) {
+    if (i.has(t))
+      throw new Error("Circular reference detected in serialized props");
+    i.add(t);
+    const s = {};
+    for (const [o, a] of Object.entries(t))
+      s[o] = z(a, e, r, n, i);
+    return s;
+  }
+  return t;
+}
+function W(t = window) {
+  try {
+    return t.location.origin;
+  } catch {
+    return "";
+  }
+}
+function oe(t, e = window) {
+  try {
+    return t.location.origin === e.location.origin;
+  } catch {
+    return !1;
+  }
+}
+function ae(t, e) {
+  return typeof t == "string" ? t === "*" ? !0 : t === e : t instanceof RegExp ? t.test(e) : Array.isArray(t) ? t.some((r) => ae(r, e)) : !1;
+}
+function ce(t) {
+  if (!t) return !0;
+  try {
+    return t.closed;
+  } catch {
+    return !0;
+  }
+}
+function Oe(t = window) {
+  try {
+    return t.opener;
+  } catch {
+    return null;
+  }
+}
+function be(t = window) {
+  try {
+    const e = t.parent;
+    return e && e !== t ? e : null;
+  } catch {
+    return null;
+  }
+}
+function _e(t = window) {
+  try {
+    return t.parent !== t;
+  } catch {
+    return !0;
+  }
+}
+function Ie(t = window) {
+  try {
+    return t.opener !== null && t.opener !== void 0;
+  } catch {
+    return !1;
+  }
+}
+const G = 32 * 1024;
+function Te(t) {
+  const e = Ne(t);
+  return `${N}${e}`;
+}
+function le(t) {
+  if (!t || !t.startsWith(N))
+    return null;
+  const e = t.slice(N.length);
+  return Se(e);
+}
+function de(t = window) {
+  try {
+    return t.name.startsWith(N);
+  } catch {
+    return !1;
+  }
+}
+function Y(t, e = window) {
+  return le(e.name)?.tag === t;
+}
+function Ne(t) {
+  try {
+    const e = JSON.stringify(t), r = btoa(encodeURIComponent(e)), n = new Blob([r]).size;
+    if (n > G)
+      throw new Error(
+        `Payload size (${Math.round(n / 1024)}KB) exceeds maximum allowed size (${G / 1024}KB). Consider reducing the amount of data passed via props.`
+      );
+    return r;
+  } catch (e) {
+    throw e instanceof Error && e.message.includes("Payload size") ? e : new Error(`Failed to encode payload: ${e}`);
+  }
+}
+function Se(t) {
+  try {
+    const e = decodeURIComponent(atob(t));
+    return JSON.parse(e);
+  } catch {
+    return null;
+  }
+}
+function xe(t) {
+  return {
+    uid: t.uid,
+    tag: t.tag,
+    version: re,
+    context: t.context,
+    parentDomain: t.parentDomain,
+    props: t.props,
+    exports: t.exports,
+    children: t.children
+  };
+}
+function De(t = window) {
+  return le(t.name);
+}
+const V = 100, y = /* @__PURE__ */ new Map();
+function Fe() {
+  const t = [];
+  for (const [e, r] of y.entries())
+    ce(r) && t.push(e);
+  for (const e of t)
+    y.delete(e);
+}
+function ve(t, e) {
+  if (y.size >= V && Fe(), y.size >= V) {
+    const r = y.keys().next().value;
+    r && y.delete(r);
+  }
+  y.set(t, e);
+}
+function Ae(t) {
+  y.delete(t);
+}
+const E = {
+  uid: {
+    type: h.STRING,
+    required: !1,
+    sendToChild: !0
+  },
+  tag: {
+    type: h.STRING,
+    required: !1,
+    sendToChild: !0
+  },
+  dimensions: {
+    type: h.OBJECT,
+    required: !1,
+    sendToChild: !1,
+    default: () => ({ width: "100%", height: "100%" })
+  },
+  timeout: {
+    type: h.NUMBER,
+    required: !1,
+    sendToChild: !1,
+    default: () => 1e4
+  },
+  cspNonce: {
+    type: h.STRING,
+    required: !1,
+    sendToChild: !0
+  },
+  // Lifecycle callbacks - functions sent to child
+  onDisplay: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onRendered: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onRender: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onPrerendered: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onPrerender: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onClose: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onDestroy: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onResize: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onFocus: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onError: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  },
+  onProps: {
+    type: h.FUNCTION,
+    required: !1,
+    sendToChild: !1
+  }
+};
+function Z(t, e, r) {
+  const n = {
+    ...E,
+    ...e
+  }, i = {};
+  for (const [s, o] of Object.entries(n)) {
+    const a = o;
+    let c;
+    const d = a.alias, u = s in t, g = d && d in t;
+    u ? c = t[s] : g ? c = t[d] : a.value ? c = a.value(r) : a.default !== void 0 && (c = typeof a.default == "function" ? a.default(r) : a.default), c !== void 0 && a.decorate && (c = a.decorate({ value: c, props: i })), i[s] = c;
+  }
+  return i;
+}
+function ke(t, e) {
+  const r = {
+    ...E,
+    ...e
+  };
+  for (const [n, i] of Object.entries(r)) {
+    const s = i, o = t[n];
+    if (s.required && o === void 0)
+      throw new Error(`Prop "${n}" is required but was not provided`);
+    if (o !== void 0) {
+      if (!ze(o, s.type))
+        throw new Error(
+          `Prop "${n}" expected type "${s.type}" but got "${typeof o}"`
+        );
+      s.validate && s.validate({ value: o, props: t });
+    }
+  }
+}
+function ze(t, e) {
+  switch (e) {
+    case h.STRING:
+      return typeof t == "string";
+    case h.NUMBER:
+      return typeof t == "number";
+    case h.BOOLEAN:
+      return typeof t == "boolean";
+    case h.FUNCTION:
+      return typeof t == "function";
+    case h.ARRAY:
+      return Array.isArray(t);
+    case h.OBJECT:
+      return typeof t == "object" && t !== null && !Array.isArray(t);
+    default:
+      return !0;
+  }
+}
+function K(t, e, r, n) {
+  const i = {
+    ...E,
+    ...e
+  }, s = {};
+  for (const [o, a] of Object.entries(i)) {
+    const c = a, d = t[o];
+    if (c.sendToChild === !1 || c.sameDomain && !n) continue;
+    if (c.trustedDomains) {
+      const g = c.trustedDomains;
+      if (!ae(g, r)) continue;
+    }
+    let u = d;
+    c.childDecorate && d !== void 0 && (u = c.childDecorate({ value: d, props: t })), s[o] = u;
+  }
+  return s;
+}
+function We(t, e) {
+  const r = new URLSearchParams(), n = {
+    ...E,
+    ...e
+  };
+  for (const [i, s] of Object.entries(n)) {
+    const o = s, a = t[i];
+    if (a === void 0 || o.type === h.FUNCTION || !o.queryParam) continue;
+    const c = typeof o.queryParam == "string" ? o.queryParam : i;
+    let d;
+    typeof o.queryParam == "function" ? d = o.queryParam({ value: a }) : typeof a == "object" ? d = JSON.stringify(a) : d = String(a), r.set(c, d);
+  }
+  return r;
+}
+function he(t, e = "") {
+  const r = [];
+  for (const [n, i] of Object.entries(t)) {
+    const s = e ? `${e}.${n}` : n;
+    if (i !== null && typeof i == "object" && !Array.isArray(i))
+      r.push(he(i, s));
+    else {
+      const o = encodeURIComponent(JSON.stringify(i));
+      r.push(`${s}=${o}`);
+    }
+  }
+  return r.filter(Boolean).join("&");
+}
+function $e(t) {
+  const e = {};
+  if (!t) return e;
+  const r = t.split("&");
+  for (const n of r) {
+    const [i, s] = n.split("=");
+    if (!i || s === void 0) continue;
+    let o;
+    try {
+      o = JSON.parse(decodeURIComponent(s));
+    } catch {
+      o = decodeURIComponent(s);
+    }
+    const a = i.split(".");
+    let c = e;
+    for (let d = 0; d < a.length - 1; d++) {
+      const u = a[d];
+      (!(u in c) || typeof c[u] != "object") && (c[u] = {}), c = c[u];
+    }
+    c[a[a.length - 1]] = o;
+  }
+  return e;
+}
+function Me(t) {
+  return typeof t == "object" && t !== null && t.__type__ === "dotify" && typeof t.__value__ == "string";
+}
+function Q(t, e, r) {
+  const n = {
+    ...E,
+    ...e
+  }, i = {};
+  for (const [s, o] of Object.entries(t)) {
+    if (o === void 0) continue;
+    const a = n[s];
+    i[s] = Ue(o, a, r);
+  }
+  return i;
+}
+function Ue(t, e, r) {
+  if (typeof t == "function")
+    return r.serialize(t);
+  const n = e?.serialization ?? I.JSON;
+  if (n === I.BASE64 && typeof t == "object") {
+    const i = JSON.stringify(t);
+    return {
+      __type__: "base64",
+      __value__: btoa(encodeURIComponent(i))
+    };
+  }
+  return n === I.DOTIFY && typeof t == "object" && t !== null && !Array.isArray(t) ? {
+    __type__: "dotify",
+    __value__: he(t)
+  } : k(t, r);
+}
+function ee(t, e, r, n, i, s) {
+  const o = {
+    ...E,
+    ...e
+  }, a = {};
+  for (const [c, d] of Object.entries(t)) {
+    const u = o[c];
+    a[c] = Le(
+      d,
+      u,
+      r,
+      n,
+      i,
+      s
+    );
+  }
+  return a;
+}
+function Le(t, e, r, n, i, s) {
+  if (qe(t))
+    try {
+      const o = decodeURIComponent(atob(t.__value__));
+      return JSON.parse(o);
+    } catch {
+      return t;
+    }
+  if (Me(t))
+    try {
+      return $e(t.__value__);
+    } catch {
+      return t;
+    }
+  return z(t, n, i, s);
+}
+function qe(t) {
+  return typeof t == "object" && t !== null && t.__type__ === "base64" && typeof t.__value__ == "string";
+}
+function w(t, e = "100%") {
+  return t === void 0 ? e : typeof t == "number" ? `${t}px` : t;
+}
+function S(t, e) {
+  if (t === void 0) return e;
+  if (typeof t == "number") return t;
+  const r = parseInt(t, 10);
+  return isNaN(r) ? e : r;
+}
+function Be(t) {
+  try {
+    t.src = "about:blank", t.parentNode?.removeChild(t);
+  } catch {
+  }
+}
+function je(t, e) {
+  Je(t, e);
+}
+function He(t) {
+  t.style.display = "", t.style.visibility = "visible";
+}
+function te(t) {
+  t.style.display = "none", t.style.visibility = "hidden";
+}
+function Xe(t) {
+  try {
+    t.focus(), t.contentWindow?.focus();
+  } catch {
+  }
+}
+function Je(t, e) {
+  e.width !== void 0 && (t.style.width = w(e.width)), e.height !== void 0 && (t.style.height = w(e.height));
+}
+class ue extends Error {
+  constructor(e = "Popup blocked by browser") {
+    super(e), this.name = "PopupOpenError";
+  }
+}
+function Ge(t) {
+  const { url: e, name: r, dimensions: n } = t, i = S(n.width, 500), s = S(n.height, 500), o = Math.floor(window.screenX + (window.outerWidth - i) / 2), a = Math.floor(window.screenY + (window.outerHeight - s) / 2), c = [
+    `width=${i}`,
+    `height=${s}`,
+    `left=${o}`,
+    `top=${a}`,
+    "menubar=no",
+    "toolbar=no",
+    "location=yes",
+    // Required for security
+    "status=no",
+    "resizable=yes",
+    "scrollbars=yes"
+  ].join(","), d = window.open(e, r, c);
+  if (!d || Ze(d))
+    throw new ue();
+  return d;
+}
+function Ye(t) {
+  try {
+    t.closed || t.close();
+  } catch {
+  }
+}
+function Ve(t) {
+  try {
+    t.closed || t.focus();
+  } catch {
+  }
+}
+function Ze(t) {
+  if (!t) return !0;
+  try {
+    return !!(t.closed || t.innerHeight === 0 || t.innerWidth === 0);
+  } catch {
+    return !0;
+  }
+}
+function Ke(t, e, r = {}) {
+  const {
+    initialInterval: n = 100,
+    // Start fast to catch quick closes
+    maxInterval: i = 2e3,
+    // Cap at 2 seconds
+    multiplier: s = 1.5
+    // Exponential backoff multiplier
+  } = r;
+  let o = n, a, c = !1;
+  const d = () => {
+    try {
+      e();
+    } catch (g) {
+      console.error("Error in popup close callback:", g);
+    }
+  }, u = () => {
+    if (!c) {
+      try {
+        if (t.closed) {
+          d();
+          return;
+        }
+      } catch {
+        d();
+        return;
+      }
+      o = Math.min(o * s, i), a = setTimeout(u, o);
+    }
+  };
+  return a = setTimeout(u, o), () => {
+    c = !0, clearTimeout(a);
+  };
+}
+function Qe(t, e) {
+  try {
+    const r = S(e.width, t.outerWidth), n = S(
+      e.height,
+      t.outerHeight
+    );
+    t.resizeTo(r, n);
+  } catch {
+  }
+}
+function et(t) {
+  const { doc: e, dimensions: r, uid: n, tag: i } = t, s = e.createElement("div");
+  return s.id = `forgeframe-container-${n}`, s.setAttribute("data-forgeframe-tag", i), Object.assign(s.style, {
+    display: "inline-block",
+    position: "relative",
+    width: w(r.width),
+    height: w(r.height),
+    overflow: "hidden"
+  }), s;
+}
+function tt(t) {
+  const { doc: e, dimensions: r, cspNonce: n } = t, i = e.createElement("div");
+  Object.assign(i.style, {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: w(r.width),
+    height: w(r.height),
+    backgroundColor: "#f5f5f5",
+    position: "absolute",
+    top: "0",
+    left: "0",
+    zIndex: "100"
+  });
+  const s = e.createElement("div");
+  Object.assign(s.style, {
+    width: "40px",
+    height: "40px",
+    border: "3px solid #e0e0e0",
+    borderTopColor: "#3498db",
+    borderRadius: "50%",
+    animation: "forgeframe-spin 1s linear infinite"
+  });
+  const o = e.createElement("style");
+  return n && o.setAttribute("nonce", n), o.textContent = `
+    @keyframes forgeframe-spin {
+      to { transform: rotate(360deg); }
+    }
+  `, i.appendChild(o), i.appendChild(s), i;
+}
+function rt(t, e = 200) {
+  return new Promise((r) => {
+    t.style.opacity = "0", t.style.transition = `opacity ${e}ms ease-in`, t.offsetHeight, t.style.opacity = "1", setTimeout(r, e);
+  });
+}
+function nt(t, e = 200) {
+  return new Promise((r) => {
+    t.style.transition = `opacity ${e}ms ease-out`, t.style.opacity = "0", setTimeout(r, e);
+  });
+}
+async function it(t, e, r) {
+  e && (await nt(e, 150), e.remove()), r.style.display = "", r.style.visibility = "visible", r.style.opacity = "0", await rt(r, 150);
+}
+class M {
+  /** Event emitter for lifecycle events. */
+  event;
+  /** Arbitrary state storage for the component instance. */
+  state = {};
+  /** Data exported by the child component. */
+  exports;
+  /** Data exported from the parent by the child. */
+  parentExports;
+  /** @internal */
+  _uid;
+  /**
+   * Unique instance identifier.
+   * @readonly
+   */
+  get uid() {
+    return this._uid;
+  }
+  /** @internal */
+  options;
+  /** @internal */
+  props;
+  /** @internal */
+  context;
+  /** @internal */
+  messenger;
+  /** @internal */
+  bridge;
+  /** @internal */
+  cleanup;
+  /** @internal */
+  childWindow = null;
+  /** @internal */
+  iframe = null;
+  /** @internal */
+  container = null;
+  /** @internal */
+  prerenderElement = null;
+  /** @internal */
+  initPromise = null;
+  /** @internal */
+  rendered = !1;
+  /** @internal */
+  destroyed = !1;
+  /**
+   * Creates a new ParentComponent instance.
+   *
+   * @param options - Component configuration options
+   * @param props - Initial props to pass to the component
+   */
+  constructor(e, r = {}) {
+    this._uid = we(), this.options = this.normalizeOptions(e), this.context = this.options.defaultContext, this.event = new ne(), this.cleanup = new Ee();
+    const n = this.buildTrustedDomains();
+    this.messenger = new se(this.uid, window, W(), n), this.bridge = new $(this.messenger);
+    const i = this.createPropContext();
+    this.props = Z(r, this.options.props, i), this.setupMessageHandlers(), this.setupCleanup();
+  }
+  /**
+   * Builds the list of trusted domains for messenger communication.
+   * @internal
+   */
+  buildTrustedDomains() {
+    const e = [], r = typeof this.options.url == "function" ? this.options.url(this.props) : this.options.url;
+    try {
+      const n = new URL(r);
+      e.push(n.origin);
+    } catch {
+    }
+    if (this.options.domain) {
+      if (typeof this.options.domain == "string")
+        e.push(this.options.domain);
+      else if (Array.isArray(this.options.domain))
+        e.push(...this.options.domain);
+      else if (this.options.domain instanceof RegExp)
+        return this.options.domain;
+    }
+    return e.length > 0 ? e : void 0;
+  }
+  /**
+   * Renders the component into a DOM container.
+   *
+   * @remarks
+   * This is the primary method for displaying the component. It creates
+   * an iframe or popup, establishes communication with the child, and
+   * handles the prerender/render lifecycle.
+   *
+   * @param container - CSS selector or HTMLElement to render into
+   * @param context - Override the default rendering context (iframe or popup)
+   * @throws Error if component was already destroyed or rendered
+   *
+   * @example
+   * ```typescript
+   * await instance.render('#container');
+   * await instance.render(document.getElementById('target'), 'popup');
+   * ```
+   */
+  async render(e, r) {
+    if (this.destroyed)
+      throw new Error("Component has been destroyed");
+    if (this.rendered)
+      throw new Error("Component has already been rendered");
+    this.context = r ?? this.options.defaultContext, this.checkEligibility(), ke(this.props, this.options.props), this.container = this.resolveContainer(e), this.event.emit(p.PRERENDER), this.callPropCallback("onPrerender"), await this.prerender(), this.event.emit(p.PRERENDERED), this.callPropCallback("onPrerendered"), this.event.emit(p.RENDER), this.callPropCallback("onRender"), await this.open(), await this.waitForChild(), this.context === f.IFRAME && this.iframe && this.prerenderElement && (await it(
+      this.container,
+      this.prerenderElement,
+      this.iframe
+    ), this.prerenderElement = null), this.rendered = !0, this.event.emit(p.RENDERED), this.callPropCallback("onRendered"), this.event.emit(p.DISPLAY), this.callPropCallback("onDisplay");
+  }
+  /**
+   * Renders the component into a container in a different window.
+   *
+   * @remarks
+   * Currently delegates to regular render. Full cross-window rendering
+   * would require additional complexity.
+   *
+   * @param _win - Target window (currently unused)
+   * @param container - CSS selector or HTMLElement to render into
+   * @param context - Override the default rendering context
+   */
+  async renderTo(e, r, n) {
+    return this.render(r, n);
+  }
+  /**
+   * Closes and destroys the component.
+   *
+   * @remarks
+   * Emits the 'close' event before destruction. Safe to call multiple times.
+   */
+  async close() {
+    this.destroyed || (this.event.emit(p.CLOSE), await this.destroy());
+  }
+  /**
+   * Focuses the component window.
+   *
+   * @remarks
+   * For iframes, focuses the iframe element. For popups, brings the window to front.
+   */
+  async focus() {
+    this.context === f.IFRAME && this.iframe ? Xe(this.iframe) : this.context === f.POPUP && this.childWindow && Ve(this.childWindow), this.event.emit(p.FOCUS), this.callPropCallback("onFocus");
+  }
+  /**
+   * Resizes the component to the specified dimensions.
+   *
+   * @param dimensions - New width and height for the component
+   */
+  async resize(e) {
+    this.context === f.IFRAME && this.iframe ? je(this.iframe, e) : this.context === f.POPUP && this.childWindow && Qe(this.childWindow, e), this.event.emit(p.RESIZE, e), this.callPropCallback("onResize", e);
+  }
+  /**
+   * Shows the component if hidden.
+   *
+   * @remarks
+   * Only applicable to iframe context.
+   */
+  async show() {
+    this.context === f.IFRAME && this.iframe && He(this.iframe);
+  }
+  /**
+   * Hides the component.
+   *
+   * @remarks
+   * Only applicable to iframe context.
+   */
+  async hide() {
+    this.context === f.IFRAME && this.iframe && te(this.iframe);
+  }
+  /**
+   * Updates the component props and sends them to the child.
+   *
+   * @remarks
+   * Props are normalized and serialized before being sent to the child window.
+   *
+   * @param newProps - Partial props object to merge with existing props
+   */
+  async updateProps(e) {
+    const r = this.createPropContext();
+    if (this.props = Z(
+      { ...this.props, ...e },
+      this.options.props,
+      r
+    ), this.childWindow && !ce(this.childWindow)) {
+      const n = this.getChildDomain(), i = K(
+        this.props,
+        this.options.props,
+        n,
+        oe(this.childWindow)
+      ), s = Q(
+        i,
+        this.options.props,
+        this.bridge
+      );
+      await this.messenger.send(
+        this.childWindow,
+        n,
+        l.PROPS,
+        s
+      );
+    }
+    this.event.emit(p.PROPS, this.props), this.callPropCallback("onProps", this.props);
+  }
+  /**
+   * Creates a clone of this instance with the same props.
+   *
+   * @returns A new unrendered component instance with identical configuration
+   */
+  clone() {
+    return new M(this.options, this.props);
+  }
+  /**
+   * Checks if the component is eligible to render based on the eligible option.
+   *
+   * @returns True if eligible or no eligibility check defined
+   */
+  isEligible() {
+    return this.options.eligible ? this.options.eligible({ props: this.props }).eligible : !0;
+  }
+  /**
+   * Normalizes component options with default values.
+   * @internal
+   */
+  normalizeOptions(e) {
+    return {
+      ...e,
+      props: e.props ?? {},
+      defaultContext: e.defaultContext ?? f.IFRAME,
+      dimensions: typeof e.dimensions == "function" ? e.dimensions(this.props) : e.dimensions ?? { width: "100%", height: "100%" },
+      timeout: e.timeout ?? 1e4,
+      children: e.children
+    };
+  }
+  /**
+   * Creates the prop context passed to prop callbacks and validators.
+   * @internal
+   */
+  createPropContext() {
+    return {
+      props: this.props,
+      state: this.state,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      onError: (e) => this.handleError(e),
+      container: this.container,
+      uid: this.uid,
+      tag: this.options.tag
+    };
+  }
+  /**
+   * Resolves a container selector or element to an HTMLElement.
+   * @internal
+   */
+  resolveContainer(e) {
+    if (!e)
+      throw new Error("Container is required for rendering");
+    if (typeof e == "string") {
+      const r = document.querySelector(e);
+      if (!r)
+        throw new Error(`Container "${e}" not found`);
+      return r;
+    }
+    return e;
+  }
+  /**
+   * Checks eligibility and throws if component cannot render.
+   * @internal
+   */
+  checkEligibility() {
+    if (!this.options.eligible) return;
+    const e = this.options.eligible({ props: this.props });
+    if (!e.eligible)
+      throw new Error(`Component not eligible: ${e.reason ?? "Unknown reason"}`);
+  }
+  /**
+   * Creates and displays the prerender (loading) content.
+   * @internal
+   */
+  async prerender() {
+    if (!this.container) return;
+    const e = this.options.prerenderTemplate ?? tt, r = this.options.containerTemplate ?? et, n = this.options.dimensions, i = this.props.cspNonce;
+    if (this.context === f.IFRAME) {
+      const c = this.buildWindowName();
+      this.iframe = this.createIframeElement(c), te(this.iframe);
+    }
+    const s = {
+      uid: this.uid,
+      tag: this.options.tag,
+      context: this.context,
+      dimensions: n,
+      props: this.props,
+      doc: document,
+      container: this.container,
+      frame: this.iframe,
+      prerenderFrame: null,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      cspNonce: i
+    };
+    this.prerenderElement = e(s);
+    const o = {
+      uid: this.uid,
+      tag: this.options.tag,
+      context: this.context,
+      dimensions: n,
+      props: this.props,
+      doc: document,
+      container: this.container,
+      frame: this.iframe,
+      prerenderFrame: this.prerenderElement,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      cspNonce: i
+    }, a = r(o);
+    a && (this.container.appendChild(a), this.container = a), this.prerenderElement && !this.prerenderElement.parentNode && this.container.appendChild(this.prerenderElement), this.iframe && !this.iframe.parentNode && this.container.appendChild(this.iframe);
+  }
+  /**
+   * Creates an iframe element without setting src (for prerender phase).
+   * The window name is set immediately as it carries the payload for the child.
+   * @internal
+   */
+  createIframeElement(e) {
+    const r = document.createElement("iframe"), n = this.options.dimensions, i = typeof this.options.attributes == "function" ? this.options.attributes(this.props) : this.options.attributes ?? {}, s = typeof this.options.style == "function" ? this.options.style(this.props) : this.options.style ?? {};
+    r.name = e, r.setAttribute("frameborder", "0"), r.setAttribute("allowtransparency", "true"), r.setAttribute("scrolling", "auto"), n.width !== void 0 && (r.style.width = typeof n.width == "number" ? `${n.width}px` : n.width), n.height !== void 0 && (r.style.height = typeof n.height == "number" ? `${n.height}px` : n.height);
+    for (const [o, a] of Object.entries(i))
+      a !== void 0 && (typeof a == "boolean" ? a && r.setAttribute(o, "") : r.setAttribute(o, a));
+    for (const [o, a] of Object.entries(s)) {
+      if (a === void 0) continue;
+      const c = typeof a == "number" ? `${a}px` : a;
+      r.style.setProperty(
+        o.replace(/([A-Z])/g, "-$1").toLowerCase(),
+        String(c)
+      );
+    }
+    return i.sandbox || r.setAttribute(
+      "sandbox",
+      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
+    ), r;
+  }
+  /**
+   * Opens the child window (iframe or popup).
+   * @internal
+   */
+  async open() {
+    const e = this.buildUrl();
+    if (this.context === f.IFRAME) {
+      if (!this.iframe)
+        throw new Error("Iframe not created during prerender");
+      this.iframe.src = e, this.childWindow = this.iframe.contentWindow;
+    } else {
+      const r = this.buildWindowName();
+      this.childWindow = Ge({
+        url: e,
+        name: r,
+        dimensions: this.options.dimensions
+      });
+      const n = Ke(this.childWindow, () => {
+        this.destroy();
+      });
+      this.cleanup.register(n);
+    }
+    this.childWindow && ve(this.uid, this.childWindow);
+  }
+  /**
+   * Builds the URL for the child window including query parameters.
+   * @internal
+   */
+  buildUrl() {
+    const e = typeof this.options.url == "function" ? this.options.url(this.props) : this.options.url, n = We(this.props, this.options.props).toString();
+    if (!n) return e;
+    const i = e.includes("?") ? "&" : "?";
+    return `${e}${i}${n}`;
+  }
+  /**
+   * Builds the window.name payload for the child window.
+   * @internal
+   */
+  buildWindowName() {
+    const e = this.getChildDomain(), r = K(
+      this.props,
+      this.options.props,
+      e,
+      !1
+      // Assume cross-domain for initial payload
+    ), n = Q(
+      r,
+      this.options.props,
+      this.bridge
+    ), i = this.buildChildrenRefs(), s = xe({
+      uid: this.uid,
+      tag: this.options.tag,
+      context: this.context,
+      parentDomain: W(),
+      props: n,
+      exports: this.createParentExports(),
+      children: i
+    });
+    return Te(s);
+  }
+  /**
+   * Builds component references for nested child components.
+   * @internal
+   */
+  buildChildrenRefs() {
+    if (!this.options.children) return;
+    const e = this.options.children({ props: this.props }), r = {};
+    for (const [n, i] of Object.entries(e)) {
+      const s = i;
+      r[n] = {
+        tag: s.tag ?? n,
+        url: typeof s.url == "function" ? s.url.toString() : s.url ?? ""
+      };
+    }
+    return Object.keys(r).length > 0 ? r : void 0;
+  }
+  /**
+   * Creates the exports object sent to the child.
+   * @internal
+   */
+  createParentExports() {
+    return {
+      init: l.INIT,
+      close: l.CLOSE,
+      resize: l.RESIZE,
+      show: l.SHOW,
+      hide: l.HIDE,
+      onError: l.ERROR,
+      updateProps: l.PROPS,
+      export: l.EXPORT
+    };
+  }
+  /**
+   * Extracts the origin domain from the component URL.
+   * @internal
+   */
+  getChildDomain() {
+    const e = typeof this.options.url == "function" ? this.options.url(this.props) : this.options.url;
+    try {
+      return new URL(e, window.location.origin).origin;
+    } catch {
+      return "*";
+    }
+  }
+  /**
+   * Waits for the child to send the init message.
+   * @internal
+   */
+  async waitForChild() {
+    this.initPromise = ie();
+    try {
+      await Ce(
+        this.initPromise.promise,
+        this.options.timeout,
+        `Child component "${this.options.tag}" (uid: ${this._uid}) did not initialize within ${this.options.timeout}ms. Check that the child page loads correctly and calls the initialization code.`
+      );
+    } catch (e) {
+      throw this.handleError(e), e;
+    }
+  }
+  /**
+   * Sets up message handlers for child communication.
+   * @internal
+   */
+  setupMessageHandlers() {
+    this.messenger.on(l.INIT, () => (this.initPromise && this.initPromise.resolve(), { success: !0 })), this.messenger.on(l.CLOSE, async () => (await this.close(), { success: !0 })), this.messenger.on(l.RESIZE, async (e) => (await this.resize(e), { success: !0 })), this.messenger.on(l.FOCUS, async () => (await this.focus(), { success: !0 })), this.messenger.on(l.SHOW, async () => (await this.show(), { success: !0 })), this.messenger.on(l.HIDE, async () => (await this.hide(), { success: !0 })), this.messenger.on(
+      l.ERROR,
+      async (e) => {
+        const r = new Error(e.message);
+        return r.stack = e.stack, this.handleError(r), { success: !0 };
+      }
+    ), this.messenger.on(l.EXPORT, async (e) => (this.exports = e, { success: !0 })), this.messenger.on(l.PARENT_EXPORT, async (e) => (this.parentExports = e, { success: !0 })), this.messenger.on(
+      l.GET_SIBLINGS,
+      async (e) => {
+        const r = [], n = lt(e.tag);
+        if (n)
+          for (const i of n.instances)
+            i.uid !== e.uid && r.push({
+              uid: i.uid,
+              tag: e.tag,
+              exports: i.exports
+            });
+        return r;
+      }
+    );
+  }
+  /**
+   * Registers cleanup handlers for the instance.
+   * @internal
+   */
+  setupCleanup() {
+    this.cleanup.register(() => {
+      this.messenger.destroy(), this.bridge.destroy(), this.event.removeAllListeners(), Ae(this.uid);
+    });
+  }
+  /**
+   * Handles errors by emitting events and calling callbacks.
+   * @internal
+   */
+  handleError(e) {
+    this.event.emit(p.ERROR, e), this.callPropCallback("onError", e);
+  }
+  /**
+   * Calls a prop callback if it exists.
+   * @internal
+   */
+  callPropCallback(e, ...r) {
+    const n = this.props[e];
+    if (typeof n == "function")
+      try {
+        const i = n(...r);
+        i && typeof i == "object" && "catch" in i && typeof i.catch == "function" && i.catch((s) => {
+          console.error(`Error in async ${e} callback:`, s);
+        });
+      } catch (i) {
+        console.error(`Error in ${e} callback:`, i);
+      }
+  }
+  /**
+   * Destroys the component and cleans up all resources.
+   * @internal
+   */
+  async destroy() {
+    this.destroyed || (this.destroyed = !0, this.initPromise && (this.initPromise.reject(
+      new Error(`Component "${this.options.tag}" was destroyed before initialization completed`)
+    ), this.initPromise = null), this.iframe && (Be(this.iframe), this.iframe = null), this.context === f.POPUP && this.childWindow && Ye(this.childWindow), this.childWindow = null, this.prerenderElement && (this.prerenderElement.remove(), this.prerenderElement = null), await this.cleanup.cleanup(), this.event.emit(p.DESTROY), this.callPropCallback("onDestroy"));
+  }
+}
+class st {
+  /**
+   * Creates a new ChildComponent instance.
+   *
+   * @param payload - The payload parsed from window.name
+   * @param propDefinitions - Optional prop definitions for deserialization
+   */
+  constructor(e, r = {}) {
+    this.propDefinitions = r, this.uid = e.uid, this.tag = e.tag, this.parentDomain = e.parentDomain, this.event = new ne(), this.messenger = new se(this.uid, window, W(), this.parentDomain), this.setupMessageHandlers(), this.parentWindow = this.resolveParentWindow(), this.bridge = new $(this.messenger), this.xprops = this.buildXProps(e), window.xprops = this.xprops, this.sendInit();
+  }
+  /** The xprops object containing props and control methods. */
+  xprops;
+  /** Event emitter for lifecycle events. */
+  event;
+  /** @internal */
+  uid;
+  /** @internal */
+  tag;
+  /** @internal */
+  parentWindow;
+  /** @internal */
+  parentDomain;
+  /** @internal */
+  messenger;
+  /** @internal */
+  bridge;
+  /** @internal */
+  propsHandlers = /* @__PURE__ */ new Set();
+  /** @internal */
+  parentProps;
+  /** @internal */
+  initError = null;
+  /**
+   * Returns the xprops object.
+   *
+   * @returns The xprops object with props and control methods
+   */
+  getProps() {
+    return this.xprops;
+  }
+  /**
+   * Resolves the parent window reference (iframe parent or popup opener).
+   * @internal
+   */
+  resolveParentWindow() {
+    if (_e()) {
+      const e = be();
+      if (e) return e;
+    }
+    if (Ie()) {
+      const e = Oe();
+      if (e) return e;
+    }
+    throw new Error("Could not resolve parent window");
+  }
+  /**
+   * Builds the xprops object with deserialized props and control methods.
+   * @internal
+   */
+  buildXProps(e) {
+    const r = ee(
+      e.props,
+      this.propDefinitions,
+      this.messenger,
+      this.bridge,
+      this.parentWindow,
+      this.parentDomain
+    );
+    return this.parentProps = r, {
+      ...r,
+      uid: this.uid,
+      tag: this.tag,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      resize: (n) => this.resize(n),
+      show: () => this.show(),
+      hide: () => this.hide(),
+      onProps: (n) => this.onProps(n),
+      onError: (n) => this.onError(n),
+      getParent: () => this.parentWindow,
+      getParentDomain: () => this.parentDomain,
+      export: (n) => this.exportData(n),
+      parent: {
+        props: this.parentProps,
+        export: (n) => this.parentExport(n)
+      },
+      getSiblings: (n) => this.getSiblings(n),
+      children: this.buildChildComponents(e.children)
+    };
+  }
+  /**
+   * Sends initialization message to the parent.
+   * @internal
+   */
+  async sendInit() {
+    try {
+      await this.messenger.send(
+        this.parentWindow,
+        this.parentDomain,
+        l.INIT,
+        { uid: this.uid, tag: this.tag }
+      );
+    } catch (e) {
+      const r = e instanceof Error ? e : new Error(String(e));
+      this.initError = r, this.event.emit(p.ERROR, {
+        type: "init_failed",
+        message: `Failed to initialize child component: ${r.message}`,
+        error: r
+      }), console.error("Failed to send init message:", e);
+    }
+  }
+  /**
+   * Returns the initialization error if one occurred.
+   *
+   * @returns The initialization error or null if successful
+   */
+  getInitError() {
+    return this.initError;
+  }
+  /**
+   * Requests the parent to close this component.
+   * @internal
+   */
+  async close() {
+    await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.CLOSE,
+      {}
+    );
+  }
+  /**
+   * Focuses this window and notifies the parent.
+   * @internal
+   */
+  async focus() {
+    window.focus(), await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.FOCUS,
+      {}
+    );
+  }
+  /**
+   * Requests the parent to resize this component.
+   * @internal
+   */
+  async resize(e) {
+    await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.RESIZE,
+      e
+    );
+  }
+  /**
+   * Requests the parent to show this component.
+   * @internal
+   */
+  async show() {
+    await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.SHOW,
+      {}
+    );
+  }
+  /**
+   * Requests the parent to hide this component.
+   * @internal
+   */
+  async hide() {
+    await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.HIDE,
+      {}
+    );
+  }
+  /**
+   * Subscribes to prop updates from the parent.
+   * @internal
+   */
+  onProps(e) {
+    return this.propsHandlers.add(e), {
+      cancel: () => this.propsHandlers.delete(e)
+    };
+  }
+  /**
+   * Reports an error to the parent.
+   * @internal
+   */
+  async onError(e) {
+    await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.ERROR,
+      {
+        message: e.message,
+        stack: e.stack
+      }
+    );
+  }
+  /**
+   * Exports data or methods to the parent.
+   * @internal
+   */
+  async exportData(e) {
+    await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.EXPORT,
+      e
+    );
+  }
+  /**
+   * Exports data to the parent for bidirectional communication.
+   * @internal
+   */
+  async parentExport(e) {
+    await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.PARENT_EXPORT,
+      e
+    );
+  }
+  /**
+   * Gets information about sibling component instances.
+   * @internal
+   */
+  async getSiblings(e) {
+    return await this.messenger.send(
+      this.parentWindow,
+      this.parentDomain,
+      l.GET_SIBLINGS,
+      { uid: this.uid, tag: this.tag, options: e }
+    ) ?? [];
+  }
+  /**
+   * Builds child component factories from refs passed by the parent.
+   * @internal
+   */
+  buildChildComponents(e) {
+    if (!e) return;
+    const r = {};
+    for (const [n, i] of Object.entries(e))
+      try {
+        r[n] = fe({
+          tag: i.tag,
+          url: i.url,
+          props: i.props,
+          dimensions: i.dimensions,
+          defaultContext: i.defaultContext
+        });
+      } catch (s) {
+        console.warn(`Failed to create child component "${n}":`, s);
+      }
+    return Object.keys(r).length > 0 ? r : void 0;
+  }
+  /**
+   * Sets up message handlers for parent communication.
+   * @internal
+   */
+  setupMessageHandlers() {
+    this.messenger.on(l.PROPS, (e) => {
+      try {
+        const r = ee(
+          e,
+          this.propDefinitions,
+          this.messenger,
+          this.bridge,
+          this.parentWindow,
+          this.parentDomain
+        );
+        Object.assign(this.xprops, r);
+        for (const n of this.propsHandlers)
+          try {
+            n(r);
+          } catch (i) {
+            console.error("Error in props handler:", i);
+          }
+        return this.event.emit(p.PROPS, r), { success: !0 };
+      } catch (r) {
+        const n = r instanceof Error ? r : new Error(String(r));
+        throw console.error("Error deserializing props:", n), this.event.emit(p.ERROR, n), n;
+      }
+    });
+  }
+  /**
+   * Destroys the child component and cleans up resources.
+   */
+  destroy() {
+    this.messenger.destroy(), this.bridge.destroy(), this.event.removeAllListeners(), this.propsHandlers.clear();
+  }
+}
+let _ = null;
+function pe(t) {
+  if (_)
+    return _;
+  if (!de())
+    return null;
+  const e = De();
+  return e ? (_ = new st(
+    e,
+    t
+  ), _) : (console.error("Failed to parse ForgeFrame payload from window.name"), null);
+}
+function ot() {
+  return de();
+}
+function at() {
+  return window.xprops;
+}
+const P = /* @__PURE__ */ new Map();
+function ct(t) {
+  if (!t.tag)
+    throw new Error("Component tag is required");
+  if (!/^[a-z][a-z0-9-]*$/.test(t.tag))
+    throw new Error(
+      `Invalid component tag "${t.tag}". Must start with lowercase letter and contain only lowercase letters, numbers, and hyphens.`
+    );
+  if (!t.url)
+    throw new Error("Component url is required");
+  if (typeof t.url == "string")
+    try {
+      new URL(t.url, window.location.origin);
+    } catch {
+      throw new Error(
+        `Invalid component URL "${t.url}". Must be a valid absolute or relative URL.`
+      );
+    }
+  if (P.has(t.tag))
+    throw new Error(`Component "${t.tag}" is already registered`);
+}
+function fe(t) {
+  ct(t);
+  const e = [];
+  let r;
+  if (Y(t.tag)) {
+    const i = pe(t.props);
+    i && (r = i.xprops);
+  }
+  const n = function(i = {}) {
+    const s = new M(t, i);
+    return e.push(s), s.event.once("destroy", () => {
+      const o = e.indexOf(s);
+      o !== -1 && e.splice(o, 1);
+    }), s;
+  };
+  return n.instances = e, n.isChild = () => Y(t.tag), n.xprops = r, n.canRenderTo = async (i) => {
+    try {
+      return !!(oe(i) || t.domain);
+    } catch {
+      return !1;
+    }
+  }, P.set(t.tag, n), n;
+}
+function lt(t) {
+  return P.get(t);
+}
+async function dt(t) {
+  await t.close();
+}
+async function me(t) {
+  const e = P.get(t);
+  if (!e) return;
+  const r = [...e.instances];
+  await Promise.all(r.map((n) => n.close()));
+}
+async function ht() {
+  const t = Array.from(P.keys());
+  await Promise.all(t.map((e) => me(e)));
+}
+function ut(t, e) {
+  const { React: r } = e, { createElement: n, useRef: i, useEffect: s, useState: o, forwardRef: a } = r, c = a(
+    function(g, R) {
+      const {
+        onRendered: U,
+        onError: O,
+        onClose: L,
+        context: ye,
+        className: q,
+        style: B,
+        ...x
+      } = g, b = i(null), D = i(null), [j, ge] = o(null);
+      return s(() => {
+        const C = b.current;
+        if (!C) return;
+        const m = t(x);
+        return D.current = m, U && m.event.once("rendered", U), L && m.event.once("close", L), O && m.event.on("error", O), m.render(C, ye).catch((H) => {
+          ge(H), O?.(H);
+        }), () => {
+          m.close().catch(() => {
+          }), D.current = null;
+        };
+      }, []), s(() => {
+        const C = D.current;
+        C && C.updateProps(x).catch((m) => {
+          O?.(m);
+        });
+      }, [JSON.stringify(x)]), s(() => {
+        R && typeof R == "object" && b.current && (R.current = b.current);
+      }, [R]), j ? n(
+        "div",
+        {
+          className: q,
+          style: { color: "red", padding: "16px", ...B }
+        },
+        `Error: ${j.message}`
+      ) : n("div", {
+        ref: b,
+        className: q,
+        style: {
+          display: "inline-block",
+          ...B
+        }
+      });
+    }
+  ), d = `ForgeFrame(${t.name || "Component"})`;
+  return c.displayName = d, c;
+}
+function pt(t) {
+  return function(r) {
+    return ut(r, { React: t });
+  };
+}
+pe();
+const ft = {
+  /**
+   * Create a new component definition.
+   *
+   * @remarks
+   * This is the main entry point for defining components. Returns a
+   * component factory function that can be called to create instances.
+   *
+   * @example
+   * ```typescript
+   * const MyComponent = ForgeFrame.create({
+   *   tag: 'my-component',
+   *   url: 'https://example.com/component',
+   *   props: {
+   *     onLogin: { type: ForgeFrame.PROP_TYPE.FUNCTION },
+   *   },
+   * });
+   *
+   * const instance = MyComponent({ onLogin: (user) => {} });
+   * await instance.render('#container');
+   * ```
+   */
+  create: fe,
+  /**
+   * Destroy a single component instance.
+   *
+   * @param instance - The component instance to destroy
+   */
+  destroy: dt,
+  /**
+   * Destroy all instances of a specific component by tag.
+   *
+   * @param tag - The component tag name
+   */
+  destroyComponents: me,
+  /**
+   * Destroy all ForgeFrame component instances.
+   */
+  destroyAll: ht,
+  /**
+   * Check if the current window is a child component context.
+   *
+   * @returns True if running inside a ForgeFrame iframe/popup
+   */
+  isChild: ot,
+  /**
+   * Get xprops from the current child window.
+   *
+   * @returns The xprops object if in child context, undefined otherwise
+   */
+  getXProps: at,
+  /**
+   * Prop type constants for defining component props.
+   * @see {@link PROP_TYPE}
+   */
+  PROP_TYPE: h,
+  /**
+   * Serialization strategy constants.
+   * @see {@link PROP_SERIALIZATION}
+   */
+  PROP_SERIALIZATION: I,
+  /**
+   * Rendering context constants (IFRAME, POPUP).
+   * @see {@link CONTEXT}
+   */
+  CONTEXT: f,
+  /**
+   * Lifecycle event name constants.
+   * @see {@link EVENT}
+   */
+  EVENT: p,
+  /**
+   * Error thrown when popup window fails to open.
+   */
+  PopupOpenError: ue,
+  /**
+   * Current library version.
+   */
+  VERSION: re
+};
+export {
+  f as CONTEXT,
+  p as EVENT,
+  ft as ForgeFrame,
+  I as PROP_SERIALIZATION,
+  h as PROP_TYPE,
+  ue as PopupOpenError,
+  re as VERSION,
+  fe as create,
+  ut as createReactDriver,
+  ft as default,
+  dt as destroy,
+  ht as destroyAll,
+  me as destroyComponents,
+  at as getXProps,
+  ot as isChild,
+  pt as withReactDriver
+};