penpal 6.2.0

package/lib/connectCallSender.d.ts

@@ -0,0 +1,14 @@
+import { CallSender, WindowsInfo } from './types';
+declare const _default: (callSender: CallSender, info: WindowsInfo, methodKeyPaths: string[], destroyConnection: Function, log: Function) => () => void;
+/**
+ * Augments an object with methods that match those defined by the remote. When these methods are
+ * called, a "call" message will be sent to the remote, the remote's corresponding method will be
+ * executed, and the method's return value will be returned via a message.
+ * @param {Object} callSender Sender object that should be augmented with methods.
+ * @param {Object} info Information about the local and remote windows.
+ * @param {Array} methodKeyPaths Key paths of methods available to be called on the remote.
+ * @param {Promise} destructionPromise A promise resolved when destroy() is called on the penpal
+ * connection.
+ * @returns {Object} The call sender object with methods that may be called.
+ */
+export default _default;

package/lib/connectCallSender.js

@@ -0,0 +1,93 @@
+import generateId from './generateId';
+import { deserializeError } from './errorSerialization';
+import { deserializeMethods } from './methodSerialization';
+import { ErrorCode, MessageType, NativeEventType, Resolution } from './enums';
+/**
+ * Augments an object with methods that match those defined by the remote. When these methods are
+ * called, a "call" message will be sent to the remote, the remote's corresponding method will be
+ * executed, and the method's return value will be returned via a message.
+ * @param {Object} callSender Sender object that should be augmented with methods.
+ * @param {Object} info Information about the local and remote windows.
+ * @param {Array} methodKeyPaths Key paths of methods available to be called on the remote.
+ * @param {Promise} destructionPromise A promise resolved when destroy() is called on the penpal
+ * connection.
+ * @returns {Object} The call sender object with methods that may be called.
+ */
+export default (callSender, info, methodKeyPaths, destroyConnection, log) => {
+    const { localName, local, remote, originForSending, originForReceiving, } = info;
+    let destroyed = false;
+    log(`${localName}: Connecting call sender`);
+    const createMethodProxy = (methodName) => {
+        return (...args) => {
+            log(`${localName}: Sending ${methodName}() call`);
+            // This handles the case where the iframe has been removed from the DOM
+            // (and therefore its window closed), the consumer has not yet
+            // called destroy(), and the user calls a method exposed by
+            // the remote. We detect the iframe has been removed and force
+            // a destroy() immediately so that the consumer sees the error saying
+            // the connection has been destroyed. We wrap this check in a try catch
+            // because Edge throws an "Object expected" error when accessing
+            // contentWindow.closed on a contentWindow from an iframe that's been
+            // removed from the DOM.
+            let iframeRemoved;
+            try {
+                if (remote.closed) {
+                    iframeRemoved = true;
+                }
+            }
+            catch (e) {
+                iframeRemoved = true;
+            }
+            if (iframeRemoved) {
+                destroyConnection();
+            }
+            if (destroyed) {
+                const error = new Error(`Unable to send ${methodName}() call due ` + `to destroyed connection`);
+                error.code = ErrorCode.ConnectionDestroyed;
+                throw error;
+            }
+            return new Promise((resolve, reject) => {
+                const id = generateId();
+                const handleMessageEvent = (event) => {
+                    if (event.source !== remote ||
+                        event.data.penpal !== MessageType.Reply ||
+                        event.data.id !== id) {
+                        return;
+                    }
+                    if (originForReceiving !== '*' &&
+                        event.origin !== originForReceiving) {
+                        log(`${localName} received message from origin ${event.origin} which did not match expected origin ${originForReceiving}`);
+                        return;
+                    }
+                    const replyMessage = event.data;
+                    log(`${localName}: Received ${methodName}() reply`);
+                    local.removeEventListener(NativeEventType.Message, handleMessageEvent);
+                    let returnValue = replyMessage.returnValue;
+                    if (replyMessage.returnValueIsError) {
+                        returnValue = deserializeError(returnValue);
+                    }
+                    (replyMessage.resolution === Resolution.Fulfilled ? resolve : reject)(returnValue);
+                };
+                local.addEventListener(NativeEventType.Message, handleMessageEvent);
+                const callMessage = {
+                    penpal: MessageType.Call,
+                    id,
+                    methodName,
+                    args,
+                };
+                remote.postMessage(callMessage, originForSending);
+            });
+        };
+    };
+    // Wrap each method in a proxy which sends it to the corresponding receiver.
+    const flattenedMethods = methodKeyPaths.reduce((api, name) => {
+        api[name] = createMethodProxy(name);
+        return api;
+    }, {});
+    // Unpack the structure of the provided methods object onto the CallSender, exposing
+    // the methods in the same shape they were provided.
+    Object.assign(callSender, deserializeMethods(flattenedMethods));
+    return () => {
+        destroyed = true;
+    };
+};

