osra 0.2.0 → 0.2.1

package/build/extension-test/content.js

@@ -0,0 +1,4585 @@
+(async ()=>{
+    const OSRA_KEY = "__OSRA_KEY__";
+    const OSRA_DEFAULT_KEY = "__OSRA_DEFAULT_KEY__";
+    const OSRA_BOX = "__OSRA_BOX__";
+    const makeMessageChannelAllocator = ()=>{
+        const channels = new Map();
+        const result = {
+            getUniqueUuid: ()=>{
+                let uuid = globalThis.crypto.randomUUID();
+                while(channels.has(uuid)){
+                    uuid = globalThis.crypto.randomUUID();
+                }
+                return uuid;
+            },
+            set: (uuid, messagePorts)=>{
+                channels.set(uuid, {
+                    uuid,
+                    ...messagePorts
+                });
+            },
+            alloc: (uuid = result.getUniqueUuid(), messagePorts)=>{
+                if (messagePorts) {
+                    channels.set(uuid, {
+                        uuid,
+                        ...messagePorts
+                    });
+                    return {
+                        uuid,
+                        ...messagePorts
+                    };
+                }
+                const messageChannel = new MessageChannel();
+                const allocatedMessageChannel = {
+                    uuid,
+                    port1: messageChannel.port1,
+                    port2: messageChannel.port2
+                };
+                channels.set(uuid, allocatedMessageChannel);
+                return allocatedMessageChannel;
+            },
+            has: (uuid)=>channels.has(uuid),
+            get: (uuid)=>channels.get(uuid),
+            free: (uuid)=>channels.delete(uuid),
+            getOrAlloc: (uuid = result.getUniqueUuid(), messagePorts)=>{
+                const existingChannel = result.get(uuid);
+                if (existingChannel) return existingChannel;
+                return result.alloc(uuid, messagePorts);
+            }
+        };
+        return result;
+    };
+    const checkOsraMessageKey = (message, key)=>isOsraMessage(message) && message[OSRA_KEY] === key;
+    const registerOsraMessageListener = ({ listener, transport, remoteName, key = OSRA_KEY, unregisterSignal })=>{
+        const registerListenerOnReceiveTransport = (receiveTransport)=>{
+            if (typeof receiveTransport === "function") {
+                receiveTransport(listener);
+            } else if (isWebExtensionPort(receiveTransport) || isWebExtensionOnConnect(receiveTransport) || isWebExtensionOnMessage(receiveTransport)) {
+                const listenOnWebExtOnMessage = (onMessage, port)=>{
+                    const _listener = (message, sender)=>{
+                        if (!checkOsraMessageKey(message, key)) return;
+                        if (remoteName && message.name !== remoteName) return;
+                        listener(message, {
+                            port,
+                            sender
+                        });
+                    };
+                    onMessage.addListener(_listener);
+                    if (unregisterSignal) {
+                        unregisterSignal.addEventListener("abort", ()=>onMessage.removeListener(_listener));
+                    }
+                };
+                if (isWebExtensionOnConnect(receiveTransport)) {
+                    const _listener = (port)=>{
+                        listenOnWebExtOnMessage(port.onMessage, port);
+                    };
+                    receiveTransport.addListener(_listener);
+                    if (unregisterSignal) {
+                        unregisterSignal.addEventListener("abort", ()=>receiveTransport.removeListener(_listener));
+                    }
+                } else if (isWebExtensionOnMessage(receiveTransport)) {
+                    listenOnWebExtOnMessage(receiveTransport);
+                } else {
+                    listenOnWebExtOnMessage(receiveTransport.onMessage);
+                }
+            } else {
+                const _listener = (event)=>{
+                    if (!checkOsraMessageKey(event.data, key)) return;
+                    if (remoteName && event.data.name !== remoteName) return;
+                    listener(event.data, {
+                        receiveTransport,
+                        source: event.source
+                    });
+                };
+                receiveTransport.addEventListener("message", _listener);
+                if (unregisterSignal) {
+                    unregisterSignal.addEventListener("abort", ()=>receiveTransport.removeEventListener("message", _listener));
+                }
+            }
+        };
+        if (isCustomTransport(transport)) {
+            registerListenerOnReceiveTransport(transport.receive);
+        } else {
+            registerListenerOnReceiveTransport(transport);
+        }
+    };
+    const sendOsraMessage = (transport, message, origin = "*", transferables = [])=>{
+        const sendToEmitTransport = (emitTransport)=>{
+            if (typeof emitTransport === "function") {
+                emitTransport(message, transferables);
+            } else if (isWebExtensionPort(emitTransport)) {
+                emitTransport.postMessage(message);
+            } else if (isWindow(emitTransport)) {
+                emitTransport.postMessage(message, origin, transferables);
+            } else if (isWebSocket(emitTransport)) {
+                emitTransport.send(JSON.stringify(message));
+            } else if (isSharedWorker(emitTransport)) {
+                emitTransport.port.postMessage(message, transferables);
+            } else {
+                emitTransport.postMessage(message, transferables);
+            }
+        };
+        if (isCustomTransport(transport)) {
+            sendToEmitTransport(transport.emit);
+        } else {
+            sendToEmitTransport(transport);
+        }
+    };
+    const typedArrayConstructors = [
+        Int8Array,
+        Uint8Array,
+        Uint8ClampedArray,
+        Int16Array,
+        Uint16Array,
+        Int32Array,
+        Uint32Array,
+        Float16Array,
+        Float32Array,
+        Float64Array,
+        BigInt64Array,
+        BigUint64Array
+    ];
+    [
+        new Int8Array(),
+        new Uint8Array(),
+        new Uint8ClampedArray(),
+        new Int16Array(),
+        new Uint16Array(),
+        new Int32Array(),
+        new Uint32Array(),
+        new Float16Array(),
+        new Float32Array(),
+        new Float64Array(),
+        new BigInt64Array(),
+        new BigUint64Array()
+    ];
+    const typedArrayToType = (value)=>{
+        const type = value instanceof Int8Array ? "Int8Array" : value instanceof Uint8Array ? "Uint8Array" : value instanceof Uint8ClampedArray ? "Uint8ClampedArray" : value instanceof Int16Array ? "Int16Array" : value instanceof Uint16Array ? "Uint16Array" : value instanceof Int32Array ? "Int32Array" : value instanceof Uint32Array ? "Uint32Array" : value instanceof Float16Array ? "Float16Array" : value instanceof Float32Array ? "Float32Array" : value instanceof Float64Array ? "Float64Array" : value instanceof BigInt64Array ? "BigInt64Array" : value instanceof BigUint64Array ? "BigUint64Array" : void 0;
+        if (type === void 0) throw new Error("Unknown typed array type");
+        return type;
+    };
+    const typedArrayTypeToTypedArrayConstructor = (value)=>{
+        const typedArray = value === "Int8Array" ? Int8Array : value === "Uint8Array" ? Uint8Array : value === "Uint8ClampedArray" ? Uint8ClampedArray : value === "Int16Array" ? Int16Array : value === "Uint16Array" ? Uint16Array : value === "Int32Array" ? Int32Array : value === "Uint32Array" ? Uint32Array : value === "Float16Array" ? Float16Array : value === "Float32Array" ? Float32Array : value === "Float64Array" ? Float64Array : value === "BigInt64Array" ? BigInt64Array : value === "BigUint64Array" ? BigUint64Array : void 0;
+        if (typedArray === void 0) throw new Error("Unknown typed array type");
+        return typedArray;
+    };
+    const isTypedArray = (value)=>typedArrayConstructors.some((typedArray)=>value instanceof typedArray);
+    const isWebSocket = (value)=>value instanceof WebSocket;
+    const isServiceWorkerContainer = (value)=>globalThis.ServiceWorkerContainer && value instanceof ServiceWorkerContainer;
+    const isWorker = (value)=>globalThis.Worker && value instanceof Worker;
+    const isDedicatedWorker = (value)=>globalThis.DedicatedWorkerGlobalScope && value instanceof DedicatedWorkerGlobalScope;
+    const isSharedWorker = (value)=>globalThis.SharedWorker && value instanceof SharedWorker;
+    const isMessagePort = (value)=>value instanceof MessagePort;
+    const isPromise = (value)=>value instanceof Promise;
+    const isFunction = (value)=>typeof value === "function";
+    const isArrayBuffer = (value)=>value instanceof ArrayBuffer;
+    const isReadableStream = (value)=>value instanceof ReadableStream;
+    const isDate = (value)=>value instanceof Date;
+    const isError = (value)=>value instanceof Error;
+    const isAlwaysBox = (value)=>isFunction(value) || isPromise(value) || isTypedArray(value) || isDate(value) || isError(value);
+    const isOsraMessage = (value)=>Boolean(value && typeof value === "object" && value[OSRA_KEY]);
+    const isClonable = (value)=>globalThis.SharedArrayBuffer && value instanceof globalThis.SharedArrayBuffer ? true : false;
+    const isTransferable = (value)=>globalThis.ArrayBuffer && value instanceof globalThis.ArrayBuffer ? true : globalThis.MessagePort && value instanceof globalThis.MessagePort ? true : globalThis.ReadableStream && value instanceof globalThis.ReadableStream ? true : globalThis.WritableStream && value instanceof globalThis.WritableStream ? true : globalThis.TransformStream && value instanceof globalThis.TransformStream ? true : globalThis.ImageBitmap && value instanceof globalThis.ImageBitmap ? true : false;
+    const isWebExtensionPort = (value, connectPort = false)=>{
+        return Boolean(value && typeof value === "object" && value.name && value.disconnect && value.postMessage && (connectPort ? value.sender && value.onMessage && value.onDisconnect : true));
+    };
+    const isWebExtensionOnConnect = (value)=>Boolean(value && typeof value === "object" && value.addListener && value.hasListener && value.removeListener);
+    const isWebExtensionOnMessage = (value)=>Boolean(value && typeof value === "object" && value.addListener && value.hasListener && value.removeListener);
+    const isWindow = (value)=>{
+        return Boolean(value && typeof value === "object" && value.document && value.location && value.navigator && value.screen && value.history);
+    };
+    const isEmitJsonOnlyTransport = (value)=>isWebSocket(value) || isWebExtensionPort(value);
+    const isReceiveJsonOnlyTransport = (value)=>isWebSocket(value) || isWebExtensionPort(value) || isWebExtensionOnConnect(value) || isWebExtensionOnMessage(value);
+    const isJsonOnlyTransport = (value)=>isEmitJsonOnlyTransport(value) || isReceiveJsonOnlyTransport(value);
+    const isEmitTransport = (value)=>isEmitJsonOnlyTransport(value) || isWindow(value) || isServiceWorkerContainer(value) || isWorker(value) || isDedicatedWorker(value) || isSharedWorker(value) || isMessagePort(value) || isCustomEmitTransport(value);
+    const isReceiveTransport = (value)=>isReceiveJsonOnlyTransport(value) || isWindow(value) || isServiceWorkerContainer(value) || isWorker(value) || isDedicatedWorker(value) || isSharedWorker(value) || isMessagePort(value) || isCustomReceiveTransport(value);
+    const isCustomEmitTransport = (value)=>Boolean(value && typeof value === "object" && ("emit" in value && (isEmitTransport(value.emit) || typeof value.emit === "function")));
+    const isCustomReceiveTransport = (value)=>Boolean(value && typeof value === "object" && ("receive" in value && (isReceiveTransport(value.receive) || typeof value.receive === "function")));
+    const isCustomTransport = (value)=>isCustomEmitTransport(value) || isCustomReceiveTransport(value);
+    const isRevivable = (value)=>isMessagePort(value) || isFunction(value) || isPromise(value) || isTypedArray(value) || isArrayBuffer(value) || isReadableStream(value) || isDate(value) || isError(value);
+    const isRevivableBox = (value)=>value && typeof value === "object" && OSRA_BOX in value && value[OSRA_BOX] === "revivable";
+    const isRevivableMessagePortBox = (value)=>isRevivableBox(value) && value.type === "messagePort";
+    const isRevivablePromiseBox = (value)=>isRevivableBox(value) && value.type === "promise";
+    const isRevivableFunctionBox = (value)=>isRevivableBox(value) && value.type === "function";
+    const isRevivableTypedArrayBox = (value)=>isRevivableBox(value) && value.type === "typedArray";
+    const isRevivableArrayBufferBox = (value)=>isRevivableBox(value) && value.type === "arrayBuffer";
+    const isRevivableReadableStreamBox = (value)=>isRevivableBox(value) && value.type === "readableStream";
+    const isRevivableErrorBox = (value)=>isRevivableBox(value) && value.type === "error";
+    const isRevivableDateBox = (value)=>isRevivableBox(value) && value.type === "date";
+    const getTransferableObjects = (value)=>{
+        const transferables = [];
+        const recurse = (value2)=>isClonable(value2) ? void 0 : isTransferable(value2) ? transferables.push(value2) : Array.isArray(value2) ? value2.map(recurse) : value2 && typeof value2 === "object" ? Object.values(value2).map(recurse) : void 0;
+        recurse(value);
+        return transferables;
+    };
+    const probePlatformCapabilityUtil = (value, transfer = false)=>{
+        const { port1, port2 } = new MessageChannel();
+        const result = new Promise((resolve)=>port1.addEventListener("message", (message)=>resolve(message.data)));
+        port1.start();
+        port2.postMessage(value, transfer ? getTransferableObjects(value) : []);
+        return result;
+    };
+    const probeMessagePortTransfer = async ()=>{
+        const { port1 } = new MessageChannel();
+        const port = await probePlatformCapabilityUtil(port1, true);
+        return port instanceof MessagePort;
+    };
+    const probeArrayBufferClone = async ()=>{
+        const buffer = new ArrayBuffer(1);
+        const arrayBuffer = await probePlatformCapabilityUtil(buffer);
+        return arrayBuffer instanceof ArrayBuffer;
+    };
+    const probeArrayBufferTransfer = async ()=>{
+        const buffer = new ArrayBuffer(1);
+        const arrayBuffer = await probePlatformCapabilityUtil(buffer, true);
+        return arrayBuffer instanceof ArrayBuffer;
+    };
+    const probeTransferableStream = async ()=>{
+        const stream = new ReadableStream({
+            start (controller) {
+                controller.enqueue(new Uint8Array(1));
+                controller.close();
+            }
+        });
+        const transferableStream = await probePlatformCapabilityUtil(stream, true);
+        return transferableStream instanceof ReadableStream;
+    };
+    const probePlatformCapabilities = async ()=>{
+        const [messagePort, arrayBuffer, transferable, transferableStream] = await Promise.all([
+            probeMessagePortTransfer().catch(()=>false),
+            probeArrayBufferClone().catch(()=>false),
+            probeArrayBufferTransfer().catch(()=>false),
+            probeTransferableStream().catch(()=>false)
+        ]);
+        return {
+            jsonOnly: !messagePort && !arrayBuffer && !transferable && !transferableStream,
+            messagePort,
+            arrayBuffer,
+            transferable,
+            transferableStream
+        };
+    };
+    const boxMessagePort = (value, context)=>{
+        const messagePort = value;
+        const { uuid: portId } = context.messageChannels.alloc(void 0, {
+            port1: messagePort
+        });
+        messagePort.addEventListener("message", ({ data })=>{
+            context.sendMessage({
+                type: "message",
+                remoteUuid: context.remoteUuid,
+                data: isRevivableBox(data) ? data : recursiveBox(data, context),
+                portId
+            });
+        });
+        messagePort.start();
+        context.eventTarget.addEventListener("message", function listener({ detail: message }) {
+            if (message.type === "message-port-close") {
+                if (message.portId !== portId) return;
+                context.eventTarget.removeEventListener("message", listener);
+                messagePort.close();
+                context.messageChannels.free(portId);
+                return;
+            }
+            if (message.type !== "message" || message.portId !== portId) return;
+            messagePort.postMessage(message.data, getTransferableObjects(message.data));
+        });
+        return {
+            type: "messagePort",
+            portId
+        };
+    };
+    const reviveMessagePort = (value, context)=>{
+        const { port1: userPort, port2: internalPort } = new MessageChannel();
+        internalPort.addEventListener("message", ({ data })=>{
+            context.sendMessage({
+                type: "message",
+                remoteUuid: context.remoteUuid,
+                data: isRevivableBox(data) ? data : recursiveBox(data, context),
+                portId: value.portId
+            });
+        });
+        internalPort.start();
+        const existingChannel = context.messageChannels.get(value.portId);
+        const { port1 } = existingChannel ? existingChannel : context.messageChannels.alloc(value.portId);
+        port1.addEventListener("message", function listener({ data: message }) {
+            if (message.type === "message-port-close") {
+                if (message.portId !== value.portId) return;
+                port1.removeEventListener("message", listener);
+                internalPort.close();
+                context.messageChannels.free(value.portId);
+                return;
+            }
+            if (message.type !== "message" || message.portId !== value.portId) return;
+            if (context.messagePorts.has(userPort)) {
+                internalPort.postMessage(message.data);
+            } else {
+                const revivedData = recursiveRevive(message.data, context);
+                internalPort.postMessage(revivedData, getTransferableObjects(revivedData));
+            }
+        });
+        port1.start();
+        return userPort;
+    };
+    const boxPromise = (value, context)=>{
+        const { port1: localPort, port2: remotePort } = new MessageChannel();
+        context.messagePorts.add(remotePort);
+        const sendResult = (result)=>{
+            const boxedResult = recursiveBox(result, context);
+            localPort.postMessage(boxedResult, getTransferableObjects(boxedResult));
+            localPort.close();
+        };
+        value.then((data)=>sendResult({
+                type: "resolve",
+                data
+            })).catch((error)=>sendResult({
+                type: "reject",
+                error: error.stack
+            }));
+        return {
+            type: "promise",
+            port: remotePort
+        };
+    };
+    const revivePromise = (value, context)=>{
+        context.messagePorts.add(value.port);
+        return new Promise((resolve, reject)=>{
+            value.port.addEventListener("message", ({ data })=>{
+                const result = recursiveRevive(data, context);
+                if (result.type === "resolve") {
+                    resolve(result.data);
+                } else {
+                    reject(result.error);
+                }
+                value.port.close();
+            }, {
+                once: true
+            });
+            value.port.start();
+        });
+    };
+    const boxFunction = (value, context)=>{
+        const { port1: localPort, port2: remotePort } = new MessageChannel();
+        context.messagePorts.add(remotePort);
+        localPort.addEventListener("message", ({ data })=>{
+            const [returnValuePort, args] = recursiveRevive(data, context);
+            const result = (async ()=>value(...args))();
+            const boxedResult = recursiveBox(result, context);
+            returnValuePort.postMessage(boxedResult, getTransferableObjects(boxedResult));
+        });
+        localPort.start();
+        return {
+            type: "function",
+            port: remotePort
+        };
+    };
+    const reviveFunction = (value, context)=>{
+        const func = (...args)=>new Promise((resolve, reject)=>{
+                const { port1: returnValueLocalPort, port2: returnValueRemotePort } = new MessageChannel();
+                context.messagePorts.add(returnValueRemotePort);
+                const callContext = recursiveBox([
+                    returnValueRemotePort,
+                    args
+                ], context);
+                value.port.postMessage(callContext, getTransferableObjects(callContext));
+                returnValueLocalPort.addEventListener("message", ({ data })=>{
+                    if (!isRevivablePromiseBox(data)) throw new Error(`Proxied function did not return a promise`);
+                    const result = recursiveRevive(data, context);
+                    result.then(resolve).catch(reject).finally(()=>returnValueLocalPort.close());
+                });
+                returnValueLocalPort.start();
+            });
+        return func;
+    };
+    const boxTypedArray = (value, context)=>{
+        return {
+            type: "typedArray",
+            typedArrayType: typedArrayToType(value),
+            arrayBuffer: value.buffer
+        };
+    };
+    const reviveTypedArray = (value, context)=>{
+        const TypedArrayConstructor = typedArrayTypeToTypedArrayConstructor(value.typedArrayType);
+        const result = new TypedArrayConstructor(value.arrayBuffer);
+        return result;
+    };
+    const boxArrayBuffer = (value, context)=>{
+        return {
+            type: "arrayBuffer",
+            base64Buffer: new Uint8Array(value).toBase64()
+        };
+    };
+    const reviveArrayBuffer = (value, context)=>{
+        return Uint8Array.fromBase64(value.base64Buffer).buffer;
+    };
+    const boxError = (value, context)=>{
+        return {
+            type: "error",
+            message: value.message,
+            stack: value.stack || value.toString()
+        };
+    };
+    const reviveError = (value, context)=>{
+        return new Error(value.message, {
+            cause: value.stack
+        });
+    };
+    const boxReadableStream = (value, context)=>{
+        const { port1: localPort, port2: remotePort } = new MessageChannel();
+        context.messagePorts.add(remotePort);
+        const reader = value.getReader();
+        localPort.addEventListener("message", async ({ data })=>{
+            const { type } = recursiveRevive(data, context);
+            if (type === "pull") {
+                const pullResult = reader.read();
+                const boxedResult = recursiveBox(pullResult, context);
+                localPort.postMessage(boxedResult, getTransferableObjects(boxedResult));
+            } else {
+                reader.cancel();
+                localPort.close();
+            }
+        });
+        localPort.start();
+        return {
+            type: "readableStream",
+            port: remotePort
+        };
+    };
+    const reviveReadableStream = (value, context)=>{
+        context.messagePorts.add(value.port);
+        value.port.start();
+        return new ReadableStream({
+            start (controller) {},
+            pull (controller) {
+                return new Promise((resolve, reject)=>{
+                    value.port.addEventListener("message", async ({ data })=>{
+                        if (!isRevivablePromiseBox(data)) throw new Error(`Proxied function did not return a promise`);
+                        const result = recursiveRevive(data, context);
+                        result.then((result2)=>{
+                            if (result2.done) controller.close();
+                            else controller.enqueue(result2.value);
+                            resolve();
+                        }).catch(reject);
+                    }, {
+                        once: true
+                    });
+                    value.port.postMessage(recursiveBox({
+                        type: "pull"
+                    }, context));
+                });
+            },
+            cancel () {
+                value.port.postMessage(recursiveBox({
+                    type: "cancel"
+                }, context));
+                value.port.close();
+            }
+        });
+    };
+    const boxDate = (value, context)=>{
+        return {
+            type: "date",
+            ISOString: value.toISOString()
+        };
+    };
+    const reviveDate = (value, context)=>{
+        return new Date(value.ISOString);
+    };
+    const box = (value, context)=>{
+        if (isAlwaysBox(value) || isReadableStream(value) && !context.platformCapabilities.transferableStream) {
+            return {
+                [OSRA_BOX]: "revivable",
+                ...isFunction(value) ? boxFunction(value, context) : isPromise(value) ? boxPromise(value, context) : isTypedArray(value) ? boxTypedArray(value) : isReadableStream(value) ? boxReadableStream(value, context) : isDate(value) ? boxDate(value) : isError(value) ? boxError(value) : value
+            };
+        }
+        return {
+            [OSRA_BOX]: "revivable",
+            ..."isJson" in context.transport && context.transport.isJson ? isMessagePort(value) ? boxMessagePort(value, context) : isArrayBuffer(value) ? boxArrayBuffer(value) : isReadableStream(value) ? boxReadableStream(value, context) : {
+                type: "unknown",
+                value
+            } : {
+                type: isMessagePort(value) ? "messagePort" : isArrayBuffer(value) ? "arrayBuffer" : isReadableStream(value) ? "readableStream" : "unknown",
+                value
+            }
+        };
+    };
+    const recursiveBox = (value, context)=>{
+        const boxedValue = isRevivable(value) ? box(value, context) : value;
+        return Array.isArray(boxedValue) ? boxedValue.map((value2)=>recursiveBox(value2, context)) : boxedValue && typeof boxedValue === "object" && Object.getPrototypeOf(boxedValue) === Object.prototype ? Object.fromEntries(Object.entries(boxedValue).map(([key, value2])=>[
+                key,
+                isRevivableBox(boxedValue) && boxedValue.type === "messagePort" && boxedValue.value instanceof MessagePort || isRevivableBox(boxedValue) && boxedValue.type === "arrayBuffer" && boxedValue.value instanceof ArrayBuffer || isRevivableBox(boxedValue) && boxedValue.type === "readableStream" && boxedValue.value instanceof ReadableStream ? value2 : recursiveBox(value2, context)
+            ])) : boxedValue;
+    };
+    const revive = (box2, context)=>{
+        if (isRevivable(box2.value)) return box2.value;
+        return isRevivableMessagePortBox(box2) ? reviveMessagePort(box2, context) : isRevivableFunctionBox(box2) ? reviveFunction(box2, context) : isRevivablePromiseBox(box2) ? revivePromise(box2, context) : isRevivableErrorBox(box2) ? reviveError(box2) : isRevivableTypedArrayBox(box2) ? reviveTypedArray(box2) : isRevivableArrayBufferBox(box2) ? reviveArrayBuffer(box2) : isRevivableReadableStreamBox(box2) ? reviveReadableStream(box2, context) : isRevivableDateBox(box2) ? reviveDate(box2) : box2;
+    };
+    const recursiveRevive = (value, context)=>{
+        const recursedValue = isTransferable(value) ? value : Array.isArray(value) ? value.map((value2)=>recursiveRevive(value2, context)) : value && typeof value === "object" ? Object.fromEntries(Object.entries(value).map(([key, value2])=>[
+                key,
+                recursiveRevive(value2, context)
+            ])) : value;
+        return isRevivableBox(recursedValue) ? revive(recursedValue, context) : recursedValue;
+    };
+    const startBidirectionalConnection = ({ transport, value, uuid, remoteUuid, platformCapabilities, eventTarget, send, close })=>{
+        const revivableContext = {
+            platformCapabilities,
+            transport,
+            remoteUuid,
+            messagePorts: new Set(),
+            messageChannels: makeMessageChannelAllocator(),
+            sendMessage: send,
+            eventTarget
+        };
+        let initResolve;
+        const initMessage = new Promise((resolve, reject)=>{
+            initResolve = resolve;
+        });
+        eventTarget.addEventListener("message", ({ detail })=>{
+            if (detail.type === "init") {
+                initResolve(detail);
+                return;
+            } else if (detail.type === "message") {
+                const messageChannel = revivableContext.messageChannels.getOrAlloc(detail.portId);
+                messageChannel.port2?.postMessage(detail);
+            }
+        });
+        send({
+            type: "init",
+            remoteUuid,
+            data: recursiveBox(value, revivableContext)
+        });
+        return {
+            revivableContext,
+            close: ()=>{},
+            remoteValue: initMessage.then((initMessage2)=>recursiveRevive(initMessage2.data, revivableContext))
+        };
+    };
+    const startUnidirectionalEmittingConnection = ({ value, uuid, platformCapabilities, send, close })=>{
+        return {
+            close: ()=>{},
+            remoteValueProxy: new Proxy(new Function(), {
+                apply: (target, thisArg, args)=>{},
+                get: (target, prop)=>{}
+            })
+        };
+    };
+    var e = class extends EventTarget {
+        dispatchTypedEvent(s, t) {
+            return super.dispatchEvent(t);
+        }
+    };
+    const expose = async (value, { transport: _transport, name, remoteName, key = OSRA_DEFAULT_KEY, origin = "*", unregisterSignal, platformCapabilities: _platformCapabilities, transferAll, logger })=>{
+        const transport = {
+            isJson: "isJson" in _transport && _transport.isJson !== void 0 ? _transport.isJson : isJsonOnlyTransport(_transport),
+            ...isCustomTransport(_transport) ? _transport : {
+                emit: _transport,
+                receive: _transport
+            }
+        };
+        const platformCapabilities = _platformCapabilities ?? await probePlatformCapabilities();
+        const connectionContexts = new Map();
+        let resolveRemoteValue;
+        const remoteValuePromise = new Promise((resolve)=>{
+            resolveRemoteValue = resolve;
+        });
+        let uuid = globalThis.crypto.randomUUID();
+        const sendMessage = (transport2, message)=>{
+            const transferables = getTransferableObjects(message);
+            sendOsraMessage(transport2, {
+                [OSRA_KEY]: key,
+                name,
+                uuid,
+                ...message
+            }, origin, transferables);
+        };
+        const listener = async (message, messageContext)=>{
+            if (message.uuid === uuid) return;
+            if (!isEmitTransport(transport)) {
+                throw new Error("Unidirectional receiving mode not implemented");
+            }
+            if (message.type === "announce") {
+                if (!message.remoteUuid) {
+                    sendMessage(transport, {
+                        type: "announce",
+                        remoteUuid: message.uuid
+                    });
+                    return;
+                }
+                if (message.remoteUuid !== uuid) return;
+                if (connectionContexts.has(message.uuid)) {
+                    sendMessage(transport, {
+                        type: "reject-uuid-taken",
+                        remoteUuid: message.uuid
+                    });
+                    return;
+                }
+                const eventTarget = new e();
+                const connectionContext = {
+                    type: "bidirectional",
+                    eventTarget,
+                    connection: startBidirectionalConnection({
+                        transport,
+                        value,
+                        uuid,
+                        remoteUuid: message.uuid,
+                        platformCapabilities,
+                        eventTarget,
+                        send: (message2)=>sendMessage(transport, message2),
+                        close: ()=>void connectionContexts.delete(message.uuid)
+                    })
+                };
+                connectionContexts.set(message.uuid, connectionContext);
+                connectionContext.connection.remoteValue.then((remoteValue)=>resolveRemoteValue(remoteValue));
+            } else if (message.type === "reject-uuid-taken") {
+                if (message.remoteUuid !== uuid) return;
+                uuid = globalThis.crypto.randomUUID();
+                sendMessage(transport, {
+                    type: "announce"
+                });
+            } else if (message.type === "close") {
+                if (message.remoteUuid !== uuid) return;
+                const connectionContext = connectionContexts.get(message.uuid);
+                if (!connectionContext) {
+                    console.warn(`Connection not found for remoteUuid: ${message.uuid}`);
+                    return;
+                }
+                connectionContext.connection.close();
+                connectionContexts.delete(message.uuid);
+            } else {
+                if (message.remoteUuid !== uuid) return;
+                const connection = connectionContexts.get(message.uuid);
+                if (!connection) {
+                    console.warn(`Connection not found for remoteUuid: ${message.uuid}`);
+                    return;
+                }
+                if (connection.type !== "unidirectional-emitting") {
+                    connection.eventTarget.dispatchTypedEvent("message", new CustomEvent("message", {
+                        detail: message
+                    }));
+                }
+            }
+        };
+        if (isReceiveTransport(transport)) {
+            registerOsraMessageListener({
+                listener,
+                transport,
+                remoteName,
+                key,
+                unregisterSignal
+            });
+        }
+        if (isEmitTransport(transport)) {
+            sendMessage(transport, {
+                type: "announce"
+            });
+        }
+        if (isEmitTransport(transport) && !isReceiveTransport(transport)) {
+            const { remoteValueProxy } = startUnidirectionalEmittingConnection({
+                value,
+                uuid,
+                platformCapabilities,
+                send: (message)=>sendMessage(transport, message),
+                close: ()=>connectionContexts.delete(uuid)
+            });
+            return remoteValueProxy;
+        }
+        return remoteValuePromise;
+    };
+    var __defProp = Object.defineProperty;
+    var __name = (target, value)=>__defProp(target, "name", {
+            value,
+            configurable: true
+        });
+    var __export = (target, all)=>{
+        for(var name in all)__defProp(target, name, {
+            get: all[name],
+            enumerable: true
+        });
+    };
+    var utils_exports = {};
+    __export(utils_exports, {
+        addChainableMethod: ()=>addChainableMethod,
+        addLengthGuard: ()=>addLengthGuard,
+        addMethod: ()=>addMethod,
+        addProperty: ()=>addProperty,
+        checkError: ()=>check_error_exports,
+        compareByInspect: ()=>compareByInspect,
+        eql: ()=>deep_eql_default,
+        expectTypes: ()=>expectTypes,
+        flag: ()=>flag,
+        getActual: ()=>getActual,
+        getMessage: ()=>getMessage2,
+        getName: ()=>getName,
+        getOperator: ()=>getOperator,
+        getOwnEnumerableProperties: ()=>getOwnEnumerableProperties,
+        getOwnEnumerablePropertySymbols: ()=>getOwnEnumerablePropertySymbols,
+        getPathInfo: ()=>getPathInfo,
+        hasProperty: ()=>hasProperty,
+        inspect: ()=>inspect2,
+        isNaN: ()=>isNaN2,
+        isNumeric: ()=>isNumeric,
+        isProxyEnabled: ()=>isProxyEnabled,
+        isRegExp: ()=>isRegExp2,
+        objDisplay: ()=>objDisplay,
+        overwriteChainableMethod: ()=>overwriteChainableMethod,
+        overwriteMethod: ()=>overwriteMethod,
+        overwriteProperty: ()=>overwriteProperty,
+        proxify: ()=>proxify,
+        test: ()=>test,
+        transferFlags: ()=>transferFlags,
+        type: ()=>type
+    });
+    var check_error_exports = {};
+    __export(check_error_exports, {
+        compatibleConstructor: ()=>compatibleConstructor$1,
+        compatibleInstance: ()=>compatibleInstance$1,
+        compatibleMessage: ()=>compatibleMessage$1,
+        getConstructorName: ()=>getConstructorName$1,
+        getMessage: ()=>getMessage$1
+    });
+    function isErrorInstance$1(obj) {
+        return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]";
+    }
+    __name(isErrorInstance$1, "isErrorInstance");
+    function isRegExp$1(obj) {
+        return Object.prototype.toString.call(obj) === "[object RegExp]";
+    }
+    __name(isRegExp$1, "isRegExp");
+    function compatibleInstance$1(thrown, errorLike) {
+        return isErrorInstance$1(errorLike) && thrown === errorLike;
+    }
+    __name(compatibleInstance$1, "compatibleInstance");
+    function compatibleConstructor$1(thrown, errorLike) {
+        if (isErrorInstance$1(errorLike)) {
+            return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
+        } else if ((typeof errorLike === "object" || typeof errorLike === "function") && errorLike.prototype) {
+            return thrown.constructor === errorLike || thrown instanceof errorLike;
+        }
+        return false;
+    }
+    __name(compatibleConstructor$1, "compatibleConstructor");
+    function compatibleMessage$1(thrown, errMatcher) {
+        const comparisonString = typeof thrown === "string" ? thrown : thrown.message;
+        if (isRegExp$1(errMatcher)) {
+            return errMatcher.test(comparisonString);
+        } else if (typeof errMatcher === "string") {
+            return comparisonString.indexOf(errMatcher) !== -1;
+        }
+        return false;
+    }
+    __name(compatibleMessage$1, "compatibleMessage");
+    function getConstructorName$1(errorLike) {
+        let constructorName = errorLike;
+        if (isErrorInstance$1(errorLike)) {
+            constructorName = errorLike.constructor.name;
+        } else if (typeof errorLike === "function") {
+            constructorName = errorLike.name;
+            if (constructorName === "") {
+                const newConstructorName = new errorLike().name;
+                constructorName = newConstructorName || constructorName;
+            }
+        }
+        return constructorName;
+    }
+    __name(getConstructorName$1, "getConstructorName");
+    function getMessage$1(errorLike) {
+        let msg = "";
+        if (errorLike && errorLike.message) {
+            msg = errorLike.message;
+        } else if (typeof errorLike === "string") {
+            msg = errorLike;
+        }
+        return msg;
+    }
+    __name(getMessage$1, "getMessage");
+    function flag(obj, key, value) {
+        let flags = obj.__flags || (obj.__flags = Object.create(null));
+        if (arguments.length === 3) {
+            flags[key] = value;
+        } else {
+            return flags[key];
+        }
+    }
+    __name(flag, "flag");
+    function test(obj, args) {
+        let negate = flag(obj, "negate"), expr = args[0];
+        return negate ? !expr : expr;
+    }
+    __name(test, "test");
+    function type(obj) {
+        if (typeof obj === "undefined") {
+            return "undefined";
+        }
+        if (obj === null) {
+            return "null";
+        }
+        const stringTag = obj[Symbol.toStringTag];
+        if (typeof stringTag === "string") {
+            return stringTag;
+        }
+        const type3 = Object.prototype.toString.call(obj).slice(8, -1);
+        return type3;
+    }
+    __name(type, "type");
+    var canElideFrames = "captureStackTrace" in Error;
+    var AssertionError = class _AssertionError extends Error {
+        static{
+            __name(this, "AssertionError");
+        }
+        message;
+        get name() {
+            return "AssertionError";
+        }
+        get ok() {
+            return false;
+        }
+        constructor(message = "Unspecified AssertionError", props, ssf){
+            super(message);
+            this.message = message;
+            if (canElideFrames) {
+                Error.captureStackTrace(this, ssf || _AssertionError);
+            }
+            for(const key in props){
+                if (!(key in this)) {
+                    this[key] = props[key];
+                }
+            }
+        }
+        toJSON(stack) {
+            return {
+                ...this,
+                name: this.name,
+                message: this.message,
+                ok: false,
+                stack: stack !== false ? this.stack : void 0
+            };
+        }
+    };
+    function expectTypes(obj, types) {
+        let flagMsg = flag(obj, "message");
+        let ssfi = flag(obj, "ssfi");
+        flagMsg = flagMsg ? flagMsg + ": " : "";
+        obj = flag(obj, "object");
+        types = types.map(function(t) {
+            return t.toLowerCase();
+        });
+        types.sort();
+        let str = types.map(function(t, index) {
+            let art = ~[
+                "a",
+                "e",
+                "i",
+                "o",
+                "u"
+            ].indexOf(t.charAt(0)) ? "an" : "a";
+            let or = types.length > 1 && index === types.length - 1 ? "or " : "";
+            return or + art + " " + t;
+        }).join(", ");
+        let objType = type(obj).toLowerCase();
+        if (!types.some(function(expected) {
+            return objType === expected;
+        })) {
+            throw new AssertionError(flagMsg + "object tested must be " + str + ", but " + objType + " given", void 0, ssfi);
+        }
+    }
+    __name(expectTypes, "expectTypes");
+    function getActual(obj, args) {
+        return args.length > 4 ? args[4] : obj._obj;
+    }
+    __name(getActual, "getActual");
+    var ansiColors = {
+        bold: [
+            "1",
+            "22"
+        ],
+        dim: [
+            "2",
+            "22"
+        ],
+        italic: [
+            "3",
+            "23"
+        ],
+        underline: [
+            "4",
+            "24"
+        ],
+        inverse: [
+            "7",
+            "27"
+        ],
+        hidden: [
+            "8",
+            "28"
+        ],
+        strike: [
+            "9",
+            "29"
+        ],
+        black: [
+            "30",
+            "39"
+        ],
+        red: [
+            "31",
+            "39"
+        ],
+        green: [
+            "32",
+            "39"
+        ],
+        yellow: [
+            "33",
+            "39"
+        ],
+        blue: [
+            "34",
+            "39"
+        ],
+        magenta: [
+            "35",
+            "39"
+        ],
+        cyan: [
+            "36",
+            "39"
+        ],
+        white: [
+            "37",
+            "39"
+        ],
+        brightblack: [
+            "30;1",
+            "39"
+        ],
+        brightred: [
+            "31;1",
+            "39"
+        ],
+        brightgreen: [
+            "32;1",
+            "39"
+        ],
+        brightyellow: [
+            "33;1",
+            "39"
+        ],
+        brightblue: [
+            "34;1",
+            "39"
+        ],
+        brightmagenta: [
+            "35;1",
+            "39"
+        ],
+        brightcyan: [
+            "36;1",
+            "39"
+        ],
+        brightwhite: [
+            "37;1",
+            "39"
+        ],
+        grey: [
+            "90",
+            "39"
+        ]
+    };
+    var styles = {
+        special: "cyan",
+        number: "yellow",
+        bigint: "yellow",
+        boolean: "yellow",
+        undefined: "grey",
+        null: "bold",
+        string: "green",
+        symbol: "green",
+        date: "magenta",
+        regexp: "red"
+    };
+    var truncator = "\u2026";
+    function colorise(value, styleType) {
+        const color = ansiColors[styles[styleType]] || ansiColors[styleType] || "";
+        if (!color) {
+            return String(value);
+        }
+        return `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m`;
+    }
+    __name(colorise, "colorise");
+    function normaliseOptions({ showHidden = false, depth = 2, colors = false, customInspect = true, showProxy = false, maxArrayLength = Infinity, breakLength = Infinity, seen = [], truncate: truncate2 = Infinity, stylize = String } = {}, inspect3) {
+        const options = {
+            showHidden: Boolean(showHidden),
+            depth: Number(depth),
+            colors: Boolean(colors),
+            customInspect: Boolean(customInspect),
+            showProxy: Boolean(showProxy),
+            maxArrayLength: Number(maxArrayLength),
+            breakLength: Number(breakLength),
+            truncate: Number(truncate2),
+            seen,
+            inspect: inspect3,
+            stylize
+        };
+        if (options.colors) {
+            options.stylize = colorise;
+        }
+        return options;
+    }
+    __name(normaliseOptions, "normaliseOptions");
+    function isHighSurrogate(char) {
+        return char >= "\uD800" && char <= "\uDBFF";
+    }
+    __name(isHighSurrogate, "isHighSurrogate");
+    function truncate(string, length, tail = truncator) {
+        string = String(string);
+        const tailLength = tail.length;
+        const stringLength = string.length;
+        if (tailLength > length && stringLength > tailLength) {
+            return tail;
+        }
+        if (stringLength > length && stringLength > tailLength) {
+            let end = length - tailLength;
+            if (end > 0 && isHighSurrogate(string[end - 1])) {
+                end = end - 1;
+            }
+            return `${string.slice(0, end)}${tail}`;
+        }
+        return string;
+    }
+    __name(truncate, "truncate");
+    function inspectList(list, options, inspectItem, separator = ", ") {
+        inspectItem = inspectItem || options.inspect;
+        const size = list.length;
+        if (size === 0) return "";
+        const originalLength = options.truncate;
+        let output = "";
+        let peek = "";
+        let truncated = "";
+        for(let i = 0; i < size; i += 1){
+            const last = i + 1 === list.length;
+            const secondToLast = i + 2 === list.length;
+            truncated = `${truncator}(${list.length - i})`;
+            const value = list[i];
+            options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+            const string = peek || inspectItem(value, options) + (last ? "" : separator);
+            const nextLength = output.length + string.length;
+            const truncatedLength = nextLength + truncated.length;
+            if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+                break;
+            }
+            if (!last && !secondToLast && truncatedLength > originalLength) {
+                break;
+            }
+            peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator);
+            if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
+                break;
+            }
+            output += string;
+            if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+                truncated = `${truncator}(${list.length - i - 1})`;
+                break;
+            }
+            truncated = "";
+        }
+        return `${output}${truncated}`;
+    }
+    __name(inspectList, "inspectList");
+    function quoteComplexKey(key) {
+        if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
+            return key;
+        }
+        return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+    }
+    __name(quoteComplexKey, "quoteComplexKey");
+    function inspectProperty([key, value], options) {
+        options.truncate -= 2;
+        if (typeof key === "string") {
+            key = quoteComplexKey(key);
+        } else if (typeof key !== "number") {
+            key = `[${options.inspect(key, options)}]`;
+        }
+        options.truncate -= key.length;
+        value = options.inspect(value, options);
+        return `${key}: ${value}`;
+    }
+    __name(inspectProperty, "inspectProperty");
+    function inspectArray(array, options) {
+        const nonIndexProperties = Object.keys(array).slice(array.length);
+        if (!array.length && !nonIndexProperties.length) return "[]";
+        options.truncate -= 4;
+        const listContents = inspectList(array, options);
+        options.truncate -= listContents.length;
+        let propertyContents = "";
+        if (nonIndexProperties.length) {
+            propertyContents = inspectList(nonIndexProperties.map((key)=>[
+                    key,
+                    array[key]
+                ]), options, inspectProperty);
+        }
+        return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+    }
+    __name(inspectArray, "inspectArray");
+    var getArrayName = __name((array)=>{
+        if (typeof Buffer === "function" && array instanceof Buffer) {
+            return "Buffer";
+        }
+        if (array[Symbol.toStringTag]) {
+            return array[Symbol.toStringTag];
+        }
+        return array.constructor.name;
+    }, "getArrayName");
+    function inspectTypedArray(array, options) {
+        const name = getArrayName(array);
+        options.truncate -= name.length + 4;
+        const nonIndexProperties = Object.keys(array).slice(array.length);
+        if (!array.length && !nonIndexProperties.length) return `${name}[]`;
+        let output = "";
+        for(let i = 0; i < array.length; i++){
+            const string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;
+            options.truncate -= string.length;
+            if (array[i] !== array.length && options.truncate <= 3) {
+                output += `${truncator}(${array.length - array[i] + 1})`;
+                break;
+            }
+            output += string;
+        }
+        let propertyContents = "";
+        if (nonIndexProperties.length) {
+            propertyContents = inspectList(nonIndexProperties.map((key)=>[
+                    key,
+                    array[key]
+                ]), options, inspectProperty);
+        }
+        return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+    }
+    __name(inspectTypedArray, "inspectTypedArray");
+    function inspectDate(dateObject, options) {
+        const stringRepresentation = dateObject.toJSON();
+        if (stringRepresentation === null) {
+            return "Invalid Date";
+        }
+        const split = stringRepresentation.split("T");
+        const date = split[0];
+        return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
+    }
+    __name(inspectDate, "inspectDate");
+    function inspectFunction(func, options) {
+        const functionType = func[Symbol.toStringTag] || "Function";
+        const name = func.name;
+        if (!name) {
+            return options.stylize(`[${functionType}]`, "special");
+        }
+        return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
+    }
+    __name(inspectFunction, "inspectFunction");
+    function inspectMapEntry([key, value], options) {
+        options.truncate -= 4;
+        key = options.inspect(key, options);
+        options.truncate -= key.length;
+        value = options.inspect(value, options);
+        return `${key} => ${value}`;
+    }
+    __name(inspectMapEntry, "inspectMapEntry");
+    function mapToEntries(map) {
+        const entries = [];
+        map.forEach((value, key)=>{
+            entries.push([
+                key,
+                value
+            ]);
+        });
+        return entries;
+    }
+    __name(mapToEntries, "mapToEntries");
+    function inspectMap(map, options) {
+        if (map.size === 0) return "Map{}";
+        options.truncate -= 7;
+        return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+    }
+    __name(inspectMap, "inspectMap");
+    var isNaN = Number.isNaN || ((i)=>i !== i);
+    function inspectNumber(number, options) {
+        if (isNaN(number)) {
+            return options.stylize("NaN", "number");
+        }
+        if (number === Infinity) {
+            return options.stylize("Infinity", "number");
+        }
+        if (number === -Infinity) {
+            return options.stylize("-Infinity", "number");
+        }
+        if (number === 0) {
+            return options.stylize(1 / number === Infinity ? "+0" : "-0", "number");
+        }
+        return options.stylize(truncate(String(number), options.truncate), "number");
+    }
+    __name(inspectNumber, "inspectNumber");
+    function inspectBigInt(number, options) {
+        let nums = truncate(number.toString(), options.truncate - 1);
+        if (nums !== truncator) nums += "n";
+        return options.stylize(nums, "bigint");
+    }
+    __name(inspectBigInt, "inspectBigInt");
+    function inspectRegExp(value, options) {
+        const flags = value.toString().split("/")[2];
+        const sourceLength = options.truncate - (2 + flags.length);
+        const source = value.source;
+        return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
+    }
+    __name(inspectRegExp, "inspectRegExp");
+    function arrayFromSet(set2) {
+        const values = [];
+        set2.forEach((value)=>{
+            values.push(value);
+        });
+        return values;
+    }
+    __name(arrayFromSet, "arrayFromSet");
+    function inspectSet(set2, options) {
+        if (set2.size === 0) return "Set{}";
+        options.truncate -= 7;
+        return `Set{ ${inspectList(arrayFromSet(set2), options)} }`;
+    }
+    __name(inspectSet, "inspectSet");
+    var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
+    var escapeCharacters = {
+        "\b": "\\b",
+        "	": "\\t",
+        "\n": "\\n",
+        "\f": "\\f",
+        "\r": "\\r",
+        "'": "\\'",
+        "\\": "\\\\"
+    };
+    var hex = 16;
+    function escape(char) {
+        return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-4)}`;
+    }
+    __name(escape, "escape");
+    function inspectString(string, options) {
+        if (stringEscapeChars.test(string)) {
+            string = string.replace(stringEscapeChars, escape);
+        }
+        return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
+    }
+    __name(inspectString, "inspectString");
+    function inspectSymbol(value) {
+        if ("description" in Symbol.prototype) {
+            return value.description ? `Symbol(${value.description})` : "Symbol()";
+        }
+        return value.toString();
+    }
+    __name(inspectSymbol, "inspectSymbol");
+    var getPromiseValue = __name(()=>"Promise{\u2026}", "getPromiseValue");
+    var promise_default = getPromiseValue;
+    function inspectObject(object, options) {
+        const properties = Object.getOwnPropertyNames(object);
+        const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+        if (properties.length === 0 && symbols.length === 0) {
+            return "{}";
+        }
+        options.truncate -= 4;
+        options.seen = options.seen || [];
+        if (options.seen.includes(object)) {
+            return "[Circular]";
+        }
+        options.seen.push(object);
+        const propertyContents = inspectList(properties.map((key)=>[
+                key,
+                object[key]
+            ]), options, inspectProperty);
+        const symbolContents = inspectList(symbols.map((key)=>[
+                key,
+                object[key]
+            ]), options, inspectProperty);
+        options.seen.pop();
+        let sep = "";
+        if (propertyContents && symbolContents) {
+            sep = ", ";
+        }
+        return `{ ${propertyContents}${sep}${symbolContents} }`;
+    }
+    __name(inspectObject, "inspectObject");
+    var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;
+    function inspectClass(value, options) {
+        let name = "";
+        if (toStringTag && toStringTag in value) {
+            name = value[toStringTag];
+        }
+        name = name || value.constructor.name;
+        if (!name || name === "_class") {
+            name = "<Anonymous Class>";
+        }
+        options.truncate -= name.length;
+        return `${name}${inspectObject(value, options)}`;
+    }
+    __name(inspectClass, "inspectClass");
+    function inspectArguments(args, options) {
+        if (args.length === 0) return "Arguments[]";
+        options.truncate -= 13;
+        return `Arguments[ ${inspectList(args, options)} ]`;
+    }
+    __name(inspectArguments, "inspectArguments");
+    var errorKeys = [
+        "stack",
+        "line",
+        "column",
+        "name",
+        "message",
+        "fileName",
+        "lineNumber",
+        "columnNumber",
+        "number",
+        "description",
+        "cause"
+    ];
+    function inspectObject2(error, options) {
+        const properties = Object.getOwnPropertyNames(error).filter((key)=>errorKeys.indexOf(key) === -1);
+        const name = error.name;
+        options.truncate -= name.length;
+        let message = "";
+        if (typeof error.message === "string") {
+            message = truncate(error.message, options.truncate);
+        } else {
+            properties.unshift("message");
+        }
+        message = message ? `: ${message}` : "";
+        options.truncate -= message.length + 5;
+        options.seen = options.seen || [];
+        if (options.seen.includes(error)) {
+            return "[Circular]";
+        }
+        options.seen.push(error);
+        const propertyContents = inspectList(properties.map((key)=>[
+                key,
+                error[key]
+            ]), options, inspectProperty);
+        return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
+    }
+    __name(inspectObject2, "inspectObject");
+    function inspectAttribute([key, value], options) {
+        options.truncate -= 3;
+        if (!value) {
+            return `${options.stylize(String(key), "yellow")}`;
+        }
+        return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
+    }
+    __name(inspectAttribute, "inspectAttribute");
+    function inspectNodeCollection(collection, options) {
+        return inspectList(collection, options, inspectNode, "\n");
+    }
+    __name(inspectNodeCollection, "inspectNodeCollection");
+    function inspectNode(node, options) {
+        switch(node.nodeType){
+            case 1:
+                return inspectHTML(node, options);
+            case 3:
+                return options.inspect(node.data, options);
+            default:
+                return options.inspect(node, options);
+        }
+    }
+    __name(inspectNode, "inspectNode");
+    function inspectHTML(element, options) {
+        const properties = element.getAttributeNames();
+        const name = element.tagName.toLowerCase();
+        const head = options.stylize(`<${name}`, "special");
+        const headClose = options.stylize(`>`, "special");
+        const tail = options.stylize(`</${name}>`, "special");
+        options.truncate -= name.length * 2 + 5;
+        let propertyContents = "";
+        if (properties.length > 0) {
+            propertyContents += " ";
+            propertyContents += inspectList(properties.map((key)=>[
+                    key,
+                    element.getAttribute(key)
+                ]), options, inspectAttribute, " ");
+        }
+        options.truncate -= propertyContents.length;
+        const truncate2 = options.truncate;
+        let children = inspectNodeCollection(element.children, options);
+        if (children && children.length > truncate2) {
+            children = `${truncator}(${element.children.length})`;
+        }
+        return `${head}${propertyContents}${headClose}${children}${tail}`;
+    }
+    __name(inspectHTML, "inspectHTML");
+    var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
+    var chaiInspect = symbolsSupported ? Symbol.for("chai/inspect") : "@@chai/inspect";
+    var nodeInspect = Symbol.for("nodejs.util.inspect.custom");
+    var constructorMap = new WeakMap();
+    var stringTagMap = {};
+    var baseTypesMap = {
+        undefined: __name((value, options)=>options.stylize("undefined", "undefined"), "undefined"),
+        null: __name((value, options)=>options.stylize("null", "null"), "null"),
+        boolean: __name((value, options)=>options.stylize(String(value), "boolean"), "boolean"),
+        Boolean: __name((value, options)=>options.stylize(String(value), "boolean"), "Boolean"),
+        number: inspectNumber,
+        Number: inspectNumber,
+        bigint: inspectBigInt,
+        BigInt: inspectBigInt,
+        string: inspectString,
+        String: inspectString,
+        function: inspectFunction,
+        Function: inspectFunction,
+        symbol: inspectSymbol,
+        Symbol: inspectSymbol,
+        Array: inspectArray,
+        Date: inspectDate,
+        Map: inspectMap,
+        Set: inspectSet,
+        RegExp: inspectRegExp,
+        Promise: promise_default,
+        WeakSet: __name((value, options)=>options.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
+        WeakMap: __name((value, options)=>options.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
+        Arguments: inspectArguments,
+        Int8Array: inspectTypedArray,
+        Uint8Array: inspectTypedArray,
+        Uint8ClampedArray: inspectTypedArray,
+        Int16Array: inspectTypedArray,
+        Uint16Array: inspectTypedArray,
+        Int32Array: inspectTypedArray,
+        Uint32Array: inspectTypedArray,
+        Float32Array: inspectTypedArray,
+        Float64Array: inspectTypedArray,
+        Generator: __name(()=>"", "Generator"),
+        DataView: __name(()=>"", "DataView"),
+        ArrayBuffer: __name(()=>"", "ArrayBuffer"),
+        Error: inspectObject2,
+        HTMLCollection: inspectNodeCollection,
+        NodeList: inspectNodeCollection
+    };
+    var inspectCustom = __name((value, options, type3)=>{
+        if (chaiInspect in value && typeof value[chaiInspect] === "function") {
+            return value[chaiInspect](options);
+        }
+        if (nodeInspect in value && typeof value[nodeInspect] === "function") {
+            return value[nodeInspect](options.depth, options);
+        }
+        if ("inspect" in value && typeof value.inspect === "function") {
+            return value.inspect(options.depth, options);
+        }
+        if ("constructor" in value && constructorMap.has(value.constructor)) {
+            return constructorMap.get(value.constructor)(value, options);
+        }
+        if (stringTagMap[type3]) {
+            return stringTagMap[type3](value, options);
+        }
+        return "";
+    }, "inspectCustom");
+    var toString = Object.prototype.toString;
+    function inspect(value, opts = {}) {
+        const options = normaliseOptions(opts, inspect);
+        const { customInspect } = options;
+        let type3 = value === null ? "null" : typeof value;
+        if (type3 === "object") {
+            type3 = toString.call(value).slice(8, -1);
+        }
+        if (type3 in baseTypesMap) {
+            return baseTypesMap[type3](value, options);
+        }
+        if (customInspect && value) {
+            const output = inspectCustom(value, options, type3);
+            if (output) {
+                if (typeof output === "string") return output;
+                return inspect(output, options);
+            }
+        }
+        const proto = value ? Object.getPrototypeOf(value) : false;
+        if (proto === Object.prototype || proto === null) {
+            return inspectObject(value, options);
+        }
+        if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) {
+            return inspectHTML(value, options);
+        }
+        if ("constructor" in value) {
+            if (value.constructor !== Object) {
+                return inspectClass(value, options);
+            }
+            return inspectObject(value, options);
+        }
+        if (value === Object(value)) {
+            return inspectObject(value, options);
+        }
+        return options.stylize(String(value), type3);
+    }
+    __name(inspect, "inspect");
+    var config = {
+        includeStack: false,
+        showDiff: true,
+        truncateThreshold: 40,
+        useProxy: true,
+        proxyExcludedKeys: [
+            "then",
+            "catch",
+            "inspect",
+            "toJSON"
+        ],
+        deepEqual: null
+    };
+    function inspect2(obj, showHidden, depth, colors) {
+        let options = {
+            colors,
+            depth: typeof depth === "undefined" ? 2 : depth,
+            showHidden,
+            truncate: config.truncateThreshold ? config.truncateThreshold : Infinity
+        };
+        return inspect(obj, options);
+    }
+    __name(inspect2, "inspect");
+    function objDisplay(obj) {
+        let str = inspect2(obj), type3 = Object.prototype.toString.call(obj);
+        if (config.truncateThreshold && str.length >= config.truncateThreshold) {
+            if (type3 === "[object Function]") {
+                return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]";
+            } else if (type3 === "[object Array]") {
+                return "[ Array(" + obj.length + ") ]";
+            } else if (type3 === "[object Object]") {
+                let keys = Object.keys(obj), kstr = keys.length > 2 ? keys.splice(0, 2).join(", ") + ", ..." : keys.join(", ");
+                return "{ Object (" + kstr + ") }";
+            } else {
+                return str;
+            }
+        } else {
+            return str;
+        }
+    }
+    __name(objDisplay, "objDisplay");
+    function getMessage2(obj, args) {
+        let negate = flag(obj, "negate");
+        let val = flag(obj, "object");
+        let expected = args[3];
+        let actual = getActual(obj, args);
+        let msg = negate ? args[2] : args[1];
+        let flagMsg = flag(obj, "message");
+        if (typeof msg === "function") msg = msg();
+        msg = msg || "";
+        msg = msg.replace(/#\{this\}/g, function() {
+            return objDisplay(val);
+        }).replace(/#\{act\}/g, function() {
+            return objDisplay(actual);
+        }).replace(/#\{exp\}/g, function() {
+            return objDisplay(expected);
+        });
+        return flagMsg ? flagMsg + ": " + msg : msg;
+    }
+    __name(getMessage2, "getMessage");
+    function transferFlags(assertion, object, includeAll) {
+        let flags = assertion.__flags || (assertion.__flags = Object.create(null));
+        if (!object.__flags) {
+            object.__flags = Object.create(null);
+        }
+        includeAll = arguments.length === 3 ? includeAll : true;
+        for(let flag3 in flags){
+            if (includeAll || flag3 !== "object" && flag3 !== "ssfi" && flag3 !== "lockSsfi" && flag3 != "message") {
+                object.__flags[flag3] = flags[flag3];
+            }
+        }
+    }
+    __name(transferFlags, "transferFlags");
+    function type2(obj) {
+        if (typeof obj === "undefined") {
+            return "undefined";
+        }
+        if (obj === null) {
+            return "null";
+        }
+        const stringTag = obj[Symbol.toStringTag];
+        if (typeof stringTag === "string") {
+            return stringTag;
+        }
+        const sliceStart = 8;
+        const sliceEnd = -1;
+        return Object.prototype.toString.call(obj).slice(sliceStart, sliceEnd);
+    }
+    __name(type2, "type");
+    function FakeMap() {
+        this._key = "chai/deep-eql__" + Math.random() + Date.now();
+    }
+    __name(FakeMap, "FakeMap");
+    FakeMap.prototype = {
+        get: __name(function get(key) {
+            return key[this._key];
+        }, "get"),
+        set: __name(function set(key, value) {
+            if (Object.isExtensible(key)) {
+                Object.defineProperty(key, this._key, {
+                    value,
+                    configurable: true
+                });
+            }
+        }, "set")
+    };
+    var MemoizeMap = typeof WeakMap === "function" ? WeakMap : FakeMap;
+    function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) {
+        if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
+            return null;
+        }
+        var leftHandMap = memoizeMap.get(leftHandOperand);
+        if (leftHandMap) {
+            var result = leftHandMap.get(rightHandOperand);
+            if (typeof result === "boolean") {
+                return result;
+            }
+        }
+        return null;
+    }
+    __name(memoizeCompare, "memoizeCompare");
+    function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) {
+        if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
+            return;
+        }
+        var leftHandMap = memoizeMap.get(leftHandOperand);
+        if (leftHandMap) {
+            leftHandMap.set(rightHandOperand, result);
+        } else {
+            leftHandMap = new MemoizeMap();
+            leftHandMap.set(rightHandOperand, result);
+            memoizeMap.set(leftHandOperand, leftHandMap);
+        }
+    }
+    __name(memoizeSet, "memoizeSet");
+    var deep_eql_default = deepEqual;
+    function deepEqual(leftHandOperand, rightHandOperand, options) {
+        if (options && options.comparator) {
+            return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);
+        }
+        var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);
+        if (simpleResult !== null) {
+            return simpleResult;
+        }
+        return extensiveDeepEqual(leftHandOperand, rightHandOperand, options);
+    }
+    __name(deepEqual, "deepEqual");
+    function simpleEqual(leftHandOperand, rightHandOperand) {
+        if (leftHandOperand === rightHandOperand) {
+            return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand;
+        }
+        if (leftHandOperand !== leftHandOperand && rightHandOperand !== rightHandOperand) {
+            return true;
+        }
+        if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) {
+            return false;
+        }
+        return null;
+    }
+    __name(simpleEqual, "simpleEqual");
+    function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) {
+        options = options || {};
+        options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap();
+        var comparator = options && options.comparator;
+        var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize);
+        if (memoizeResultLeft !== null) {
+            return memoizeResultLeft;
+        }
+        var memoizeResultRight = memoizeCompare(rightHandOperand, leftHandOperand, options.memoize);
+        if (memoizeResultRight !== null) {
+            return memoizeResultRight;
+        }
+        if (comparator) {
+            var comparatorResult = comparator(leftHandOperand, rightHandOperand);
+            if (comparatorResult === false || comparatorResult === true) {
+                memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult);
+                return comparatorResult;
+            }
+            var simpleResult = simpleEqual(leftHandOperand, rightHandOperand);
+            if (simpleResult !== null) {
+                return simpleResult;
+            }
+        }
+        var leftHandType = type2(leftHandOperand);
+        if (leftHandType !== type2(rightHandOperand)) {
+            memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false);
+            return false;
+        }
+        memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true);
+        var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options);
+        memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result);
+        return result;
+    }
+    __name(extensiveDeepEqual, "extensiveDeepEqual");
+    function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) {
+        switch(leftHandType){
+            case "String":
+            case "Number":
+            case "Boolean":
+            case "Date":
+                return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf());
+            case "Promise":
+            case "Symbol":
+            case "function":
+            case "WeakMap":
+            case "WeakSet":
+                return leftHandOperand === rightHandOperand;
+            case "Error":
+                return keysEqual(leftHandOperand, rightHandOperand, [
+                    "name",
+                    "message",
+                    "code"
+                ], options);
+            case "Arguments":
+            case "Int8Array":
+            case "Uint8Array":
+            case "Uint8ClampedArray":
+            case "Int16Array":
+            case "Uint16Array":
+            case "Int32Array":
+            case "Uint32Array":
+            case "Float32Array":
+            case "Float64Array":
+            case "Array":
+                return iterableEqual(leftHandOperand, rightHandOperand, options);
+            case "RegExp":
+                return regexpEqual(leftHandOperand, rightHandOperand);
+            case "Generator":
+                return generatorEqual(leftHandOperand, rightHandOperand, options);
+            case "DataView":
+                return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options);
+            case "ArrayBuffer":
+                return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options);
+            case "Set":
+                return entriesEqual(leftHandOperand, rightHandOperand, options);
+            case "Map":
+                return entriesEqual(leftHandOperand, rightHandOperand, options);
+            case "Temporal.PlainDate":
+            case "Temporal.PlainTime":
+            case "Temporal.PlainDateTime":
+            case "Temporal.Instant":
+            case "Temporal.ZonedDateTime":
+            case "Temporal.PlainYearMonth":
+            case "Temporal.PlainMonthDay":
+                return leftHandOperand.equals(rightHandOperand);
+            case "Temporal.Duration":
+                return leftHandOperand.total("nanoseconds") === rightHandOperand.total("nanoseconds");
+            case "Temporal.TimeZone":
+            case "Temporal.Calendar":
+                return leftHandOperand.toString() === rightHandOperand.toString();
+            default:
+                return objectEqual(leftHandOperand, rightHandOperand, options);
+        }
+    }
+    __name(extensiveDeepEqualByType, "extensiveDeepEqualByType");
+    function regexpEqual(leftHandOperand, rightHandOperand) {
+        return leftHandOperand.toString() === rightHandOperand.toString();
+    }
+    __name(regexpEqual, "regexpEqual");
+    function entriesEqual(leftHandOperand, rightHandOperand, options) {
+        try {
+            if (leftHandOperand.size !== rightHandOperand.size) {
+                return false;
+            }
+            if (leftHandOperand.size === 0) {
+                return true;
+            }
+        } catch (sizeError) {
+            return false;
+        }
+        var leftHandItems = [];
+        var rightHandItems = [];
+        leftHandOperand.forEach(__name(function gatherEntries(key, value) {
+            leftHandItems.push([
+                key,
+                value
+            ]);
+        }, "gatherEntries"));
+        rightHandOperand.forEach(__name(function gatherEntries(key, value) {
+            rightHandItems.push([
+                key,
+                value
+            ]);
+        }, "gatherEntries"));
+        return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options);
+    }
+    __name(entriesEqual, "entriesEqual");
+    function iterableEqual(leftHandOperand, rightHandOperand, options) {
+        var length = leftHandOperand.length;
+        if (length !== rightHandOperand.length) {
+            return false;
+        }
+        if (length === 0) {
+            return true;
+        }
+        var index = -1;
+        while(++index < length){
+            if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+    __name(iterableEqual, "iterableEqual");
+    function generatorEqual(leftHandOperand, rightHandOperand, options) {
+        return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options);
+    }
+    __name(generatorEqual, "generatorEqual");
+    function hasIteratorFunction(target) {
+        return typeof Symbol !== "undefined" && typeof target === "object" && typeof Symbol.iterator !== "undefined" && typeof target[Symbol.iterator] === "function";
+    }
+    __name(hasIteratorFunction, "hasIteratorFunction");
+    function getIteratorEntries(target) {
+        if (hasIteratorFunction(target)) {
+            try {
+                return getGeneratorEntries(target[Symbol.iterator]());
+            } catch (iteratorError) {
+                return [];
+            }
+        }
+        return [];
+    }
+    __name(getIteratorEntries, "getIteratorEntries");
+    function getGeneratorEntries(generator) {
+        var generatorResult = generator.next();
+        var accumulator = [
+            generatorResult.value
+        ];
+        while(generatorResult.done === false){
+            generatorResult = generator.next();
+            accumulator.push(generatorResult.value);
+        }
+        return accumulator;
+    }
+    __name(getGeneratorEntries, "getGeneratorEntries");
+    function getEnumerableKeys(target) {
+        var keys = [];
+        for(var key in target){
+            keys.push(key);
+        }
+        return keys;
+    }
+    __name(getEnumerableKeys, "getEnumerableKeys");
+    function getEnumerableSymbols(target) {
+        var keys = [];
+        var allKeys = Object.getOwnPropertySymbols(target);
+        for(var i = 0; i < allKeys.length; i += 1){
+            var key = allKeys[i];
+            if (Object.getOwnPropertyDescriptor(target, key).enumerable) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
+    __name(getEnumerableSymbols, "getEnumerableSymbols");
+    function keysEqual(leftHandOperand, rightHandOperand, keys, options) {
+        var length = keys.length;
+        if (length === 0) {
+            return true;
+        }
+        for(var i = 0; i < length; i += 1){
+            if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+    __name(keysEqual, "keysEqual");
+    function objectEqual(leftHandOperand, rightHandOperand, options) {
+        var leftHandKeys = getEnumerableKeys(leftHandOperand);
+        var rightHandKeys = getEnumerableKeys(rightHandOperand);
+        var leftHandSymbols = getEnumerableSymbols(leftHandOperand);
+        var rightHandSymbols = getEnumerableSymbols(rightHandOperand);
+        leftHandKeys = leftHandKeys.concat(leftHandSymbols);
+        rightHandKeys = rightHandKeys.concat(rightHandSymbols);
+        if (leftHandKeys.length && leftHandKeys.length === rightHandKeys.length) {
+            if (iterableEqual(mapSymbols(leftHandKeys).sort(), mapSymbols(rightHandKeys).sort()) === false) {
+                return false;
+            }
+            return keysEqual(leftHandOperand, rightHandOperand, leftHandKeys, options);
+        }
+        var leftHandEntries = getIteratorEntries(leftHandOperand);
+        var rightHandEntries = getIteratorEntries(rightHandOperand);
+        if (leftHandEntries.length && leftHandEntries.length === rightHandEntries.length) {
+            leftHandEntries.sort();
+            rightHandEntries.sort();
+            return iterableEqual(leftHandEntries, rightHandEntries, options);
+        }
+        if (leftHandKeys.length === 0 && leftHandEntries.length === 0 && rightHandKeys.length === 0 && rightHandEntries.length === 0) {
+            return true;
+        }
+        return false;
+    }
+    __name(objectEqual, "objectEqual");
+    function isPrimitive(value) {
+        return value === null || typeof value !== "object";
+    }
+    __name(isPrimitive, "isPrimitive");
+    function mapSymbols(arr) {
+        return arr.map(__name(function mapSymbol(entry) {
+            if (typeof entry === "symbol") {
+                return entry.toString();
+            }
+            return entry;
+        }, "mapSymbol"));
+    }
+    __name(mapSymbols, "mapSymbols");
+    function hasProperty(obj, name) {
+        if (typeof obj === "undefined" || obj === null) {
+            return false;
+        }
+        return name in Object(obj);
+    }
+    __name(hasProperty, "hasProperty");
+    function parsePath(path) {
+        const str = path.replace(/([^\\])\[/g, "$1.[");
+        const parts = str.match(/(\\\.|[^.]+?)+/g);
+        return parts.map((value)=>{
+            if (value === "constructor" || value === "__proto__" || value === "prototype") {
+                return {};
+            }
+            const regexp = /^\[(\d+)\]$/;
+            const mArr = regexp.exec(value);
+            let parsed = null;
+            if (mArr) {
+                parsed = {
+                    i: parseFloat(mArr[1])
+                };
+            } else {
+                parsed = {
+                    p: value.replace(/\\([.[\]])/g, "$1")
+                };
+            }
+            return parsed;
+        });
+    }
+    __name(parsePath, "parsePath");
+    function internalGetPathValue(obj, parsed, pathDepth) {
+        let temporaryValue = obj;
+        let res = null;
+        pathDepth = typeof pathDepth === "undefined" ? parsed.length : pathDepth;
+        for(let i = 0; i < pathDepth; i++){
+            const part = parsed[i];
+            if (temporaryValue) {
+                if (typeof part.p === "undefined") {
+                    temporaryValue = temporaryValue[part.i];
+                } else {
+                    temporaryValue = temporaryValue[part.p];
+                }
+                if (i === pathDepth - 1) {
+                    res = temporaryValue;
+                }
+            }
+        }
+        return res;
+    }
+    __name(internalGetPathValue, "internalGetPathValue");
+    function getPathInfo(obj, path) {
+        const parsed = parsePath(path);
+        const last = parsed[parsed.length - 1];
+        const info = {
+            parent: parsed.length > 1 ? internalGetPathValue(obj, parsed, parsed.length - 1) : obj,
+            name: last.p || last.i,
+            value: internalGetPathValue(obj, parsed)
+        };
+        info.exists = hasProperty(info.parent, info.name);
+        return info;
+    }
+    __name(getPathInfo, "getPathInfo");
+    var Assertion = class _Assertion {
+        static{
+            __name(this, "Assertion");
+        }
+        __flags = {};
+        constructor(obj, msg, ssfi, lockSsfi){
+            flag(this, "ssfi", ssfi || _Assertion);
+            flag(this, "lockSsfi", lockSsfi);
+            flag(this, "object", obj);
+            flag(this, "message", msg);
+            flag(this, "eql", config.deepEqual || deep_eql_default);
+            return proxify(this);
+        }
+        static get includeStack() {
+            console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead.");
+            return config.includeStack;
+        }
+        static set includeStack(value) {
+            console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead.");
+            config.includeStack = value;
+        }
+        static get showDiff() {
+            console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead.");
+            return config.showDiff;
+        }
+        static set showDiff(value) {
+            console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead.");
+            config.showDiff = value;
+        }
+        static addProperty(name, fn) {
+            addProperty(this.prototype, name, fn);
+        }
+        static addMethod(name, fn) {
+            addMethod(this.prototype, name, fn);
+        }
+        static addChainableMethod(name, fn, chainingBehavior) {
+            addChainableMethod(this.prototype, name, fn, chainingBehavior);
+        }
+        static overwriteProperty(name, fn) {
+            overwriteProperty(this.prototype, name, fn);
+        }
+        static overwriteMethod(name, fn) {
+            overwriteMethod(this.prototype, name, fn);
+        }
+        static overwriteChainableMethod(name, fn, chainingBehavior) {
+            overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
+        }
+        assert(_expr, msg, _negateMsg, expected, _actual, showDiff) {
+            const ok = test(this, arguments);
+            if (false !== showDiff) showDiff = true;
+            if (void 0 === expected && void 0 === _actual) showDiff = false;
+            if (true !== config.showDiff) showDiff = false;
+            if (!ok) {
+                msg = getMessage2(this, arguments);
+                const actual = getActual(this, arguments);
+                const assertionErrorObjectProperties = {
+                    actual,
+                    expected,
+                    showDiff
+                };
+                const operator = getOperator(this, arguments);
+                if (operator) {
+                    assertionErrorObjectProperties.operator = operator;
+                }
+                throw new AssertionError(msg, assertionErrorObjectProperties, config.includeStack ? this.assert : flag(this, "ssfi"));
+            }
+        }
+        get _obj() {
+            return flag(this, "object");
+        }
+        set _obj(val) {
+            flag(this, "object", val);
+        }
+    };
+    function isProxyEnabled() {
+        return config.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined";
+    }
+    __name(isProxyEnabled, "isProxyEnabled");
+    function addProperty(ctx, name, getter) {
+        getter = getter === void 0 ? function() {} : getter;
+        Object.defineProperty(ctx, name, {
+            get: __name(function propertyGetter() {
+                if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
+                    flag(this, "ssfi", propertyGetter);
+                }
+                let result = getter.call(this);
+                if (result !== void 0) return result;
+                let newAssertion = new Assertion();
+                transferFlags(this, newAssertion);
+                return newAssertion;
+            }, "propertyGetter"),
+            configurable: true
+        });
+    }
+    __name(addProperty, "addProperty");
+    var fnLengthDesc = Object.getOwnPropertyDescriptor(function() {}, "length");
+    function addLengthGuard(fn, assertionName, isChainable) {
+        if (!fnLengthDesc.configurable) return fn;
+        Object.defineProperty(fn, "length", {
+            get: __name(function() {
+                if (isChainable) {
+                    throw Error("Invalid Chai property: " + assertionName + '.length. Due to a compatibility issue, "length" cannot directly follow "' + assertionName + '". Use "' + assertionName + '.lengthOf" instead.');
+                }
+                throw Error("Invalid Chai property: " + assertionName + '.length. See docs for proper usage of "' + assertionName + '".');
+            }, "get")
+        });
+        return fn;
+    }
+    __name(addLengthGuard, "addLengthGuard");
+    function getProperties(object) {
+        let result = Object.getOwnPropertyNames(object);
+        function addProperty2(property) {
+            if (result.indexOf(property) === -1) {
+                result.push(property);
+            }
+        }
+        __name(addProperty2, "addProperty");
+        let proto = Object.getPrototypeOf(object);
+        while(proto !== null){
+            Object.getOwnPropertyNames(proto).forEach(addProperty2);
+            proto = Object.getPrototypeOf(proto);
+        }
+        return result;
+    }
+    __name(getProperties, "getProperties");
+    var builtins = [
+        "__flags",
+        "__methods",
+        "_obj",
+        "assert"
+    ];
+    function proxify(obj, nonChainableMethodName) {
+        if (!isProxyEnabled()) return obj;
+        return new Proxy(obj, {
+            get: __name(function proxyGetter(target, property) {
+                if (typeof property === "string" && config.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) {
+                    if (nonChainableMethodName) {
+                        throw Error("Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".');
+                    }
+                    let suggestion = null;
+                    let suggestionDistance = 4;
+                    getProperties(target).forEach(function(prop) {
+                        if (!Object.prototype.hasOwnProperty(prop) && builtins.indexOf(prop) === -1) {
+                            let dist = stringDistanceCapped(property, prop, suggestionDistance);
+                            if (dist < suggestionDistance) {
+                                suggestion = prop;
+                                suggestionDistance = dist;
+                            }
+                        }
+                    });
+                    if (suggestion !== null) {
+                        throw Error("Invalid Chai property: " + property + '. Did you mean "' + suggestion + '"?');
+                    } else {
+                        throw Error("Invalid Chai property: " + property);
+                    }
+                }
+                if (builtins.indexOf(property) === -1 && !flag(target, "lockSsfi")) {
+                    flag(target, "ssfi", proxyGetter);
+                }
+                return Reflect.get(target, property);
+            }, "proxyGetter")
+        });
+    }
+    __name(proxify, "proxify");
+    function stringDistanceCapped(strA, strB, cap) {
+        if (Math.abs(strA.length - strB.length) >= cap) {
+            return cap;
+        }
+        let memo = [];
+        for(let i = 0; i <= strA.length; i++){
+            memo[i] = Array(strB.length + 1).fill(0);
+            memo[i][0] = i;
+        }
+        for(let j = 0; j < strB.length; j++){
+            memo[0][j] = j;
+        }
+        for(let i = 1; i <= strA.length; i++){
+            let ch = strA.charCodeAt(i - 1);
+            for(let j = 1; j <= strB.length; j++){
+                if (Math.abs(i - j) >= cap) {
+                    memo[i][j] = cap;
+                    continue;
+                }
+                memo[i][j] = Math.min(memo[i - 1][j] + 1, memo[i][j - 1] + 1, memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1));
+            }
+        }
+        return memo[strA.length][strB.length];
+    }
+    __name(stringDistanceCapped, "stringDistanceCapped");
+    function addMethod(ctx, name, method) {
+        let methodWrapper = __name(function() {
+            if (!flag(this, "lockSsfi")) {
+                flag(this, "ssfi", methodWrapper);
+            }
+            let result = method.apply(this, arguments);
+            if (result !== void 0) return result;
+            let newAssertion = new Assertion();
+            transferFlags(this, newAssertion);
+            return newAssertion;
+        }, "methodWrapper");
+        addLengthGuard(methodWrapper, name, false);
+        ctx[name] = proxify(methodWrapper, name);
+    }
+    __name(addMethod, "addMethod");
+    function overwriteProperty(ctx, name, getter) {
+        let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = __name(function() {}, "_super");
+        if (_get && "function" === typeof _get.get) _super = _get.get;
+        Object.defineProperty(ctx, name, {
+            get: __name(function overwritingPropertyGetter() {
+                if (!isProxyEnabled() && !flag(this, "lockSsfi")) {
+                    flag(this, "ssfi", overwritingPropertyGetter);
+                }
+                let origLockSsfi = flag(this, "lockSsfi");
+                flag(this, "lockSsfi", true);
+                let result = getter(_super).call(this);
+                flag(this, "lockSsfi", origLockSsfi);
+                if (result !== void 0) {
+                    return result;
+                }
+                let newAssertion = new Assertion();
+                transferFlags(this, newAssertion);
+                return newAssertion;
+            }, "overwritingPropertyGetter"),
+            configurable: true
+        });
+    }
+    __name(overwriteProperty, "overwriteProperty");
+    function overwriteMethod(ctx, name, method) {
+        let _method = ctx[name], _super = __name(function() {
+            throw new Error(name + " is not a function");
+        }, "_super");
+        if (_method && "function" === typeof _method) _super = _method;
+        let overwritingMethodWrapper = __name(function() {
+            if (!flag(this, "lockSsfi")) {
+                flag(this, "ssfi", overwritingMethodWrapper);
+            }
+            let origLockSsfi = flag(this, "lockSsfi");
+            flag(this, "lockSsfi", true);
+            let result = method(_super).apply(this, arguments);
+            flag(this, "lockSsfi", origLockSsfi);
+            if (result !== void 0) {
+                return result;
+            }
+            let newAssertion = new Assertion();
+            transferFlags(this, newAssertion);
+            return newAssertion;
+        }, "overwritingMethodWrapper");
+        addLengthGuard(overwritingMethodWrapper, name, false);
+        ctx[name] = proxify(overwritingMethodWrapper, name);
+    }
+    __name(overwriteMethod, "overwriteMethod");
+    var canSetPrototype = typeof Object.setPrototypeOf === "function";
+    var testFn = __name(function() {}, "testFn");
+    var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
+        let propDesc = Object.getOwnPropertyDescriptor(testFn, name);
+        if (typeof propDesc !== "object") return true;
+        return !propDesc.configurable;
+    });
+    var call = Function.prototype.call;
+    var apply = Function.prototype.apply;
+    function addChainableMethod(ctx, name, method, chainingBehavior) {
+        if (typeof chainingBehavior !== "function") {
+            chainingBehavior = __name(function() {}, "chainingBehavior");
+        }
+        let chainableBehavior = {
+            method,
+            chainingBehavior
+        };
+        if (!ctx.__methods) {
+            ctx.__methods = {};
+        }
+        ctx.__methods[name] = chainableBehavior;
+        Object.defineProperty(ctx, name, {
+            get: __name(function chainableMethodGetter() {
+                chainableBehavior.chainingBehavior.call(this);
+                let chainableMethodWrapper = __name(function() {
+                    if (!flag(this, "lockSsfi")) {
+                        flag(this, "ssfi", chainableMethodWrapper);
+                    }
+                    let result = chainableBehavior.method.apply(this, arguments);
+                    if (result !== void 0) {
+                        return result;
+                    }
+                    let newAssertion = new Assertion();
+                    transferFlags(this, newAssertion);
+                    return newAssertion;
+                }, "chainableMethodWrapper");
+                addLengthGuard(chainableMethodWrapper, name, true);
+                if (canSetPrototype) {
+                    let prototype = Object.create(this);
+                    prototype.call = call;
+                    prototype.apply = apply;
+                    Object.setPrototypeOf(chainableMethodWrapper, prototype);
+                } else {
+                    let asserterNames = Object.getOwnPropertyNames(ctx);
+                    asserterNames.forEach(function(asserterName) {
+                        if (excludeNames.indexOf(asserterName) !== -1) {
+                            return;
+                        }
+                        let pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
+                        Object.defineProperty(chainableMethodWrapper, asserterName, pd);
+                    });
+                }
+                transferFlags(this, chainableMethodWrapper);
+                return proxify(chainableMethodWrapper);
+            }, "chainableMethodGetter"),
+            configurable: true
+        });
+    }
+    __name(addChainableMethod, "addChainableMethod");
+    function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
+        let chainableBehavior = ctx.__methods[name];
+        let _chainingBehavior = chainableBehavior.chainingBehavior;
+        chainableBehavior.chainingBehavior = __name(function overwritingChainableMethodGetter() {
+            let result = chainingBehavior(_chainingBehavior).call(this);
+            if (result !== void 0) {
+                return result;
+            }
+            let newAssertion = new Assertion();
+            transferFlags(this, newAssertion);
+            return newAssertion;
+        }, "overwritingChainableMethodGetter");
+        let _method = chainableBehavior.method;
+        chainableBehavior.method = __name(function overwritingChainableMethodWrapper() {
+            let result = method(_method).apply(this, arguments);
+            if (result !== void 0) {
+                return result;
+            }
+            let newAssertion = new Assertion();
+            transferFlags(this, newAssertion);
+            return newAssertion;
+        }, "overwritingChainableMethodWrapper");
+    }
+    __name(overwriteChainableMethod, "overwriteChainableMethod");
+    function compareByInspect(a, b) {
+        return inspect2(a) < inspect2(b) ? -1 : 1;
+    }
+    __name(compareByInspect, "compareByInspect");
+    function getOwnEnumerablePropertySymbols(obj) {
+        if (typeof Object.getOwnPropertySymbols !== "function") return [];
+        return Object.getOwnPropertySymbols(obj).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
+        });
+    }
+    __name(getOwnEnumerablePropertySymbols, "getOwnEnumerablePropertySymbols");
+    function getOwnEnumerableProperties(obj) {
+        return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj));
+    }
+    __name(getOwnEnumerableProperties, "getOwnEnumerableProperties");
+    var isNaN2 = Number.isNaN;
+    function isObjectType(obj) {
+        let objectType = type(obj);
+        let objectTypes = [
+            "Array",
+            "Object",
+            "Function"
+        ];
+        return objectTypes.indexOf(objectType) !== -1;
+    }
+    __name(isObjectType, "isObjectType");
+    function getOperator(obj, args) {
+        let operator = flag(obj, "operator");
+        let negate = flag(obj, "negate");
+        let expected = args[3];
+        let msg = negate ? args[2] : args[1];
+        if (operator) {
+            return operator;
+        }
+        if (typeof msg === "function") msg = msg();
+        msg = msg || "";
+        if (!msg) {
+            return void 0;
+        }
+        if (/\shave\s/.test(msg)) {
+            return void 0;
+        }
+        let isObject = isObjectType(expected);
+        if (/\snot\s/.test(msg)) {
+            return isObject ? "notDeepStrictEqual" : "notStrictEqual";
+        }
+        return isObject ? "deepStrictEqual" : "strictEqual";
+    }
+    __name(getOperator, "getOperator");
+    function getName(fn) {
+        return fn.name;
+    }
+    __name(getName, "getName");
+    function isRegExp2(obj) {
+        return Object.prototype.toString.call(obj) === "[object RegExp]";
+    }
+    __name(isRegExp2, "isRegExp");
+    function isNumeric(obj) {
+        return [
+            "Number",
+            "BigInt"
+        ].includes(type(obj));
+    }
+    __name(isNumeric, "isNumeric");
+    var { flag: flag2 } = utils_exports;
+    [
+        "to",
+        "be",
+        "been",
+        "is",
+        "and",
+        "has",
+        "have",
+        "with",
+        "that",
+        "which",
+        "at",
+        "of",
+        "same",
+        "but",
+        "does",
+        "still",
+        "also"
+    ].forEach(function(chain) {
+        Assertion.addProperty(chain);
+    });
+    Assertion.addProperty("not", function() {
+        flag2(this, "negate", true);
+    });
+    Assertion.addProperty("deep", function() {
+        flag2(this, "deep", true);
+    });
+    Assertion.addProperty("nested", function() {
+        flag2(this, "nested", true);
+    });
+    Assertion.addProperty("own", function() {
+        flag2(this, "own", true);
+    });
+    Assertion.addProperty("ordered", function() {
+        flag2(this, "ordered", true);
+    });
+    Assertion.addProperty("any", function() {
+        flag2(this, "any", true);
+        flag2(this, "all", false);
+    });
+    Assertion.addProperty("all", function() {
+        flag2(this, "all", true);
+        flag2(this, "any", false);
+    });
+    var functionTypes = {
+        function: [
+            "function",
+            "asyncfunction",
+            "generatorfunction",
+            "asyncgeneratorfunction"
+        ],
+        asyncfunction: [
+            "asyncfunction",
+            "asyncgeneratorfunction"
+        ],
+        generatorfunction: [
+            "generatorfunction",
+            "asyncgeneratorfunction"
+        ],
+        asyncgeneratorfunction: [
+            "asyncgeneratorfunction"
+        ]
+    };
+    function an(type3, msg) {
+        if (msg) flag2(this, "message", msg);
+        type3 = type3.toLowerCase();
+        let obj = flag2(this, "object"), article = ~[
+            "a",
+            "e",
+            "i",
+            "o",
+            "u"
+        ].indexOf(type3.charAt(0)) ? "an " : "a ";
+        const detectedType = type(obj).toLowerCase();
+        if (functionTypes["function"].includes(type3)) {
+            this.assert(functionTypes[type3].includes(detectedType), "expected #{this} to be " + article + type3, "expected #{this} not to be " + article + type3);
+        } else {
+            this.assert(type3 === detectedType, "expected #{this} to be " + article + type3, "expected #{this} not to be " + article + type3);
+        }
+    }
+    __name(an, "an");
+    Assertion.addChainableMethod("an", an);
+    Assertion.addChainableMethod("a", an);
+    function SameValueZero(a, b) {
+        return isNaN2(a) && isNaN2(b) || a === b;
+    }
+    __name(SameValueZero, "SameValueZero");
+    function includeChainingBehavior() {
+        flag2(this, "contains", true);
+    }
+    __name(includeChainingBehavior, "includeChainingBehavior");
+    function include(val, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag2(this, "eql") : SameValueZero;
+        flagMsg = flagMsg ? flagMsg + ": " : "";
+        let included = false;
+        switch(objType){
+            case "string":
+                included = obj.indexOf(val) !== -1;
+                break;
+            case "weakset":
+                if (isDeep) {
+                    throw new AssertionError(flagMsg + "unable to use .deep.include with WeakSet", void 0, ssfi);
+                }
+                included = obj.has(val);
+                break;
+            case "map":
+                obj.forEach(function(item) {
+                    included = included || isEql(item, val);
+                });
+                break;
+            case "set":
+                if (isDeep) {
+                    obj.forEach(function(item) {
+                        included = included || isEql(item, val);
+                    });
+                } else {
+                    included = obj.has(val);
+                }
+                break;
+            case "array":
+                if (isDeep) {
+                    included = obj.some(function(item) {
+                        return isEql(item, val);
+                    });
+                } else {
+                    included = obj.indexOf(val) !== -1;
+                }
+                break;
+            default:
+                {
+                    if (val !== Object(val)) {
+                        throw new AssertionError(flagMsg + "the given combination of arguments (" + objType + " and " + type(val).toLowerCase() + ") is invalid for this assertion. You can use an array, a map, an object, a set, a string, or a weakset instead of a " + type(val).toLowerCase(), void 0, ssfi);
+                    }
+                    let props = Object.keys(val);
+                    let firstErr = null;
+                    let numErrs = 0;
+                    props.forEach(function(prop) {
+                        let propAssertion = new Assertion(obj);
+                        transferFlags(this, propAssertion, true);
+                        flag2(propAssertion, "lockSsfi", true);
+                        if (!negate || props.length === 1) {
+                            propAssertion.property(prop, val[prop]);
+                            return;
+                        }
+                        try {
+                            propAssertion.property(prop, val[prop]);
+                        } catch (err) {
+                            if (!check_error_exports.compatibleConstructor(err, AssertionError)) {
+                                throw err;
+                            }
+                            if (firstErr === null) firstErr = err;
+                            numErrs++;
+                        }
+                    }, this);
+                    if (negate && props.length > 1 && numErrs === props.length) {
+                        throw firstErr;
+                    }
+                    return;
+                }
+        }
+        this.assert(included, "expected #{this} to " + descriptor + "include " + inspect2(val), "expected #{this} to not " + descriptor + "include " + inspect2(val));
+    }
+    __name(include, "include");
+    Assertion.addChainableMethod("include", include, includeChainingBehavior);
+    Assertion.addChainableMethod("contain", include, includeChainingBehavior);
+    Assertion.addChainableMethod("contains", include, includeChainingBehavior);
+    Assertion.addChainableMethod("includes", include, includeChainingBehavior);
+    Assertion.addProperty("ok", function() {
+        this.assert(flag2(this, "object"), "expected #{this} to be truthy", "expected #{this} to be falsy");
+    });
+    Assertion.addProperty("true", function() {
+        this.assert(true === flag2(this, "object"), "expected #{this} to be true", "expected #{this} to be false", flag2(this, "negate") ? false : true);
+    });
+    Assertion.addProperty("numeric", function() {
+        const object = flag2(this, "object");
+        this.assert([
+            "Number",
+            "BigInt"
+        ].includes(type(object)), "expected #{this} to be numeric", "expected #{this} to not be numeric", flag2(this, "negate") ? false : true);
+    });
+    Assertion.addProperty("callable", function() {
+        const val = flag2(this, "object");
+        const ssfi = flag2(this, "ssfi");
+        const message = flag2(this, "message");
+        const msg = message ? `${message}: ` : "";
+        const negate = flag2(this, "negate");
+        const assertionMessage = negate ? `${msg}expected ${inspect2(val)} not to be a callable function` : `${msg}expected ${inspect2(val)} to be a callable function`;
+        const isCallable = [
+            "Function",
+            "AsyncFunction",
+            "GeneratorFunction",
+            "AsyncGeneratorFunction"
+        ].includes(type(val));
+        if (isCallable && negate || !isCallable && !negate) {
+            throw new AssertionError(assertionMessage, void 0, ssfi);
+        }
+    });
+    Assertion.addProperty("false", function() {
+        this.assert(false === flag2(this, "object"), "expected #{this} to be false", "expected #{this} to be true", flag2(this, "negate") ? true : false);
+    });
+    Assertion.addProperty("null", function() {
+        this.assert(null === flag2(this, "object"), "expected #{this} to be null", "expected #{this} not to be null");
+    });
+    Assertion.addProperty("undefined", function() {
+        this.assert(void 0 === flag2(this, "object"), "expected #{this} to be undefined", "expected #{this} not to be undefined");
+    });
+    Assertion.addProperty("NaN", function() {
+        this.assert(isNaN2(flag2(this, "object")), "expected #{this} to be NaN", "expected #{this} not to be NaN");
+    });
+    function assertExist() {
+        let val = flag2(this, "object");
+        this.assert(val !== null && val !== void 0, "expected #{this} to exist", "expected #{this} to not exist");
+    }
+    __name(assertExist, "assertExist");
+    Assertion.addProperty("exist", assertExist);
+    Assertion.addProperty("exists", assertExist);
+    Assertion.addProperty("empty", function() {
+        let val = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), itemsCount;
+        flagMsg = flagMsg ? flagMsg + ": " : "";
+        switch(type(val).toLowerCase()){
+            case "array":
+            case "string":
+                itemsCount = val.length;
+                break;
+            case "map":
+            case "set":
+                itemsCount = val.size;
+                break;
+            case "weakmap":
+            case "weakset":
+                throw new AssertionError(flagMsg + ".empty was passed a weak collection", void 0, ssfi);
+            case "function":
+                {
+                    const msg = flagMsg + ".empty was passed a function " + getName(val);
+                    throw new AssertionError(msg.trim(), void 0, ssfi);
+                }
+            default:
+                if (val !== Object(val)) {
+                    throw new AssertionError(flagMsg + ".empty was passed non-string primitive " + inspect2(val), void 0, ssfi);
+                }
+                itemsCount = Object.keys(val).length;
+        }
+        this.assert(0 === itemsCount, "expected #{this} to be empty", "expected #{this} not to be empty");
+    });
+    function checkArguments() {
+        let obj = flag2(this, "object"), type3 = type(obj);
+        this.assert("Arguments" === type3, "expected #{this} to be arguments but got " + type3, "expected #{this} to not be arguments");
+    }
+    __name(checkArguments, "checkArguments");
+    Assertion.addProperty("arguments", checkArguments);
+    Assertion.addProperty("Arguments", checkArguments);
+    function assertEqual(val, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object");
+        if (flag2(this, "deep")) {
+            let prevLockSsfi = flag2(this, "lockSsfi");
+            flag2(this, "lockSsfi", true);
+            this.eql(val);
+            flag2(this, "lockSsfi", prevLockSsfi);
+        } else {
+            this.assert(val === obj, "expected #{this} to equal #{exp}", "expected #{this} to not equal #{exp}", val, this._obj, true);
+        }
+    }
+    __name(assertEqual, "assertEqual");
+    Assertion.addMethod("equal", assertEqual);
+    Assertion.addMethod("equals", assertEqual);
+    Assertion.addMethod("eq", assertEqual);
+    function assertEql(obj, msg) {
+        if (msg) flag2(this, "message", msg);
+        let eql = flag2(this, "eql");
+        this.assert(eql(obj, flag2(this, "object")), "expected #{this} to deeply equal #{exp}", "expected #{this} to not deeply equal #{exp}", obj, this._obj, true);
+    }
+    __name(assertEql, "assertEql");
+    Assertion.addMethod("eql", assertEql);
+    Assertion.addMethod("eqls", assertEql);
+    function assertAbove(n, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase();
+        if (doLength && objType !== "map" && objType !== "set") {
+            new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+        }
+        if (!doLength && objType === "date" && nType !== "date") {
+            throw new AssertionError(msgPrefix + "the argument to above must be a date", void 0, ssfi);
+        } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+            throw new AssertionError(msgPrefix + "the argument to above must be a number", void 0, ssfi);
+        } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+            let printObj = objType === "string" ? "'" + obj + "'" : obj;
+            throw new AssertionError(msgPrefix + "expected " + printObj + " to be a number or a date", void 0, ssfi);
+        }
+        if (doLength) {
+            let descriptor = "length", itemsCount;
+            if (objType === "map" || objType === "set") {
+                descriptor = "size";
+                itemsCount = obj.size;
+            } else {
+                itemsCount = obj.length;
+            }
+            this.assert(itemsCount > n, "expected #{this} to have a " + descriptor + " above #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " above #{exp}", n, itemsCount);
+        } else {
+            this.assert(obj > n, "expected #{this} to be above #{exp}", "expected #{this} to be at most #{exp}", n);
+        }
+    }
+    __name(assertAbove, "assertAbove");
+    Assertion.addMethod("above", assertAbove);
+    Assertion.addMethod("gt", assertAbove);
+    Assertion.addMethod("greaterThan", assertAbove);
+    function assertLeast(n, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
+        if (doLength && objType !== "map" && objType !== "set") {
+            new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+        }
+        if (!doLength && objType === "date" && nType !== "date") {
+            errorMessage = msgPrefix + "the argument to least must be a date";
+        } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+            errorMessage = msgPrefix + "the argument to least must be a number";
+        } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+            let printObj = objType === "string" ? "'" + obj + "'" : obj;
+            errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+        } else {
+            shouldThrow = false;
+        }
+        if (shouldThrow) {
+            throw new AssertionError(errorMessage, void 0, ssfi);
+        }
+        if (doLength) {
+            let descriptor = "length", itemsCount;
+            if (objType === "map" || objType === "set") {
+                descriptor = "size";
+                itemsCount = obj.size;
+            } else {
+                itemsCount = obj.length;
+            }
+            this.assert(itemsCount >= n, "expected #{this} to have a " + descriptor + " at least #{exp} but got #{act}", "expected #{this} to have a " + descriptor + " below #{exp}", n, itemsCount);
+        } else {
+            this.assert(obj >= n, "expected #{this} to be at least #{exp}", "expected #{this} to be below #{exp}", n);
+        }
+    }
+    __name(assertLeast, "assertLeast");
+    Assertion.addMethod("least", assertLeast);
+    Assertion.addMethod("gte", assertLeast);
+    Assertion.addMethod("greaterThanOrEqual", assertLeast);
+    function assertBelow(n, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
+        if (doLength && objType !== "map" && objType !== "set") {
+            new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+        }
+        if (!doLength && objType === "date" && nType !== "date") {
+            errorMessage = msgPrefix + "the argument to below must be a date";
+        } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+            errorMessage = msgPrefix + "the argument to below must be a number";
+        } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+            let printObj = objType === "string" ? "'" + obj + "'" : obj;
+            errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+        } else {
+            shouldThrow = false;
+        }
+        if (shouldThrow) {
+            throw new AssertionError(errorMessage, void 0, ssfi);
+        }
+        if (doLength) {
+            let descriptor = "length", itemsCount;
+            if (objType === "map" || objType === "set") {
+                descriptor = "size";
+                itemsCount = obj.size;
+            } else {
+                itemsCount = obj.length;
+            }
+            this.assert(itemsCount < n, "expected #{this} to have a " + descriptor + " below #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " below #{exp}", n, itemsCount);
+        } else {
+            this.assert(obj < n, "expected #{this} to be below #{exp}", "expected #{this} to be at least #{exp}", n);
+        }
+    }
+    __name(assertBelow, "assertBelow");
+    Assertion.addMethod("below", assertBelow);
+    Assertion.addMethod("lt", assertBelow);
+    Assertion.addMethod("lessThan", assertBelow);
+    function assertMost(n, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true;
+        if (doLength && objType !== "map" && objType !== "set") {
+            new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+        }
+        if (!doLength && objType === "date" && nType !== "date") {
+            errorMessage = msgPrefix + "the argument to most must be a date";
+        } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+            errorMessage = msgPrefix + "the argument to most must be a number";
+        } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+            let printObj = objType === "string" ? "'" + obj + "'" : obj;
+            errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+        } else {
+            shouldThrow = false;
+        }
+        if (shouldThrow) {
+            throw new AssertionError(errorMessage, void 0, ssfi);
+        }
+        if (doLength) {
+            let descriptor = "length", itemsCount;
+            if (objType === "map" || objType === "set") {
+                descriptor = "size";
+                itemsCount = obj.size;
+            } else {
+                itemsCount = obj.length;
+            }
+            this.assert(itemsCount <= n, "expected #{this} to have a " + descriptor + " at most #{exp} but got #{act}", "expected #{this} to have a " + descriptor + " above #{exp}", n, itemsCount);
+        } else {
+            this.assert(obj <= n, "expected #{this} to be at most #{exp}", "expected #{this} to be above #{exp}", n);
+        }
+    }
+    __name(assertMost, "assertMost");
+    Assertion.addMethod("most", assertMost);
+    Assertion.addMethod("lte", assertMost);
+    Assertion.addMethod("lessThanOrEqual", assertMost);
+    Assertion.addMethod("within", function(start, finish, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), startType = type(start).toLowerCase(), finishType = type(finish).toLowerCase(), errorMessage, shouldThrow = true, range = startType === "date" && finishType === "date" ? start.toISOString() + ".." + finish.toISOString() : start + ".." + finish;
+        if (doLength && objType !== "map" && objType !== "set") {
+            new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+        }
+        if (!doLength && objType === "date" && (startType !== "date" || finishType !== "date")) {
+            errorMessage = msgPrefix + "the arguments to within must be dates";
+        } else if ((!isNumeric(start) || !isNumeric(finish)) && (doLength || isNumeric(obj))) {
+            errorMessage = msgPrefix + "the arguments to within must be numbers";
+        } else if (!doLength && objType !== "date" && !isNumeric(obj)) {
+            let printObj = objType === "string" ? "'" + obj + "'" : obj;
+            errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date";
+        } else {
+            shouldThrow = false;
+        }
+        if (shouldThrow) {
+            throw new AssertionError(errorMessage, void 0, ssfi);
+        }
+        if (doLength) {
+            let descriptor = "length", itemsCount;
+            if (objType === "map" || objType === "set") {
+                descriptor = "size";
+                itemsCount = obj.size;
+            } else {
+                itemsCount = obj.length;
+            }
+            this.assert(itemsCount >= start && itemsCount <= finish, "expected #{this} to have a " + descriptor + " within " + range, "expected #{this} to not have a " + descriptor + " within " + range);
+        } else {
+            this.assert(obj >= start && obj <= finish, "expected #{this} to be within " + range, "expected #{this} to not be within " + range);
+        }
+    });
+    function assertInstanceOf(constructor, msg) {
+        if (msg) flag2(this, "message", msg);
+        let target = flag2(this, "object");
+        let ssfi = flag2(this, "ssfi");
+        let flagMsg = flag2(this, "message");
+        let isInstanceOf;
+        try {
+            isInstanceOf = target instanceof constructor;
+        } catch (err) {
+            if (err instanceof TypeError) {
+                flagMsg = flagMsg ? flagMsg + ": " : "";
+                throw new AssertionError(flagMsg + "The instanceof assertion needs a constructor but " + type(constructor) + " was given.", void 0, ssfi);
+            }
+            throw err;
+        }
+        let name = getName(constructor);
+        if (name == null) {
+            name = "an unnamed constructor";
+        }
+        this.assert(isInstanceOf, "expected #{this} to be an instance of " + name, "expected #{this} to not be an instance of " + name);
+    }
+    __name(assertInstanceOf, "assertInstanceOf");
+    Assertion.addMethod("instanceof", assertInstanceOf);
+    Assertion.addMethod("instanceOf", assertInstanceOf);
+    function assertProperty(name, val, msg) {
+        if (msg) flag2(this, "message", msg);
+        let isNested = flag2(this, "nested"), isOwn = flag2(this, "own"), flagMsg = flag2(this, "message"), obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), nameType = typeof name;
+        flagMsg = flagMsg ? flagMsg + ": " : "";
+        if (isNested) {
+            if (nameType !== "string") {
+                throw new AssertionError(flagMsg + "the argument to property must be a string when using nested syntax", void 0, ssfi);
+            }
+        } else {
+            if (nameType !== "string" && nameType !== "number" && nameType !== "symbol") {
+                throw new AssertionError(flagMsg + "the argument to property must be a string, number, or symbol", void 0, ssfi);
+            }
+        }
+        if (isNested && isOwn) {
+            throw new AssertionError(flagMsg + 'The "nested" and "own" flags cannot be combined.', void 0, ssfi);
+        }
+        if (obj === null || obj === void 0) {
+            throw new AssertionError(flagMsg + "Target cannot be null or undefined.", void 0, ssfi);
+        }
+        let isDeep = flag2(this, "deep"), negate = flag2(this, "negate"), pathInfo = isNested ? getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name], isEql = isDeep ? flag2(this, "eql") : (val1, val2)=>val1 === val2;
+        let descriptor = "";
+        if (isDeep) descriptor += "deep ";
+        if (isOwn) descriptor += "own ";
+        if (isNested) descriptor += "nested ";
+        descriptor += "property ";
+        let hasProperty2;
+        if (isOwn) hasProperty2 = Object.prototype.hasOwnProperty.call(obj, name);
+        else if (isNested) hasProperty2 = pathInfo.exists;
+        else hasProperty2 = hasProperty(obj, name);
+        if (!negate || arguments.length === 1) {
+            this.assert(hasProperty2, "expected #{this} to have " + descriptor + inspect2(name), "expected #{this} to not have " + descriptor + inspect2(name));
+        }
+        if (arguments.length > 1) {
+            this.assert(hasProperty2 && isEql(val, value), "expected #{this} to have " + descriptor + inspect2(name) + " of #{exp}, but got #{act}", "expected #{this} to not have " + descriptor + inspect2(name) + " of #{act}", val, value);
+        }
+        flag2(this, "object", value);
+    }
+    __name(assertProperty, "assertProperty");
+    Assertion.addMethod("property", assertProperty);
+    function assertOwnProperty(_name, _value, _msg) {
+        flag2(this, "own", true);
+        assertProperty.apply(this, arguments);
+    }
+    __name(assertOwnProperty, "assertOwnProperty");
+    Assertion.addMethod("ownProperty", assertOwnProperty);
+    Assertion.addMethod("haveOwnProperty", assertOwnProperty);
+    function assertOwnPropertyDescriptor(name, descriptor, msg) {
+        if (typeof descriptor === "string") {
+            msg = descriptor;
+            descriptor = null;
+        }
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object");
+        let actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
+        let eql = flag2(this, "eql");
+        if (actualDescriptor && descriptor) {
+            this.assert(eql(descriptor, actualDescriptor), "expected the own property descriptor for " + inspect2(name) + " on #{this} to match " + inspect2(descriptor) + ", got " + inspect2(actualDescriptor), "expected the own property descriptor for " + inspect2(name) + " on #{this} to not match " + inspect2(descriptor), descriptor, actualDescriptor, true);
+        } else {
+            this.assert(actualDescriptor, "expected #{this} to have an own property descriptor for " + inspect2(name), "expected #{this} to not have an own property descriptor for " + inspect2(name));
+        }
+        flag2(this, "object", actualDescriptor);
+    }
+    __name(assertOwnPropertyDescriptor, "assertOwnPropertyDescriptor");
+    Assertion.addMethod("ownPropertyDescriptor", assertOwnPropertyDescriptor);
+    Assertion.addMethod("haveOwnPropertyDescriptor", assertOwnPropertyDescriptor);
+    function assertLengthChain() {
+        flag2(this, "doLength", true);
+    }
+    __name(assertLengthChain, "assertLengthChain");
+    function assertLength(n, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount;
+        switch(objType){
+            case "map":
+            case "set":
+                descriptor = "size";
+                itemsCount = obj.size;
+                break;
+            default:
+                new Assertion(obj, flagMsg, ssfi, true).to.have.property("length");
+                itemsCount = obj.length;
+        }
+        this.assert(itemsCount == n, "expected #{this} to have a " + descriptor + " of #{exp} but got #{act}", "expected #{this} to not have a " + descriptor + " of #{act}", n, itemsCount);
+    }
+    __name(assertLength, "assertLength");
+    Assertion.addChainableMethod("length", assertLength, assertLengthChain);
+    Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain);
+    function assertMatch(re, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object");
+        this.assert(re.exec(obj), "expected #{this} to match " + re, "expected #{this} not to match " + re);
+    }
+    __name(assertMatch, "assertMatch");
+    Assertion.addMethod("match", assertMatch);
+    Assertion.addMethod("matches", assertMatch);
+    Assertion.addMethod("string", function(str, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+        new Assertion(obj, flagMsg, ssfi, true).is.a("string");
+        this.assert(~obj.indexOf(str), "expected #{this} to contain " + inspect2(str), "expected #{this} to not contain " + inspect2(str));
+    });
+    function assertKeys(keys) {
+        let obj = flag2(this, "object"), objType = type(obj), keysType = type(keys), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message");
+        flagMsg = flagMsg ? flagMsg + ": " : "";
+        let mixedArgsMsg = flagMsg + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments";
+        if (objType === "Map" || objType === "Set") {
+            deepStr = isDeep ? "deeply " : "";
+            actual = [];
+            obj.forEach(function(val, key) {
+                actual.push(key);
+            });
+            if (keysType !== "Array") {
+                keys = Array.prototype.slice.call(arguments);
+            }
+        } else {
+            actual = getOwnEnumerableProperties(obj);
+            switch(keysType){
+                case "Array":
+                    if (arguments.length > 1) {
+                        throw new AssertionError(mixedArgsMsg, void 0, ssfi);
+                    }
+                    break;
+                case "Object":
+                    if (arguments.length > 1) {
+                        throw new AssertionError(mixedArgsMsg, void 0, ssfi);
+                    }
+                    keys = Object.keys(keys);
+                    break;
+                default:
+                    keys = Array.prototype.slice.call(arguments);
+            }
+            keys = keys.map(function(val) {
+                return typeof val === "symbol" ? val : String(val);
+            });
+        }
+        if (!keys.length) {
+            throw new AssertionError(flagMsg + "keys required", void 0, ssfi);
+        }
+        let len = keys.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys, isEql = isDeep ? flag2(this, "eql") : (val1, val2)=>val1 === val2;
+        if (!any && !all) {
+            all = true;
+        }
+        if (any) {
+            ok = expected.some(function(expectedKey) {
+                return actual.some(function(actualKey) {
+                    return isEql(expectedKey, actualKey);
+                });
+            });
+        }
+        if (all) {
+            ok = expected.every(function(expectedKey) {
+                return actual.some(function(actualKey) {
+                    return isEql(expectedKey, actualKey);
+                });
+            });
+            if (!flag2(this, "contains")) {
+                ok = ok && keys.length == actual.length;
+            }
+        }
+        if (len > 1) {
+            keys = keys.map(function(key) {
+                return inspect2(key);
+            });
+            let last = keys.pop();
+            if (all) {
+                str = keys.join(", ") + ", and " + last;
+            }
+            if (any) {
+                str = keys.join(", ") + ", or " + last;
+            }
+        } else {
+            str = inspect2(keys[0]);
+        }
+        str = (len > 1 ? "keys " : "key ") + str;
+        str = (flag2(this, "contains") ? "contain " : "have ") + str;
+        this.assert(ok, "expected #{this} to " + deepStr + str, "expected #{this} to not " + deepStr + str, expected.slice(0).sort(compareByInspect), actual.sort(compareByInspect), true);
+    }
+    __name(assertKeys, "assertKeys");
+    Assertion.addMethod("keys", assertKeys);
+    Assertion.addMethod("key", assertKeys);
+    function assertThrows(errorLike, errMsgMatcher, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false;
+        new Assertion(obj, flagMsg, ssfi, true).is.a("function");
+        if (isRegExp2(errorLike) || typeof errorLike === "string") {
+            errMsgMatcher = errorLike;
+            errorLike = null;
+        }
+        let caughtErr;
+        let errorWasThrown = false;
+        try {
+            obj();
+        } catch (err) {
+            errorWasThrown = true;
+            caughtErr = err;
+        }
+        let everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
+        let everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
+        let errorLikeFail = false;
+        let errMsgMatcherFail = false;
+        if (everyArgIsUndefined || !everyArgIsUndefined && !negate) {
+            let errorLikeString = "an error";
+            if (errorLike instanceof Error) {
+                errorLikeString = "#{exp}";
+            } else if (errorLike) {
+                errorLikeString = check_error_exports.getConstructorName(errorLike);
+            }
+            let actual = caughtErr;
+            if (caughtErr instanceof Error) {
+                actual = caughtErr.toString();
+            } else if (typeof caughtErr === "string") {
+                actual = caughtErr;
+            } else if (caughtErr && (typeof caughtErr === "object" || typeof caughtErr === "function")) {
+                try {
+                    actual = check_error_exports.getConstructorName(caughtErr);
+                } catch (_err) {}
+            }
+            this.assert(errorWasThrown, "expected #{this} to throw " + errorLikeString, "expected #{this} to not throw an error but #{act} was thrown", errorLike && errorLike.toString(), actual);
+        }
+        if (errorLike && caughtErr) {
+            if (errorLike instanceof Error) {
+                let isCompatibleInstance = check_error_exports.compatibleInstance(caughtErr, errorLike);
+                if (isCompatibleInstance === negate) {
+                    if (everyArgIsDefined && negate) {
+                        errorLikeFail = true;
+                    } else {
+                        this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr && !negate ? " but #{act} was thrown" : ""), errorLike.toString(), caughtErr.toString());
+                    }
+                }
+            }
+            let isCompatibleConstructor = check_error_exports.compatibleConstructor(caughtErr, errorLike);
+            if (isCompatibleConstructor === negate) {
+                if (everyArgIsDefined && negate) {
+                    errorLikeFail = true;
+                } else {
+                    this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr));
+                }
+            }
+        }
+        if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) {
+            let placeholder = "including";
+            if (isRegExp2(errMsgMatcher)) {
+                placeholder = "matching";
+            }
+            let isCompatibleMessage = check_error_exports.compatibleMessage(caughtErr, errMsgMatcher);
+            if (isCompatibleMessage === negate) {
+                if (everyArgIsDefined && negate) {
+                    errMsgMatcherFail = true;
+                } else {
+                    this.assert(negate, "expected #{this} to throw error " + placeholder + " #{exp} but got #{act}", "expected #{this} to throw error not " + placeholder + " #{exp}", errMsgMatcher, check_error_exports.getMessage(caughtErr));
+                }
+            }
+        }
+        if (errorLikeFail && errMsgMatcherFail) {
+            this.assert(negate, "expected #{this} to throw #{exp} but #{act} was thrown", "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr));
+        }
+        flag2(this, "object", caughtErr);
+    }
+    __name(assertThrows, "assertThrows");
+    Assertion.addMethod("throw", assertThrows);
+    Assertion.addMethod("throws", assertThrows);
+    Assertion.addMethod("Throw", assertThrows);
+    function respondTo(method, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), itself = flag2(this, "itself"), context = "function" === typeof obj && !itself ? obj.prototype[method] : obj[method];
+        this.assert("function" === typeof context, "expected #{this} to respond to " + inspect2(method), "expected #{this} to not respond to " + inspect2(method));
+    }
+    __name(respondTo, "respondTo");
+    Assertion.addMethod("respondTo", respondTo);
+    Assertion.addMethod("respondsTo", respondTo);
+    Assertion.addProperty("itself", function() {
+        flag2(this, "itself", true);
+    });
+    function satisfy(matcher, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object");
+        let result = matcher(obj);
+        this.assert(result, "expected #{this} to satisfy " + objDisplay(matcher), "expected #{this} to not satisfy" + objDisplay(matcher), flag2(this, "negate") ? false : true, result);
+    }
+    __name(satisfy, "satisfy");
+    Assertion.addMethod("satisfy", satisfy);
+    Assertion.addMethod("satisfies", satisfy);
+    function closeTo(expected, delta, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+        new Assertion(obj, flagMsg, ssfi, true).is.numeric;
+        let message = "A `delta` value is required for `closeTo`";
+        if (delta == void 0) {
+            throw new AssertionError(flagMsg ? `${flagMsg}: ${message}` : message, void 0, ssfi);
+        }
+        new Assertion(delta, flagMsg, ssfi, true).is.numeric;
+        message = "A `expected` value is required for `closeTo`";
+        if (expected == void 0) {
+            throw new AssertionError(flagMsg ? `${flagMsg}: ${message}` : message, void 0, ssfi);
+        }
+        new Assertion(expected, flagMsg, ssfi, true).is.numeric;
+        const abs = __name((x)=>x < 0n ? -x : x, "abs");
+        const strip = __name((number)=>parseFloat(parseFloat(number).toPrecision(12)), "strip");
+        this.assert(strip(abs(obj - expected)) <= delta, "expected #{this} to be close to " + expected + " +/- " + delta, "expected #{this} not to be close to " + expected + " +/- " + delta);
+    }
+    __name(closeTo, "closeTo");
+    Assertion.addMethod("closeTo", closeTo);
+    Assertion.addMethod("approximately", closeTo);
+    function isSubsetOf(_subset, _superset, cmp, contains, ordered) {
+        let superset = Array.from(_superset);
+        let subset = Array.from(_subset);
+        if (!contains) {
+            if (subset.length !== superset.length) return false;
+            superset = superset.slice();
+        }
+        return subset.every(function(elem, idx) {
+            if (ordered) return cmp ? cmp(elem, superset[idx]) : elem === superset[idx];
+            if (!cmp) {
+                let matchIdx = superset.indexOf(elem);
+                if (matchIdx === -1) return false;
+                if (!contains) superset.splice(matchIdx, 1);
+                return true;
+            }
+            return superset.some(function(elem2, matchIdx) {
+                if (!cmp(elem, elem2)) return false;
+                if (!contains) superset.splice(matchIdx, 1);
+                return true;
+            });
+        });
+    }
+    __name(isSubsetOf, "isSubsetOf");
+    Assertion.addMethod("members", function(subset, msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+        new Assertion(obj, flagMsg, ssfi, true).to.be.iterable;
+        new Assertion(subset, flagMsg, ssfi, true).to.be.iterable;
+        let contains = flag2(this, "contains");
+        let ordered = flag2(this, "ordered");
+        let subject, failMsg, failNegateMsg;
+        if (contains) {
+            subject = ordered ? "an ordered superset" : "a superset";
+            failMsg = "expected #{this} to be " + subject + " of #{exp}";
+            failNegateMsg = "expected #{this} to not be " + subject + " of #{exp}";
+        } else {
+            subject = ordered ? "ordered members" : "members";
+            failMsg = "expected #{this} to have the same " + subject + " as #{exp}";
+            failNegateMsg = "expected #{this} to not have the same " + subject + " as #{exp}";
+        }
+        let cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0;
+        this.assert(isSubsetOf(subset, obj, cmp, contains, ordered), failMsg, failNegateMsg, subset, obj, true);
+    });
+    Assertion.addProperty("iterable", function(msg) {
+        if (msg) flag2(this, "message", msg);
+        let obj = flag2(this, "object");
+        this.assert(obj != void 0 && obj[Symbol.iterator], "expected #{this} to be an iterable", "expected #{this} to not be an iterable", obj);
+    });
+    function oneOf(list, msg) {
+        if (msg) flag2(this, "message", msg);
+        let expected = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), contains = flag2(this, "contains"), isDeep = flag2(this, "deep"), eql = flag2(this, "eql");
+        new Assertion(list, flagMsg, ssfi, true).to.be.an("array");
+        if (contains) {
+            this.assert(list.some(function(possibility) {
+                return expected.indexOf(possibility) > -1;
+            }), "expected #{this} to contain one of #{exp}", "expected #{this} to not contain one of #{exp}", list, expected);
+        } else {
+            if (isDeep) {
+                this.assert(list.some(function(possibility) {
+                    return eql(expected, possibility);
+                }), "expected #{this} to deeply equal one of #{exp}", "expected #{this} to deeply equal one of #{exp}", list, expected);
+            } else {
+                this.assert(list.indexOf(expected) > -1, "expected #{this} to be one of #{exp}", "expected #{this} to not be one of #{exp}", list, expected);
+            }
+        }
+    }
+    __name(oneOf, "oneOf");
+    Assertion.addMethod("oneOf", oneOf);
+    function assertChanges(subject, prop, msg) {
+        if (msg) flag2(this, "message", msg);
+        let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+        new Assertion(fn, flagMsg, ssfi, true).is.a("function");
+        let initial;
+        if (!prop) {
+            new Assertion(subject, flagMsg, ssfi, true).is.a("function");
+            initial = subject();
+        } else {
+            new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
+            initial = subject[prop];
+        }
+        fn();
+        let final = prop === void 0 || prop === null ? subject() : subject[prop];
+        let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
+        flag2(this, "deltaMsgObj", msgObj);
+        flag2(this, "initialDeltaValue", initial);
+        flag2(this, "finalDeltaValue", final);
+        flag2(this, "deltaBehavior", "change");
+        flag2(this, "realDelta", final !== initial);
+        this.assert(initial !== final, "expected " + msgObj + " to change", "expected " + msgObj + " to not change");
+    }
+    __name(assertChanges, "assertChanges");
+    Assertion.addMethod("change", assertChanges);
+    Assertion.addMethod("changes", assertChanges);
+    function assertIncreases(subject, prop, msg) {
+        if (msg) flag2(this, "message", msg);
+        let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+        new Assertion(fn, flagMsg, ssfi, true).is.a("function");
+        let initial;
+        if (!prop) {
+            new Assertion(subject, flagMsg, ssfi, true).is.a("function");
+            initial = subject();
+        } else {
+            new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
+            initial = subject[prop];
+        }
+        new Assertion(initial, flagMsg, ssfi, true).is.a("number");
+        fn();
+        let final = prop === void 0 || prop === null ? subject() : subject[prop];
+        let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
+        flag2(this, "deltaMsgObj", msgObj);
+        flag2(this, "initialDeltaValue", initial);
+        flag2(this, "finalDeltaValue", final);
+        flag2(this, "deltaBehavior", "increase");
+        flag2(this, "realDelta", final - initial);
+        this.assert(final - initial > 0, "expected " + msgObj + " to increase", "expected " + msgObj + " to not increase");
+    }
+    __name(assertIncreases, "assertIncreases");
+    Assertion.addMethod("increase", assertIncreases);
+    Assertion.addMethod("increases", assertIncreases);
+    function assertDecreases(subject, prop, msg) {
+        if (msg) flag2(this, "message", msg);
+        let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+        new Assertion(fn, flagMsg, ssfi, true).is.a("function");
+        let initial;
+        if (!prop) {
+            new Assertion(subject, flagMsg, ssfi, true).is.a("function");
+            initial = subject();
+        } else {
+            new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
+            initial = subject[prop];
+        }
+        new Assertion(initial, flagMsg, ssfi, true).is.a("number");
+        fn();
+        let final = prop === void 0 || prop === null ? subject() : subject[prop];
+        let msgObj = prop === void 0 || prop === null ? initial : "." + prop;
+        flag2(this, "deltaMsgObj", msgObj);
+        flag2(this, "initialDeltaValue", initial);
+        flag2(this, "finalDeltaValue", final);
+        flag2(this, "deltaBehavior", "decrease");
+        flag2(this, "realDelta", initial - final);
+        this.assert(final - initial < 0, "expected " + msgObj + " to decrease", "expected " + msgObj + " to not decrease");
+    }
+    __name(assertDecreases, "assertDecreases");
+    Assertion.addMethod("decrease", assertDecreases);
+    Assertion.addMethod("decreases", assertDecreases);
+    function assertDelta(delta, msg) {
+        if (msg) flag2(this, "message", msg);
+        let msgObj = flag2(this, "deltaMsgObj");
+        let initial = flag2(this, "initialDeltaValue");
+        let final = flag2(this, "finalDeltaValue");
+        let behavior = flag2(this, "deltaBehavior");
+        let realDelta = flag2(this, "realDelta");
+        let expression;
+        if (behavior === "change") {
+            expression = Math.abs(final - initial) === Math.abs(delta);
+        } else {
+            expression = realDelta === Math.abs(delta);
+        }
+        this.assert(expression, "expected " + msgObj + " to " + behavior + " by " + delta, "expected " + msgObj + " to not " + behavior + " by " + delta);
+    }
+    __name(assertDelta, "assertDelta");
+    Assertion.addMethod("by", assertDelta);
+    Assertion.addProperty("extensible", function() {
+        let obj = flag2(this, "object");
+        let isExtensible = obj === Object(obj) && Object.isExtensible(obj);
+        this.assert(isExtensible, "expected #{this} to be extensible", "expected #{this} to not be extensible");
+    });
+    Assertion.addProperty("sealed", function() {
+        let obj = flag2(this, "object");
+        let isSealed = obj === Object(obj) ? Object.isSealed(obj) : true;
+        this.assert(isSealed, "expected #{this} to be sealed", "expected #{this} to not be sealed");
+    });
+    Assertion.addProperty("frozen", function() {
+        let obj = flag2(this, "object");
+        let isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true;
+        this.assert(isFrozen, "expected #{this} to be frozen", "expected #{this} to not be frozen");
+    });
+    Assertion.addProperty("finite", function(_msg) {
+        let obj = flag2(this, "object");
+        this.assert(typeof obj === "number" && isFinite(obj), "expected #{this} to be a finite number", "expected #{this} to not be a finite number");
+    });
+    function compareSubset(expected, actual) {
+        if (expected === actual) {
+            return true;
+        }
+        if (typeof actual !== typeof expected) {
+            return false;
+        }
+        if (typeof expected !== "object" || expected === null) {
+            return expected === actual;
+        }
+        if (!actual) {
+            return false;
+        }
+        if (Array.isArray(expected)) {
+            if (!Array.isArray(actual)) {
+                return false;
+            }
+            return expected.every(function(exp) {
+                return actual.some(function(act) {
+                    return compareSubset(exp, act);
+                });
+            });
+        }
+        if (expected instanceof Date) {
+            if (actual instanceof Date) {
+                return expected.getTime() === actual.getTime();
+            } else {
+                return false;
+            }
+        }
+        return Object.keys(expected).every(function(key) {
+            let expectedValue = expected[key];
+            let actualValue = actual[key];
+            if (typeof expectedValue === "object" && expectedValue !== null && actualValue !== null) {
+                return compareSubset(expectedValue, actualValue);
+            }
+            if (typeof expectedValue === "function") {
+                return expectedValue(actualValue);
+            }
+            return actualValue === expectedValue;
+        });
+    }
+    __name(compareSubset, "compareSubset");
+    Assertion.addMethod("containSubset", function(expected) {
+        const actual = flag(this, "object");
+        const showDiff = config.showDiff;
+        this.assert(compareSubset(expected, actual), "expected #{act} to contain subset #{exp}", "expected #{act} to not contain subset #{exp}", expected, actual, showDiff);
+    });
+    function expect(val, message) {
+        return new Assertion(val, message);
+    }
+    __name(expect, "expect");
+    expect.fail = function(actual, expected, message, operator) {
+        if (arguments.length < 2) {
+            message = actual;
+            actual = void 0;
+        }
+        message = message || "expect.fail()";
+        throw new AssertionError(message, {
+            actual,
+            expected,
+            operator
+        }, expect.fail);
+    };
+    var should_exports = {};
+    __export(should_exports, {
+        Should: ()=>Should,
+        should: ()=>should
+    });
+    function loadShould() {
+        function shouldGetter() {
+            if (this instanceof String || this instanceof Number || this instanceof Boolean || typeof Symbol === "function" && this instanceof Symbol || typeof BigInt === "function" && this instanceof BigInt) {
+                return new Assertion(this.valueOf(), null, shouldGetter);
+            }
+            return new Assertion(this, null, shouldGetter);
+        }
+        __name(shouldGetter, "shouldGetter");
+        function shouldSetter(value) {
+            Object.defineProperty(this, "should", {
+                value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
+        __name(shouldSetter, "shouldSetter");
+        Object.defineProperty(Object.prototype, "should", {
+            set: shouldSetter,
+            get: shouldGetter,
+            configurable: true
+        });
+        let should2 = {};
+        should2.fail = function(actual, expected, message, operator) {
+            if (arguments.length < 2) {
+                message = actual;
+                actual = void 0;
+            }
+            message = message || "should.fail()";
+            throw new AssertionError(message, {
+                actual,
+                expected,
+                operator
+            }, should2.fail);
+        };
+        should2.equal = function(actual, expected, message) {
+            new Assertion(actual, message).to.equal(expected);
+        };
+        should2.Throw = function(fn, errt, errs, msg) {
+            new Assertion(fn, msg).to.Throw(errt, errs);
+        };
+        should2.exist = function(val, msg) {
+            new Assertion(val, msg).to.exist;
+        };
+        should2.not = {};
+        should2.not.equal = function(actual, expected, msg) {
+            new Assertion(actual, msg).to.not.equal(expected);
+        };
+        should2.not.Throw = function(fn, errt, errs, msg) {
+            new Assertion(fn, msg).to.not.Throw(errt, errs);
+        };
+        should2.not.exist = function(val, msg) {
+            new Assertion(val, msg).to.not.exist;
+        };
+        should2["throw"] = should2["Throw"];
+        should2.not["throw"] = should2.not["Throw"];
+        return should2;
+    }
+    __name(loadShould, "loadShould");
+    var should = loadShould;
+    var Should = loadShould;
+    function assert(express, errmsg) {
+        let test2 = new Assertion(null, null, assert, true);
+        test2.assert(express, errmsg, "[ negation message unavailable ]");
+    }
+    __name(assert, "assert");
+    assert.fail = function(actual, expected, message, operator) {
+        if (arguments.length < 2) {
+            message = actual;
+            actual = void 0;
+        }
+        message = message || "assert.fail()";
+        throw new AssertionError(message, {
+            actual,
+            expected,
+            operator
+        }, assert.fail);
+    };
+    assert.isOk = function(val, msg) {
+        new Assertion(val, msg, assert.isOk, true).is.ok;
+    };
+    assert.isNotOk = function(val, msg) {
+        new Assertion(val, msg, assert.isNotOk, true).is.not.ok;
+    };
+    assert.equal = function(act, exp, msg) {
+        let test2 = new Assertion(act, msg, assert.equal, true);
+        test2.assert(exp == flag(test2, "object"), "expected #{this} to equal #{exp}", "expected #{this} to not equal #{act}", exp, act, true);
+    };
+    assert.notEqual = function(act, exp, msg) {
+        let test2 = new Assertion(act, msg, assert.notEqual, true);
+        test2.assert(exp != flag(test2, "object"), "expected #{this} to not equal #{exp}", "expected #{this} to equal #{act}", exp, act, true);
+    };
+    assert.strictEqual = function(act, exp, msg) {
+        new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);
+    };
+    assert.notStrictEqual = function(act, exp, msg) {
+        new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp);
+    };
+    assert.deepEqual = assert.deepStrictEqual = function(act, exp, msg) {
+        new Assertion(act, msg, assert.deepEqual, true).to.eql(exp);
+    };
+    assert.notDeepEqual = function(act, exp, msg) {
+        new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp);
+    };
+    assert.isAbove = function(val, abv, msg) {
+        new Assertion(val, msg, assert.isAbove, true).to.be.above(abv);
+    };
+    assert.isAtLeast = function(val, atlst, msg) {
+        new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst);
+    };
+    assert.isBelow = function(val, blw, msg) {
+        new Assertion(val, msg, assert.isBelow, true).to.be.below(blw);
+    };
+    assert.isAtMost = function(val, atmst, msg) {
+        new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst);
+    };
+    assert.isTrue = function(val, msg) {
+        new Assertion(val, msg, assert.isTrue, true).is["true"];
+    };
+    assert.isNotTrue = function(val, msg) {
+        new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true);
+    };
+    assert.isFalse = function(val, msg) {
+        new Assertion(val, msg, assert.isFalse, true).is["false"];
+    };
+    assert.isNotFalse = function(val, msg) {
+        new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false);
+    };
+    assert.isNull = function(val, msg) {
+        new Assertion(val, msg, assert.isNull, true).to.equal(null);
+    };
+    assert.isNotNull = function(val, msg) {
+        new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null);
+    };
+    assert.isNaN = function(val, msg) {
+        new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
+    };
+    assert.isNotNaN = function(value, message) {
+        new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
+    };
+    assert.exists = function(val, msg) {
+        new Assertion(val, msg, assert.exists, true).to.exist;
+    };
+    assert.notExists = function(val, msg) {
+        new Assertion(val, msg, assert.notExists, true).to.not.exist;
+    };
+    assert.isUndefined = function(val, msg) {
+        new Assertion(val, msg, assert.isUndefined, true).to.equal(void 0);
+    };
+    assert.isDefined = function(val, msg) {
+        new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
+    };
+    assert.isCallable = function(value, message) {
+        new Assertion(value, message, assert.isCallable, true).is.callable;
+    };
+    assert.isNotCallable = function(value, message) {
+        new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
+    };
+    assert.isObject = function(val, msg) {
+        new Assertion(val, msg, assert.isObject, true).to.be.a("object");
+    };
+    assert.isNotObject = function(val, msg) {
+        new Assertion(val, msg, assert.isNotObject, true).to.not.be.a("object");
+    };
+    assert.isArray = function(val, msg) {
+        new Assertion(val, msg, assert.isArray, true).to.be.an("array");
+    };
+    assert.isNotArray = function(val, msg) {
+        new Assertion(val, msg, assert.isNotArray, true).to.not.be.an("array");
+    };
+    assert.isString = function(val, msg) {
+        new Assertion(val, msg, assert.isString, true).to.be.a("string");
+    };
+    assert.isNotString = function(val, msg) {
+        new Assertion(val, msg, assert.isNotString, true).to.not.be.a("string");
+    };
+    assert.isNumber = function(val, msg) {
+        new Assertion(val, msg, assert.isNumber, true).to.be.a("number");
+    };
+    assert.isNotNumber = function(val, msg) {
+        new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a("number");
+    };
+    assert.isNumeric = function(val, msg) {
+        new Assertion(val, msg, assert.isNumeric, true).is.numeric;
+    };
+    assert.isNotNumeric = function(val, msg) {
+        new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
+    };
+    assert.isFinite = function(val, msg) {
+        new Assertion(val, msg, assert.isFinite, true).to.be.finite;
+    };
+    assert.isBoolean = function(val, msg) {
+        new Assertion(val, msg, assert.isBoolean, true).to.be.a("boolean");
+    };
+    assert.isNotBoolean = function(val, msg) {
+        new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a("boolean");
+    };
+    assert.typeOf = function(val, type3, msg) {
+        new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
+    };
+    assert.notTypeOf = function(value, type3, message) {
+        new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
+    };
+    assert.instanceOf = function(val, type3, msg) {
+        new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
+    };
+    assert.notInstanceOf = function(val, type3, msg) {
+        new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(type3);
+    };
+    assert.include = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.include, true).include(inc);
+    };
+    assert.notInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.notInclude, true).not.include(inc);
+    };
+    assert.deepInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc);
+    };
+    assert.notDeepInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc);
+    };
+    assert.nestedInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);
+    };
+    assert.notNestedInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(inc);
+    };
+    assert.deepNestedInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(inc);
+    };
+    assert.notDeepNestedInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.notDeepNestedInclude, true).not.deep.nested.include(inc);
+    };
+    assert.ownInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
+    };
+    assert.notOwnInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);
+    };
+    assert.deepOwnInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
+    };
+    assert.notDeepOwnInclude = function(exp, inc, msg) {
+        new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(inc);
+    };
+    assert.match = function(exp, re, msg) {
+        new Assertion(exp, msg, assert.match, true).to.match(re);
+    };
+    assert.notMatch = function(exp, re, msg) {
+        new Assertion(exp, msg, assert.notMatch, true).to.not.match(re);
+    };
+    assert.property = function(obj, prop, msg) {
+        new Assertion(obj, msg, assert.property, true).to.have.property(prop);
+    };
+    assert.notProperty = function(obj, prop, msg) {
+        new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop);
+    };
+    assert.propertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
+    };
+    assert.notPropertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(prop, val);
+    };
+    assert.deepPropertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(prop, val);
+    };
+    assert.notDeepPropertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.notDeepPropertyVal, true).to.not.have.deep.property(prop, val);
+    };
+    assert.ownProperty = function(obj, prop, msg) {
+        new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop);
+    };
+    assert.notOwnProperty = function(obj, prop, msg) {
+        new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(prop);
+    };
+    assert.ownPropertyVal = function(obj, prop, value, msg) {
+        new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(prop, value);
+    };
+    assert.notOwnPropertyVal = function(obj, prop, value, msg) {
+        new Assertion(obj, msg, assert.notOwnPropertyVal, true).to.not.have.own.property(prop, value);
+    };
+    assert.deepOwnPropertyVal = function(obj, prop, value, msg) {
+        new Assertion(obj, msg, assert.deepOwnPropertyVal, true).to.have.deep.own.property(prop, value);
+    };
+    assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
+        new Assertion(obj, msg, assert.notDeepOwnPropertyVal, true).to.not.have.deep.own.property(prop, value);
+    };
+    assert.nestedProperty = function(obj, prop, msg) {
+        new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(prop);
+    };
+    assert.notNestedProperty = function(obj, prop, msg) {
+        new Assertion(obj, msg, assert.notNestedProperty, true).to.not.have.nested.property(prop);
+    };
+    assert.nestedPropertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.nestedPropertyVal, true).to.have.nested.property(prop, val);
+    };
+    assert.notNestedPropertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.notNestedPropertyVal, true).to.not.have.nested.property(prop, val);
+    };
+    assert.deepNestedPropertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.deepNestedPropertyVal, true).to.have.deep.nested.property(prop, val);
+    };
+    assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
+        new Assertion(obj, msg, assert.notDeepNestedPropertyVal, true).to.not.have.deep.nested.property(prop, val);
+    };
+    assert.lengthOf = function(exp, len, msg) {
+        new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len);
+    };
+    assert.hasAnyKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys);
+    };
+    assert.hasAllKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys);
+    };
+    assert.containsAllKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(keys);
+    };
+    assert.doesNotHaveAnyKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(keys);
+    };
+    assert.doesNotHaveAllKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(keys);
+    };
+    assert.hasAnyDeepKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(keys);
+    };
+    assert.hasAllDeepKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(keys);
+    };
+    assert.containsAllDeepKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.containsAllDeepKeys, true).to.contain.all.deep.keys(keys);
+    };
+    assert.doesNotHaveAnyDeepKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.doesNotHaveAnyDeepKeys, true).to.not.have.any.deep.keys(keys);
+    };
+    assert.doesNotHaveAllDeepKeys = function(obj, keys, msg) {
+        new Assertion(obj, msg, assert.doesNotHaveAllDeepKeys, true).to.not.have.all.deep.keys(keys);
+    };
+    assert.throws = function(fn, errorLike, errMsgMatcher, msg) {
+        if ("string" === typeof errorLike || errorLike instanceof RegExp) {
+            errMsgMatcher = errorLike;
+            errorLike = null;
+        }
+        let assertErr = new Assertion(fn, msg, assert.throws, true).to.throw(errorLike, errMsgMatcher);
+        return flag(assertErr, "object");
+    };
+    assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, message) {
+        if ("string" === typeof errorLike || errorLike instanceof RegExp) {
+            errMsgMatcher = errorLike;
+            errorLike = null;
+        }
+        new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher);
+    };
+    assert.operator = function(val, operator, val2, msg) {
+        let ok;
+        switch(operator){
+            case "==":
+                ok = val == val2;
+                break;
+            case "===":
+                ok = val === val2;
+                break;
+            case ">":
+                ok = val > val2;
+                break;
+            case ">=":
+                ok = val >= val2;
+                break;
+            case "<":
+                ok = val < val2;
+                break;
+            case "<=":
+                ok = val <= val2;
+                break;
+            case "!=":
+                ok = val != val2;
+                break;
+            case "!==":
+                ok = val !== val2;
+                break;
+            default:
+                msg = msg ? msg + ": " : msg;
+                throw new AssertionError(msg + 'Invalid operator "' + operator + '"', void 0, assert.operator);
+        }
+        let test2 = new Assertion(ok, msg, assert.operator, true);
+        test2.assert(true === flag(test2, "object"), "expected " + inspect2(val) + " to be " + operator + " " + inspect2(val2), "expected " + inspect2(val) + " to not be " + operator + " " + inspect2(val2));
+    };
+    assert.closeTo = function(act, exp, delta, msg) {
+        new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);
+    };
+    assert.approximately = function(act, exp, delta, msg) {
+        new Assertion(act, msg, assert.approximately, true).to.be.approximately(exp, delta);
+    };
+    assert.sameMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set2);
+    };
+    assert.notSameMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.notSameMembers, true).to.not.have.same.members(set2);
+    };
+    assert.sameDeepMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.sameDeepMembers, true).to.have.same.deep.members(set2);
+    };
+    assert.notSameDeepMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.notSameDeepMembers, true).to.not.have.same.deep.members(set2);
+    };
+    assert.sameOrderedMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.sameOrderedMembers, true).to.have.same.ordered.members(set2);
+    };
+    assert.notSameOrderedMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.notSameOrderedMembers, true).to.not.have.same.ordered.members(set2);
+    };
+    assert.sameDeepOrderedMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.sameDeepOrderedMembers, true).to.have.same.deep.ordered.members(set2);
+    };
+    assert.notSameDeepOrderedMembers = function(set1, set2, msg) {
+        new Assertion(set1, msg, assert.notSameDeepOrderedMembers, true).to.not.have.same.deep.ordered.members(set2);
+    };
+    assert.includeMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.includeMembers, true).to.include.members(subset);
+    };
+    assert.notIncludeMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.notIncludeMembers, true).to.not.include.members(subset);
+    };
+    assert.includeDeepMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.includeDeepMembers, true).to.include.deep.members(subset);
+    };
+    assert.notIncludeDeepMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.notIncludeDeepMembers, true).to.not.include.deep.members(subset);
+    };
+    assert.includeOrderedMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.includeOrderedMembers, true).to.include.ordered.members(subset);
+    };
+    assert.notIncludeOrderedMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.notIncludeOrderedMembers, true).to.not.include.ordered.members(subset);
+    };
+    assert.includeDeepOrderedMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.includeDeepOrderedMembers, true).to.include.deep.ordered.members(subset);
+    };
+    assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
+        new Assertion(superset, msg, assert.notIncludeDeepOrderedMembers, true).to.not.include.deep.ordered.members(subset);
+    };
+    assert.oneOf = function(inList, list, msg) {
+        new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
+    };
+    assert.isIterable = function(obj, msg) {
+        if (obj == void 0 || !obj[Symbol.iterator]) {
+            msg = msg ? `${msg} expected ${inspect2(obj)} to be an iterable` : `expected ${inspect2(obj)} to be an iterable`;
+            throw new AssertionError(msg, void 0, assert.isIterable);
+        }
+    };
+    assert.changes = function(fn, obj, prop, msg) {
+        if (arguments.length === 3 && typeof obj === "function") {
+            msg = prop;
+            prop = null;
+        }
+        new Assertion(fn, msg, assert.changes, true).to.change(obj, prop);
+    };
+    assert.changesBy = function(fn, obj, prop, delta, msg) {
+        if (arguments.length === 4 && typeof obj === "function") {
+            let tmpMsg = delta;
+            delta = prop;
+            msg = tmpMsg;
+        } else if (arguments.length === 3) {
+            delta = prop;
+            prop = null;
+        }
+        new Assertion(fn, msg, assert.changesBy, true).to.change(obj, prop).by(delta);
+    };
+    assert.doesNotChange = function(fn, obj, prop, msg) {
+        if (arguments.length === 3 && typeof obj === "function") {
+            msg = prop;
+            prop = null;
+        }
+        return new Assertion(fn, msg, assert.doesNotChange, true).to.not.change(obj, prop);
+    };
+    assert.changesButNotBy = function(fn, obj, prop, delta, msg) {
+        if (arguments.length === 4 && typeof obj === "function") {
+            let tmpMsg = delta;
+            delta = prop;
+            msg = tmpMsg;
+        } else if (arguments.length === 3) {
+            delta = prop;
+            prop = null;
+        }
+        new Assertion(fn, msg, assert.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
+    };
+    assert.increases = function(fn, obj, prop, msg) {
+        if (arguments.length === 3 && typeof obj === "function") {
+            msg = prop;
+            prop = null;
+        }
+        return new Assertion(fn, msg, assert.increases, true).to.increase(obj, prop);
+    };
+    assert.increasesBy = function(fn, obj, prop, delta, msg) {
+        if (arguments.length === 4 && typeof obj === "function") {
+            let tmpMsg = delta;
+            delta = prop;
+            msg = tmpMsg;
+        } else if (arguments.length === 3) {
+            delta = prop;
+            prop = null;
+        }
+        new Assertion(fn, msg, assert.increasesBy, true).to.increase(obj, prop).by(delta);
+    };
+    assert.doesNotIncrease = function(fn, obj, prop, msg) {
+        if (arguments.length === 3 && typeof obj === "function") {
+            msg = prop;
+            prop = null;
+        }
+        return new Assertion(fn, msg, assert.doesNotIncrease, true).to.not.increase(obj, prop);
+    };
+    assert.increasesButNotBy = function(fn, obj, prop, delta, msg) {
+        if (arguments.length === 4 && typeof obj === "function") {
+            let tmpMsg = delta;
+            delta = prop;
+            msg = tmpMsg;
+        } else if (arguments.length === 3) {
+            delta = prop;
+            prop = null;
+        }
+        new Assertion(fn, msg, assert.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
+    };
+    assert.decreases = function(fn, obj, prop, msg) {
+        if (arguments.length === 3 && typeof obj === "function") {
+            msg = prop;
+            prop = null;
+        }
+        return new Assertion(fn, msg, assert.decreases, true).to.decrease(obj, prop);
+    };
+    assert.decreasesBy = function(fn, obj, prop, delta, msg) {
+        if (arguments.length === 4 && typeof obj === "function") {
+            let tmpMsg = delta;
+            delta = prop;
+            msg = tmpMsg;
+        } else if (arguments.length === 3) {
+            delta = prop;
+            prop = null;
+        }
+        new Assertion(fn, msg, assert.decreasesBy, true).to.decrease(obj, prop).by(delta);
+    };
+    assert.doesNotDecrease = function(fn, obj, prop, msg) {
+        if (arguments.length === 3 && typeof obj === "function") {
+            msg = prop;
+            prop = null;
+        }
+        return new Assertion(fn, msg, assert.doesNotDecrease, true).to.not.decrease(obj, prop);
+    };
+    assert.doesNotDecreaseBy = function(fn, obj, prop, delta, msg) {
+        if (arguments.length === 4 && typeof obj === "function") {
+            let tmpMsg = delta;
+            delta = prop;
+            msg = tmpMsg;
+        } else if (arguments.length === 3) {
+            delta = prop;
+            prop = null;
+        }
+        return new Assertion(fn, msg, assert.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
+    };
+    assert.decreasesButNotBy = function(fn, obj, prop, delta, msg) {
+        if (arguments.length === 4 && typeof obj === "function") {
+            let tmpMsg = delta;
+            delta = prop;
+            msg = tmpMsg;
+        } else if (arguments.length === 3) {
+            delta = prop;
+            prop = null;
+        }
+        new Assertion(fn, msg, assert.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
+    };
+    assert.ifError = function(val) {
+        if (val) {
+            throw val;
+        }
+    };
+    assert.isExtensible = function(obj, msg) {
+        new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible;
+    };
+    assert.isNotExtensible = function(obj, msg) {
+        new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible;
+    };
+    assert.isSealed = function(obj, msg) {
+        new Assertion(obj, msg, assert.isSealed, true).to.be.sealed;
+    };
+    assert.isNotSealed = function(obj, msg) {
+        new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed;
+    };
+    assert.isFrozen = function(obj, msg) {
+        new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen;
+    };
+    assert.isNotFrozen = function(obj, msg) {
+        new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen;
+    };
+    assert.isEmpty = function(val, msg) {
+        new Assertion(val, msg, assert.isEmpty, true).to.be.empty;
+    };
+    assert.isNotEmpty = function(val, msg) {
+        new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;
+    };
+    assert.containsSubset = function(val, exp, msg) {
+        new Assertion(val, msg).to.containSubset(exp);
+    };
+    assert.doesNotContainSubset = function(val, exp, msg) {
+        new Assertion(val, msg).to.not.containSubset(exp);
+    };
+    var aliases = [
+        [
+            "isOk",
+            "ok"
+        ],
+        [
+            "isNotOk",
+            "notOk"
+        ],
+        [
+            "throws",
+            "throw"
+        ],
+        [
+            "throws",
+            "Throw"
+        ],
+        [
+            "isExtensible",
+            "extensible"
+        ],
+        [
+            "isNotExtensible",
+            "notExtensible"
+        ],
+        [
+            "isSealed",
+            "sealed"
+        ],
+        [
+            "isNotSealed",
+            "notSealed"
+        ],
+        [
+            "isFrozen",
+            "frozen"
+        ],
+        [
+            "isNotFrozen",
+            "notFrozen"
+        ],
+        [
+            "isEmpty",
+            "empty"
+        ],
+        [
+            "isNotEmpty",
+            "notEmpty"
+        ],
+        [
+            "isCallable",
+            "isFunction"
+        ],
+        [
+            "isNotCallable",
+            "isNotFunction"
+        ],
+        [
+            "containsSubset",
+            "containSubset"
+        ]
+    ];
+    for (const [name, as] of aliases){
+        assert[as] = assert[name];
+    }
+    var used = [];
+    function use(fn) {
+        const exports$1 = {
+            use,
+            AssertionError,
+            util: utils_exports,
+            config,
+            expect,
+            assert,
+            Assertion,
+            ...should_exports
+        };
+        if (!~used.indexOf(fn)) {
+            fn(exports$1, utils_exports);
+            used.push(fn);
+        }
+        return exports$1;
+    }
+    __name(use, "use");
+    function isErrorInstance(obj) {
+        return obj instanceof Error || Object.prototype.toString.call(obj) === '[object Error]';
+    }
+    function isRegExp(obj) {
+        return Object.prototype.toString.call(obj) === '[object RegExp]';
+    }
+    function compatibleInstance(thrown, errorLike) {
+        return isErrorInstance(errorLike) && thrown === errorLike;
+    }
+    function compatibleConstructor(thrown, errorLike) {
+        if (isErrorInstance(errorLike)) {
+            return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
+        } else if ((typeof errorLike === 'object' || typeof errorLike === 'function') && errorLike.prototype) {
+            return thrown.constructor === errorLike || thrown instanceof errorLike;
+        }
+        return false;
+    }
+    function compatibleMessage(thrown, errMatcher) {
+        const comparisonString = typeof thrown === 'string' ? thrown : thrown.message;
+        if (isRegExp(errMatcher)) {
+            return errMatcher.test(comparisonString);
+        } else if (typeof errMatcher === 'string') {
+            return comparisonString.indexOf(errMatcher) !== -1;
+        }
+        return false;
+    }
+    function getConstructorName(errorLike) {
+        let constructorName = errorLike;
+        if (isErrorInstance(errorLike)) {
+            constructorName = errorLike.constructor.name;
+        } else if (typeof errorLike === 'function') {
+            constructorName = errorLike.name;
+            if (constructorName === '') {
+                const newConstructorName = (new errorLike().name);
+                constructorName = newConstructorName || constructorName;
+            }
+        }
+        return constructorName;
+    }
+    function getMessage(errorLike) {
+        let msg = '';
+        if (errorLike && errorLike.message) {
+            msg = errorLike.message;
+        } else if (typeof errorLike === 'string') {
+            msg = errorLike;
+        }
+        return msg;
+    }
+    const checkErrorDefault = Object.freeze(Object.defineProperty({
+        __proto__: null,
+        compatibleConstructor,
+        compatibleInstance,
+        compatibleMessage,
+        getConstructorName,
+        getMessage
+    }, Symbol.toStringTag, {
+        value: 'Module'
+    }));
+    let checkError = checkErrorDefault;
+    function chaiAsPromised(chai, utils) {
+        const Assertion = chai.Assertion;
+        const assert = chai.assert;
+        const proxify = utils.proxify;
+        if (utils.checkError) {
+            checkError = utils.checkError;
+        }
+        function isLegacyJQueryPromise(thenable) {
+            return (typeof thenable.catch !== 'function' && typeof thenable.always === 'function' && typeof thenable.done === 'function' && typeof thenable.fail === 'function' && typeof thenable.pipe === 'function' && typeof thenable.progress === 'function' && typeof thenable.state === 'function');
+        }
+        function assertIsAboutPromise(assertion) {
+            if (typeof assertion._obj.then !== 'function') {
+                throw new TypeError(utils.inspect(assertion._obj) + ' is not a thenable.');
+            }
+            if (isLegacyJQueryPromise(assertion._obj)) {
+                throw new TypeError('Chai as Promised is incompatible with thenables of jQuery<3.0.0, sorry! Please ' + 'upgrade jQuery or use another Promises/A+ compatible library (see ' + 'http://promisesaplus.com/).');
+            }
+        }
+        function proxifyIfSupported(assertion) {
+            return proxify === undefined ? assertion : proxify(assertion);
+        }
+        function method(name, asserter) {
+            utils.addMethod(Assertion.prototype, name, function() {
+                assertIsAboutPromise(this);
+                return asserter.apply(this, arguments);
+            });
+        }
+        function property(name, asserter) {
+            utils.addProperty(Assertion.prototype, name, function() {
+                assertIsAboutPromise(this);
+                return proxifyIfSupported(asserter.apply(this, arguments));
+            });
+        }
+        function doNotify(promise, done) {
+            promise.then(()=>done(), done);
+        }
+        function assertIfNegated(assertion, message, extra) {
+            assertion.assert(true, null, message, extra.expected, extra.actual);
+        }
+        function assertIfNotNegated(assertion, message, extra) {
+            assertion.assert(false, message, null, extra.expected, extra.actual);
+        }
+        function getBasePromise(assertion) {
+            return typeof assertion.then === 'function' ? assertion : assertion._obj;
+        }
+        function getReasonName(reason) {
+            return reason instanceof Error ? reason.toString() : checkError.getConstructorName(reason);
+        }
+        const propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
+        const propertyDescs = {};
+        for (const name of propertyNames){
+            propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
+        }
+        property('fulfilled', function() {
+            const derivedPromise = getBasePromise(this).then((value)=>{
+                assertIfNegated(this, 'expected promise not to be fulfilled but it was fulfilled with #{act}', {
+                    actual: value
+                });
+                return value;
+            }, (reason)=>{
+                assertIfNotNegated(this, 'expected promise to be fulfilled but it was rejected with #{act}', {
+                    actual: getReasonName(reason)
+                });
+                return reason;
+            });
+            transferPromiseness(this, derivedPromise);
+            return this;
+        });
+        property('rejected', function() {
+            const derivedPromise = getBasePromise(this).then((value)=>{
+                assertIfNotNegated(this, 'expected promise to be rejected but it was fulfilled with #{act}', {
+                    actual: value
+                });
+                return value;
+            }, (reason)=>{
+                assertIfNegated(this, 'expected promise not to be rejected but it was rejected with #{act}', {
+                    actual: getReasonName(reason)
+                });
+                return reason;
+            });
+            transferPromiseness(this, derivedPromise);
+            return this;
+        });
+        method('rejectedWith', function(errorLike, errMsgMatcher, message) {
+            let errorLikeName = null;
+            const negate = utils.flag(this, 'negate') || false;
+            if (errorLike === undefined && errMsgMatcher === undefined && message === undefined) {
+                return this.rejected;
+            }
+            if (message !== undefined) {
+                utils.flag(this, 'message', message);
+            }
+            if (errorLike instanceof RegExp || typeof errorLike === 'string') {
+                errMsgMatcher = errorLike;
+                errorLike = null;
+            } else if (errorLike && errorLike instanceof Error) {
+                errorLikeName = errorLike.toString();
+            } else if (typeof errorLike === 'function') {
+                errorLikeName = checkError.getConstructorName(errorLike);
+            } else {
+                errorLike = null;
+            }
+            const everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
+            let matcherRelation = 'including';
+            if (errMsgMatcher instanceof RegExp) {
+                matcherRelation = 'matching';
+            }
+            const derivedPromise = getBasePromise(this).then((value)=>{
+                let assertionMessage = null;
+                let expected = null;
+                if (errorLike) {
+                    assertionMessage = 'expected promise to be rejected with #{exp} but it was fulfilled with #{act}';
+                    expected = errorLikeName;
+                } else if (errMsgMatcher) {
+                    assertionMessage = `expected promise to be rejected with an error ${matcherRelation} #{exp} but ` + `it was fulfilled with #{act}`;
+                    expected = errMsgMatcher;
+                }
+                assertIfNotNegated(this, assertionMessage, {
+                    expected,
+                    actual: value
+                });
+                return value;
+            }, (reason)=>{
+                const errorLikeCompatible = errorLike && (errorLike instanceof Error ? checkError.compatibleInstance(reason, errorLike) : checkError.compatibleConstructor(reason, errorLike));
+                const errMsgMatcherCompatible = errMsgMatcher === reason || (errMsgMatcher && reason && checkError.compatibleMessage(reason, errMsgMatcher));
+                const reasonName = getReasonName(reason);
+                if (negate && everyArgIsDefined) {
+                    if (errorLikeCompatible && errMsgMatcherCompatible) {
+                        this.assert(true, null, 'expected promise not to be rejected with #{exp} but it was rejected ' + 'with #{act}', errorLikeName, reasonName);
+                    }
+                } else {
+                    if (errorLike) {
+                        this.assert(errorLikeCompatible, 'expected promise to be rejected with #{exp} but it was rejected with #{act}', 'expected promise not to be rejected with #{exp} but it was rejected ' + 'with #{act}', errorLikeName, reasonName);
+                    }
+                    if (errMsgMatcher) {
+                        this.assert(errMsgMatcherCompatible, `expected promise to be rejected with an error ${matcherRelation} #{exp} but got ` + `#{act}`, `expected promise not to be rejected with an error ${matcherRelation} #{exp}`, errMsgMatcher, checkError.getMessage(reason));
+                    }
+                }
+                return reason;
+            });
+            transferPromiseness(this, derivedPromise);
+            return this;
+        });
+        property('eventually', function() {
+            utils.flag(this, 'eventually', true);
+            return this;
+        });
+        method('notify', function(done) {
+            doNotify(getBasePromise(this), done);
+            return this;
+        });
+        method('become', function(value, message) {
+            return this.eventually.deep.equal(value, message);
+        });
+        const methodNames = propertyNames.filter((name)=>{
+            return name !== 'assert' && typeof propertyDescs[name].value === 'function';
+        });
+        methodNames.forEach((methodName)=>{
+            Assertion.overwriteMethod(methodName, (originalMethod)=>function() {
+                    return doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+                });
+        });
+        const getterNames = propertyNames.filter((name)=>{
+            return name !== '_obj' && typeof propertyDescs[name].get === 'function';
+        });
+        getterNames.forEach((getterName)=>{
+            const isChainableMethod = Object.prototype.hasOwnProperty.call(Assertion.prototype.__methods, getterName);
+            if (isChainableMethod) {
+                Assertion.overwriteChainableMethod(getterName, (originalMethod)=>function() {
+                        return doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+                    }, (originalGetter)=>function() {
+                        return doAsserterAsyncAndAddThen(originalGetter, this);
+                    });
+            } else {
+                Assertion.overwriteProperty(getterName, (originalGetter)=>function() {
+                        return proxifyIfSupported(doAsserterAsyncAndAddThen(originalGetter, this));
+                    });
+            }
+        });
+        function doAsserterAsyncAndAddThen(asserter, assertion, args) {
+            if (!utils.flag(assertion, 'eventually')) {
+                asserter.apply(assertion, args);
+                return assertion;
+            }
+            const derivedPromise = getBasePromise(assertion).then((value)=>{
+                assertion._obj = value;
+                utils.flag(assertion, 'eventually', false);
+                return args ? transformAsserterArgs(args) : args;
+            }).then((newArgs)=>{
+                asserter.apply(assertion, newArgs);
+                return assertion._obj;
+            });
+            transferPromiseness(assertion, derivedPromise);
+            return assertion;
+        }
+        const originalAssertMethods = Object.getOwnPropertyNames(assert).filter((propName)=>{
+            return typeof assert[propName] === 'function';
+        });
+        assert.isFulfilled = (promise, message)=>new Assertion(promise, message).to.be.fulfilled;
+        assert.isRejected = (promise, errorLike, errMsgMatcher, message)=>{
+            const assertion = new Assertion(promise, message);
+            return assertion.to.be.rejectedWith(errorLike, errMsgMatcher, message);
+        };
+        assert.becomes = (promise, value, message)=>assert.eventually.deepEqual(promise, value, message);
+        assert.doesNotBecome = (promise, value, message)=>assert.eventually.notDeepEqual(promise, value, message);
+        assert.eventually = {};
+        originalAssertMethods.forEach((assertMethodName)=>{
+            assert.eventually[assertMethodName] = function(promise) {
+                const otherArgs = Array.prototype.slice.call(arguments, 1);
+                let customRejectionHandler;
+                const message = arguments[assert[assertMethodName].length - 1];
+                if (typeof message === 'string') {
+                    customRejectionHandler = (reason)=>{
+                        throw new chai.AssertionError(`${message}\n\nOriginal reason: ${utils.inspect(reason)}`);
+                    };
+                }
+                const returnedPromise = promise.then((fulfillmentValue)=>assert[assertMethodName].apply(assert, [
+                        fulfillmentValue
+                    ].concat(otherArgs)), customRejectionHandler);
+                returnedPromise.notify = (done)=>{
+                    doNotify(returnedPromise, done);
+                };
+                return returnedPromise;
+            };
+        });
+    }
+    function defaultTransferPromiseness(assertion, promise) {
+        assertion.then = promise.then.bind(promise);
+    }
+    function defaultTransformAsserterArgs(values) {
+        return values;
+    }
+    function transferPromiseness(assertion, promise) {
+        {
+            defaultTransferPromiseness(assertion, promise);
+        }
+    }
+    function transformAsserterArgs(values) {
+        return defaultTransformAsserterArgs(values);
+    }
+    const echo$1 = async (api)=>{
+        expect(await api.echo({
+            foo: "bar"
+        })).to.deep.equal({
+            foo: "bar"
+        });
+    };
+    const add$1 = async (api)=>{
+        expect(await api.add(5, 3)).to.equal(8);
+    };
+    const mathMultiply$1 = async (api)=>{
+        expect(await api.math.multiply(6, 7)).to.equal(42);
+    };
+    const mathDivide$1 = async (api)=>{
+        expect(await api.math.divide(100, 4)).to.equal(25);
+    };
+    const createCallback$1 = async (api)=>{
+        const callback = await api.createCallback();
+        expect(await callback()).to.equal(42);
+    };
+    const callWithCallback$1 = async (api)=>{
+        expect(await api.callWithCallback(()=>123)).to.equal(123);
+    };
+    const getDate$1 = async (api)=>{
+        const date = await api.getDate();
+        expect(date).to.be.instanceOf(Date);
+        expect(Date.now() - date.getTime()).to.be.lessThan(6e4);
+    };
+    const getError$1 = async (api)=>{
+        const error = await api.getError();
+        expect(error).to.be.instanceOf(Error);
+        expect(error.message).to.equal("Test error");
+    };
+    const throwError$1 = async (api)=>{
+        await expect(api.throwError()).to.be.rejected;
+    };
+    const processBuffer$1 = async (api)=>{
+        const result = await api.processBuffer(new Uint8Array([
+            1,
+            2,
+            3,
+            4
+        ]));
+        expect(result).to.be.instanceOf(Uint8Array);
+        expect(Array.from(result)).to.deep.equal([
+            2,
+            4,
+            6,
+            8
+        ]);
+    };
+    const getBuffer$1 = async (api)=>{
+        const buffer = await api.getBuffer();
+        expect(buffer).to.be.instanceOf(ArrayBuffer);
+        expect(buffer.byteLength).to.equal(16);
+    };
+    const getPromise$1 = async (api)=>{
+        const result = await api.getPromise();
+        expect(result instanceof Promise ? await result : result).to.equal(123);
+    };
+    const getStream$1 = async (api)=>{
+        const stream = await api.getStream();
+        expect(stream).to.be.instanceOf(ReadableStream);
+        const reader = stream.getReader();
+        const chunks = [];
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) break;
+            chunks.push(value);
+        }
+        expect(chunks.length).to.equal(2);
+        expect(Array.from(chunks[0])).to.deep.equal([
+            1,
+            2,
+            3
+        ]);
+        expect(Array.from(chunks[1])).to.deep.equal([
+            4,
+            5,
+            6
+        ]);
+    };
+    const base = {
+        echo: echo$1,
+        add: add$1,
+        mathMultiply: mathMultiply$1,
+        mathDivide: mathDivide$1,
+        createCallback: createCallback$1,
+        callWithCallback: callWithCallback$1,
+        getDate: getDate$1,
+        getError: getError$1,
+        throwError: throwError$1,
+        processBuffer: processBuffer$1,
+        getBuffer: getBuffer$1,
+        getPromise: getPromise$1,
+        getStream: getStream$1
+    };
+    use(chaiAsPromised);
+    let api$1;
+    const setApi = (newApi)=>{
+        api$1 = newApi;
+    };
+    const echo = ()=>base.echo(api$1);
+    const add = ()=>base.add(api$1);
+    const mathMultiply = ()=>base.mathMultiply(api$1);
+    const mathDivide = ()=>base.mathDivide(api$1);
+    const createCallback = ()=>base.createCallback(api$1);
+    const callWithCallback = ()=>base.callWithCallback(api$1);
+    const getDate = ()=>base.getDate(api$1);
+    const getError = ()=>base.getError(api$1);
+    const throwError = ()=>base.throwError(api$1);
+    const processBuffer = ()=>base.processBuffer(api$1);
+    const getBuffer = ()=>base.getBuffer(api$1);
+    const getPromise = ()=>base.getPromise(api$1);
+    const getStream = ()=>base.getStream(api$1);
+    const contentTests = Object.freeze(Object.defineProperty({
+        __proto__: null,
+        add,
+        callWithCallback,
+        createCallback,
+        echo,
+        getBuffer,
+        getDate,
+        getError,
+        getPromise,
+        getStream,
+        mathDivide,
+        mathMultiply,
+        processBuffer,
+        setApi,
+        throwError
+    }, Symbol.toStringTag, {
+        value: 'Module'
+    }));
+    const jsonOnlyCapabilities = {
+        jsonOnly: true,
+        messagePort: false,
+        arrayBuffer: false,
+        transferable: false,
+        transferableStream: false
+    };
+    const port = chrome.runtime.connect({
+        name: `content-${Date.now()}`
+    });
+    const api = await expose({}, {
+        transport: {
+            isJson: true,
+            emit: port,
+            receive: port
+        },
+        platformCapabilities: jsonOnlyCapabilities
+    });
+    setApi(api);
+    const tests = {
+        Content: contentTests
+    };
+    globalThis.tests = tests;
+    const findTest = (path, key)=>{
+        const obj = path.reduce((obj2, k)=>obj2?.[k], tests);
+        return obj?.[key];
+    };
+    window.addEventListener("message", async (event)=>{
+        if (event.source !== window) return;
+        if (event.data?.type === "OSRA_RUN_TEST") {
+            const { key, path, id } = event.data;
+            try {
+                const test = findTest(path, key);
+                if (!test) {
+                    throw new Error(`Test not found: ${[
+                        ...path,
+                        key
+                    ].join(".")}`);
+                }
+                await test();
+                window.postMessage({
+                    type: "OSRA_TEST_RESULT",
+                    id,
+                    success: true
+                }, "*");
+            } catch (error) {
+                window.postMessage({
+                    type: "OSRA_TEST_RESULT",
+                    id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error)
+                }, "*");
+            }
+        }
+        if (event.data?.type === "OSRA_PING") {
+            window.postMessage({
+                type: "OSRA_PONG"
+            }, "*");
+        }
+    });
+    window.postMessage({
+        type: "OSRA_CONTENT_READY"
+    }, "*");
+    console.log("content script");
+})();