chrome-in-iframe 2.0.1 → 2.1.0

package/dist/index.cjs

@@ -0,0 +1,2153 @@
+'use strict';
+
+const TRANSPORT_DETACHED = Symbol.for('chrome-in-iframe.transport-detached');
+function isTransportDetachedError(err) {
+    return err instanceof Error && err[TRANSPORT_DETACHED] === true;
+}
+function createTransportDetachedError(message) {
+    const err = new Error(message);
+    Object.defineProperty(err, TRANSPORT_DETACHED, { value: true, enumerable: false });
+    return err;
+}
+
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+
+/* @ts-self-types="./index.d.ts" */
+let nanoid = (size = 21) => {
+  let id = '';
+  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)));
+  while (size--) {
+    id += urlAlphabet[bytes[size] & 63];
+  }
+  return id
+};
+
+const PREFIX = 'chrome-in-iframe';
+const defaultLogger = (scope, ...args) => {
+    if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+        console.warn(`[${PREFIX}] ${scope}`, ...args);
+    }
+};
+let activeLogger = defaultLogger;
+function setLogger(logger) {
+    activeLogger = logger;
+}
+function warn(scope, ...args) {
+    if (!activeLogger)
+        return;
+    activeLogger(scope, ...args);
+}
+
+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,
+};
+const WELL_KNOWN_SYMBOL_NAMES = new Map(Object.entries(WELL_KNOWN_SYMBOLS).map(([name, symbol]) => [symbol, name]));
+function getWellKnownSymbolName(value) {
+    return WELL_KNOWN_SYMBOL_NAMES.get(value);
+}
+function getWellKnownSymbol(name) {
+    return WELL_KNOWN_SYMBOLS[name];
+}
+function encodeSymbolToken(value, context) {
+    const globalKey = Symbol.keyFor(value);
+    if (globalKey)
+        return `global:${globalKey}`;
+    const wellKnownName = getWellKnownSymbolName(value);
+    if (wellKnownName)
+        return `wellKnown:${wellKnownName}`;
+    throw new TypeError(context ? `Cannot serialize non-global symbol ${context}` : 'Cannot serialize non-global symbol');
+}
+function decodeSymbolToken(value, context) {
+    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(context ? `Cannot deserialize symbol ${context}` : 'Cannot deserialize symbol');
+}
+function setOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+function serializeThrownError(err) {
+    if (err instanceof Error) {
+        return { message: err.message, stack: err.stack };
+    }
+    return { message: String(err) };
+}
+function isPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
+
+function serializePath(path) {
+    return path.map((key) => {
+        if (typeof key === 'string')
+            return key;
+        return {
+            $type: 'symbol',
+            value: encodeSymbolToken(key, 'path key'),
+        };
+    });
+}
+function deserializePath(path) {
+    return path.map((key) => {
+        if (typeof key === 'string')
+            return key;
+        return decodeSymbolToken(key.value, 'path key');
+    });
+}
+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 createMessageSender(poster, key, instanceId) {
+    return {
+        sendMessage(type, data, targetInstanceId) {
+            const body = {
+                type,
+                key,
+                data: serializeMessageData(type, data),
+                senderInstanceId: instanceId,
+            };
+            if (targetInstanceId !== undefined)
+                body.targetInstanceId = targetInstanceId;
+            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;
+}
+
+const MAX_PATH_LENGTH = 64;
+const MAX_INVOKE_ARGS = 1024;
+const MAX_MESSAGE_LENGTH = 1000000;
+const MAX_RELEASE_IDS = 10000;
+const MAX_ID_LENGTH = 200;
+const MAX_TYPE_LENGTH = 64;
+const MESSAGE_SPECS = {
+    connectRequest: { validate: isConnectMessage },
+    connectResponse: { validate: isConnectMessage },
+    invokeRequest: {
+        validate: isInvokeRequest,
+        preDeserialize: (data) => ({ ...data, path: deserializePath(data.path) }),
+        errorResponse: { type: 'invokeResponse', extractId: (data) => data.id },
+    },
+    invokeResponse: { validate: isResponse },
+    accessPropertyRequest: {
+        validate: isAccessPropertyRequest,
+        preDeserialize: (data) => ({ ...data, path: deserializePath(data.path) }),
+        errorResponse: { type: 'accessPropertyResponse', extractId: (data) => data.id },
+    },
+    accessPropertyResponse: { validate: isResponse },
+    invokeFunctionByIdRequest: {
+        validate: isCallbackRequest,
+        errorResponse: { type: 'invokeFunctionByIdResponse', extractId: (data) => data.callId },
+    },
+    invokeFunctionByIdResponse: { validate: isResponse },
+    releaseCallbacks: { validate: isReleaseCallbacks },
+    destroyEndpoint: { validate: isDestroyEndpoint },
+};
+function createMessageChannel(poster, key, instanceId, context, processorRegistry) {
+    const sender = createMessageSender(poster, key, instanceId);
+    const keyMatch = `"key":${JSON.stringify(key)}`;
+    const listener = (event) => {
+        if (typeof event.data !== 'string')
+            return;
+        if (event.data.length === 0 || event.data.charCodeAt(0) !== 123)
+            return;
+        if (event.data.length > MAX_MESSAGE_LENGTH) {
+            warn('createMessageChannel', `dropping oversized message (${event.data.length} > ${MAX_MESSAGE_LENGTH})`);
+            return;
+        }
+        if (event.data.indexOf(keyMatch) === -1)
+            return;
+        let body;
+        try {
+            body = JSON.parse(event.data);
+        }
+        catch (err) {
+            warn('createMessageChannel', 'failed to parse incoming message as JSON', err);
+            return;
+        }
+        if (!isMessageEnvelope(body))
+            return;
+        if (body.key !== key)
+            return;
+        if (body.senderInstanceId === instanceId)
+            return;
+        if (body.targetInstanceId !== undefined && body.targetInstanceId !== instanceId)
+            return;
+        const handler = processorRegistry.get(body.type);
+        if (!handler)
+            return;
+        if (!isValidMessagePayload(body))
+            return;
+        const meta = { senderInstanceId: body.senderInstanceId };
+        context.noteRemoteSeen(body.senderInstanceId);
+        try {
+            handler(deserializeMessageData(body), context, meta);
+        }
+        catch (err) {
+            sendProcessorError(body, sender, err);
+        }
+    };
+    poster.addEventListener('message', listener);
+    return {
+        getSender() {
+            return sender;
+        },
+        destroy() {
+            poster.removeEventListener('message', listener);
+        },
+    };
+}
+function isMessageEnvelope(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.type !== 'string' || value.type.length === 0 || value.type.length > MAX_TYPE_LENGTH)
+        return false;
+    if (typeof value.key !== 'string')
+        return false;
+    if (typeof value.senderInstanceId !== 'string' ||
+        value.senderInstanceId.length === 0 ||
+        value.senderInstanceId.length > MAX_ID_LENGTH)
+        return false;
+    if ('targetInstanceId' in value &&
+        value.targetInstanceId !== undefined &&
+        (typeof value.targetInstanceId !== 'string' || value.targetInstanceId.length > MAX_ID_LENGTH))
+        return false;
+    return true;
+}
+function isValidMessagePayload(value) {
+    const spec = MESSAGE_SPECS[value.type];
+    return spec ? spec.validate(value.data) : false;
+}
+function isConnectMessage(value) {
+    return isRecord(value) && isMessageId(value.instanceId);
+}
+function isInvokeRequest(value) {
+    return (isRecord(value) &&
+        isMessageId(value.id) &&
+        isSerializedPath(value.path) &&
+        value.path.length <= MAX_PATH_LENGTH &&
+        Array.isArray(value.args) &&
+        value.args.length <= MAX_INVOKE_ARGS);
+}
+function isAccessPropertyRequest(value) {
+    return (isRecord(value) &&
+        isMessageId(value.id) &&
+        isSerializedPath(value.path) &&
+        value.path.length <= MAX_PATH_LENGTH);
+}
+function isCallbackRequest(value) {
+    return (isRecord(value) &&
+        isMessageId(value.id) &&
+        isMessageId(value.callId) &&
+        Array.isArray(value.args) &&
+        value.args.length <= MAX_INVOKE_ARGS);
+}
+function isResponse(value) {
+    return (isRecord(value) &&
+        isMessageId(value.id) &&
+        (!('error' in value) || isSerializedError(value.error)) &&
+        ('data' in value || 'error' in value));
+}
+function isReleaseCallbacks(value) {
+    return (isRecord(value) && Array.isArray(value.ids) && value.ids.length <= MAX_RELEASE_IDS && value.ids.every(isMessageId));
+}
+function isDestroyEndpoint(value) {
+    return isRecord(value) && isMessageId(value.instanceId);
+}
+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 && value.length <= MAX_ID_LENGTH;
+}
+function deserializeMessageData(body) {
+    const spec = MESSAGE_SPECS[body.type];
+    if (spec.preDeserialize) {
+        return spec.preDeserialize(body.data);
+    }
+    return body.data;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function sendProcessorError(body, sender, err) {
+    const spec = MESSAGE_SPECS[body.type];
+    if (!spec.errorResponse)
+        return;
+    const error = serializeThrownError(err);
+    if (body.type === 'invokeFunctionByIdRequest') {
+        const data = body.data;
+        warn('sendProcessorError', `callback '${data.id}' failed: ${error.message}`);
+    }
+    sender.sendMessage(spec.errorResponse.type, { id: spec.errorResponse.extractId(body.data), error }, body.senderInstanceId);
+}
+
+function isListenerRegistrationPath(path) {
+    const last = path[path.length - 1];
+    return last === 'addListener';
+}
+function isListenerRemovalPath(path) {
+    const last = path[path.length - 1];
+    return last === 'removeListener';
+}
+function isLikelyListenerPath(path) {
+    const last = path[path.length - 1];
+    return typeof last === 'string' && /^on[A-Z]/.test(last);
+}
+
+const TYPE_KEY = '$cii$';
+const MAX_SERIALIZE_DEPTH = 200;
+function serialize(arg, registerFunction, options = {}) {
+    return serialize0(arg, undefined, registerFunction, options, new WeakSet(), 0);
+}
+function serialize0(arg, owner, registerFunction, options, seen, depth) {
+    if (depth > MAX_SERIALIZE_DEPTH) {
+        throw new TypeError(`Serialization exceeded maximum depth of ${MAX_SERIALIZE_DEPTH}`);
+    }
+    if (arg === undefined)
+        return { [TYPE_KEY]: 'undef' };
+    if (arg === null)
+        return null;
+    const typeOf = typeof arg;
+    if (typeOf === 'string')
+        return arg;
+    if (typeOf === 'boolean')
+        return arg;
+    if (typeOf === 'number')
+        return serializeNumber(arg);
+    if (typeOf === 'bigint')
+        return { [TYPE_KEY]: 'big', v: arg.toString() };
+    if (typeOf === 'function') {
+        const id = registerFunction(arg, owner, options);
+        return options.persistent ? { [TYPE_KEY]: 'fn', id, persistent: true } : { [TYPE_KEY]: 'fn', id };
+    }
+    if (typeOf === 'symbol')
+        return { [TYPE_KEY]: 'sym', v: encodeSymbolToken(arg) };
+    if (typeOf === 'object') {
+        if (seen.has(arg)) {
+            throw new TypeError('Cannot serialize circular structure');
+        }
+        seen.add(arg);
+        try {
+            if (Array.isArray(arg)) {
+                return arg.map((item) => serialize0(item, arg, registerFunction, options, seen, depth + 1));
+            }
+            const proto = Object.getPrototypeOf(arg);
+            if (proto === Object.prototype || proto === null) {
+                return serializePlainObject(arg, registerFunction, options, seen, depth);
+            }
+            if (arg instanceof Error)
+                return serializeError(arg, owner, registerFunction, options, seen, depth);
+            if (arg instanceof Date)
+                return { [TYPE_KEY]: 'date', v: arg.getTime() };
+            if (arg instanceof RegExp)
+                return { [TYPE_KEY]: 're', source: arg.source, flags: arg.flags };
+            if (arg instanceof Map) {
+                const entries = [];
+                for (const [k, v] of arg.entries()) {
+                    entries.push([
+                        serialize0(k, arg, registerFunction, options, seen, depth + 1),
+                        serialize0(v, arg, registerFunction, options, seen, depth + 1),
+                    ]);
+                }
+                return { [TYPE_KEY]: 'map', entries };
+            }
+            if (arg instanceof Set) {
+                const values = [];
+                for (const v of arg.values()) {
+                    values.push(serialize0(v, arg, registerFunction, options, seen, depth + 1));
+                }
+                return { [TYPE_KEY]: 'set', values };
+            }
+            return serializePlainObject(arg, registerFunction, options, seen, depth);
+        }
+        finally {
+            seen.delete(arg);
+        }
+    }
+    return null;
+}
+function serializeError(err, owner, registerFunction, options, seen, depth) {
+    const result = { [TYPE_KEY]: 'err', message: err.message };
+    if (err.name && err.name !== 'Error')
+        result.name = err.name;
+    if (err.stack !== undefined)
+        result.stack = err.stack;
+    const cause = err.cause;
+    if (cause !== undefined) {
+        result.cause = serialize0(cause, owner, registerFunction, options, seen, depth + 1);
+    }
+    const RESERVED_ERROR_KEYS = new Set(['message', 'name', 'stack', 'cause']);
+    const extras = [];
+    for (const k of Reflect.ownKeys(err)) {
+        if (typeof k === 'symbol')
+            continue;
+        if (RESERVED_ERROR_KEYS.has(k))
+            continue;
+        if (!isEnumerable(err, k))
+            continue;
+        const value = err[k];
+        extras.push([k, serialize0(value, owner, registerFunction, options, seen, depth + 1)]);
+    }
+    if (extras.length > 0)
+        result.extras = extras;
+    return result;
+}
+function serializePlainObject(source, registerFunction, options, seen, depth) {
+    const record = source;
+    const ownKeys = Reflect.ownKeys(source).filter((k) => isEnumerable(source, k));
+    const symbolKeys = [];
+    const stringKeys = [];
+    for (const k of ownKeys) {
+        if (typeof k === 'symbol') {
+            if (isSerializableSymbol(k))
+                symbolKeys.push(k);
+        }
+        else {
+            stringKeys.push(k);
+        }
+    }
+    const hasReservedKey = Object.prototype.hasOwnProperty.call(record, TYPE_KEY);
+    if (symbolKeys.length > 0 || hasReservedKey) {
+        const entries = [];
+        for (const k of stringKeys) {
+            entries.push([k, serialize0(record[k], source, registerFunction, options, seen, depth + 1)]);
+        }
+        for (const k of symbolKeys) {
+            entries.push([
+                { [TYPE_KEY]: 'sym', v: encodeSymbolToken(k) },
+                serialize0(record[k], source, registerFunction, options, seen, depth + 1),
+            ]);
+        }
+        return { [TYPE_KEY]: 'obj', entries };
+    }
+    const result = {};
+    for (const k of stringKeys) {
+        const value = serialize0(record[k], source, registerFunction, options, seen, depth + 1);
+        if (k === '__proto__') {
+            setOwnProperty(result, k, value);
+        }
+        else {
+            result[k] = value;
+        }
+    }
+    return result;
+}
+function isSerializableSymbol(value) {
+    if (Symbol.keyFor(value) !== undefined)
+        return true;
+    return getWellKnownSymbolName(value) !== undefined;
+}
+function isEnumerable(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    return descriptor ? descriptor.enumerable === true : false;
+}
+function serializeNumber(value) {
+    if (Number.isNaN(value))
+        return { [TYPE_KEY]: 'num', v: 'NaN' };
+    if (value === Infinity)
+        return { [TYPE_KEY]: 'num', v: 'Infinity' };
+    if (value === -Infinity)
+        return { [TYPE_KEY]: 'num', v: '-Infinity' };
+    if (Object.is(value, -0))
+        return { [TYPE_KEY]: 'num', v: '-0' };
+    return value;
+}
+
+const MAX_DESERIALIZE_DEPTH = 200;
+const ERROR_FACTORIES = {
+    Error: (m) => new Error(m),
+    TypeError: (m) => new TypeError(m),
+    RangeError: (m) => new RangeError(m),
+    SyntaxError: (m) => new SyntaxError(m),
+    ReferenceError: (m) => new ReferenceError(m),
+    URIError: (m) => new URIError(m),
+    EvalError: (m) => new EvalError(m),
+};
+const globalScope = globalThis;
+const AggregateErrorCtorRef = globalScope.AggregateError;
+if (typeof AggregateErrorCtorRef === 'function') {
+    ERROR_FACTORIES.AggregateError = (m) => new AggregateErrorCtorRef([], m);
+}
+const DOMExceptionCtorRef = globalScope.DOMException;
+if (typeof DOMExceptionCtorRef === 'function') {
+    ERROR_FACTORIES.DOMException = (m) => new DOMExceptionCtorRef(m);
+}
+function deserialize(arg, generateCallback, getRemoteCallback) {
+    return deserialize0(arg, generateCallback, getRemoteCallback, 0);
+}
+function deserialize0(arg, generateCallback, getRemoteCallback, depth) {
+    if (depth > MAX_DESERIALIZE_DEPTH) {
+        throw new TypeError(`Deserialization exceeded maximum depth of ${MAX_DESERIALIZE_DEPTH}`);
+    }
+    if (arg === null)
+        return null;
+    if (typeof arg !== 'object')
+        return arg;
+    if (Array.isArray(arg)) {
+        return arg.map((item) => deserialize0(item, generateCallback, getRemoteCallback, depth + 1));
+    }
+    const source = arg;
+    const tag = source[TYPE_KEY];
+    if (typeof tag === 'string') {
+        return deserializeTagged(tag, source, generateCallback, getRemoteCallback, depth);
+    }
+    return deserializePlainObject(source, generateCallback, getRemoteCallback, depth);
+}
+function deserializePlainObject(source, generateCallback, getRemoteCallback, depth) {
+    const result = {};
+    for (const key of Object.keys(source)) {
+        const value = deserialize0(source[key], generateCallback, getRemoteCallback, depth + 1);
+        if (key === '__proto__') {
+            setOwnProperty(result, key, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function deserializeTagged(tag, source, generateCallback, getRemoteCallback, depth) {
+    switch (tag) {
+        case 'undef':
+            return undefined;
+        case 'big':
+            return deserializeBigInt(source.v);
+        case 'sym':
+            return deserializeSymbol(expectString(source.v, 'symbol'));
+        case 'num':
+            return deserializeNumber(expectString(source.v, 'number'));
+        case 'err':
+            return deserializeError(source, generateCallback, getRemoteCallback, depth);
+        case 'date':
+            return deserializeDate(source.v);
+        case 're':
+            return deserializeRegExp(source.source, source.flags);
+        case 'map':
+            return deserializeMap(source.entries, generateCallback, getRemoteCallback, depth);
+        case 'set':
+            return deserializeSet(source.values, generateCallback, getRemoteCallback, depth);
+        case 'fn':
+            return deserializeFunction(source, generateCallback, getRemoteCallback);
+        case 'obj':
+            return deserializeWrappedObject(source.entries, generateCallback, getRemoteCallback, depth);
+        default:
+            return deserializePlainObject(source, generateCallback, getRemoteCallback, depth);
+    }
+}
+function deserializeBigInt(raw) {
+    if (typeof raw !== 'string')
+        throw new TypeError('Invalid bigint payload');
+    try {
+        return BigInt(raw);
+    }
+    catch {
+        throw new TypeError(`Invalid bigint payload: ${raw}`);
+    }
+}
+function deserializeDate(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        throw new TypeError('Invalid date payload');
+    }
+    return new Date(raw);
+}
+function deserializeRegExp(rawSource, rawFlags) {
+    if (typeof rawSource !== 'string')
+        throw new TypeError('Invalid regexp source');
+    if (typeof rawFlags !== 'string')
+        throw new TypeError('Invalid regexp flags');
+    try {
+        return new RegExp(rawSource, rawFlags);
+    }
+    catch (err) {
+        throw new TypeError(`Invalid regexp payload: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function deserializeMap(entries, generateCallback, getRemoteCallback, depth) {
+    const result = new Map();
+    if (!Array.isArray(entries))
+        return result;
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length !== 2)
+            continue;
+        const k = deserialize0(entry[0], generateCallback, getRemoteCallback, depth + 1);
+        const v = deserialize0(entry[1], generateCallback, getRemoteCallback, depth + 1);
+        result.set(k, v);
+    }
+    return result;
+}
+function deserializeSet(values, generateCallback, getRemoteCallback, depth) {
+    const result = new Set();
+    if (!Array.isArray(values))
+        return result;
+    for (const v of values) {
+        result.add(deserialize0(v, generateCallback, getRemoteCallback, depth + 1));
+    }
+    return result;
+}
+function deserializeFunction(source, generateCallback, getRemoteCallback) {
+    const id = source.id;
+    if (typeof id !== 'string' || id.length === 0) {
+        throw new TypeError('Invalid function payload');
+    }
+    const persistent = source.persistent === true;
+    const fnOptions = { persistent };
+    const invoke = (args) => {
+        if (persistent)
+            return generateCallback(id, args, fnOptions);
+        return generateCallback(id, args);
+    };
+    return getRemoteCallback ? getRemoteCallback(id, invoke, fnOptions) : (...args) => invoke(args);
+}
+function rebuildErrorFromSerialized(serialized) {
+    const name = typeof serialized.name === 'string' && serialized.name ? serialized.name : 'Error';
+    const factory = ERROR_FACTORIES[name] ?? ERROR_FACTORIES.Error;
+    const error = factory(serialized.message);
+    if (name && error.name !== name) {
+        try {
+            error.name = name;
+        }
+        catch {
+            try {
+                Object.defineProperty(error, 'name', { value: name, configurable: true, writable: true });
+            }
+            catch (err) {
+                warn('rebuildErrorFromSerialized', 'failed to set error.name', name, err);
+            }
+        }
+    }
+    if (typeof serialized.stack === 'string')
+        error.stack = serialized.stack;
+    return error;
+}
+function deserializeError(source, generateCallback, getRemoteCallback, depth) {
+    const error = rebuildErrorFromSerialized({
+        message: typeof source.message === 'string' ? source.message : '',
+        name: typeof source.name === 'string' ? source.name : undefined,
+        stack: typeof source.stack === 'string' ? source.stack : undefined,
+    });
+    if (source.cause !== undefined) {
+        error.cause = deserialize0(source.cause, generateCallback, getRemoteCallback, depth + 1);
+    }
+    if (Array.isArray(source.extras)) {
+        for (const entry of source.extras) {
+            if (!Array.isArray(entry) || entry.length !== 2)
+                continue;
+            const [rawKey, rawValue] = entry;
+            if (typeof rawKey !== 'string')
+                continue;
+            try {
+                setOwnProperty(error, rawKey, deserialize0(rawValue, generateCallback, getRemoteCallback, depth + 1));
+            }
+            catch (err) {
+                warn('deserializeError', 'failed to set error property', rawKey, err);
+            }
+        }
+    }
+    return error;
+}
+function deserializeWrappedObject(entries, generateCallback, getRemoteCallback, depth) {
+    const result = {};
+    if (!Array.isArray(entries))
+        return result;
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length !== 2)
+            continue;
+        const rawKey = entry[0];
+        const value = deserialize0(entry[1], generateCallback, getRemoteCallback, depth + 1);
+        const key = resolveObjectKey(rawKey);
+        if (key === undefined) {
+            warn('deserializeWrappedObject', 'dropping wrapped-object entry with unresolvable key', rawKey);
+            continue;
+        }
+        setOwnProperty(result, key, value);
+    }
+    return result;
+}
+function resolveObjectKey(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (raw !== null && typeof raw === 'object') {
+        const tagged = raw;
+        if (tagged[TYPE_KEY] === 'sym' && typeof tagged.v === 'string') {
+            try {
+                return deserializeSymbol(tagged.v);
+            }
+            catch (err) {
+                warn('resolveObjectKey', 'failed to deserialize symbol key', tagged.v, err);
+                return undefined;
+            }
+        }
+    }
+    return undefined;
+}
+function expectString(raw, label) {
+    if (typeof raw !== 'string')
+        throw new TypeError(`Invalid ${label} payload`);
+    return raw;
+}
+function deserializeNumber(raw) {
+    if (raw === 'NaN')
+        return NaN;
+    if (raw === 'Infinity')
+        return Infinity;
+    if (raw === '-Infinity')
+        return -Infinity;
+    if (raw === '-0')
+        return -0;
+    return Number(raw);
+}
+function deserializeSymbol(value) {
+    return decodeSymbolToken(value);
+}
+
+function createResponder(ctx, targetInstanceId, responseType, id) {
+    const sender = () => ctx.getMessageChannel().getSender();
+    const sendError = (error) => {
+        sender().sendMessage(responseType, { id, error }, targetInstanceId);
+    };
+    return {
+        respondError(message) {
+            sendError({ message });
+        },
+        respondThrown(err) {
+            sendError(serializeThrownError(err));
+        },
+        respondSuccess(value) {
+            try {
+                sender().sendMessage(responseType, { id, data: ctx.serializeForRemote(value, targetInstanceId) }, targetInstanceId);
+            }
+            catch (err) {
+                sendError(serializeThrownError(err));
+            }
+        },
+    };
+}
+function createScopedRemoteCallback(ctx, remoteInstanceId) {
+    return (id, invoke, options) => ctx.getRemoteCallback(id, invoke, options, remoteInstanceId);
+}
+function createGenerateCallback(ctx, remoteInstanceId) {
+    return (id, args, options) => ctx.invokeFunctionById(id, args, options, remoteInstanceId);
+}
+function safeInvokeReject(callbacks, scope, warn) {
+    if (!callbacks.onReject)
+        return;
+    try {
+        callbacks.onReject();
+    }
+    catch (err) {
+        warn(scope, 'onReject hook threw', err);
+    }
+}
+function safeInvokeResolve(callbacks, scope, warn) {
+    if (!callbacks.onResolve)
+        return;
+    try {
+        callbacks.onResolve();
+    }
+    catch (err) {
+        warn(scope, 'onResolve hook threw', err);
+    }
+}
+function createResponseHandler(scope, warn) {
+    return function handleResponse(data, ctx, meta) {
+        const pending = ctx.getAndRemovePendingPromise(data.id, meta.senderInstanceId);
+        if (!pending)
+            return;
+        if (data.error) {
+            const err = rebuildErrorFromSerialized(data.error);
+            safeInvokeReject(pending, scope, warn);
+            pending.reject(err);
+            return;
+        }
+        try {
+            safeInvokeResolve(pending, scope, warn);
+            pending.resolve(deserialize(data.data, createGenerateCallback(ctx, meta.senderInstanceId), createScopedRemoteCallback(ctx, meta.senderInstanceId)));
+        }
+        catch (err) {
+            safeInvokeReject(pending, scope, warn);
+            pending.reject(err instanceof Error ? err : new Error(String(err)));
+        }
+    };
+}
+
+const DANGEROUS_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    '__defineGetter__',
+    '__defineSetter__',
+    '__lookupGetter__',
+    '__lookupSetter__',
+]);
+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, meta) {
+    if (ctx.isDestroyed())
+        return;
+    const target = ctx.getDelegateTarget();
+    const { respondError, respondThrown } = createResponder(ctx, meta.senderInstanceId, 'accessPropertyResponse', data.id);
+    if (data.path.length === 0) {
+        respondError('Property path must not be empty');
+        return;
+    }
+    if (target === undefined || target === null) {
+        respondError('No delegate target is configured');
+        return;
+    }
+    try {
+        let current = target;
+        let owner = target;
+        for (let i = 0; i < data.path.length; i++) {
+            const key = data.path[i];
+            if (current === undefined || current === null) {
+                respondError(`Cannot read property '${String(key)}' of ${current === null ? 'null' : 'undefined'} (at '${data.path
+                    .slice(0, i)
+                    .map(String)
+                    .join('.')}')`);
+                return;
+            }
+            owner = current;
+            current = readProperty(current, key);
+        }
+        const value = typeof current === 'function' ? ctx.bindMethod(current, owner) : current;
+        ctx
+            .getMessageChannel()
+            .getSender()
+            .sendMessage('accessPropertyResponse', {
+            id: data.id,
+            data: ctx.serializeForRemote(value, meta.senderInstanceId, {
+                persistent: isLikelyListenerPath(data.path),
+            }),
+        }, meta.senderInstanceId);
+    }
+    catch (err) {
+        respondThrown(err);
+    }
+}
+const handleAccessPropertyResponse = createResponseHandler('handleAccessPropertyResponse', warn);
+
+function handleInvokeRequest(data, ctx, meta) {
+    if (ctx.isDestroyed())
+        return;
+    const target = ctx.getDelegateTarget();
+    const scopedRemoteCallback = createScopedRemoteCallback(ctx, meta.senderInstanceId);
+    const generateCallback = createGenerateCallback(ctx, meta.senderInstanceId);
+    const { respondError, respondThrown, respondSuccess } = createResponder(ctx, meta.senderInstanceId, 'invokeResponse', data.id);
+    if (target === undefined || target === null) {
+        respondError('No delegate target is configured');
+        return;
+    }
+    if (data.path.length === 0) {
+        respondError('Invocation path must not be empty');
+        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) {
+            respondError(`Cannot read property '${String(data.path[i + 1])}' of ${current === null ? 'null' : 'undefined'} (at '${data.path
+                .slice(0, i + 1)
+                .map(String)
+                .join('.')}')`);
+            return;
+        }
+    }
+    const lastKey = data.path[data.path.length - 1];
+    const fn = readProperty(current, lastKey);
+    if (typeof fn !== 'function') {
+        respondError(`'${String(lastKey)}' is not a function`);
+        return;
+    }
+    let deserializedArgs;
+    try {
+        deserializedArgs = data.args.map((arg) => deserialize(arg, generateCallback, scopedRemoteCallback));
+    }
+    catch (err) {
+        respondThrown(err);
+        return;
+    }
+    let result;
+    try {
+        result = Reflect.apply(fn, current, deserializedArgs);
+    }
+    catch (err) {
+        respondThrown(err);
+        return;
+    }
+    if (isPromiseLike(result)) {
+        Promise.resolve(result)
+            .then((value) => {
+            respondSuccess(value);
+        })
+            .catch((err) => {
+            respondThrown(err);
+        });
+        return;
+    }
+    respondSuccess(result);
+}
+const handleInvokeResponse = createResponseHandler('handleInvokeResponse', warn);
+
+function handleCallbackInvoke(data, ctx, meta) {
+    if (ctx.isDestroyed())
+        return;
+    const { respondError, respondThrown, respondSuccess } = createResponder(ctx, meta.senderInstanceId, 'invokeFunctionByIdResponse', data.callId);
+    const persistentEntry = ctx.getPersistentFunctionCache().get(data.id);
+    const entry = persistentEntry ?? ctx.getFunctionCache().get(data.id);
+    if (!entry) {
+        const message = `Callback '${data.id}' is not available or has expired`;
+        warn('handleCallbackInvoke', message);
+        respondError(message);
+        return;
+    }
+    const scopedRemoteCallback = createScopedRemoteCallback(ctx, meta.senderInstanceId);
+    const generateCallback = createGenerateCallback(ctx, meta.senderInstanceId);
+    let deserializedArgs;
+    try {
+        deserializedArgs = data.args.map((arg) => deserialize(arg, generateCallback, scopedRemoteCallback));
+    }
+    catch (err) {
+        respondThrown(err);
+        return;
+    }
+    try {
+        const result = Reflect.apply(entry.fn, entry.thisArg, deserializedArgs);
+        if (isPromiseLike(result)) {
+            Promise.resolve(result)
+                .then((value) => {
+                respondSuccess(value);
+            })
+                .catch((err) => {
+                respondThrown(err);
+            });
+            return;
+        }
+        respondSuccess(result);
+    }
+    catch (err) {
+        respondThrown(err);
+    }
+}
+const handleCallbackInvokeResponse = createResponseHandler('handleCallbackInvokeResponse', warn);
+
+const RELEASE_CHUNK_SIZE = 1000;
+const scheduleNextChunk = typeof queueMicrotask === 'function' ? (cb) => queueMicrotask(cb) : (cb) => setTimeout(cb, 0);
+function handleConnectRequest(_data, ctx, meta) {
+    ctx.noteFreshConnect(meta.senderInstanceId);
+    ctx.getMessageChannel().getSender().sendMessage('connectResponse', {
+        instanceId: ctx.getInstanceId(),
+    }, meta.senderInstanceId);
+}
+function handleConnectResponse(_data, ctx, meta) {
+    ctx.bindRemote(meta.senderInstanceId);
+}
+function handleReleaseCallbacks(data, ctx, meta) {
+    const ids = data.ids;
+    const total = ids.length;
+    ctx.releaseRemoteCallbacks(meta.senderInstanceId, ids);
+    let cursor = 0;
+    const sender = meta.senderInstanceId;
+    const processChunk = () => {
+        if (ctx.isDestroyed())
+            return;
+        const end = Math.min(cursor + RELEASE_CHUNK_SIZE, total);
+        for (let i = cursor; i < end; i++) {
+            ctx.dropLocalCallback(ids[i], sender);
+        }
+        cursor = end;
+        if (cursor < total)
+            scheduleNextChunk(processChunk);
+    };
+    processChunk();
+}
+function handleDestroyEndpoint(data, ctx, meta) {
+    if (data.instanceId !== meta.senderInstanceId)
+        return;
+    ctx.handleRemoteDestroy(meta.senderInstanceId);
+}
+
+function createProcessorRegistry() {
+    const handlers = new Map();
+    return {
+        register(type, handler) {
+            handlers.set(type, { handler: handler });
+        },
+        get(type) {
+            return handlers.get(type)?.handler;
+        },
+    };
+}
+
+var C={hasSubscribers:false},S=C;var L=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date;var j=new Set,M=typeof process=="object"&&process?process:{},G=(u,e,t,i)=>{typeof M.emitWarning=="function"?M.emitWarning(u,e,t,i):console.error(`[${t}] ${e}: ${u}`);},P=u=>!j.has(u),F=u=>!!u&&u===Math.floor(u)&&u>0&&isFinite(u),I=u=>F(u)?u<=Math.pow(2,8)?Uint8Array:u<=Math.pow(2,16)?Uint16Array:u<=Math.pow(2,32)?Uint32Array:u<=Number.MAX_SAFE_INTEGER?O:null:null,O=class extends Array{constructor(e){super(e),this.fill(0);}},R=class u{heap;length;static#o=false;static create(e){let t=I(e);if(!t)return [];u.#o=true;let i=new u(e,t);return u.#o=false,i}constructor(e,t){if(!u.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new t(e),this.length=0;}push(e){this.heap[this.length++]=e;}pop(){return this.heap[--this.length]}},U=class u{#o;#u;#w;#x;#S;#M;#U;#m;get perf(){return this.#m}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;#n;#b;#s;#i;#t;#a;#c;#l;#h;#y;#r;#_;#F;#d;#g;#T;#W;#f;#j;static unsafeExposeInternals(e){return {starts:e.#F,ttls:e.#d,autopurgeTimers:e.#g,sizes:e.#_,keyMap:e.#s,keyList:e.#i,valList:e.#t,next:e.#a,prev:e.#c,get head(){return e.#l},get tail(){return e.#h},free:e.#y,isBackgroundFetch:t=>e.#e(t),backgroundFetch:(t,i,s,n)=>e.#P(t,i,s,n),moveToTail:t=>e.#L(t),indexes:t=>e.#A(t),rindexes:t=>e.#z(t),isStale:t=>e.#p(t)}}get max(){return this.#o}get maxSize(){return this.#u}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#U}get dispose(){return this.#w}get onInsert(){return this.#x}get disposeAfter(){return this.#S}constructor(e){let{max:t=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:o,updateAgeOnHas:r,allowStale:h,dispose:l,onInsert:c,disposeAfter:f,noDisposeOnSet:g,noUpdateTTL:p,maxSize:T=0,maxEntrySize:w=0,sizeCalculation:y,fetchMethod:a,memoMethod:m,noDeleteOnFetchRejection:_,noDeleteOnStaleGet:b,allowStaleOnFetchRejection:d,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,perf:x}=e;if(x!==void 0&&typeof x?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#m=x??L,t!==0&&!F(t))throw new TypeError("max option must be a nonnegative integer");let v=t?I(t):Array;if(!v)throw new Error("invalid max value: "+t);if(this.#o=t,this.#u=T,this.maxEntrySize=w||this.#u,this.sizeCalculation=y,this.sizeCalculation){if(!this.#u&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(m!==void 0&&typeof m!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#U=m,a!==void 0&&typeof a!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=a,this.#W=!!a,this.#s=new Map,this.#i=Array.from({length:t}).fill(void 0),this.#t=Array.from({length:t}).fill(void 0),this.#a=new v(t),this.#c=new v(t),this.#l=0,this.#h=0,this.#y=R.create(t),this.#n=0,this.#b=0,typeof l=="function"&&(this.#w=l),typeof c=="function"&&(this.#x=c),typeof f=="function"?(this.#S=f,this.#r=[]):(this.#S=void 0,this.#r=void 0),this.#T=!!this.#w,this.#j=!!this.#x,this.#f=!!this.#S,this.noDisposeOnSet=!!g,this.noUpdateTTL=!!p,this.noDeleteOnFetchRejection=!!_,this.allowStaleOnFetchRejection=!!d,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#u!==0&&!F(this.#u))throw new TypeError("maxSize must be a positive integer if specified");if(!F(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X();}if(this.allowStale=!!h,this.noDeleteOnStaleGet=!!b,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!r,this.ttlResolution=F(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!F(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#H();}if(this.#o===0&&this.ttl===0&&this.#u===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#u){let E="LRU_CACHE_UNBOUNDED";P(E)&&(j.add(E),G("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",E,u));}}getRemainingTTL(e){return this.#s.has(e)?1/0:0}#H(){let e=new O(this.#o),t=new O(this.#o);this.#d=e,this.#F=t;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#N=(r,h,l=this.#m.now())=>{t[r]=h!==0?l:0,e[r]=h,s(r,h);},this.#D=r=>{t[r]=e[r]!==0?this.#m.now():0,s(r,e[r]);};let s=this.ttlAutopurge?(r,h)=>{if(i?.[r]&&(clearTimeout(i[r]),i[r]=void 0),h&&h!==0&&i){let l=setTimeout(()=>{this.#p(r)&&this.#v(this.#i[r],"expire");},h+1);l.unref&&l.unref(),i[r]=l;}}:()=>{};this.#E=(r,h)=>{if(e[h]){let l=e[h],c=t[h];if(!l||!c)return;r.ttl=l,r.start=c,r.now=n||o();let f=r.now-c;r.remainingTTL=l-f;}};let n=0,o=()=>{let r=this.#m.now();if(this.ttlResolution>0){n=r;let h=setTimeout(()=>n=0,this.ttlResolution);h.unref&&h.unref();}return r};this.getRemainingTTL=r=>{let h=this.#s.get(r);if(h===void 0)return 0;let l=e[h],c=t[h];if(!l||!c)return 1/0;let f=(n||o())-c;return l-f},this.#p=r=>{let h=t[r],l=e[r];return !!l&&!!h&&(n||o())-h>l};}#D=()=>{};#E=()=>{};#N=()=>{};#p=()=>false;#X(){let e=new O(this.#o);this.#b=0,this.#_=e,this.#R=t=>{this.#b-=e[t],e[t]=0;},this.#k=(t,i,s,n)=>{if(this.#e(i))return 0;if(!F(s))if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,t),!F(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");return s},this.#I=(t,i,s)=>{if(e[t]=i,this.#u){let n=this.#u-e[t];for(;this.#b>n;)this.#G(true);}this.#b+=e[t],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b);};}#R=e=>{};#I=(e,t,i)=>{};#k=(e,t,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#h;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#l);)t=this.#c[t];}*#z({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#l;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#h);)t=this.#a[t];}#V(e){return e!==void 0&&this.#s.get(this.#i[e])===e}*entries(){for(let e of this.#A())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield [this.#i[e],this.#t[e]]);}*rentries(){for(let e of this.#z())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield [this.#i[e],this.#t[e]]);}*keys(){for(let e of this.#A()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t);}}*rkeys(){for(let e of this.#z()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t);}}*values(){for(let e of this.#A())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e]);}*rvalues(){for(let e of this.#z())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e]);}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(e,t={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&e(n,this.#i[i],this))return this.#C(this.#i[i],t)}}forEach(e,t=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this);}}rforEach(e,t=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this);}}purgeStale(){let e=false;for(let t of this.#z({allowStale:true}))this.#p(t)&&(this.#v(this.#i[t],"expire"),e=true);return e}info(e){let t=this.#s.get(e);if(t===void 0)return;let i=this.#t[t],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let o=this.#d[t],r=this.#F[t];if(o&&r){let h=o-(this.#m.now()-r);n.ttl=h,n.start=Date.now();}}return this.#_&&(n.size=this.#_[t]),n}dump(){let e=[];for(let t of this.#A({allowStale:true})){let i=this.#i[t],s=this.#t[t],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let o={value:n};if(this.#d&&this.#F){o.ttl=this.#d[t];let r=this.#m.now()-this.#F[t];o.start=Math.floor(Date.now()-r);}this.#_&&(o.size=this.#_[t]),e.unshift([i,o]);}return e}load(e){this.clear();for(let[t,i]of e){if(i.start){let s=Date.now()-i.start;i.start=this.#m.now()-s;}this.#O(t,i.value,i);}}set(e,t,i={}){let{status:s=void 0}=i;i.status=s,s&&(s.op="set",s.key=e,t!==void 0&&(s.value=t));let n=this.#O(e,t,i);return n}#O(e,t,i={}){let{ttl:s=this.ttl,start:n,noDisposeOnSet:o=this.noDisposeOnSet,sizeCalculation:r=this.sizeCalculation,status:h}=i;if(t===void 0)return h&&(h.set="deleted"),this.delete(e),this;let{noUpdateTTL:l=this.noUpdateTTL}=i;h&&!this.#e(t)&&(h.value=t);let c=this.#k(e,t,i.size||0,r,h);if(this.maxEntrySize&&c>this.maxEntrySize)return this.#v(e,"set"),h&&(h.set="miss",h.maxEntrySizeExceeded=true),this;let f=this.#n===0?void 0:this.#s.get(e);if(f===void 0)f=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(false):this.#n,this.#i[f]=e,this.#t[f]=t,this.#s.set(e,f),this.#a[this.#h]=f,this.#c[f]=this.#h,this.#h=f,this.#n++,this.#I(f,c,h),h&&(h.set="add"),l=false,this.#j&&this.#x?.(t,e,"add");else {this.#L(f);let g=this.#t[f];if(t!==g){if(this.#W&&this.#e(g)){g.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:p}=g;p!==void 0&&!o&&(this.#T&&this.#w?.(p,e,"set"),this.#f&&this.#r?.push([p,e,"set"]));}else o||(this.#T&&this.#w?.(g,e,"set"),this.#f&&this.#r?.push([g,e,"set"]));if(this.#R(f),this.#I(f,c,h),this.#t[f]=t,h){h.set="replace";let p=g&&this.#e(g)?g.__staleWhileFetching:g;p!==void 0&&(h.oldValue=p);}}else h&&(h.set="update");this.#j&&this.onInsert?.(t,e,t===g?"update":"replace");}if(s!==0&&!this.#d&&this.#H(),this.#d&&(l||this.#N(f,s,n),h&&this.#E(h,f)),!o&&this.#f&&this.#r){let g=this.#r,p;for(;p=g?.shift();)this.#S?.(...p);}return this}pop(){try{for(;this.#n;){let e=this.#t[this.#l];if(this.#G(!0),this.#e(e)){if(e.__staleWhileFetching)return e.__staleWhileFetching}else if(e!==void 0)return e}}finally{if(this.#f&&this.#r){let e=this.#r,t;for(;t=e?.shift();)this.#S?.(...t);}}}#G(e){let t=this.#l,i=this.#i[t],s=this.#t[t];return this.#W&&this.#e(s)?s.__abortController.abort(new Error("evicted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(s,i,"evict"),this.#f&&this.#r?.push([s,i,"evict"])),this.#R(t),this.#g?.[t]&&(clearTimeout(this.#g[t]),this.#g[t]=void 0),e&&(this.#i[t]=void 0,this.#t[t]=void 0,this.#y.push(t)),this.#n===1?(this.#l=this.#h=0,this.#y.length=0):this.#l=this.#a[t],this.#s.delete(i),this.#n--,t}has(e,t={}){let{status:i=void 0}=t;t.status=i,i&&(i.op="has",i.key=e);let s=this.#Y(e,t);return s}#Y(e,t={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=t,n=this.#s.get(e);if(n!==void 0){let o=this.#t[n];if(this.#e(o)&&o.__staleWhileFetching===void 0)return  false;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#D(n),s&&(s.has="hit",this.#E(s,n)),true}else s&&(s.has="miss");return  false}peek(e,t={}){let{status:i=void 0}=t;i&&(i.op="peek",i.key=e),t.status=i;let s=this.#J(e,t);return s}#J(e,t){let{status:i,allowStale:s=this.allowStale}=t,n=this.#s.get(e);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let o=this.#t[n],r=this.#e(o)?o.__staleWhileFetching:o;return i&&(r!==void 0?(i.peek="hit",i.value=r):i.peek="miss"),r}#P(e,t,i,s){let n=t===void 0?void 0:this.#t[t];if(this.#e(n))return n;let o=new AbortController,{signal:r}=i;r?.addEventListener("abort",()=>o.abort(r.reason),{signal:o.signal});let h={signal:o.signal,options:i,context:s},l=(w,y=false)=>{let{aborted:a}=o.signal,m=i.ignoreFetchAbort&&w!==void 0,_=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&w!==void 0);if(i.status&&(a&&!y?(i.status.fetchAborted=true,i.status.fetchError=o.signal.reason,m&&(i.status.fetchAbortIgnored=true)):i.status.fetchResolved=true),a&&!m&&!y)return f(o.signal.reason,_);let b=p,d=this.#t[t];return (d===p||d===void 0&&m&&y)&&(w===void 0?b.__staleWhileFetching!==void 0?this.#t[t]=b.__staleWhileFetching:this.#v(e,"fetch"):(i.status&&(i.status.fetchUpdated=true),this.#O(e,w,h.options))),w},c=w=>(i.status&&(i.status.fetchRejected=true,i.status.fetchError=w),f(w,false)),f=(w,y)=>{let{aborted:a}=o.signal,m=a&&i.allowStaleOnFetchAbort,_=m||i.allowStaleOnFetchRejection,b=_||i.noDeleteOnFetchRejection,d=p;if(this.#t[t]===p&&(!b||!y&&d.__staleWhileFetching===void 0?this.#v(e,"fetch"):m||(this.#t[t]=d.__staleWhileFetching)),_)return i.status&&d.__staleWhileFetching!==void 0&&(i.status.returnedStale=true),d.__staleWhileFetching;if(d.__returned===d)throw w},g=(w,y)=>{let a=this.#M?.(e,n,h);a&&a instanceof Promise&&a.then(m=>w(m===void 0?void 0:m),y),o.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(w(void 0),i.allowStaleOnFetchAbort&&(w=m=>l(m,true)));});};i.status&&(i.status.fetchDispatched=true);let p=new Promise(g).then(l,c),T=Object.assign(p,{__abortController:o,__staleWhileFetching:n,__returned:void 0});return t===void 0?(this.#O(e,T,{...h.options,status:void 0}),t=this.#s.get(e)):this.#t[t]=T,T}#e(e){if(!this.#W)return  false;let t=e;return !!t&&t instanceof Promise&&t.hasOwnProperty("__staleWhileFetching")&&t.__abortController instanceof AbortController}fetch(e,t={}){let {status:s=void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#B(e,t);return n}async#B(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:o=this.ttl,noDisposeOnSet:r=this.noDisposeOnSet,size:h=0,sizeCalculation:l=this.sizeCalculation,noUpdateTTL:c=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:g=this.allowStaleOnFetchRejection,ignoreFetchAbort:p=this.ignoreFetchAbort,allowStaleOnFetchAbort:T=this.allowStaleOnFetchAbort,context:w,forceRefresh:y=false,status:a,signal:m}=t;if(a&&(a.op="fetch",a.key=e,y&&(a.forceRefresh=true)),!this.#W)return a&&(a.fetch="get"),this.#C(e,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:a});let _={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:o,noDisposeOnSet:r,size:h,sizeCalculation:l,noUpdateTTL:c,noDeleteOnFetchRejection:f,allowStaleOnFetchRejection:g,allowStaleOnFetchAbort:T,ignoreFetchAbort:p,status:a,signal:m},b=this.#s.get(e);if(b===void 0){a&&(a.fetch="miss");let d=this.#P(e,b,_,w);return d.__returned=d}else {let d=this.#t[b];if(this.#e(d)){let E=i&&d.__staleWhileFetching!==void 0;return a&&(a.fetch="inflight",E&&(a.returnedStale=true)),E?d.__staleWhileFetching:d.__returned=d}let A=this.#p(b);if(!y&&!A)return a&&(a.fetch="hit"),this.#L(b),s&&this.#D(b),a&&this.#E(a,b),d;let z=this.#P(e,b,_,w),v=z.__staleWhileFetching!==void 0&&i;return a&&(a.fetch=A?"stale":"refresh",v&&A&&(a.returnedStale=true)),v?z.__staleWhileFetching:z.__returned=z}}forceFetch(e,t={}){let {status:s=void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#K(e,t);return n}async#K(e,t={}){let i=await this.#B(e,t);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(e,t={}){let{status:i=void 0}=t;t.status=i,i&&(i.op="memo",i.key=e,t.context&&(i.context=t.context));let s=this.#Q(e,t);return i&&(i.value=s),s}#Q(e,t={}){let i=this.#U;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:o,...r}=t;n&&o&&(n.forceRefresh=true);let h=this.#C(e,r),l=o||h===void 0;if(n&&(n.memo=l?"miss":"hit",l||(n.value=h)),!l)return h;let c=i(e,h,{options:r,context:s});return n&&(n.value=c),this.#O(e,c,r),c}get(e,t={}){let{status:i=void 0}=t;t.status=i,i&&(i.op="get",i.key=e);let s=this.#C(e,t);return i&&(s!==void 0&&(i.value=s),S.hasSubscribers),s}#C(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:o}=t,r=this.#s.get(e);if(r===void 0){o&&(o.get="miss");return}let h=this.#t[r],l=this.#e(h);return o&&this.#E(o,r),this.#p(r)?l?(o&&(o.get="stale-fetching"),i&&h.__staleWhileFetching!==void 0?(o&&(o.returnedStale=true),h.__staleWhileFetching):void 0):(n||this.#v(e,"expire"),o&&(o.get="stale"),i?(o&&(o.returnedStale=true),h):void 0):(o&&(o.get=l?"fetching":"hit"),this.#L(r),s&&this.#D(r),l?h.__staleWhileFetching:h)}#$(e,t){this.#c[t]=e,this.#a[e]=t;}#L(e){e!==this.#h&&(e===this.#l?this.#l=this.#a[e]:this.#$(this.#c[e],this.#a[e]),this.#$(this.#h,e),this.#h=e);}delete(e){return this.#v(e,"delete")}#v(e,t){let i=false;if(this.#n!==0){let s=this.#s.get(e);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=true,this.#n===1)this.#q(t);else {this.#R(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(n,e,t),this.#f&&this.#r?.push([n,e,t])),this.#s.delete(e),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#c[s];else if(s===this.#l)this.#l=this.#a[s];else {let o=this.#c[s];this.#a[o]=this.#a[s];let r=this.#a[s];this.#c[r]=this.#c[s];}this.#n--,this.#y.push(s);}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#S?.(...n);}return i}clear(){return this.#q("delete")}#q(e){for(let t of this.#z({allowStale:true})){let i=this.#t[t];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else {let s=this.#i[t];this.#T&&this.#w?.(i,s,e),this.#f&&this.#r?.push([i,s,e]);}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let t of this.#g??[])t!==void 0&&clearTimeout(t);this.#g?.fill(void 0);}if(this.#_&&this.#_.fill(0),this.#l=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let t=this.#r,i;for(;i=t?.shift();)this.#S?.(...i);}}};
+
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_FUNCTION_CACHE_MAX = 100;
+const DEFAULT_FUNCTION_CACHE_TTL = 5 * 60 * 1000;
+const DEFAULT_REMOTE_CALLBACK_CACHE_MAX = 500;
+const DEFAULT_REMOTE_CALLBACK_CACHE_TTL = 5 * 60 * 1000;
+const RELEASE_CALLBACKS_CHUNK_SIZE = 10000;
+const BROADCAST_OWNER = Symbol('chrome-in-iframe.broadcast-owner');
+function resolveTimeout(raw) {
+    if (raw === undefined)
+        return DEFAULT_TIMEOUT;
+    if (typeof raw !== 'number')
+        return DEFAULT_TIMEOUT;
+    if (raw === Infinity)
+        return Infinity;
+    if (!Number.isFinite(raw) || raw <= 0)
+        return DEFAULT_TIMEOUT;
+    return raw;
+}
+function createClientContext(getMessageChannel, instanceId, options = {}) {
+    const remoteCacheMax = options.remoteCallbackCacheMax ?? DEFAULT_REMOTE_CALLBACK_CACHE_MAX;
+    const remoteCacheTtl = options.remoteCallbackCacheTtl ?? DEFAULT_REMOTE_CALLBACK_CACHE_TTL;
+    const callTimeout = resolveTimeout(options.timeout);
+    const pending = new Map();
+    const functionIds = new WeakMap();
+    const persistentFunctionCache = new Map();
+    const persistentRefcount = new Map();
+    const functionCache = new U({
+        max: options.functionCacheMax ?? DEFAULT_FUNCTION_CACHE_MAX,
+        ttl: options.functionCacheTtl ?? DEFAULT_FUNCTION_CACHE_TTL,
+        dispose: (value, key, reason) => {
+            if (reason === 'set' || reason === 'delete')
+                return;
+            if (persistentFunctionCache.has(key))
+                return;
+            removeFunctionIdMapping(value.fn, value.thisArg);
+        },
+    });
+    const remoteCallbacksByOwner = new Map();
+    const persistentRemoteCallbacksByOwner = new Map();
+    const boundMethodCache = new WeakMap();
+    const callbackOwners = new Map();
+    const knownRemotes = new Set();
+    const remoteTargetWaiters = new Set();
+    let boundRemoteInstanceId;
+    let remoteTargetWaitDisabled = false;
+    let destroyed = false;
+    const armTimer = (onTimeout) => {
+        if (callTimeout === Infinity)
+            return null;
+        return setTimeout(onTimeout, callTimeout);
+    };
+    const cancelTimer = (timer) => {
+        if (timer !== null)
+            clearTimeout(timer);
+    };
+    const getPreferredRemote = () => {
+        if (boundRemoteInstanceId !== undefined)
+            return boundRemoteInstanceId;
+        if (knownRemotes.size !== 1)
+            return undefined;
+        return knownRemotes.values().next().value;
+    };
+    const resolveRemoteTargetWaiters = (remoteInstanceId) => {
+        if (remoteTargetWaiters.size === 0)
+            return;
+        const waiters = Array.from(remoteTargetWaiters);
+        remoteTargetWaiters.clear();
+        for (const resolve of waiters)
+            resolve(remoteInstanceId);
+    };
+    const waitForRemoteTarget = () => {
+        const preferred = getPreferredRemote();
+        if (preferred !== undefined)
+            return Promise.resolve(preferred);
+        if (destroyed)
+            return Promise.resolve(undefined);
+        return new Promise((resolve) => {
+            remoteTargetWaiters.add(resolve);
+        });
+    };
+    const recordCallbackOwners = (ids, owner) => {
+        if (ids.length === 0)
+            return;
+        if (owner === 'broadcast') {
+            for (const id of ids)
+                callbackOwners.set(id, BROADCAST_OWNER);
+            return;
+        }
+        for (const id of ids) {
+            const cur = callbackOwners.get(id);
+            if (cur === BROADCAST_OWNER)
+                continue;
+            if (cur === undefined) {
+                callbackOwners.set(id, owner);
+                continue;
+            }
+            if (typeof cur === 'string') {
+                if (cur === owner)
+                    continue;
+                callbackOwners.set(id, new Set([cur, owner]));
+                continue;
+            }
+            cur.add(owner);
+        }
+    };
+    const bindMethod = (fn, owner) => {
+        if (owner === null || typeof owner !== 'object') {
+            return (...args) => Reflect.apply(fn, owner, args);
+        }
+        let perOwner = boundMethodCache.get(fn);
+        if (!perOwner) {
+            perOwner = new WeakMap();
+            boundMethodCache.set(fn, perOwner);
+        }
+        const cached = perOwner.get(owner);
+        if (cached)
+            return cached;
+        const bound = (...args) => Reflect.apply(fn, owner, args);
+        perOwner.set(owner, bound);
+        return bound;
+    };
+    const removeFunctionIdMapping = (fn, thisArg) => {
+        const perOwner = functionIds.get(fn);
+        if (!perOwner)
+            return;
+        perOwner.delete(thisArg);
+        if (perOwner.size === 0)
+            functionIds.delete(fn);
+    };
+    const getOrCreateRemoteLru = (remoteId) => {
+        let lru = remoteCallbacksByOwner.get(remoteId);
+        if (!lru) {
+            lru = new U({ max: remoteCacheMax, ttl: remoteCacheTtl });
+            remoteCallbacksByOwner.set(remoteId, lru);
+        }
+        return lru;
+    };
+    const getOrCreatePersistentRemoteMap = (remoteId) => {
+        let map = persistentRemoteCallbacksByOwner.get(remoteId);
+        if (!map) {
+            map = new Map();
+            persistentRemoteCallbacksByOwner.set(remoteId, map);
+        }
+        return map;
+    };
+    const registerFunction = (fn, thisArg, callbackOptions = {}) => {
+        let perOwner = functionIds.get(fn);
+        if (!perOwner) {
+            perOwner = new Map();
+            functionIds.set(fn, perOwner);
+        }
+        let id = perOwner.get(thisArg);
+        if (!id) {
+            id = createId('cb');
+            perOwner.set(thisArg, id);
+        }
+        const entry = { fn, thisArg };
+        if (callbackOptions.persistent) {
+            persistentFunctionCache.set(id, entry);
+            functionCache.delete(id);
+            persistentRefcount.set(id, (persistentRefcount.get(id) ?? 0) + 1);
+        }
+        else if (!persistentFunctionCache.has(id)) {
+            functionCache.set(id, entry);
+        }
+        return id;
+    };
+    const releasePersistentRegistrationById = (id) => {
+        if (!persistentRefcount.has(id))
+            return undefined;
+        const next = (persistentRefcount.get(id) ?? 0) - 1;
+        if (next > 0) {
+            persistentRefcount.set(id, next);
+            return undefined;
+        }
+        persistentRefcount.delete(id);
+        const entry = persistentFunctionCache.get(id);
+        persistentFunctionCache.delete(id);
+        functionCache.delete(id);
+        if (entry)
+            removeFunctionIdMapping(entry.fn, entry.thisArg);
+        return id;
+    };
+    const dropLocalCallback = (id, requesterInstanceId) => {
+        if (requesterInstanceId !== undefined) {
+            const cur = callbackOwners.get(id);
+            if (cur === BROADCAST_OWNER) {
+                const remaining = new Set();
+                for (const r of knownRemotes) {
+                    if (r !== requesterInstanceId)
+                        remaining.add(r);
+                }
+                if (remaining.size > 0) {
+                    callbackOwners.set(id, remaining.size === 1 ? remaining.values().next().value : remaining);
+                    return;
+                }
+            }
+            else if (typeof cur === 'string') {
+                if (cur !== requesterInstanceId)
+                    return;
+            }
+            else if (cur instanceof Set) {
+                if (!cur.has(requesterInstanceId))
+                    return;
+                cur.delete(requesterInstanceId);
+                if (cur.size > 1)
+                    return;
+                if (cur.size === 1) {
+                    callbackOwners.set(id, cur.values().next().value);
+                    return;
+                }
+            }
+        }
+        if (persistentRefcount.has(id)) {
+            const next = (persistentRefcount.get(id) ?? 0) - 1;
+            if (next > 0) {
+                persistentRefcount.set(id, next);
+                return;
+            }
+        }
+        callbackOwners.delete(id);
+        const entry = persistentFunctionCache.get(id) ?? functionCache.get(id);
+        persistentRefcount.delete(id);
+        persistentFunctionCache.delete(id);
+        functionCache.delete(id);
+        if (entry)
+            removeFunctionIdMapping(entry.fn, entry.thisArg);
+    };
+    const getRemoteCallback = (id, invoke, callbackOptions, remoteInstanceId) => {
+        const opts = callbackOptions ?? {};
+        const lru = remoteCallbacksByOwner.get(remoteInstanceId);
+        const pmap = persistentRemoteCallbacksByOwner.get(remoteInstanceId);
+        let callback = pmap?.get(id) ?? lru?.get(id);
+        if (!callback) {
+            callback = (...args) => invoke(args);
+            if (opts.persistent) {
+                getOrCreatePersistentRemoteMap(remoteInstanceId).set(id, callback);
+            }
+            else {
+                getOrCreateRemoteLru(remoteInstanceId).set(id, callback);
+            }
+        }
+        else if (opts.persistent && !pmap?.has(id)) {
+            lru?.delete(id);
+            getOrCreatePersistentRemoteMap(remoteInstanceId).set(id, callback);
+        }
+        return callback;
+    };
+    const notifyReleaseCallbacks = (ids) => {
+        if (ids.length === 0)
+            return;
+        try {
+            const sender = getMessageChannel().getSender();
+            for (let cursor = 0; cursor < ids.length; cursor += RELEASE_CALLBACKS_CHUNK_SIZE) {
+                sender.sendMessage('releaseCallbacks', { ids: ids.slice(cursor, cursor + RELEASE_CALLBACKS_CHUNK_SIZE) });
+            }
+        }
+        catch (err) {
+            warn('notifyReleaseCallbacks', 'failed to release callbacks', err);
+        }
+    };
+    const safeOnReject = (callbacks) => {
+        if (!callbacks.onReject)
+            return;
+        try {
+            callbacks.onReject();
+        }
+        catch (err) {
+            warn('rejectPending', 'onReject hook threw', err);
+        }
+    };
+    const rejectPending = (id, error) => {
+        const callbacks = pending.get(id);
+        if (!callbacks)
+            return;
+        cancelTimer(callbacks.timer);
+        pending.delete(id);
+        safeOnReject(callbacks);
+        callbacks.reject(error);
+    };
+    return {
+        getDelegateTarget() {
+            return options.delegateTarget;
+        },
+        getMessageChannel() {
+            return getMessageChannel();
+        },
+        getInstanceId() {
+            return instanceId;
+        },
+        getFunctionCache() {
+            return functionCache;
+        },
+        getPersistentFunctionCache() {
+            return persistentFunctionCache;
+        },
+        registerFunction(fn, thisArg, callbackOptions) {
+            return registerFunction(fn, thisArg, callbackOptions);
+        },
+        serializeForRemote(value, target, callbackOptions) {
+            const ids = [];
+            const tracking = (fn, thisArg, opts) => {
+                const id = registerFunction(fn, thisArg, opts);
+                ids.push(id);
+                return id;
+            };
+            const result = serialize(value, tracking, callbackOptions);
+            recordCallbackOwners(ids, target);
+            return result;
+        },
+        getRemoteCallback(id, invoke, callbackOptions, remoteInstanceId) {
+            return getRemoteCallback(id, invoke, callbackOptions, remoteInstanceId);
+        },
+        getAndRemovePendingPromise(id, senderInstanceId) {
+            const callbacks = pending.get(id);
+            if (!callbacks)
+                return undefined;
+            if (callbacks.expectedRemote !== undefined &&
+                senderInstanceId !== undefined &&
+                callbacks.expectedRemote !== senderInstanceId) {
+                return undefined;
+            }
+            cancelTimer(callbacks.timer);
+            pending.delete(id);
+            return callbacks;
+        },
+        invoke(path, args) {
+            return new Promise((resolve, reject) => {
+                if (destroyed) {
+                    reject(new Error('Channel has been destroyed'));
+                    return;
+                }
+                const id = createId('req');
+                const persistent = isListenerRegistrationPath(path);
+                const registeredIds = [];
+                const collectingRegister = (fn, thisArg, opts) => {
+                    const cbId = registerFunction(fn, thisArg, opts);
+                    registeredIds.push(cbId);
+                    return cbId;
+                };
+                const releaseRegisteredPersistents = () => {
+                    const released = [];
+                    for (const cbId of registeredIds) {
+                        const releasedId = releasePersistentRegistrationById(cbId);
+                        if (releasedId)
+                            released.push(releasedId);
+                    }
+                    return released;
+                };
+                const cleanupRegisteredOnFailure = () => {
+                    const released = [];
+                    for (const cbId of registeredIds) {
+                        if (persistentRefcount.has(cbId)) {
+                            const releasedId = releasePersistentRegistrationById(cbId);
+                            if (releasedId)
+                                released.push(releasedId);
+                        }
+                        else {
+                            const entry = functionCache.get(cbId);
+                            if (entry) {
+                                functionCache.delete(cbId);
+                                removeFunctionIdMapping(entry.fn, entry.thisArg);
+                            }
+                        }
+                        callbackOwners.delete(cbId);
+                    }
+                    return released;
+                };
+                const timer = armTimer(() => {
+                    rejectPending(id, new Error(`Call timed out: ${String(path.join('.'))}`));
+                });
+                let serializedArgs;
+                try {
+                    serializePath(path);
+                    serializedArgs = args.map((arg) => serialize(arg, collectingRegister, { persistent }));
+                }
+                catch (err) {
+                    cancelTimer(timer);
+                    const released = cleanupRegisteredOnFailure();
+                    if (released.length > 0)
+                        notifyReleaseCallbacks(released);
+                    reject(err);
+                    return;
+                }
+                pending.set(id, {
+                    resolve,
+                    reject,
+                    timer,
+                    onResolve: () => {
+                        if (isListenerRemovalPath(path)) {
+                            const released = releaseRegisteredPersistents();
+                            if (released.length > 0)
+                                notifyReleaseCallbacks(released);
+                        }
+                    },
+                    onReject: () => {
+                        if (isListenerRegistrationPath(path)) {
+                            const released = releaseRegisteredPersistents();
+                            if (released.length > 0)
+                                notifyReleaseCallbacks(released);
+                        }
+                    },
+                });
+                const sendRequest = (targetInstanceId, requireTarget = true) => {
+                    const callbacks = pending.get(id);
+                    if (!callbacks)
+                        return;
+                    if (targetInstanceId === undefined && requireTarget) {
+                        rejectPending(id, new Error('No remote endpoint is available'));
+                        return;
+                    }
+                    if (targetInstanceId !== undefined)
+                        callbacks.expectedRemote = targetInstanceId;
+                    try {
+                        const channel = getMessageChannel();
+                        recordCallbackOwners(registeredIds, targetInstanceId ?? 'broadcast');
+                        channel.getSender().sendMessage('invokeRequest', {
+                            id,
+                            path,
+                            args: serializedArgs,
+                        }, targetInstanceId);
+                    }
+                    catch (err) {
+                        cancelTimer(timer);
+                        pending.delete(id);
+                        const released = cleanupRegisteredOnFailure();
+                        if (released.length > 0)
+                            notifyReleaseCallbacks(released);
+                        reject(err);
+                    }
+                };
+                const targetInstanceId = getPreferredRemote();
+                if (targetInstanceId !== undefined) {
+                    sendRequest(targetInstanceId);
+                }
+                else if (remoteTargetWaitDisabled) {
+                    sendRequest(undefined, false);
+                }
+                else {
+                    void waitForRemoteTarget().then(sendRequest);
+                }
+            });
+        },
+        accessProperty(path) {
+            return new Promise((resolve, reject) => {
+                if (destroyed) {
+                    reject(new Error('Channel has been destroyed'));
+                    return;
+                }
+                const id = createId('req');
+                const timer = armTimer(() => {
+                    rejectPending(id, new Error(`Property access timed out: ${String(path.join('.'))}`));
+                });
+                pending.set(id, { resolve, reject, timer });
+                let pathSerializationError;
+                try {
+                    serializePath(path);
+                }
+                catch (err) {
+                    pathSerializationError = err;
+                }
+                if (pathSerializationError !== undefined) {
+                    cancelTimer(timer);
+                    pending.delete(id);
+                    reject(pathSerializationError);
+                    return;
+                }
+                const sendRequest = (targetInstanceId, requireTarget = true) => {
+                    const callbacks = pending.get(id);
+                    if (!callbacks)
+                        return;
+                    if (targetInstanceId === undefined && requireTarget) {
+                        rejectPending(id, new Error('No remote endpoint is available'));
+                        return;
+                    }
+                    if (targetInstanceId !== undefined)
+                        callbacks.expectedRemote = targetInstanceId;
+                    try {
+                        getMessageChannel().getSender().sendMessage('accessPropertyRequest', {
+                            id,
+                            path,
+                        }, targetInstanceId);
+                    }
+                    catch (err) {
+                        cancelTimer(timer);
+                        pending.delete(id);
+                        reject(err);
+                    }
+                };
+                const targetInstanceId = getPreferredRemote();
+                if (targetInstanceId !== undefined) {
+                    sendRequest(targetInstanceId);
+                }
+                else if (remoteTargetWaitDisabled) {
+                    sendRequest(undefined, false);
+                }
+                else {
+                    void waitForRemoteTarget().then(sendRequest);
+                }
+            });
+        },
+        invokeFunctionById(callbackId, args, callbackOptions = {}, remoteInstanceId) {
+            return new Promise((resolve, reject) => {
+                if (destroyed) {
+                    reject(new Error('Channel has been destroyed'));
+                    return;
+                }
+                const callId = createId('cbcall');
+                const timer = armTimer(() => {
+                    rejectPending(callId, new Error(`Callback call timed out: ${callbackId}`));
+                });
+                pending.set(callId, { resolve, reject, timer, expectedRemote: remoteInstanceId });
+                const registeredIds = [];
+                const collectingRegister = (fn, thisArg, opts) => {
+                    const cbId = registerFunction(fn, thisArg, opts);
+                    registeredIds.push(cbId);
+                    return cbId;
+                };
+                try {
+                    const serializedArgs = args.map((arg) => serialize(arg, collectingRegister, callbackOptions));
+                    const targetInstanceId = remoteInstanceId ?? getPreferredRemote();
+                    recordCallbackOwners(registeredIds, targetInstanceId ?? 'broadcast');
+                    getMessageChannel().getSender().sendMessage('invokeFunctionByIdRequest', {
+                        id: callbackId,
+                        callId,
+                        args: serializedArgs,
+                    }, targetInstanceId);
+                }
+                catch (err) {
+                    cancelTimer(timer);
+                    pending.delete(callId);
+                    for (const cbId of registeredIds) {
+                        if (persistentRefcount.has(cbId)) {
+                            releasePersistentRegistrationById(cbId);
+                        }
+                        else {
+                            const entry = functionCache.get(cbId);
+                            if (entry) {
+                                functionCache.delete(cbId);
+                                removeFunctionIdMapping(entry.fn, entry.thisArg);
+                            }
+                        }
+                        callbackOwners.delete(cbId);
+                    }
+                    reject(err);
+                }
+            });
+        },
+        handleRemoteDestroy(remoteInstanceId) {
+            remoteCallbacksByOwner.delete(remoteInstanceId);
+            persistentRemoteCallbacksByOwner.delete(remoteInstanceId);
+            knownRemotes.delete(remoteInstanceId);
+            if (boundRemoteInstanceId === remoteInstanceId) {
+                boundRemoteInstanceId = undefined;
+                const preferred = getPreferredRemote();
+                if (preferred !== undefined)
+                    boundRemoteInstanceId = preferred;
+            }
+            for (const [id, owners] of callbackOwners) {
+                if (owners === remoteInstanceId) {
+                    callbackOwners.delete(id);
+                }
+                else if (owners instanceof Set && owners.has(remoteInstanceId)) {
+                    owners.delete(remoteInstanceId);
+                    if (owners.size === 0)
+                        callbackOwners.delete(id);
+                    else if (owners.size === 1)
+                        callbackOwners.set(id, owners.values().next().value);
+                }
+            }
+            const reason = new Error(`Remote endpoint ${remoteInstanceId} was destroyed`);
+            const noKnownRemotesLeft = knownRemotes.size === 0;
+            for (const [id, callbacks] of pending) {
+                const targeted = callbacks.expectedRemote === remoteInstanceId;
+                const stranded = callbacks.expectedRemote === undefined && noKnownRemotesLeft;
+                if (!targeted && !stranded)
+                    continue;
+                cancelTimer(callbacks.timer);
+                pending.delete(id);
+                safeOnReject(callbacks);
+                callbacks.reject(reason);
+            }
+        },
+        bindRemote(remoteInstanceId) {
+            if (!remoteInstanceId || remoteInstanceId === instanceId)
+                return;
+            knownRemotes.add(remoteInstanceId);
+            if (boundRemoteInstanceId === undefined) {
+                boundRemoteInstanceId = remoteInstanceId;
+                resolveRemoteTargetWaiters(remoteInstanceId);
+            }
+        },
+        noteFreshConnect(remoteInstanceId) {
+            if (!remoteInstanceId || remoteInstanceId === instanceId)
+                return;
+            const isNew = !knownRemotes.has(remoteInstanceId);
+            knownRemotes.add(remoteInstanceId);
+            if (boundRemoteInstanceId === remoteInstanceId)
+                return;
+            if (boundRemoteInstanceId === undefined || isNew) {
+                boundRemoteInstanceId = remoteInstanceId;
+                resolveRemoteTargetWaiters(remoteInstanceId);
+            }
+        },
+        disableRemoteTargetWait() {
+            remoteTargetWaitDisabled = true;
+            resolveRemoteTargetWaiters(undefined);
+        },
+        releaseRemoteCallbacks(remoteInstanceId, ids) {
+            const lru = remoteCallbacksByOwner.get(remoteInstanceId);
+            const pmap = persistentRemoteCallbacksByOwner.get(remoteInstanceId);
+            if (!lru && !pmap)
+                return;
+            for (const id of ids) {
+                lru?.delete(id);
+                pmap?.delete(id);
+            }
+        },
+        dropLocalCallback(id, requesterInstanceId) {
+            dropLocalCallback(id, requesterInstanceId);
+        },
+        noteRemoteSeen(remoteInstanceId) {
+            if (remoteInstanceId && remoteInstanceId !== instanceId) {
+                knownRemotes.add(remoteInstanceId);
+                const preferred = getPreferredRemote();
+                if (preferred !== undefined)
+                    resolveRemoteTargetWaiters(preferred);
+            }
+        },
+        bindMethod(fn, owner) {
+            return bindMethod(fn, owner);
+        },
+        getRemoteCallbackCounts(remoteInstanceId) {
+            return {
+                lru: remoteCallbacksByOwner.get(remoteInstanceId)?.size ?? 0,
+                persistent: persistentRemoteCallbacksByOwner.get(remoteInstanceId)?.size ?? 0,
+            };
+        },
+        isDestroyed() {
+            return destroyed;
+        },
+        destroy(notifyRemote = true) {
+            if (destroyed)
+                return;
+            destroyed = true;
+            if (notifyRemote) {
+                const heldRemoteIdSet = new Set();
+                for (const lru of remoteCallbacksByOwner.values()) {
+                    for (const id of lru.keys())
+                        heldRemoteIdSet.add(id);
+                }
+                for (const map of persistentRemoteCallbacksByOwner.values()) {
+                    for (const id of map.keys())
+                        heldRemoteIdSet.add(id);
+                }
+                if (heldRemoteIdSet.size > 0) {
+                    notifyReleaseCallbacks(Array.from(heldRemoteIdSet));
+                }
+                try {
+                    getMessageChannel().getSender().sendMessage('destroyEndpoint', { instanceId });
+                }
+                catch (err) {
+                    if (!isTransportDetachedError(err)) {
+                        warn('destroy', 'failed to notify remote of destroy', err);
+                    }
+                }
+            }
+            for (const [id, callbacks] of pending) {
+                cancelTimer(callbacks.timer);
+                safeOnReject(callbacks);
+                callbacks.reject(new Error(`Channel has been destroyed before call ${id} completed`));
+            }
+            pending.clear();
+            functionCache.clear();
+            persistentFunctionCache.clear();
+            persistentRefcount.clear();
+            callbackOwners.clear();
+            knownRemotes.clear();
+            boundRemoteInstanceId = undefined;
+            resolveRemoteTargetWaiters(undefined);
+            remoteCallbacksByOwner.clear();
+            persistentRemoteCallbacksByOwner.clear();
+        },
+    };
+}
+function createId(prefix) {
+    return `${prefix}-${nanoid()}`;
+}
+
+const EMPTY_TARGET = () => undefined;
+const INTERCEPTED_STRING_PROPS = new Set([
+    'then',
+    'catch',
+    'finally',
+    'toJSON',
+    'toString',
+    'valueOf',
+    'nodeType',
+    'tagName',
+    'asymmetricMatch',
+    '$$typeof',
+    '@@__IMMUTABLE_ITERABLE__@@',
+    '@@__IMMUTABLE_RECORD__@@',
+    'length',
+    'name',
+    'prototype',
+    'arguments',
+    'caller',
+    'bind',
+    'call',
+    'apply',
+]);
+const INTERCEPTED_NONE_SYMBOLS = new Set([
+    Symbol.toStringTag,
+    Symbol.iterator,
+    Symbol.asyncIterator,
+    Symbol.isConcatSpreadable,
+]);
+const PROXY_DESCRIPTION = '[chrome-in-iframe proxy]';
+function toPrimitiveDescriptor() {
+    return (hint) => {
+        if (hint === 'number')
+            return NaN;
+        return PROXY_DESCRIPTION;
+    };
+}
+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) => {
+        if (parts.length === 1 && typeof parts[0] === 'string') {
+            return [...basePath, ...parts[0].split('.').filter(Boolean)];
+        }
+        const extraPath = parts.flatMap((part) => {
+            if (Array.isArray(part))
+                return part.filter(isPathKey);
+            if (typeof part === 'string')
+                return [part];
+            if (typeof part === 'symbol')
+                return [part];
+            return [];
+        });
+        return [...basePath, ...extraPath];
+    };
+    function createNode(node) {
+        const stringChildren = new Map();
+        const symbolChildren = new Map();
+        let getCache;
+        const handler = {
+            get(_target, prop) {
+                if (typeof prop === 'string') {
+                    if (INTERCEPTED_STRING_PROPS.has(prop))
+                        return undefined;
+                    if (prop === '$get') {
+                        if (!getCache) {
+                            getCache = (...parts) => {
+                                if (!accessProperty) {
+                                    return Promise.reject(new Error('Property access is not configured'));
+                                }
+                                const basePath = node ? resolvePath(node) : [];
+                                return accessProperty(normalizePropertyPath(basePath, parts));
+                            };
+                        }
+                        return getCache;
+                    }
+                    const cached = stringChildren.get(prop);
+                    if (cached !== undefined)
+                        return cached;
+                    const childNode = node ? { parent: node, key: prop } : { key: prop };
+                    const child = createNode(childNode);
+                    stringChildren.set(prop, child);
+                    return child;
+                }
+                if (prop === Symbol.toPrimitive)
+                    return toPrimitiveDescriptor();
+                if (INTERCEPTED_NONE_SYMBOLS.has(prop))
+                    return undefined;
+                const cached = symbolChildren.get(prop);
+                if (cached !== undefined)
+                    return cached;
+                const childNode = node ? { parent: node, key: prop } : { key: prop };
+                const child = createNode(childNode);
+                symbolChildren.set(prop, child);
+                return child;
+            },
+            apply(_target, _thisArg, argArray) {
+                const path = node ? resolvePath(node) : [];
+                return invoke(path, argArray);
+            },
+        };
+        return new Proxy(EMPTY_TARGET, handler);
+    }
+    return createNode();
+}
+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 instanceId = `ep-${nanoid()}`;
+    const context = createClientContext(getChannel, instanceId, options.contextOptions);
+    const channel = createMessageChannel(options.poster, options.key ?? 'default', instanceId, context, processorRegistry);
+    channelRef.current = channel;
+    processorRegistry.register('connectRequest', handleConnectRequest);
+    processorRegistry.register('connectResponse', handleConnectResponse);
+    processorRegistry.register('invokeRequest', handleInvokeRequest);
+    processorRegistry.register('invokeResponse', handleInvokeResponse);
+    processorRegistry.register('accessPropertyRequest', handleAccessPropertyRequest);
+    processorRegistry.register('accessPropertyResponse', handleAccessPropertyResponse);
+    processorRegistry.register('invokeFunctionByIdRequest', handleCallbackInvoke);
+    processorRegistry.register('invokeFunctionByIdResponse', handleCallbackInvokeResponse);
+    processorRegistry.register('releaseCallbacks', handleReleaseCallbacks);
+    processorRegistry.register('destroyEndpoint', handleDestroyEndpoint);
+    const proxy = createClientProxy((path, args) => context.invoke(path, args), (path) => context.accessProperty(path));
+    try {
+        channel.getSender().sendMessage('connectRequest', { instanceId });
+    }
+    catch {
+        context.disableRemoteTargetWait();
+    }
+    let destroyed = false;
+    return {
+        proxy,
+        getContext: () => context,
+        isDestroyed: () => destroyed,
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            channel.destroy();
+            context.destroy(true);
+        },
+    };
+}
+
+function setupInMainWindow(options) {
+    const resolveTargetOrigin = createTargetOriginResolver(() => options.iframe, options.targetOrigin, options.strictOrigin === true);
+    return setupConnection(options, {
+        resolveTargetOrigin,
+        postMessage: (message) => {
+            const contentWindow = options.iframe.contentWindow;
+            if (!contentWindow) {
+                throw createTransportDetachedError('chrome-in-iframe: iframe contentWindow is not available');
+            }
+            contentWindow.postMessage(message, resolveTargetOrigin());
+        },
+        getExpectedSource: () => options.iframe.contentWindow,
+        delegateTarget: options.delegateTarget,
+    });
+}
+function setupInIframe(options = {}) {
+    const resolveTargetOrigin = createParentTargetOriginResolver(options.targetOrigin, options.strictOrigin === true);
+    return setupConnection(options, {
+        resolveTargetOrigin,
+        postMessage: (message) => {
+            window.parent.postMessage(message, resolveTargetOrigin());
+        },
+        getExpectedSource: () => window.parent,
+    });
+}
+function setupConnection(options, sides) {
+    const allowedOrigin = createAllowedOrigin(options.allowedOrigin, sides.resolveTargetOrigin);
+    const poster = createWindowPoster({
+        postMessage: sides.postMessage,
+        getExpectedSource: sides.getExpectedSource,
+        allowedOrigin,
+    });
+    const endpoint = createEndpoint({
+        poster,
+        key: options.key,
+        contextOptions: {
+            delegateTarget: sides.delegateTarget,
+            timeout: options.timeout,
+            functionCacheMax: options.functionCacheMax,
+            functionCacheTtl: options.functionCacheTtl,
+            remoteCallbackCacheMax: options.remoteCallbackCacheMax,
+            remoteCallbackCacheTtl: options.remoteCallbackCacheTtl,
+        },
+    });
+    const proxy = endpoint.proxy;
+    return {
+        proxy,
+        get: proxy.$get,
+        destroy: endpoint.destroy,
+        isDestroyed: endpoint.isDestroyed,
+    };
+}
+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 subscriptions = new Map();
+    return {
+        postMessage(message) {
+            options.postMessage(message);
+        },
+        addEventListener(name, callback) {
+            const existing = subscriptions.get(callback);
+            if (existing)
+                windowDispatcher.remove(name, existing);
+            const sub = {
+                isExpectedSource: (source) => source === options.getExpectedSource(),
+                isAllowedOrigin: (origin) => isAllowedOrigin(origin, options.allowedOrigin),
+                deliver: callback,
+            };
+            subscriptions.set(callback, sub);
+            windowDispatcher.add(name, sub);
+        },
+        removeEventListener(name, callback) {
+            const sub = subscriptions.get(callback);
+            if (!sub)
+                return;
+            windowDispatcher.remove(name, sub);
+            subscriptions.delete(callback);
+        },
+    };
+}
+const windowDispatcher = createWindowDispatcher();
+function createWindowDispatcher() {
+    const perName = new Map();
+    const domListeners = new Map();
+    const ensureDomListener = (name) => {
+        if (domListeners.has(name))
+            return;
+        if (typeof window === 'undefined')
+            return;
+        const handler = (event) => {
+            const messageEvent = event;
+            const subs = perName.get(name);
+            if (!subs || subs.size === 0)
+                return;
+            for (const sub of subs) {
+                if (!sub.isExpectedSource(messageEvent.source))
+                    continue;
+                if (!sub.isAllowedOrigin(messageEvent.origin))
+                    continue;
+                try {
+                    sub.deliver({ data: messageEvent.data });
+                }
+                catch (err) {
+                    warn('windowDispatcher', 'subscriber threw while delivering message', err);
+                }
+            }
+        };
+        domListeners.set(name, handler);
+        window.addEventListener(name, handler);
+    };
+    return {
+        add(name, sub) {
+            let subs = perName.get(name);
+            if (!subs) {
+                subs = new Set();
+                perName.set(name, subs);
+            }
+            subs.add(sub);
+            ensureDomListener(name);
+        },
+        remove(name, sub) {
+            const subs = perName.get(name);
+            if (!subs)
+                return;
+            subs.delete(sub);
+            if (subs.size > 0)
+                return;
+            perName.delete(name);
+            const handler = domListeners.get(name);
+            if (handler && typeof window !== 'undefined') {
+                window.removeEventListener(name, handler);
+            }
+            domListeners.delete(name);
+        },
+    };
+}
+function isAllowedOrigin(origin, allowedOrigin) {
+    if (allowedOrigin === undefined)
+        return true;
+    if (typeof allowedOrigin === 'function')
+        return allowedOrigin(origin);
+    if (Array.isArray(allowedOrigin))
+        return allowedOrigin.includes(origin);
+    return allowedOrigin === origin;
+}
+function createAllowedOrigin(explicit, resolveTargetOrigin) {
+    if (explicit !== undefined)
+        return explicit;
+    return (origin) => {
+        const targetOrigin = resolveTargetOrigin();
+        if (targetOrigin === '*') {
+            if (typeof location !== 'undefined' && location.origin && location.origin !== 'null') {
+                return origin === location.origin;
+            }
+            return false;
+        }
+        return targetOrigin === origin;
+    };
+}
+function getGlobalChrome() {
+    const chromeApi = globalThis.chrome;
+    if (!chromeApi) {
+        throw new Error('chrome-in-iframe: global `chrome` API is not available. ' +
+            'Make sure this runs inside a Chrome extension page, or pass a custom ' +
+            '`chromeApi` option (e.g. for tests / non-extension environments).');
+    }
+    return chromeApi;
+}
+function createTargetOriginResolver(getIframe, explicit, strict) {
+    if (explicit)
+        return () => explicit;
+    return freezeResolvedOrigin(() => deriveOriginFromIframe(getIframe(), strict === true));
+}
+function createParentTargetOriginResolver(explicit, strict) {
+    if (explicit)
+        return () => explicit;
+    return freezeResolvedOrigin(() => deriveParentOrigin(strict === true));
+}
+function freezeResolvedOrigin(resolve) {
+    let frozen;
+    return () => {
+        if (frozen !== undefined)
+            return frozen;
+        const resolved = resolve();
+        if (resolved !== '*')
+            frozen = resolved;
+        return resolved;
+    };
+}
+function deriveOriginFromIframe(iframe, strict) {
+    const src = iframe.src || iframe.getAttribute('src') || '';
+    const origin = parseOrigin(src);
+    if (origin)
+        return origin;
+    try {
+        if (iframe.contentWindow && iframe.contentWindow.location) {
+            const loc = iframe.contentWindow.location;
+            if (loc.origin && loc.origin !== 'null')
+                return loc.origin;
+        }
+    }
+    catch (err) {
+        warn('deriveOriginFromIframe', 'unable to access cross-origin contentWindow.location', err);
+    }
+    if (strict) {
+        throw new Error('chrome-in-iframe: unable to derive iframe origin automatically; pass `targetOrigin` explicitly or set `strictOrigin: false`.');
+    }
+    warn('deriveOriginFromIframe', "unable to derive iframe origin automatically; falling back to '*'. " +
+        'Pass `targetOrigin` explicitly to lock the destination.');
+    return '*';
+}
+function deriveParentOrigin(strict) {
+    if (typeof document !== 'undefined') {
+        const referrer = document.referrer;
+        const origin = parseOrigin(referrer);
+        if (origin)
+            return origin;
+    }
+    if (typeof location !== 'undefined' && location.ancestorOrigins && location.ancestorOrigins.length > 0) {
+        const first = location.ancestorOrigins[0];
+        if (first && first !== 'null')
+            return first;
+    }
+    if (strict) {
+        throw new Error('chrome-in-iframe: unable to derive parent origin automatically; pass `targetOrigin` explicitly or set `strictOrigin: false`.');
+    }
+    warn('deriveParentOrigin', "unable to derive parent origin automatically; falling back to '*'. " +
+        'Pass `targetOrigin` explicitly to lock the destination.');
+    return '*';
+}
+function parseOrigin(url) {
+    if (!url)
+        return null;
+    try {
+        const parsed = new URL(url, typeof location !== 'undefined' ? location.href : 'http://localhost');
+        if (parsed.origin && parsed.origin !== 'null')
+            return parsed.origin;
+    }
+    catch (err) {
+        warn('parseOrigin', 'failed to parse URL', url, err);
+        return null;
+    }
+    return null;
+}
+
+exports.TRANSPORT_DETACHED = TRANSPORT_DETACHED;
+exports.connectChromeInIframe = connectChromeInIframe;
+exports.exposeChromeInIframe = exposeChromeInIframe;
+exports.isTransportDetachedError = isTransportDetachedError;
+exports.setLogger = setLogger;
+exports.setupInIframe = setupInIframe;
+exports.setupInMainWindow = setupInMainWindow;