package/lib/createDestructor.d.ts

@@ -0,0 +1,13 @@
+import { PenpalError } from './types';
+export declare type Destructor = {
+    /**
+     * Calls all onDestroy callbacks.
+     */
+    destroy(error?: PenpalError): void;
+    /**
+     * Registers a callback to be called when destroy is called.
+     */
+    onDestroy(callback: Function): void;
+};
+declare const _default: (localName: "Parent" | "Child", log: Function) => Destructor;
+export default _default;

package/lib/createDestructor.js

@@ -0,0 +1,18 @@
+export default (localName, log) => {
+    const callbacks = [];
+    let destroyed = false;
+    return {
+        destroy(error) {
+            if (!destroyed) {
+                destroyed = true;
+                log(`${localName}: Destroying connection`);
+                callbacks.forEach((callback) => {
+                    callback(error);
+                });
+            }
+        },
+        onDestroy(callback) {
+            destroyed ? callback() : callbacks.push(callback);
+        },
+    };
+};

package/lib/createLogger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (debug: boolean) => (...args: any) => void;
+export default _default;

package/lib/createLogger.js

@@ -0,0 +1,10 @@
+export default (debug) => {
+    /**
+     * Logs a message if debug is enabled.
+     */
+    return (...args) => {
+        if (debug) {
+            console.log('[Penpal]', ...args); // eslint-disable-line no-console
+        }
+    };
+};

package/lib/enums.d.ts

@@ -0,0 +1,22 @@
+export declare enum MessageType {
+    Call = "call",
+    Reply = "reply",
+    Syn = "syn",
+    SynAck = "synAck",
+    Ack = "ack"
+}
+export declare enum Resolution {
+    Fulfilled = "fulfilled",
+    Rejected = "rejected"
+}
+export declare enum ErrorCode {
+    ConnectionDestroyed = "ConnectionDestroyed",
+    ConnectionTimeout = "ConnectionTimeout",
+    NoIframeSrc = "NoIframeSrc"
+}
+export declare enum NativeErrorName {
+    DataCloneError = "DataCloneError"
+}
+export declare enum NativeEventType {
+    Message = "message"
+}

package/lib/enums.js

@@ -0,0 +1,27 @@
+export var MessageType;
+(function (MessageType) {
+    MessageType["Call"] = "call";
+    MessageType["Reply"] = "reply";
+    MessageType["Syn"] = "syn";
+    MessageType["SynAck"] = "synAck";
+    MessageType["Ack"] = "ack";
+})(MessageType || (MessageType = {}));
+export var Resolution;
+(function (Resolution) {
+    Resolution["Fulfilled"] = "fulfilled";
+    Resolution["Rejected"] = "rejected";
+})(Resolution || (Resolution = {}));
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["ConnectionDestroyed"] = "ConnectionDestroyed";
+    ErrorCode["ConnectionTimeout"] = "ConnectionTimeout";
+    ErrorCode["NoIframeSrc"] = "NoIframeSrc";
+})(ErrorCode || (ErrorCode = {}));
+export var NativeErrorName;
+(function (NativeErrorName) {
+    NativeErrorName["DataCloneError"] = "DataCloneError";
+})(NativeErrorName || (NativeErrorName = {}));
+export var NativeEventType;
+(function (NativeEventType) {
+    NativeEventType["Message"] = "message";
+})(NativeEventType || (NativeEventType = {}));

package/lib/errorSerialization.d.ts

@@ -0,0 +1,14 @@
+declare type SerializedError = {
+    name: string;
+    message: string;
+    stack: string | undefined;
+};
+/**
+ * Converts an error object into a plain object.
+ */
+export declare const serializeError: ({ name, message, stack, }: Error) => SerializedError;
+/**
+ * Converts a plain object into an error object.
+ */
+export declare const deserializeError: (obj: SerializedError) => Error;
+export {};

