{"version":3,"file":"js/chunk-vendors-d3fed2bc.10382e0a.js","mappings":"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","sources":["webpack://nologo-studios-website.vue.webclient/./node_modules/@wry/context/lib/slot.js","webpack://nologo-studios-website.vue.webclient/./node_modules/@wry/context/lib/index.js","webpack://nologo-studios-website.vue.webclient/./node_modules/@wry/equality/lib/index.js","webpack://nologo-studios-website.vue.webclient/./node_modules/@wry/trie/lib/index.js"],"sourcesContent":["// 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","import { Slot } from \"./slot.js\";\nexport { Slot };\nexport const { bind, noContext } = Slot;\n// Like global.setTimeout, except the callback runs with captured context.\nexport { setTimeoutWithContext as setTimeout };\nfunction setTimeoutWithContext(callback, delay) {\n    return setTimeout(bind(callback), delay);\n}\n// Turn any generator function into an async function (using yield instead\n// of await), with context automatically preserved across yields.\nexport function asyncFromGen(genFn) {\n    return function () {\n        const gen = genFn.apply(this, arguments);\n        const boundNext = bind(gen.next);\n        const boundThrow = bind(gen.throw);\n        return new Promise((resolve, reject) => {\n            function invoke(method, argument) {\n                try {\n                    var result = method.call(gen, argument);\n                }\n                catch (error) {\n                    return reject(error);\n                }\n                const next = result.done ? resolve : invokeNext;\n                if (isPromiseLike(result.value)) {\n                    result.value.then(next, result.done ? reject : invokeThrow);\n                }\n                else {\n                    next(result.value);\n                }\n            }\n            const invokeNext = (value) => invoke(boundNext, value);\n            const invokeThrow = (error) => invoke(boundThrow, error);\n            invokeNext();\n        });\n    };\n}\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\n// If you use the fibers npm package to implement coroutines in Node.js,\n// you should call this function at least once to ensure context management\n// remains coherent across any yields.\nconst wrappedFibers = [];\nexport function wrapYieldingFiberMethods(Fiber) {\n    // There can be only one implementation of Fiber per process, so this array\n    // should never grow longer than one element.\n    if (wrappedFibers.indexOf(Fiber) < 0) {\n        const wrap = (obj, method) => {\n            const fn = obj[method];\n            obj[method] = function () {\n                return noContext(fn, arguments, this);\n            };\n        };\n        // These methods can yield, according to\n        // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\n        wrap(Fiber, \"yield\");\n        wrap(Fiber.prototype, \"run\");\n        wrap(Fiber.prototype, \"throwInto\");\n        wrappedFibers.push(Fiber);\n    }\n    return Fiber;\n}\n//# sourceMappingURL=index.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","// 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(...array) {\n        return this.lookupArray(array);\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(...array) {\n        return this.peekArray(array);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = this.weakness && isObjRef(array[i]) ? node.weak : node.strong;\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    getChildTrie(key) {\n        const map = this.weakness && isObjRef(key)\n            ? this.weak || (this.weak = new WeakMap())\n            : this.strong || (this.strong = new Map());\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}\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"],"names":["currentContext","MISSING_VALUE","idCounter","makeSlotClass","constructor","this","id","Date","now","Math","random","toString","slice","join","hasValue","context","parent","slots","value","getValue","withValue","callback","args","thisArg","__proto__","apply","bind","saved","arguments","noContext","maybe","fn","ignored","globalKey","host","globalThis","global","Object","create","globalHost","Slot","Array","defineProperty","enumerable","writable","configurable","hasOwnProperty","prototype","fnToStr","Function","previousComparisons","Map","equal","a","b","check","clear","aTag","call","bTag","length","previouslyCompared","aKeys","definedKeys","bKeys","keyCount","k","key","name","message","size","aIterator","entries","isMap","info","next","done","aKey","aValue","has","get","Uint8Array","len","byteLength","aCode","endsWith","nativeCodeSuffix","obj","keys","filter","isDefinedKey","full","suffix","fromIndex","indexOf","bSet","set","Set","add","defaultMakeData","forEach","Trie","weakness","makeData","lookup","array","lookupArray","node","getChildTrie","data","peek","peekArray","i","map","isObjRef","weak","strong","WeakMap","child"],"sourceRoot":""}