{"version":3,"file":"@wry-C5ly1Mcc.js","sources":["../../node_modules/@wry/trie/lib/index.js","../../node_modules/@wry/caches/lib/strong.js","../../node_modules/@wry/caches/lib/weak.js","../../node_modules/@wry/context/lib/slot.js","../../node_modules/@wry/equality/lib/index.js"],"sourcesContent":["// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\n// object keys weakly, yet can also hold non-object keys, unlike the\n// native `WeakMap`.\n// If no makeData function is supplied, the looked-up data will be an empty,\n// null-prototype Object.\nconst defaultMakeData = () => Object.create(null);\n// Useful for processing arguments objects as well as arrays.\nconst { forEach, slice } = Array.prototype;\nconst { hasOwnProperty } = Object.prototype;\nexport class Trie {\n    constructor(weakness = true, makeData = defaultMakeData) {\n        this.weakness = weakness;\n        this.makeData = makeData;\n    }\n    lookup() {\n        return this.lookupArray(arguments);\n    }\n    lookupArray(array) {\n        let node = this;\n        forEach.call(array, key => node = node.getChildTrie(key));\n        return hasOwnProperty.call(node, \"data\")\n            ? node.data\n            : node.data = this.makeData(slice.call(array));\n    }\n    peek() {\n        return this.peekArray(arguments);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = node.mapFor(array[i], false);\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    remove() {\n        return this.removeArray(arguments);\n    }\n    removeArray(array) {\n        let data;\n        if (array.length) {\n            const head = array[0];\n            const map = this.mapFor(head, false);\n            const child = map && map.get(head);\n            if (child) {\n                data = child.removeArray(slice.call(array, 1));\n                if (!child.data && !child.weak && !(child.strong && child.strong.size)) {\n                    map.delete(head);\n                }\n            }\n        }\n        else {\n            data = this.data;\n            delete this.data;\n        }\n        return data;\n    }\n    getChildTrie(key) {\n        const map = this.mapFor(key, true);\n        let child = map.get(key);\n        if (!child)\n            map.set(key, child = new Trie(this.weakness, this.makeData));\n        return child;\n    }\n    mapFor(key, create) {\n        return this.weakness && isObjRef(key)\n            ? this.weak || (create ? this.weak = new WeakMap : void 0)\n            : this.strong || (create ? this.strong = new Map : void 0);\n    }\n}\nfunction isObjRef(value) {\n    switch (typeof value) {\n        case \"object\":\n            if (value === null)\n                break;\n        // Fall through to return true...\n        case \"function\":\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=index.js.map","function defaultDispose() { }\nexport class StrongCache {\n    constructor(max = Infinity, dispose = defaultDispose) {\n        this.max = max;\n        this.dispose = dispose;\n        this.map = new Map();\n        this.newest = null;\n        this.oldest = null;\n    }\n    has(key) {\n        return this.map.has(key);\n    }\n    get(key) {\n        const node = this.getNode(key);\n        return node && node.value;\n    }\n    get size() {\n        return this.map.size;\n    }\n    getNode(key) {\n        const node = this.map.get(key);\n        if (node && node !== this.newest) {\n            const { older, newer } = node;\n            if (newer) {\n                newer.older = older;\n            }\n            if (older) {\n                older.newer = newer;\n            }\n            node.older = this.newest;\n            node.older.newer = node;\n            node.newer = null;\n            this.newest = node;\n            if (node === this.oldest) {\n                this.oldest = newer;\n            }\n        }\n        return node;\n    }\n    set(key, value) {\n        let node = this.getNode(key);\n        if (node) {\n            return node.value = value;\n        }\n        node = {\n            key,\n            value,\n            newer: null,\n            older: this.newest\n        };\n        if (this.newest) {\n            this.newest.newer = node;\n        }\n        this.newest = node;\n        this.oldest = this.oldest || node;\n        this.map.set(key, node);\n        return node.value;\n    }\n    clean() {\n        while (this.oldest && this.map.size > this.max) {\n            this.delete(this.oldest.key);\n        }\n    }\n    delete(key) {\n        const node = this.map.get(key);\n        if (node) {\n            if (node === this.newest) {\n                this.newest = node.older;\n            }\n            if (node === this.oldest) {\n                this.oldest = node.newer;\n            }\n            if (node.newer) {\n                node.newer.older = node.older;\n            }\n            if (node.older) {\n                node.older.newer = node.newer;\n            }\n            this.map.delete(key);\n            this.dispose(node.value, key);\n            return true;\n        }\n        return false;\n    }\n}\n//# sourceMappingURL=strong.js.map","function noop() { }\nconst defaultDispose = noop;\nconst _WeakRef = typeof WeakRef !== \"undefined\"\n    ? WeakRef\n    : function (value) {\n        return { deref: () => value };\n    };\nconst _WeakMap = typeof WeakMap !== \"undefined\" ? WeakMap : Map;\nconst _FinalizationRegistry = typeof FinalizationRegistry !== \"undefined\"\n    ? FinalizationRegistry\n    : function () {\n        return {\n            register: noop,\n            unregister: noop,\n        };\n    };\nconst finalizationBatchSize = 10024;\nexport class WeakCache {\n    constructor(max = Infinity, dispose = defaultDispose) {\n        this.max = max;\n        this.dispose = dispose;\n        this.map = new _WeakMap();\n        this.newest = null;\n        this.oldest = null;\n        this.unfinalizedNodes = new Set();\n        this.finalizationScheduled = false;\n        this.size = 0;\n        this.finalize = () => {\n            const iterator = this.unfinalizedNodes.values();\n            for (let i = 0; i < finalizationBatchSize; i++) {\n                const node = iterator.next().value;\n                if (!node)\n                    break;\n                this.unfinalizedNodes.delete(node);\n                const key = node.key;\n                delete node.key;\n                node.keyRef = new _WeakRef(key);\n                this.registry.register(key, node, node);\n            }\n            if (this.unfinalizedNodes.size > 0) {\n                queueMicrotask(this.finalize);\n            }\n            else {\n                this.finalizationScheduled = false;\n            }\n        };\n        this.registry = new _FinalizationRegistry(this.deleteNode.bind(this));\n    }\n    has(key) {\n        return this.map.has(key);\n    }\n    get(key) {\n        const node = this.getNode(key);\n        return node && node.value;\n    }\n    getNode(key) {\n        const node = this.map.get(key);\n        if (node && node !== this.newest) {\n            const { older, newer } = node;\n            if (newer) {\n                newer.older = older;\n            }\n            if (older) {\n                older.newer = newer;\n            }\n            node.older = this.newest;\n            node.older.newer = node;\n            node.newer = null;\n            this.newest = node;\n            if (node === this.oldest) {\n                this.oldest = newer;\n            }\n        }\n        return node;\n    }\n    set(key, value) {\n        let node = this.getNode(key);\n        if (node) {\n            return (node.value = value);\n        }\n        node = {\n            key,\n            value,\n            newer: null,\n            older: this.newest,\n        };\n        if (this.newest) {\n            this.newest.newer = node;\n        }\n        this.newest = node;\n        this.oldest = this.oldest || node;\n        this.scheduleFinalization(node);\n        this.map.set(key, node);\n        this.size++;\n        return node.value;\n    }\n    clean() {\n        while (this.oldest && this.size > this.max) {\n            this.deleteNode(this.oldest);\n        }\n    }\n    deleteNode(node) {\n        if (node === this.newest) {\n            this.newest = node.older;\n        }\n        if (node === this.oldest) {\n            this.oldest = node.newer;\n        }\n        if (node.newer) {\n            node.newer.older = node.older;\n        }\n        if (node.older) {\n            node.older.newer = node.newer;\n        }\n        this.size--;\n        const key = node.key || (node.keyRef && node.keyRef.deref());\n        this.dispose(node.value, key);\n        if (!node.keyRef) {\n            this.unfinalizedNodes.delete(node);\n        }\n        else {\n            this.registry.unregister(node);\n        }\n        if (key)\n            this.map.delete(key);\n    }\n    delete(key) {\n        const node = this.map.get(key);\n        if (node) {\n            this.deleteNode(node);\n            return true;\n        }\n        return false;\n    }\n    scheduleFinalization(node) {\n        this.unfinalizedNodes.add(node);\n        if (!this.finalizationScheduled) {\n            this.finalizationScheduled = true;\n            queueMicrotask(this.finalize);\n        }\n    }\n}\n//# sourceMappingURL=weak.js.map","// This currentContext variable will only be used if the makeSlotClass\n// function is called, which happens only if this is the first copy of the\n// @wry/context package to be imported.\nlet currentContext = null;\n// This unique internal object is used to denote the absence of a value\n// for a given Slot, and is never exposed to outside code.\nconst MISSING_VALUE = {};\nlet idCounter = 1;\n// Although we can't do anything about the cost of duplicated code from\n// accidentally bundling multiple copies of the @wry/context package, we can\n// avoid creating the Slot class more than once using makeSlotClass.\nconst makeSlotClass = () => class Slot {\n    constructor() {\n        // If you have a Slot object, you can find out its slot.id, but you cannot\n        // guess the slot.id of a Slot you don't have access to, thanks to the\n        // randomized suffix.\n        this.id = [\n            \"slot\",\n            idCounter++,\n            Date.now(),\n            Math.random().toString(36).slice(2),\n        ].join(\":\");\n    }\n    hasValue() {\n        for (let context = currentContext; context; context = context.parent) {\n            // We use the Slot object iself as a key to its value, which means the\n            // value cannot be obtained without a reference to the Slot object.\n            if (this.id in context.slots) {\n                const value = context.slots[this.id];\n                if (value === MISSING_VALUE)\n                    break;\n                if (context !== currentContext) {\n                    // Cache the value in currentContext.slots so the next lookup will\n                    // be faster. This caching is safe because the tree of contexts and\n                    // the values of the slots are logically immutable.\n                    currentContext.slots[this.id] = value;\n                }\n                return true;\n            }\n        }\n        if (currentContext) {\n            // If a value was not found for this Slot, it's never going to be found\n            // no matter how many times we look it up, so we might as well cache\n            // the absence of the value, too.\n            currentContext.slots[this.id] = MISSING_VALUE;\n        }\n        return false;\n    }\n    getValue() {\n        if (this.hasValue()) {\n            return currentContext.slots[this.id];\n        }\n    }\n    withValue(value, callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        const slots = {\n            __proto__: null,\n            [this.id]: value,\n        };\n        const parent = currentContext;\n        currentContext = { parent, slots };\n        try {\n            // Function.prototype.apply allows the arguments array argument to be\n            // omitted or undefined, so args! is fine here.\n            return callback.apply(thisArg, args);\n        }\n        finally {\n            currentContext = parent;\n        }\n    }\n    // Capture the current context and wrap a callback function so that it\n    // reestablishes the captured context when called.\n    static bind(callback) {\n        const context = currentContext;\n        return function () {\n            const saved = currentContext;\n            try {\n                currentContext = context;\n                return callback.apply(this, arguments);\n            }\n            finally {\n                currentContext = saved;\n            }\n        };\n    }\n    // Immediately run a callback function without any captured context.\n    static noContext(callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        if (currentContext) {\n            const saved = currentContext;\n            try {\n                currentContext = null;\n                // Function.prototype.apply allows the arguments array argument to be\n                // omitted or undefined, so args! is fine here.\n                return callback.apply(thisArg, args);\n            }\n            finally {\n                currentContext = saved;\n            }\n        }\n        else {\n            return callback.apply(thisArg, args);\n        }\n    }\n};\nfunction maybe(fn) {\n    try {\n        return fn();\n    }\n    catch (ignored) { }\n}\n// We store a single global implementation of the Slot class as a permanent\n// non-enumerable property of the globalThis object. This obfuscation does\n// nothing to prevent access to the Slot class, but at least it ensures the\n// implementation (i.e. currentContext) cannot be tampered with, and all copies\n// of the @wry/context package (hopefully just one) will share the same Slot\n// implementation. Since the first copy of the @wry/context package to be\n// imported wins, this technique imposes a steep cost for any future breaking\n// changes to the Slot class.\nconst globalKey = \"@wry/context:Slot\";\nconst host = \n// Prefer globalThis when available.\n// https://github.com/benjamn/wryware/issues/347\nmaybe(() => globalThis) ||\n    // Fall back to global, which works in Node.js and may be converted by some\n    // bundlers to the appropriate identifier (window, self, ...) depending on the\n    // bundling target. https://github.com/endojs/endo/issues/576#issuecomment-1178515224\n    maybe(() => global) ||\n    // Otherwise, use a dummy host that's local to this module. We used to fall\n    // back to using the Array constructor as a namespace, but that was flagged in\n    // https://github.com/benjamn/wryware/issues/347, and can be avoided.\n    Object.create(null);\n// Whichever globalHost we're using, make TypeScript happy about the additional\n// globalKey property.\nconst globalHost = host;\nexport const Slot = globalHost[globalKey] ||\n    // Earlier versions of this package stored the globalKey property on the Array\n    // constructor, so we check there as well, to prevent Slot class duplication.\n    Array[globalKey] ||\n    (function (Slot) {\n        try {\n            Object.defineProperty(globalHost, globalKey, {\n                value: Slot,\n                enumerable: false,\n                writable: false,\n                // When it was possible for globalHost to be the Array constructor (a\n                // legacy Slot dedup strategy), it was important for the property to be\n                // configurable:true so it could be deleted. That does not seem to be as\n                // important when globalHost is the global object, but I don't want to\n                // cause similar problems again, and configurable:true seems safest.\n                // https://github.com/endojs/endo/issues/576#issuecomment-1178274008\n                configurable: true\n            });\n        }\n        finally {\n            return Slot;\n        }\n    })(makeSlotClass());\n//# sourceMappingURL=slot.js.map","const { toString, hasOwnProperty } = Object.prototype;\nconst fnToStr = Function.prototype.toString;\nconst previousComparisons = new Map();\n/**\n * Performs a deep equality check on two JavaScript values, tolerating cycles.\n */\nexport function equal(a, b) {\n    try {\n        return check(a, b);\n    }\n    finally {\n        previousComparisons.clear();\n    }\n}\n// Allow default imports as well.\nexport default equal;\nfunction check(a, b) {\n    // If the two values are strictly equal, our job is easy.\n    if (a === b) {\n        return true;\n    }\n    // Object.prototype.toString returns a representation of the runtime type of\n    // the given value that is considerably more precise than typeof.\n    const aTag = toString.call(a);\n    const bTag = toString.call(b);\n    // If the runtime types of a and b are different, they could maybe be equal\n    // under some interpretation of equality, but for simplicity and performance\n    // we just return false instead.\n    if (aTag !== bTag) {\n        return false;\n    }\n    switch (aTag) {\n        case '[object Array]':\n            // Arrays are a lot like other objects, but we can cheaply compare their\n            // lengths as a short-cut before comparing their elements.\n            if (a.length !== b.length)\n                return false;\n        // Fall through to object case...\n        case '[object Object]': {\n            if (previouslyCompared(a, b))\n                return true;\n            const aKeys = definedKeys(a);\n            const bKeys = definedKeys(b);\n            // If `a` and `b` have a different number of enumerable keys, they\n            // must be different.\n            const keyCount = aKeys.length;\n            if (keyCount !== bKeys.length)\n                return false;\n            // Now make sure they have the same keys.\n            for (let k = 0; k < keyCount; ++k) {\n                if (!hasOwnProperty.call(b, aKeys[k])) {\n                    return false;\n                }\n            }\n            // Finally, check deep equality of all child properties.\n            for (let k = 0; k < keyCount; ++k) {\n                const key = aKeys[k];\n                if (!check(a[key], b[key])) {\n                    return false;\n                }\n            }\n            return true;\n        }\n        case '[object Error]':\n            return a.name === b.name && a.message === b.message;\n        case '[object Number]':\n            // Handle NaN, which is !== itself.\n            if (a !== a)\n                return b !== b;\n        // Fall through to shared +a === +b case...\n        case '[object Boolean]':\n        case '[object Date]':\n            return +a === +b;\n        case '[object RegExp]':\n        case '[object String]':\n            return a == `${b}`;\n        case '[object Map]':\n        case '[object Set]': {\n            if (a.size !== b.size)\n                return false;\n            if (previouslyCompared(a, b))\n                return true;\n            const aIterator = a.entries();\n            const isMap = aTag === '[object Map]';\n            while (true) {\n                const info = aIterator.next();\n                if (info.done)\n                    break;\n                // If a instanceof Set, aValue === aKey.\n                const [aKey, aValue] = info.value;\n                // So this works the same way for both Set and Map.\n                if (!b.has(aKey)) {\n                    return false;\n                }\n                // However, we care about deep equality of values only when dealing\n                // with Map structures.\n                if (isMap && !check(aValue, b.get(aKey))) {\n                    return false;\n                }\n            }\n            return true;\n        }\n        case '[object Uint16Array]':\n        case '[object Uint8Array]': // Buffer, in Node.js.\n        case '[object Uint32Array]':\n        case '[object Int32Array]':\n        case '[object Int8Array]':\n        case '[object Int16Array]':\n        case '[object ArrayBuffer]':\n            // DataView doesn't need these conversions, but the equality check is\n            // otherwise the same.\n            a = new Uint8Array(a);\n            b = new Uint8Array(b);\n        // Fall through...\n        case '[object DataView]': {\n            let len = a.byteLength;\n            if (len === b.byteLength) {\n                while (len-- && a[len] === b[len]) {\n                    // Keep looping as long as the bytes are equal.\n                }\n            }\n            return len === -1;\n        }\n        case '[object AsyncFunction]':\n        case '[object GeneratorFunction]':\n        case '[object AsyncGeneratorFunction]':\n        case '[object Function]': {\n            const aCode = fnToStr.call(a);\n            if (aCode !== fnToStr.call(b)) {\n                return false;\n            }\n            // We consider non-native functions equal if they have the same code\n            // (native functions require === because their code is censored).\n            // Note that this behavior is not entirely sound, since !== function\n            // objects with the same code can behave differently depending on\n            // their closure scope. However, any function can behave differently\n            // depending on the values of its input arguments (including this)\n            // and its calling context (including its closure scope), even\n            // though the function object is === to itself; and it is entirely\n            // possible for functions that are not === to behave exactly the\n            // same under all conceivable circumstances. Because none of these\n            // factors are statically decidable in JavaScript, JS function\n            // equality is not well-defined. This ambiguity allows us to\n            // consider the best possible heuristic among various imperfect\n            // options, and equating non-native functions that have the same\n            // code has enormous practical benefits, such as when comparing\n            // functions that are repeatedly passed as fresh function\n            // expressions within objects that are otherwise deeply equal. Since\n            // any function created from the same syntactic expression (in the\n            // same code location) will always stringify to the same code\n            // according to fnToStr.call, we can reasonably expect these\n            // repeatedly passed function expressions to have the same code, and\n            // thus behave \"the same\" (with all the caveats mentioned above),\n            // even though the runtime function objects are !== to one another.\n            return !endsWith(aCode, nativeCodeSuffix);\n        }\n    }\n    // Otherwise the values are not equal.\n    return false;\n}\nfunction definedKeys(obj) {\n    // Remember that the second argument to Array.prototype.filter will be\n    // used as `this` within the callback function.\n    return Object.keys(obj).filter(isDefinedKey, obj);\n}\nfunction isDefinedKey(key) {\n    return this[key] !== void 0;\n}\nconst nativeCodeSuffix = \"{ [native code] }\";\nfunction endsWith(full, suffix) {\n    const fromIndex = full.length - suffix.length;\n    return fromIndex >= 0 &&\n        full.indexOf(suffix, fromIndex) === fromIndex;\n}\nfunction previouslyCompared(a, b) {\n    // Though cyclic references can make an object graph appear infinite from the\n    // perspective of a depth-first traversal, the graph still contains a finite\n    // number of distinct object references. We use the previousComparisons cache\n    // to avoid comparing the same pair of object references more than once, which\n    // guarantees termination (even if we end up comparing every object in one\n    // graph to every object in the other graph, which is extremely unlikely),\n    // while still allowing weird isomorphic structures (like rings with different\n    // lengths) a chance to pass the equality test.\n    let bSet = previousComparisons.get(a);\n    if (bSet) {\n        // Return true here because we can be sure false will be returned somewhere\n        // else if the objects are not equivalent.\n        if (bSet.has(b))\n            return true;\n    }\n    else {\n        previousComparisons.set(a, bSet = new Set);\n    }\n    bSet.add(b);\n    return false;\n}\n//# sourceMappingURL=index.js.map"],"names":["defaultMakeData","Object","create","forEach","slice","Array","prototype","hasOwnProperty","Trie","constructor","weakness","makeData","this","lookup","lookupArray","arguments","array","node","call","key","getChildTrie","data","peek","peekArray","i","len","length","map","mapFor","get","remove","removeArray","head","child","weak","strong","size","delete","set","value","isObjRef","WeakMap","Map","defaultDispose","StrongCache","max","Infinity","dispose","newest","oldest","has","getNode","older","newer","clean","noop","_WeakRef","WeakRef","deref","_WeakMap","_FinalizationRegistry","FinalizationRegistry","register","unregister","WeakCache","unfinalizedNodes","Set","finalizationScheduled","finalize","iterator","values","next","keyRef","registry","queueMicrotask","deleteNode","bind","scheduleFinalization","add","currentContext","MISSING_VALUE","idCounter","maybe","fn","ignored","globalKey","globalHost","globalThis","global","Slot","defineProperty","enumerable","writable","configurable","id","Date","now","Math","random","toString","join","hasValue","context","parent","slots","getValue","withValue","callback","args","thisArg","__proto__","apply","saved","noContext","fnToStr","Function","previousComparisons","equal","a","b","check","clear","aTag","previouslyCompared","aKeys","definedKeys","bKeys","keyCount","k","name","message","aIterator","entries","isMap","info","done","aKey","aValue","Uint8Array","byteLength","aCode","full","suffix","fromIndex","indexOf","endsWith","nativeCodeSuffix","obj","keys","filter","isDefinedKey","bSet"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4]}