package/lib/errorSerialization.js

@@ -0,0 +1,17 @@
+/**
+ * Converts an error object into a plain object.
+ */
+export const serializeError = ({ name, message, stack, }) => ({
+    name,
+    message,
+    stack,
+});
+/**
+ * Converts a plain object into an error object.
+ */
+export const deserializeError = (obj) => {
+    const deserializedError = new Error();
+    // @ts-ignore
+    Object.keys(obj).forEach((key) => (deserializedError[key] = obj[key]));
+    return deserializedError;
+};

package/lib/generateId.d.ts

@@ -0,0 +1,5 @@
+declare const _default: () => number;
+/**
+ * @return {number} A unique ID (not universally unique)
+ */
+export default _default;

package/lib/generateId.js

@@ -0,0 +1,5 @@
+let id = 0;
+/**
+ * @return {number} A unique ID (not universally unique)
+ */
+export default () => ++id;

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { default as connectToChild } from './parent/connectToChild';
+export { default as connectToParent } from './child/connectToParent';
+export { ErrorCode } from './enums';
+export { Connection, AsyncMethodReturns, CallSender, Methods, PenpalError, } from './types';

package/lib/index.js

@@ -0,0 +1,3 @@
+export { default as connectToChild } from './parent/connectToChild';
+export { default as connectToParent } from './child/connectToParent';
+export { ErrorCode } from './enums';

package/lib/indexForBundle.d.ts

@@ -0,0 +1,21 @@
+import { ErrorCode } from './enums';
+declare const _default: {
+    connectToChild: <TCallSender extends object = import("./types").CallSender>(options: {
+        iframe: HTMLIFrameElement;
+        methods?: import("./types").Methods | undefined;
+        childOrigin?: string | undefined;
+        timeout?: number | undefined;
+        debug?: boolean | undefined;
+    }) => import("./types").Connection<TCallSender>;
+    connectToParent: <TCallSender_1 extends object = import("./types").CallSender>(options?: {
+        parentOrigin?: string | RegExp | undefined;
+        methods?: import("./types").Methods | undefined;
+        timeout?: number | undefined;
+        debug?: boolean | undefined;
+    }) => {
+        promise: Promise<import("./types").AsyncMethodReturns<TCallSender_1>>;
+        destroy: Function;
+    };
+    ErrorCode: typeof ErrorCode;
+};
+export default _default;

package/lib/indexForBundle.js

@@ -0,0 +1,8 @@
+import connectToChild from './parent/connectToChild';
+import connectToParent from './child/connectToParent';
+import { ErrorCode } from './enums';
+export default {
+    connectToChild,
+    connectToParent,
+    ErrorCode,
+};

package/lib/methodSerialization.d.ts

@@ -0,0 +1,27 @@
+import { SerializedMethods, Methods } from './types';
+/**
+ * Given a `keyPath`, set it to be `value` on `subject`, creating any intermediate
+ * objects along the way.
+ *
+ * @param {Object} subject The object on which to set value.
+ * @param {string} keyPath The key path at which to set value.
+ * @param {Object} value The value to store at the given key path.
+ * @returns {Object} Updated subject.
+ */
+export declare const setAtKeyPath: (subject: Record<string, any>, keyPath: string, value: any) => Record<string, any>;
+/**
+ * Given a dictionary of (nested) keys to function, flatten them to a map
+ * from key path to function.
+ *
+ * @param {Object} methods The (potentially nested) object to serialize.
+ * @param {string} prefix A string with which to prefix entries. Typically not intended to be used by consumers.
+ * @returns {Object} An map from key path in `methods` to functions.
+ */
+export declare const serializeMethods: (methods: Methods, prefix?: string | undefined) => SerializedMethods;
+/**
+ * Given a map of key paths to functions, unpack the key paths to an object.
+ *
+ * @param {Object} flattenedMethods A map of key paths to functions to unpack.
+ * @returns {Object} A (potentially nested) map of functions.
+ */
+export declare const deserializeMethods: (flattenedMethods: SerializedMethods) => Methods;

package/lib/methodSerialization.js

