chrome-in-iframe 1.0.0

package/dist/index.js

@@ -0,0 +1,1011 @@
+import { LRUCache } from 'lru-cache';
+import { nanoid } from 'nanoid';
+
+const WELL_KNOWN_SYMBOLS = {
+    asyncIterator: Symbol.asyncIterator,
+    hasInstance: Symbol.hasInstance,
+    isConcatSpreadable: Symbol.isConcatSpreadable,
+    iterator: Symbol.iterator,
+    match: Symbol.match,
+    matchAll: Symbol.matchAll,
+    replace: Symbol.replace,
+    search: Symbol.search,
+    species: Symbol.species,
+    split: Symbol.split,
+    toPrimitive: Symbol.toPrimitive,
+    toStringTag: Symbol.toStringTag,
+    unscopables: Symbol.unscopables,
+};
+function getWellKnownSymbolName(value) {
+    for (const [name, symbol] of Object.entries(WELL_KNOWN_SYMBOLS)) {
+        if (symbol === value)
+            return name;
+    }
+    return undefined;
+}
+function getWellKnownSymbol(name) {
+    return WELL_KNOWN_SYMBOLS[name];
+}
+function serializeThrownError(err) {
+    if (err instanceof Error) {
+        return { message: err.message, stack: err.stack };
+    }
+    return { message: String(err) };
+}
+
+function serializePath(path) {
+    return path.map((key) => {
+        if (typeof key === 'string')
+            return key;
+        return {
+            $type: 'symbol',
+            value: serializeSymbol$1(key),
+        };
+    });
+}
+function deserializePath(path) {
+    return path.map((key) => {
+        if (typeof key === 'string')
+            return key;
+        return deserializeSymbol$1(key.value);
+    });
+}
+function isSerializedPath(value) {
+    return Array.isArray(value) && value.every(isSerializedPathKey);
+}
+function isSerializedPathKey(value) {
+    if (typeof value === 'string')
+        return true;
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return record.$type === 'symbol' && typeof record.value === 'string';
+}
+function serializeSymbol$1(value) {
+    const globalKey = Symbol.keyFor(value);
+    if (globalKey)
+        return `global:${globalKey}`;
+    const wellKnownName = getWellKnownSymbolName(value);
+    if (wellKnownName)
+        return `wellKnown:${wellKnownName}`;
+    throw new TypeError('Cannot serialize non-global symbol path key');
+}
+function deserializeSymbol$1(value) {
+    if (value.startsWith('global:')) {
+        return Symbol.for(value.slice('global:'.length));
+    }
+    if (value.startsWith('wellKnown:')) {
+        const symbol = getWellKnownSymbol(value.slice('wellKnown:'.length));
+        if (symbol)
+            return symbol;
+    }
+    throw new TypeError('Cannot deserialize symbol path key');
+}
+
+function createMessageSender(poster, key) {
+    return {
+        sendMessage(type, data) {
+            const body = { type, key, data: serializeMessageData(type, data) };
+            poster.postMessage(JSON.stringify(body));
+        },
+    };
+}
+function serializeMessageData(type, data) {
+    if (type === 'invokeRequest') {
+        const invokeData = data;
+        return {
+            ...invokeData,
+            path: serializePath(invokeData.path),
+        };
+    }
+    if (type === 'accessPropertyRequest') {
+        const accessData = data;
+        return {
+            ...accessData,
+            path: serializePath(accessData.path),
+        };
+    }
+    return data;
+}
+
+function createMessageChannel(poster, key, context, processorRegistry) {
+    const sender = createMessageSender(poster, key);
+    const listener = (event) => {
+        let body;
+        try {
+            body = JSON.parse(event.data);
+        }
+        catch {
+            return;
+        }
+        if (!isMessageBody(body))
+            return;
+        if (body.key !== key)
+            return;
+        const handler = processorRegistry.get(body.type);
+        if (!handler)
+            return;
+        try {
+            handler(deserializeMessageData(body), context);
+        }
+        catch (err) {
+            sendProcessorError(body, sender, err);
+        }
+    };
+    poster.addEventListener('message', listener);
+    return {
+        getSender() {
+            return sender;
+        },
+        getContext() {
+            return context;
+        },
+        getPoster() {
+            return poster;
+        },
+        getKey() {
+            return key;
+        },
+        destroy() {
+            poster.removeEventListener('message', listener);
+        },
+    };
+}
+function isMessageBody(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.type !== 'string')
+        return false;
+    if (typeof value.key !== 'string')
+        return false;
+    switch (value.type) {
+        case 'invokeRequest':
+            return isInvokeRequest(value.data);
+        case 'invokeResponse':
+            return isResponse(value.data);
+        case 'accessPropertyRequest':
+            return isAccessPropertyRequest(value.data);
+        case 'accessPropertyResponse':
+            return isResponse(value.data);
+        case 'invokeFunctionByIdRequest':
+            return isCallbackRequest(value.data);
+        case 'invokeFunctionByIdResponse':
+            return isResponse(value.data);
+        default:
+            return false;
+    }
+}
+function isInvokeRequest(value) {
+    return isRecord(value) && isMessageId(value.id) && isSerializedPath(value.path) && Array.isArray(value.args);
+}
+function isAccessPropertyRequest(value) {
+    return isRecord(value) && isMessageId(value.id) && isSerializedPath(value.path);
+}
+function isCallbackRequest(value) {
+    return isRecord(value) && typeof value.id === 'string' && isMessageId(value.callId) && Array.isArray(value.args);
+}
+function isResponse(value) {
+    return (isRecord(value) &&
+        isMessageId(value.id) &&
+        (!('error' in value) || isSerializedError(value.error)) &&
+        ('data' in value || 'error' in value));
+}
+function isSerializedError(value) {
+    return (isRecord(value) && typeof value.message === 'string' && (!('stack' in value) || typeof value.stack === 'string'));
+}
+function isMessageId(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function deserializeMessageData(body) {
+    if (body.type === 'invokeRequest') {
+        const data = body.data;
+        return {
+            ...data,
+            path: deserializePath(data.path),
+        };
+    }
+    if (body.type === 'accessPropertyRequest') {
+        const data = body.data;
+        return {
+            ...data,
+            path: deserializePath(data.path),
+        };
+    }
+    return body.data;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function sendProcessorError(body, sender, err) {
+    if (body.type === 'invokeRequest') {
+        const data = body.data;
+        sender.sendMessage('invokeResponse', {
+            id: data.id,
+            error: serializeThrownError(err),
+        });
+        return;
+    }
+    if (body.type === 'accessPropertyRequest') {
+        const data = body.data;
+        sender.sendMessage('accessPropertyResponse', {
+            id: data.id,
+            error: serializeThrownError(err),
+        });
+        return;
+    }
+    if (body.type === 'invokeFunctionByIdRequest') {
+        const data = body.data;
+        const error = serializeThrownError(err);
+        console.warn(`chrome-in-iframe: callback '${data.id}' failed: ${error.message}`);
+        sender.sendMessage('invokeFunctionByIdResponse', {
+            id: data.callId,
+            error,
+        });
+    }
+}
+
+function deserialize(arg, generateCallback, getRemoteCallback, options = {}) {
+    return deserialize0(arg, generateCallback, getRemoteCallback, options);
+}
+function deserialize0(arg, generateCallback, getRemoteCallback, options = {}) {
+    if (typeof arg === 'string') {
+        return deserializePrimitive(arg, generateCallback, getRemoteCallback, options);
+    }
+    if (typeof arg === 'object' && arg !== null) {
+        if (Array.isArray(arg)) {
+            return arg.map((item) => deserialize0(item, generateCallback, getRemoteCallback, options));
+        }
+        const source = arg;
+        const result = {};
+        for (const key of Object.keys(arg)) {
+            setOwnProperty$1(result, key, deserialize0(source[key], generateCallback, getRemoteCallback, options));
+        }
+        return result;
+    }
+    return arg;
+}
+function deserializePrimitive(value, generateCallback, getRemoteCallback, options = {}) {
+    const undefinedPrefix = '$undefined$';
+    const nullPrefix = '$null$';
+    const errorPrefix = '$error$';
+    const functionPrefix = '$function$';
+    if (value === undefinedPrefix)
+        return undefined;
+    if (value === nullPrefix)
+        return null;
+    if (value.startsWith(errorPrefix)) {
+        let serialized;
+        try {
+            serialized = JSON.parse(value.slice(errorPrefix.length));
+        }
+        catch {
+            return new Error('Unable to deserialize remote error');
+        }
+        const error = new Error(serialized.message);
+        error.stack = serialized.stack;
+        return error;
+    }
+    if (value.startsWith(functionPrefix)) {
+        const { id, options: functionOptions } = parseSerializedFunction(value.slice(functionPrefix.length), options);
+        const invoke = (args) => {
+            if (functionOptions.persistent) {
+                return generateCallback(id, args, functionOptions);
+            }
+            else {
+                return generateCallback(id, args);
+            }
+        };
+        return getRemoteCallback
+            ? getRemoteCallback(id, invoke, functionOptions)
+            : (...args) => invoke(args);
+    }
+    const match = value.match(/^\$(\w+)\$(.*)$/s);
+    if (match) {
+        const [, type, raw] = match;
+        switch (type) {
+            case 'number':
+                return Number(raw);
+            case 'string':
+                return raw;
+            case 'boolean':
+                return raw === 'true';
+            case 'bigint':
+                return BigInt(raw);
+            case 'symbol':
+                return deserializeSymbol(raw);
+        }
+    }
+    return value;
+}
+function parseSerializedFunction(value, options) {
+    const persistentPrefix = 'persistent:';
+    if (value.startsWith(persistentPrefix)) {
+        return {
+            id: value.slice(persistentPrefix.length),
+            options: { ...options, persistent: true },
+        };
+    }
+    return { id: value, options };
+}
+function deserializeSymbol(value) {
+    if (value.startsWith('global:')) {
+        return Symbol.for(value.slice('global:'.length));
+    }
+    if (value.startsWith('wellKnown:')) {
+        const symbol = getWellKnownSymbol(value.slice('wellKnown:'.length));
+        if (symbol)
+            return symbol;
+    }
+    throw new TypeError('Cannot deserialize symbol');
+}
+function setOwnProperty$1(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+
+function isListenerRegistrationPath(path) {
+    const last = path[path.length - 1];
+    return last === 'addListener' || last === 'removeListener' || last === 'hasListener';
+}
+function isLikelyListenerPath(path, value) {
+    if (typeof value === 'function')
+        return true;
+    const last = path[path.length - 1];
+    return typeof last === 'string' && /^on[A-Z]/.test(last);
+}
+
+function serialize(arg, registerFunction, options = {}) {
+    return serialize0(arg, registerFunction, options, new WeakSet());
+}
+function serialize0(arg, registerFunction, options, seen) {
+    if (arg === undefined) {
+        return '$undefined$';
+    }
+    if (arg === null)
+        return '$null$';
+    if (typeof arg === 'object') {
+        if (seen.has(arg)) {
+            throw new TypeError('Cannot serialize circular structure');
+        }
+        seen.add(arg);
+        try {
+            if (arg instanceof Error) {
+                return '$error$' + JSON.stringify({ message: arg.message, stack: arg.stack });
+            }
+            if (Array.isArray(arg)) {
+                return arg.map((item) => serialize0(item, registerFunction, options, seen));
+            }
+            const result = {};
+            const source = arg;
+            for (const key of Object.keys(arg)) {
+                setOwnProperty(result, key, serialize0(source[key], registerFunction, options, seen));
+            }
+            return result;
+        }
+        finally {
+            seen.delete(arg);
+        }
+    }
+    if (typeof arg === 'function') {
+        const id = registerFunction(arg, options);
+        return '$function$' + (options.persistent ? `persistent:${id}` : id);
+    }
+    if (typeof arg === 'symbol') {
+        return '$symbol$' + serializeSymbol(arg);
+    }
+    return `$${typeof arg}$${arg}`;
+}
+function setOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+function serializeSymbol(value) {
+    const globalKey = Symbol.keyFor(value);
+    if (globalKey)
+        return `global:${globalKey}`;
+    const wellKnownName = getWellKnownSymbolName(value);
+    if (wellKnownName)
+        return `wellKnown:${wellKnownName}`;
+    throw new TypeError('Cannot serialize non-global symbol');
+}
+
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function readProperty(target, key) {
+    if (typeof key === 'string' && DANGEROUS_KEYS.has(key)) {
+        throw new Error(`Access to dangerous property '${key}' is denied`);
+    }
+    if (target === undefined || target === null)
+        return undefined;
+    return target[key];
+}
+
+function handleAccessPropertyRequest(data, ctx) {
+    const target = ctx.getDelegateTarget();
+    const channel = ctx.getMessageChannel();
+    if (data.path.length === 0) {
+        channel.getSender().sendMessage('accessPropertyResponse', {
+            id: data.id,
+            error: { message: 'Property path must not be empty' },
+        });
+        return;
+    }
+    if (!target) {
+        channel.getSender().sendMessage('accessPropertyResponse', {
+            id: data.id,
+            error: { message: 'No delegate target is configured' },
+        });
+        return;
+    }
+    try {
+        let current = target;
+        for (const key of data.path) {
+            if (current === undefined || current === null) {
+                channel.getSender().sendMessage('accessPropertyResponse', {
+                    id: data.id,
+                    data: serialize(current, ctx.registerFunction),
+                });
+                return;
+            }
+            current = readProperty(current, key);
+        }
+        channel.getSender().sendMessage('accessPropertyResponse', {
+            id: data.id,
+            data: serialize(current, ctx.registerFunction, { persistent: isLikelyListenerPath(data.path, current) }),
+        });
+    }
+    catch (err) {
+        channel.getSender().sendMessage('accessPropertyResponse', {
+            id: data.id,
+            error: serializeThrownError(err),
+        });
+    }
+}
+function handleAccessPropertyResponse(data, ctx) {
+    const pending = ctx.getAndRemovePendingPromise(data.id);
+    if (!pending)
+        return;
+    if (data.error) {
+        const err = new Error(data.error.message);
+        err.stack = data.error.stack;
+        pending.reject(err);
+        return;
+    }
+    pending.resolve(deserialize(data.data, (id, args, options) => {
+        return ctx.invokeFunctionById(id, args, options);
+    }, ctx.getRemoteCallback));
+}
+
+function handleInvokeRequest(data, ctx) {
+    const target = ctx.getDelegateTarget();
+    const channel = ctx.getMessageChannel();
+    if (!target) {
+        channel.getSender().sendMessage('invokeResponse', {
+            id: data.id,
+            error: { message: 'No delegate target is configured' },
+        });
+        return;
+    }
+    let current = target;
+    for (let i = 0; i < data.path.length - 1; i++) {
+        current = readProperty(current, data.path[i]);
+        if (current === undefined || current === null) {
+            channel.getSender().sendMessage('invokeResponse', {
+                id: data.id,
+                error: {
+                    message: `Cannot read property '${String(data.path[i + 1])}' of ${String(data.path[i])}`,
+                },
+            });
+            return;
+        }
+    }
+    const lastKey = data.path[data.path.length - 1];
+    const fn = readProperty(current, lastKey);
+    if (typeof fn !== 'function') {
+        channel.getSender().sendMessage('invokeResponse', {
+            id: data.id,
+            error: { message: `'${String(lastKey)}' is not a function` },
+        });
+        return;
+    }
+    const deserializedArgs = data.args.map((arg) => deserialize(arg, (id, args, options) => {
+        return ctx.invokeFunctionById(id, args, options);
+    }, ctx.getRemoteCallback, { persistent: isListenerRegistrationPath(data.path) }));
+    let result;
+    try {
+        result = Reflect.apply(fn, current, deserializedArgs);
+    }
+    catch (err) {
+        channel.getSender().sendMessage('invokeResponse', {
+            id: data.id,
+            error: serializeThrownError(err),
+        });
+        return;
+    }
+    if (result instanceof Promise) {
+        result
+            .then((value) => {
+            sendInvokeSuccess(data.id, value, ctx);
+        })
+            .catch((err) => {
+            channel.getSender().sendMessage('invokeResponse', {
+                id: data.id,
+                error: serializeThrownError(err),
+            });
+        });
+    }
+    else {
+        sendInvokeSuccess(data.id, result, ctx);
+    }
+}
+function handleInvokeResponse(data, ctx) {
+    const pending = ctx.getAndRemovePendingPromise(data.id);
+    if (!pending)
+        return;
+    if (data.error) {
+        const err = new Error(data.error.message);
+        err.stack = data.error.stack;
+        pending.reject(err);
+    }
+    else {
+        pending.resolve(deserialize(data.data, (id, args, options) => {
+            return ctx.invokeFunctionById(id, args, options);
+        }, ctx.getRemoteCallback));
+    }
+}
+function sendInvokeSuccess(id, value, ctx) {
+    const channel = ctx.getMessageChannel();
+    try {
+        channel.getSender().sendMessage('invokeResponse', {
+            id,
+            data: serialize(value, ctx.registerFunction),
+        });
+    }
+    catch (err) {
+        channel.getSender().sendMessage('invokeResponse', {
+            id,
+            error: serializeThrownError(err),
+        });
+    }
+}
+
+function handleCallbackInvoke(data, ctx) {
+    const channel = ctx.getMessageChannel();
+    const isPersistentFunction = ctx.getPersistentFunctionCache().has(data.id);
+    const fn = ctx.getPersistentFunctionCache().get(data.id) ?? ctx.getFunctionCache().get(data.id);
+    if (!fn) {
+        const error = { message: `Callback '${data.id}' is not available or has expired` };
+        console.warn(`chrome-in-iframe: ${error.message}`);
+        channel.getSender().sendMessage('invokeFunctionByIdResponse', {
+            id: data.callId,
+            error,
+        });
+        return;
+    }
+    const deserializedArgs = data.args.map((arg) => deserialize(arg, (id, args, options) => {
+        return ctx.invokeFunctionById(id, args, options);
+    }, ctx.getRemoteCallback, { persistent: isPersistentFunction }));
+    try {
+        const result = fn(...deserializedArgs);
+        if (result instanceof Promise) {
+            result
+                .then((value) => {
+                sendCallbackSuccess(data.callId, value, ctx);
+            })
+                .catch((err) => {
+                sendCallbackError(data.callId, err, ctx);
+            });
+            return;
+        }
+        sendCallbackSuccess(data.callId, result, ctx);
+    }
+    catch (err) {
+        sendCallbackError(data.callId, err, ctx);
+    }
+}
+function handleCallbackInvokeResponse(data, ctx) {
+    const pending = ctx.getAndRemovePendingPromise(data.id);
+    if (!pending)
+        return;
+    if (data.error) {
+        const err = new Error(data.error.message);
+        err.stack = data.error.stack;
+        pending.reject(err);
+        return;
+    }
+    pending.resolve(deserialize(data.data, (id, args, options) => {
+        return ctx.invokeFunctionById(id, args, options);
+    }, ctx.getRemoteCallback));
+}
+function sendCallbackSuccess(id, value, ctx) {
+    const channel = ctx.getMessageChannel();
+    try {
+        channel.getSender().sendMessage('invokeFunctionByIdResponse', {
+            id,
+            data: serialize(value, ctx.registerFunction),
+        });
+    }
+    catch (err) {
+        sendCallbackError(id, err, ctx);
+    }
+}
+function sendCallbackError(id, err, ctx) {
+    ctx
+        .getMessageChannel()
+        .getSender()
+        .sendMessage('invokeFunctionByIdResponse', {
+        id,
+        error: serializeThrownError(err),
+    });
+}
+
+function createProcessorRegistry() {
+    const handlers = new Map();
+    return {
+        register(type, handler) {
+            handlers.set(type, { handler: handler });
+        },
+        get(type) {
+            return handlers.get(type)?.handler;
+        },
+    };
+}
+
+const DEFAULT_TIMEOUT = 30000;
+const FUNCTION_CACHE_MAX = 100;
+const FUNCTION_CACHE_TTL = 5 * 60 * 1000;
+const REMOTE_CALLBACK_CACHE_MAX = 500;
+const REMOTE_CALLBACK_CACHE_TTL = 5 * 60 * 1000;
+function createClientContext(getMessageChannel, options = {}) {
+    const pending = new Map();
+    const functionCache = new LRUCache({
+        max: FUNCTION_CACHE_MAX,
+        ttl: FUNCTION_CACHE_TTL,
+    });
+    const persistentFunctionCache = new Map();
+    const functionIds = new WeakMap();
+    const remoteCallbacks = new LRUCache({
+        max: REMOTE_CALLBACK_CACHE_MAX,
+        ttl: REMOTE_CALLBACK_CACHE_TTL,
+    });
+    const persistentRemoteCallbacks = new Map();
+    let destroyed = false;
+    const registerFunction = (fn, callbackOptions = {}) => {
+        let id = functionIds.get(fn);
+        if (!id) {
+            id = createId('cb');
+            functionIds.set(fn, id);
+        }
+        if (callbackOptions.persistent) {
+            persistentFunctionCache.set(id, fn);
+            functionCache.delete(id);
+        }
+        else if (!persistentFunctionCache.has(id)) {
+            functionCache.set(id, fn);
+        }
+        return id;
+    };
+    const getRemoteCallback = (id, invoke, callbackOptions = {}) => {
+        let callback = persistentRemoteCallbacks.get(id) ?? remoteCallbacks.get(id);
+        if (!callback) {
+            callback = (...args) => invoke(args);
+            if (callbackOptions.persistent) {
+                persistentRemoteCallbacks.set(id, callback);
+            }
+            else {
+                remoteCallbacks.set(id, callback);
+            }
+        }
+        else if (callbackOptions.persistent) {
+            remoteCallbacks.delete(id);
+            persistentRemoteCallbacks.set(id, callback);
+        }
+        return callback;
+    };
+    return {
+        getDelegateTarget() {
+            return options.delegateTarget;
+        },
+        getMessageChannel() {
+            return getMessageChannel();
+        },
+        getFunctionCache() {
+            return functionCache;
+        },
+        getPersistentFunctionCache() {
+            return persistentFunctionCache;
+        },
+        registerFunction(fn, callbackOptions) {
+            return registerFunction(fn, callbackOptions);
+        },
+        getRemoteCallback(id, invoke, callbackOptions) {
+            return getRemoteCallback(id, invoke, callbackOptions);
+        },
+        getAndRemovePendingPromise(id) {
+            const callbacks = pending.get(id);
+            if (callbacks) {
+                clearTimeout(callbacks.timer);
+                pending.delete(id);
+            }
+            return callbacks;
+        },
+        registerPendingPromise(id, callbacks) {
+            pending.set(id, callbacks);
+        },
+        invoke(path, args) {
+            return new Promise((resolve, reject) => {
+                if (destroyed) {
+                    reject(new Error('Channel has been destroyed'));
+                    return;
+                }
+                const id = createId('req');
+                const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+                const timer = setTimeout(() => {
+                    pending.delete(id);
+                    reject(new Error(`Call timed out: ${String(path.join('.'))}`));
+                }, timeout);
+                pending.set(id, { resolve, reject, timer });
+                const channel = getMessageChannel();
+                const persistent = isListenerRegistrationPath(path);
+                const serializedArgs = args.map((arg) => serialize(arg, registerFunction, { persistent }));
+                channel.getSender().sendMessage('invokeRequest', {
+                    id,
+                    path,
+                    args: serializedArgs,
+                });
+            });
+        },
+        accessProperty(path) {
+            return new Promise((resolve, reject) => {
+                if (destroyed) {
+                    reject(new Error('Channel has been destroyed'));
+                    return;
+                }
+                const id = createId('req');
+                const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+                const timer = setTimeout(() => {
+                    pending.delete(id);
+                    reject(new Error(`Property access timed out: ${String(path.join('.'))}`));
+                }, timeout);
+                pending.set(id, { resolve, reject, timer });
+                getMessageChannel().getSender().sendMessage('accessPropertyRequest', {
+                    id,
+                    path,
+                });
+            });
+        },
+        invokeFunctionById(callbackId, args, callbackOptions = {}) {
+            return new Promise((resolve, reject) => {
+                if (destroyed) {
+                    reject(new Error('Channel has been destroyed'));
+                    return;
+                }
+                const callId = createId('cbcall');
+                const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+                const timer = setTimeout(() => {
+                    pending.delete(callId);
+                    reject(new Error(`Callback call timed out: ${callbackId}`));
+                }, timeout);
+                pending.set(callId, { resolve, reject, timer });
+                getMessageChannel()
+                    .getSender()
+                    .sendMessage('invokeFunctionByIdRequest', {
+                    id: callbackId,
+                    callId,
+                    args: args.map((arg) => serialize(arg, registerFunction, callbackOptions)),
+                });
+            });
+        },
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            for (const [id, callbacks] of pending) {
+                clearTimeout(callbacks.timer);
+                callbacks.reject(new Error(`Channel has been destroyed before call ${id} completed`));
+            }
+            pending.clear();
+            functionCache.clear();
+            persistentFunctionCache.clear();
+            remoteCallbacks.clear();
+            persistentRemoteCallbacks.clear();
+        },
+    };
+}
+function createId(prefix) {
+    return `${prefix}-${nanoid()}`;
+}
+
+function resolvePath(node) {
+    const path = [];
+    let current = node;
+    while (current) {
+        path.unshift(current.key);
+        current = current.parent;
+    }
+    return path;
+}
+function createClientProxy(invoke, accessProperty) {
+    const normalizePropertyPath = (basePath, parts) => {
+        const extraPath = parts.flatMap((part) => {
+            if (Array.isArray(part))
+                return part.filter(isPathKey);
+            if (typeof part === 'string')
+                return part.split('.').filter(Boolean);
+            if (typeof part === 'symbol')
+                return [part];
+            return [];
+        });
+        return [...basePath, ...extraPath];
+    };
+    function createHandler(node) {
+        return {
+            get(_target, prop) {
+                if (prop === 'then')
+                    return undefined;
+                if (prop === '$get') {
+                    return (...parts) => {
+                        if (!accessProperty) {
+                            return Promise.reject(new Error('Property access is not configured'));
+                        }
+                        const basePath = node ? resolvePath(node) : [];
+                        return accessProperty(normalizePropertyPath(basePath, parts));
+                    };
+                }
+                const childNode = node ? { parent: node, key: prop } : { key: prop };
+                return new Proxy(() => { }, createHandler(childNode));
+            },
+            apply(_target, _thisArg, argArray) {
+                const path = node ? resolvePath(node) : [];
+                return invoke(path, argArray);
+            },
+        };
+    }
+    return new Proxy(() => { }, createHandler());
+}
+function isPathKey(value) {
+    return typeof value === 'string' || typeof value === 'symbol';
+}
+
+function createEndpoint(options) {
+    const processorRegistry = createProcessorRegistry();
+    const channelRef = {};
+    const getChannel = () => {
+        if (!channelRef.current) {
+            throw new Error('Channel has not been initialized');
+        }
+        return channelRef.current;
+    };
+    const context = createClientContext(getChannel, options.contextOptions);
+    const channel = createMessageChannel(options.poster, options.key ?? 'default', context, processorRegistry);
+    channelRef.current = channel;
+    processorRegistry.register('invokeRequest', handleInvokeRequest);
+    processorRegistry.register('invokeResponse', handleInvokeResponse);
+    processorRegistry.register('accessPropertyRequest', handleAccessPropertyRequest);
+    processorRegistry.register('accessPropertyResponse', handleAccessPropertyResponse);
+    processorRegistry.register('invokeFunctionByIdRequest', handleCallbackInvoke);
+    processorRegistry.register('invokeFunctionByIdResponse', handleCallbackInvokeResponse);
+    const proxy = createClientProxy((path, args) => context.invoke(path, args), (path) => context.accessProperty(path));
+    return {
+        proxy,
+        destroy() {
+            channel.destroy();
+            context.destroy();
+        },
+    };
+}
+
+function setupInMainWindow(options) {
+    const poster = createWindowPoster({
+        postMessage: (message) => {
+            const contentWindow = options.iframe.contentWindow;
+            if (!contentWindow) {
+                throw new Error('chrome-in-iframe: iframe contentWindow is not available');
+            }
+            contentWindow.postMessage(message, options.targetOrigin ?? '*');
+        },
+        getExpectedSource: () => options.iframe.contentWindow,
+        allowedOrigin: options.allowedOrigin,
+    });
+    const endpoint = createEndpoint({
+        poster,
+        key: options.key,
+        contextOptions: {
+            delegateTarget: options.delegateTarget,
+            timeout: options.timeout,
+        },
+    });
+    const proxy = endpoint.proxy;
+    return {
+        proxy,
+        get: proxy.$get,
+        destroy: endpoint.destroy,
+    };
+}
+function setupInIframe(options = {}) {
+    const poster = createWindowPoster({
+        postMessage: (message) => {
+            window.parent.postMessage(message, options.targetOrigin ?? '*');
+        },
+        getExpectedSource: () => window.parent,
+        allowedOrigin: options.allowedOrigin,
+    });
+    const endpoint = createEndpoint({
+        poster,
+        key: options.key,
+        contextOptions: {
+            timeout: options.timeout,
+        },
+    });
+    const proxy = endpoint.proxy;
+    return {
+        proxy,
+        get: proxy.$get,
+        destroy: endpoint.destroy,
+    };
+}
+function exposeChromeInIframe(options) {
+    return setupInMainWindow({
+        ...options,
+        delegateTarget: options.chromeApi ?? getGlobalChrome(),
+    });
+}
+function connectChromeInIframe(options = {}) {
+    const handle = setupInIframe(options);
+    return {
+        ...handle,
+        chrome: handle.proxy,
+    };
+}
+function createWindowPoster(options) {
+    const listenerMap = new Map();
+    return {
+        postMessage(message) {
+            options.postMessage(message);
+        },
+        addEventListener(name, callback) {
+            const listener = (event) => {
+                const messageEvent = event;
+                if (messageEvent.source !== options.getExpectedSource())
+                    return;
+                if (!isAllowedOrigin(messageEvent.origin, options.allowedOrigin))
+                    return;
+                callback(messageEvent);
+            };
+            listenerMap.set(callback, listener);
+            window.addEventListener(name, listener);
+        },
+        removeEventListener(name, callback) {
+            const listener = listenerMap.get(callback);
+            if (!listener)
+                return;
+            window.removeEventListener(name, listener);
+            listenerMap.delete(callback);
+        },
+    };
+}
+function isAllowedOrigin(origin, allowedOrigin) {
+    if (!allowedOrigin)
+        return true;
+    if (typeof allowedOrigin === 'function')
+        return allowedOrigin(origin);
+    if (Array.isArray(allowedOrigin))
+        return allowedOrigin.includes(origin);
+    return allowedOrigin === origin;
+}
+function getGlobalChrome() {
+    const chromeApi = globalThis.chrome;
+    if (!chromeApi) {
+        throw new Error('chrome-in-iframe: global chrome API is not available');
+    }
+    return chromeApi;
+}
+
+export { connectChromeInIframe, exposeChromeInIframe, setupInIframe, setupInMainWindow };