@@ -0,0 +1,67 @@
+const KEY_PATH_DELIMITER = '.';
+const keyPathToSegments = (keyPath) => keyPath ? keyPath.split(KEY_PATH_DELIMITER) : [];
+const segmentsToKeyPath = (segments) => segments.join(KEY_PATH_DELIMITER);
+const createKeyPath = (key, prefix) => {
+    const segments = keyPathToSegments(prefix || '');
+    segments.push(key);
+    return segmentsToKeyPath(segments);
+};
+/**
+ * Given a `keyPath`, set it to be `value` on `subject`, creating any intermediate
+ * objects along the way.
+ *
+ * @param {Object} subject The object on which to set value.
+ * @param {string} keyPath The key path at which to set value.
+ * @param {Object} value The value to store at the given key path.
+ * @returns {Object} Updated subject.
+ */
+export const setAtKeyPath = (subject, keyPath, value) => {
+    const segments = keyPathToSegments(keyPath);
+    segments.reduce((prevSubject, key, idx) => {
+        if (typeof prevSubject[key] === 'undefined') {
+            prevSubject[key] = {};
+        }
+        if (idx === segments.length - 1) {
+            prevSubject[key] = value;
+        }
+        return prevSubject[key];
+    }, subject);
+    return subject;
+};
+/**
+ * Given a dictionary of (nested) keys to function, flatten them to a map
+ * from key path to function.
+ *
+ * @param {Object} methods The (potentially nested) object to serialize.
+ * @param {string} prefix A string with which to prefix entries. Typically not intended to be used by consumers.
+ * @returns {Object} An map from key path in `methods` to functions.
+ */
+export const serializeMethods = (methods, prefix) => {
+    const flattenedMethods = {};
+    Object.keys(methods).forEach((key) => {
+        const value = methods[key];
+        const keyPath = createKeyPath(key, prefix);
+        if (typeof value === 'object') {
+            // Recurse into any nested children.
+            Object.assign(flattenedMethods, serializeMethods(value, keyPath));
+        }
+        if (typeof value === 'function') {
+            // If we've found a method, expose it.
+            flattenedMethods[keyPath] = value;
+        }
+    });
+    return flattenedMethods;
+};
+/**
+ * Given a map of key paths to functions, unpack the key paths to an object.
+ *
+ * @param {Object} flattenedMethods A map of key paths to functions to unpack.
+ * @returns {Object} A (potentially nested) map of functions.
+ */
+export const deserializeMethods = (flattenedMethods) => {
+    const methods = {};
+    for (const keyPath in flattenedMethods) {
+        setAtKeyPath(methods, keyPath, flattenedMethods[keyPath]);
+    }
+    return methods;
+};

package/lib/parent/connectToChild.d.ts

@@ -0,0 +1,31 @@
+import { CallSender, Connection, Methods } from '../types';
+declare type Options = {
+    /**
+     * The iframe to which a connection should be made.
+     */
+    iframe: HTMLIFrameElement;
+    /**
+     * Methods that may be called by the iframe.
+     */
+    methods?: Methods;
+    /**
+     * The child origin to use to secure communication. If
+     * not provided, the child origin will be derived from the
+     * iframe's src or srcdoc value.
+     */
+    childOrigin?: string;
+    /**
+     * The amount of time, in milliseconds, Penpal should wait
+     * for the iframe to respond before rejecting the connection promise.
+     */
+    timeout?: number;
+    /**
+     * Whether log messages should be emitted to the console.
+     */
+    debug?: boolean;
+};
+declare const _default: <TCallSender extends object = CallSender>(options: Options) => Connection<TCallSender>;
+/**
+ * Attempts to establish communication with an iframe.
+ */
+export default _default;

package/lib/parent/connectToChild.js

@@ -0,0 +1,66 @@
+import { MessageType, NativeEventType } from '../enums';
+import createDestructor from '../createDestructor';
+import createLogger from '../createLogger';
+import getOriginFromSrc from './getOriginFromSrc';
+import handleAckMessageFactory from './handleAckMessageFactory';
+import handleSynMessageFactory from './handleSynMessageFactory';
+import { serializeMethods } from '../methodSerialization';
+import monitorIframeRemoval from './monitorIframeRemoval';
+import startConnectionTimeout from '../startConnectionTimeout';
+import validateIframeHasSrcOrSrcDoc from './validateIframeHasSrcOrSrcDoc';
+/**
+ * Attempts to establish communication with an iframe.
+ */
+export default (options) => {
+    let { iframe, methods = {}, childOrigin, timeout, debug = false } = options;
+    const log = createLogger(debug);
+    const destructor = createDestructor('Parent', log);
+    const { onDestroy, destroy } = destructor;
+    if (!childOrigin) {
+        validateIframeHasSrcOrSrcDoc(iframe);
+        childOrigin = getOriginFromSrc(iframe.src);
+    }
+    // If event.origin is "null", the remote protocol is file: or data: and we
+    // must post messages with "*" as targetOrigin when sending messages.
+    // https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage#Using_window.postMessage_in_extensions
+    const originForSending = childOrigin === 'null' ? '*' : childOrigin;
+    const serializedMethods = serializeMethods(methods);
+    const handleSynMessage = handleSynMessageFactory(log, serializedMethods, childOrigin, originForSending);
+    const handleAckMessage = handleAckMessageFactory(serializedMethods, childOrigin, originForSending, destructor, log);
+    const promise = new Promise((resolve, reject) => {
+        const stopConnectionTimeout = startConnectionTimeout(timeout, destroy);
+        const handleMessage = (event) => {
+            if (event.source !== iframe.contentWindow || !event.data) {
+                return;
+            }
+            if (event.data.penpal === MessageType.Syn) {
+                handleSynMessage(event);
+                return;
+            }
+            if (event.data.penpal === MessageType.Ack) {
+                const callSender = handleAckMessage(event);
+                if (callSender) {
+                    stopConnectionTimeout();
+                    resolve(callSender);
+                }
+                return;
+            }
+        };
+        window.addEventListener(NativeEventType.Message, handleMessage);
+        log('Parent: Awaiting handshake');
+        monitorIframeRemoval(iframe, destructor);
+        onDestroy((error) => {
+            window.removeEventListener(NativeEventType.Message, handleMessage);
+            if (error) {
+                reject(error);
+            }
+        });
+    });
+    return {
+        promise,
+        destroy() {
+            // Don't allow consumer to pass an error into destroy.
+            destroy();
+        },
+    };
+};

package/lib/parent/getOriginFromSrc.d.ts

@@ -0,0 +1,5 @@
+declare const _default: (src: string) => string;
+/**
+ * Converts a src value into an origin.
+ */
+export default _default;

package/lib/parent/getOriginFromSrc.js

@@ -0,0 +1,42 @@
+const DEFAULT_PORT_BY_PROTOCOL = {
+    'http:': '80',
+    'https:': '443',
+};
+const URL_REGEX = /^(https?:)?\/\/([^/:]+)?(:(\d+))?/;
+const opaqueOriginSchemes = ['file:', 'data:'];
+/**
+ * Converts a src value into an origin.
+ */
+export default (src) => {
+    if (src && opaqueOriginSchemes.find((scheme) => src.startsWith(scheme))) {
+        // The origin of the child document is an opaque origin and its
+        // serialization is "null"
+        // https://html.spec.whatwg.org/multipage/origin.html#origin
+        return 'null';
+    }
+    // Note that if src is undefined, then srcdoc is being used instead of src
+    // and we can follow this same logic below to get the origin of the parent,
+    // which is the origin that we will need to use.
+    const location = document.location;
+    const regexResult = URL_REGEX.exec(src);
+    let protocol;
+    let hostname;
+    let port;
+    if (regexResult) {
+        // It's an absolute URL. Use the parsed info.
+        // regexResult[1] will be undefined if the URL starts with //
+        protocol = regexResult[1] ? regexResult[1] : location.protocol;
+        hostname = regexResult[2];
+        port = regexResult[4];
+    }
+    else {
+        // It's a relative path. Use the current location's info.
+        protocol = location.protocol;
+        hostname = location.hostname;
+        port = location.port;
+    }
+    // If the port is the default for the protocol, we don't want to add it to the origin string
+    // or it won't match the message's event.origin.
+    const portSuffix = port && port !== DEFAULT_PORT_BY_PROTOCOL[protocol] ? `:${port}` : '';
+    return `${protocol}//${hostname}${portSuffix}`;
+};

package/lib/parent/handleAckMessageFactory.d.ts

@@ -0,0 +1,7 @@
+import { CallSender, SerializedMethods } from '../types';
+import { Destructor } from '../createDestructor';
+declare const _default: (serializedMethods: SerializedMethods, childOrigin: string, originForSending: string, destructor: Destructor, log: Function) => (event: MessageEvent) => CallSender | undefined;
+/**
+ * Handles an ACK handshake message.
+ */
+export default _default;

package/lib/parent/handleAckMessageFactory.js

@@ -0,0 +1,47 @@
+import connectCallReceiver from '../connectCallReceiver';
+import connectCallSender from '../connectCallSender';
+/**
+ * Handles an ACK handshake message.
+ */
+export default (serializedMethods, childOrigin, originForSending, destructor, log) => {
+    const { destroy, onDestroy } = destructor;
+    let destroyCallReceiver;
+    let receiverMethodNames;
+    // We resolve the promise with the call sender. If the child reconnects
+    // (for example, after refreshing or navigating to another page that
+    // uses Penpal, we'll update the call sender with methods that match the
+    // latest provided by the child.
+    const callSender = {};
+    return (event) => {
+        if (childOrigin !== '*' && event.origin !== childOrigin) {
+            log(`Parent: Handshake - Received ACK message from origin ${event.origin} which did not match expected origin ${childOrigin}`);
+            return;
+        }
+        log('Parent: Handshake - Received ACK');
+        const info = {
+            localName: 'Parent',
+            local: window,
+            remote: event.source,
+            originForSending: originForSending,
+            originForReceiving: childOrigin,
+        };
+        // If the child reconnected, we need to destroy the prior call receiver
+        // before setting up a new one.
+        if (destroyCallReceiver) {
+            destroyCallReceiver();
+        }
+        destroyCallReceiver = connectCallReceiver(info, serializedMethods, log);
+        onDestroy(destroyCallReceiver);
+        // If the child reconnected, we need to remove the methods from the
+        // previous call receiver off the sender.
+        if (receiverMethodNames) {
+            receiverMethodNames.forEach((receiverMethodName) => {
+                delete callSender[receiverMethodName];
+            });
+        }
+        receiverMethodNames = event.data.methodNames;
+        const destroyCallSender = connectCallSender(callSender, info, receiverMethodNames, destroy, log);
+        onDestroy(destroyCallSender);
+        return callSender;
+    };
+};

package/lib/parent/handleSynMessageFactory.d.ts

@@ -0,0 +1,6 @@
+import { SerializedMethods } from '../types';
+declare const _default: (log: Function, serializedMethods: SerializedMethods, childOrigin: string, originForSending: string) => (event: MessageEvent) => void;
+/**
+ * Handles a SYN handshake message.
+ */
+export default _default;

package/lib/parent/handleSynMessageFactory.js

@@ -0,0 +1,18 @@
+import { MessageType } from '../enums';
+/**
+ * Handles a SYN handshake message.
+ */
+export default (log, serializedMethods, childOrigin, originForSending) => {
+    return (event) => {
+        if (childOrigin !== '*' && event.origin !== childOrigin) {
+            log(`Parent: Handshake - Received SYN message from origin ${event.origin} which did not match expected origin ${childOrigin}`);
+            return;
+        }
+        log('Parent: Handshake - Received SYN, responding with SYN-ACK');
+        const synAckMessage = {
+            penpal: MessageType.SynAck,
+            methodNames: Object.keys(serializedMethods),
+        };
+        event.source.postMessage(synAckMessage, originForSending);
+    };
+};

package/lib/parent/monitorIframeRemoval.d.ts

@@ -0,0 +1,12 @@
+import { Destructor } from '../createDestructor';
+declare const _default: (iframe: HTMLIFrameElement, destructor: Destructor) => void;
+/**
+ * Monitors for iframe removal and destroys connection if iframe
+ * is found to have been removed from DOM. This is to prevent memory
+ * leaks when the iframe is removed from the document and the consumer
+ * hasn't called destroy(). Without this, event listeners attached to
+ * the window would stick around and since the event handlers have a
+ * reference to the iframe in their closures, the iframe would stick
+ * around too.
+ */
+export default _default;