react-easy-wall 2.0.0 → 2.0.3

package/dist/cjs/node_modules/optimism/lib/entry.cjs

@@ -0,0 +1,306 @@
+'use strict';
+
+var context = require('./context.cjs');
+var helpers = require('./helpers.cjs');
+
+const emptySetPool = [];
+const POOL_TARGET_SIZE = 100;
+// Since this package might be used browsers, we should avoid using the
+// Node built-in assert module.
+function assert(condition, optionalMessage) {
+    if (!condition) {
+        throw new Error(optionalMessage || "assertion failure");
+    }
+}
+function valueIs(a, b) {
+    const len = a.length;
+    return (
+    // Unknown values are not equal to each other.
+    len > 0 &&
+        // Both values must be ordinary (or both exceptional) to be equal.
+        len === b.length &&
+        // The underlying value or exception must be the same.
+        a[len - 1] === b[len - 1]);
+}
+function valueGet(value) {
+    switch (value.length) {
+        case 0: throw new Error("unknown value");
+        case 1: return value[0];
+        case 2: throw value[1];
+    }
+}
+function valueCopy(value) {
+    return value.slice(0);
+}
+class Entry {
+    constructor(fn) {
+        this.fn = fn;
+        this.parents = new Set();
+        this.childValues = new Map();
+        // When this Entry has children that are dirty, this property becomes
+        // a Set containing other Entry objects, borrowed from emptySetPool.
+        // When the set becomes empty, it gets recycled back to emptySetPool.
+        this.dirtyChildren = null;
+        this.dirty = true;
+        this.recomputing = false;
+        this.value = [];
+        this.deps = null;
+        ++Entry.count;
+    }
+    peek() {
+        if (this.value.length === 1 && !mightBeDirty(this)) {
+            rememberParent(this);
+            return this.value[0];
+        }
+    }
+    // This is the most important method of the Entry API, because it
+    // determines whether the cached this.value can be returned immediately,
+    // or must be recomputed. The overall performance of the caching system
+    // depends on the truth of the following observations: (1) this.dirty is
+    // usually false, (2) this.dirtyChildren is usually null/empty, and thus
+    // (3) valueGet(this.value) is usually returned without recomputation.
+    recompute(args) {
+        assert(!this.recomputing, "already recomputing");
+        rememberParent(this);
+        return mightBeDirty(this)
+            ? reallyRecompute(this, args)
+            : valueGet(this.value);
+    }
+    setDirty() {
+        if (this.dirty)
+            return;
+        this.dirty = true;
+        reportDirty(this);
+        // We can go ahead and unsubscribe here, since any further dirty
+        // notifications we receive will be redundant, and unsubscribing may
+        // free up some resources, e.g. file watchers.
+        helpers.maybeUnsubscribe(this);
+    }
+    dispose() {
+        this.setDirty();
+        // Sever any dependency relationships with our own children, so those
+        // children don't retain this parent Entry in their child.parents sets,
+        // thereby preventing it from being fully garbage collected.
+        forgetChildren(this);
+        // Because this entry has been kicked out of the cache (in index.js),
+        // we've lost the ability to find out if/when this entry becomes dirty,
+        // whether that happens through a subscription, because of a direct call
+        // to entry.setDirty(), or because one of its children becomes dirty.
+        // Because of this loss of future information, we have to assume the
+        // worst (that this entry might have become dirty very soon), so we must
+        // immediately mark this entry's parents as dirty. Normally we could
+        // just call entry.setDirty() rather than calling parent.setDirty() for
+        // each parent, but that would leave this entry in parent.childValues
+        // and parent.dirtyChildren, which would prevent the child from being
+        // truly forgotten.
+        eachParent(this, (parent, child) => {
+            parent.setDirty();
+            forgetChild(parent, this);
+        });
+    }
+    forget() {
+        // The code that creates Entry objects in index.ts will replace this method
+        // with one that actually removes the Entry from the cache, which will also
+        // trigger the entry.dispose method.
+        this.dispose();
+    }
+    dependOn(dep) {
+        dep.add(this);
+        if (!this.deps) {
+            this.deps = emptySetPool.pop() || new Set();
+        }
+        this.deps.add(dep);
+    }
+    forgetDeps() {
+        if (this.deps) {
+            helpers.arrayFromSet(this.deps).forEach(dep => dep.delete(this));
+            this.deps.clear();
+            emptySetPool.push(this.deps);
+            this.deps = null;
+        }
+    }
+}
+Entry.count = 0;
+function rememberParent(child) {
+    const parent = context.parentEntrySlot.getValue();
+    if (parent) {
+        child.parents.add(parent);
+        if (!parent.childValues.has(child)) {
+            parent.childValues.set(child, []);
+        }
+        if (mightBeDirty(child)) {
+            reportDirtyChild(parent, child);
+        }
+        else {
+            reportCleanChild(parent, child);
+        }
+        return parent;
+    }
+}
+function reallyRecompute(entry, args) {
+    forgetChildren(entry);
+    // Set entry as the parent entry while calling recomputeNewValue(entry).
+    context.parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);
+    if (maybeSubscribe(entry, args)) {
+        // If we successfully recomputed entry.value and did not fail to
+        // (re)subscribe, then this Entry is no longer explicitly dirty.
+        setClean(entry);
+    }
+    return valueGet(entry.value);
+}
+function recomputeNewValue(entry, args) {
+    entry.recomputing = true;
+    const { normalizeResult } = entry;
+    let oldValueCopy;
+    if (normalizeResult && entry.value.length === 1) {
+        oldValueCopy = valueCopy(entry.value);
+    }
+    // Make entry.value an empty array, representing an unknown value.
+    entry.value.length = 0;
+    try {
+        // If entry.fn succeeds, entry.value will become a normal Value.
+        entry.value[0] = entry.fn.apply(null, args);
+        // If we have a viable oldValueCopy to compare with the (successfully
+        // recomputed) new entry.value, and they are not already === identical, give
+        // normalizeResult a chance to pick/choose/reuse parts of oldValueCopy[0]
+        // and/or entry.value[0] to determine the final cached entry.value.
+        if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) {
+            try {
+                entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]);
+            }
+            catch (_a) {
+                // If normalizeResult throws, just use the newer value, rather than
+                // saving the exception as entry.value[1].
+            }
+        }
+    }
+    catch (e) {
+        // If entry.fn throws, entry.value will hold that exception.
+        entry.value[1] = e;
+    }
+    // Either way, this line is always reached.
+    entry.recomputing = false;
+}
+function mightBeDirty(entry) {
+    return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);
+}
+function setClean(entry) {
+    entry.dirty = false;
+    if (mightBeDirty(entry)) {
+        // This Entry may still have dirty children, in which case we can't
+        // let our parents know we're clean just yet.
+        return;
+    }
+    reportClean(entry);
+}
+function reportDirty(child) {
+    eachParent(child, reportDirtyChild);
+}
+function reportClean(child) {
+    eachParent(child, reportCleanChild);
+}
+function eachParent(child, callback) {
+    const parentCount = child.parents.size;
+    if (parentCount) {
+        const parents = helpers.arrayFromSet(child.parents);
+        for (let i = 0; i < parentCount; ++i) {
+            callback(parents[i], child);
+        }
+    }
+}
+// Let a parent Entry know that one of its children may be dirty.
+function reportDirtyChild(parent, child) {
+    // Must have called rememberParent(child) before calling
+    // reportDirtyChild(parent, child).
+    assert(parent.childValues.has(child));
+    assert(mightBeDirty(child));
+    const parentWasClean = !mightBeDirty(parent);
+    if (!parent.dirtyChildren) {
+        parent.dirtyChildren = emptySetPool.pop() || new Set;
+    }
+    else if (parent.dirtyChildren.has(child)) {
+        // If we already know this child is dirty, then we must have already
+        // informed our own parents that we are dirty, so we can terminate
+        // the recursion early.
+        return;
+    }
+    parent.dirtyChildren.add(child);
+    // If parent was clean before, it just became (possibly) dirty (according to
+    // mightBeDirty), since we just added child to parent.dirtyChildren.
+    if (parentWasClean) {
+        reportDirty(parent);
+    }
+}
+// Let a parent Entry know that one of its children is no longer dirty.
+function reportCleanChild(parent, child) {
+    // Must have called rememberChild(child) before calling
+    // reportCleanChild(parent, child).
+    assert(parent.childValues.has(child));
+    assert(!mightBeDirty(child));
+    const childValue = parent.childValues.get(child);
+    if (childValue.length === 0) {
+        parent.childValues.set(child, valueCopy(child.value));
+    }
+    else if (!valueIs(childValue, child.value)) {
+        parent.setDirty();
+    }
+    removeDirtyChild(parent, child);
+    if (mightBeDirty(parent)) {
+        return;
+    }
+    reportClean(parent);
+}
+function removeDirtyChild(parent, child) {
+    const dc = parent.dirtyChildren;
+    if (dc) {
+        dc.delete(child);
+        if (dc.size === 0) {
+            if (emptySetPool.length < POOL_TARGET_SIZE) {
+                emptySetPool.push(dc);
+            }
+            parent.dirtyChildren = null;
+        }
+    }
+}
+// Removes all children from this entry and returns an array of the
+// removed children.
+function forgetChildren(parent) {
+    if (parent.childValues.size > 0) {
+        parent.childValues.forEach((_value, child) => {
+            forgetChild(parent, child);
+        });
+    }
+    // Remove this parent Entry from any sets to which it was added by the
+    // addToSet method.
+    parent.forgetDeps();
+    // After we forget all our children, this.dirtyChildren must be empty
+    // and therefore must have been reset to null.
+    assert(parent.dirtyChildren === null);
+}
+function forgetChild(parent, child) {
+    child.parents.delete(parent);
+    parent.childValues.delete(child);
+    removeDirtyChild(parent, child);
+}
+function maybeSubscribe(entry, args) {
+    if (typeof entry.subscribe === "function") {
+        try {
+            helpers.maybeUnsubscribe(entry); // Prevent double subscriptions.
+            entry.unsubscribe = entry.subscribe.apply(null, args);
+        }
+        catch (e) {
+            // If this Entry has a subscribe function and it threw an exception
+            // (or an unsubscribe function it previously returned now throws),
+            // return false to indicate that we were not able to subscribe (or
+            // unsubscribe), and this Entry should remain dirty.
+            entry.setDirty();
+            return false;
+        }
+    }
+    // Returning true indicates either that there was no entry.subscribe
+    // function or that it succeeded.
+    return true;
+}
+
+exports.Entry = Entry;
+//# sourceMappingURL=entry.cjs.map

package/dist/cjs/node_modules/optimism/lib/entry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.cjs","sources":["../../../../../node_modules/optimism/lib/entry.js"],"sourcesContent":["import { parentEntrySlot } from \"./context.js\";\nimport { maybeUnsubscribe, arrayFromSet } from \"./helpers.js\";\nconst emptySetPool = [];\nconst POOL_TARGET_SIZE = 100;\n// Since this package might be used browsers, we should avoid using the\n// Node built-in assert module.\nfunction assert(condition, optionalMessage) {\n    if (!condition) {\n        throw new Error(optionalMessage || \"assertion failure\");\n    }\n}\nfunction valueIs(a, b) {\n    const len = a.length;\n    return (\n    // Unknown values are not equal to each other.\n    len > 0 &&\n        // Both values must be ordinary (or both exceptional) to be equal.\n        len === b.length &&\n        // The underlying value or exception must be the same.\n        a[len - 1] === b[len - 1]);\n}\nfunction valueGet(value) {\n    switch (value.length) {\n        case 0: throw new Error(\"unknown value\");\n        case 1: return value[0];\n        case 2: throw value[1];\n    }\n}\nfunction valueCopy(value) {\n    return value.slice(0);\n}\nexport class Entry {\n    constructor(fn) {\n        this.fn = fn;\n        this.parents = new Set();\n        this.childValues = new Map();\n        // When this Entry has children that are dirty, this property becomes\n        // a Set containing other Entry objects, borrowed from emptySetPool.\n        // When the set becomes empty, it gets recycled back to emptySetPool.\n        this.dirtyChildren = null;\n        this.dirty = true;\n        this.recomputing = false;\n        this.value = [];\n        this.deps = null;\n        ++Entry.count;\n    }\n    peek() {\n        if (this.value.length === 1 && !mightBeDirty(this)) {\n            rememberParent(this);\n            return this.value[0];\n        }\n    }\n    // This is the most important method of the Entry API, because it\n    // determines whether the cached this.value can be returned immediately,\n    // or must be recomputed. The overall performance of the caching system\n    // depends on the truth of the following observations: (1) this.dirty is\n    // usually false, (2) this.dirtyChildren is usually null/empty, and thus\n    // (3) valueGet(this.value) is usually returned without recomputation.\n    recompute(args) {\n        assert(!this.recomputing, \"already recomputing\");\n        rememberParent(this);\n        return mightBeDirty(this)\n            ? reallyRecompute(this, args)\n            : valueGet(this.value);\n    }\n    setDirty() {\n        if (this.dirty)\n            return;\n        this.dirty = true;\n        reportDirty(this);\n        // We can go ahead and unsubscribe here, since any further dirty\n        // notifications we receive will be redundant, and unsubscribing may\n        // free up some resources, e.g. file watchers.\n        maybeUnsubscribe(this);\n    }\n    dispose() {\n        this.setDirty();\n        // Sever any dependency relationships with our own children, so those\n        // children don't retain this parent Entry in their child.parents sets,\n        // thereby preventing it from being fully garbage collected.\n        forgetChildren(this);\n        // Because this entry has been kicked out of the cache (in index.js),\n        // we've lost the ability to find out if/when this entry becomes dirty,\n        // whether that happens through a subscription, because of a direct call\n        // to entry.setDirty(), or because one of its children becomes dirty.\n        // Because of this loss of future information, we have to assume the\n        // worst (that this entry might have become dirty very soon), so we must\n        // immediately mark this entry's parents as dirty. Normally we could\n        // just call entry.setDirty() rather than calling parent.setDirty() for\n        // each parent, but that would leave this entry in parent.childValues\n        // and parent.dirtyChildren, which would prevent the child from being\n        // truly forgotten.\n        eachParent(this, (parent, child) => {\n            parent.setDirty();\n            forgetChild(parent, this);\n        });\n    }\n    forget() {\n        // The code that creates Entry objects in index.ts will replace this method\n        // with one that actually removes the Entry from the cache, which will also\n        // trigger the entry.dispose method.\n        this.dispose();\n    }\n    dependOn(dep) {\n        dep.add(this);\n        if (!this.deps) {\n            this.deps = emptySetPool.pop() || new Set();\n        }\n        this.deps.add(dep);\n    }\n    forgetDeps() {\n        if (this.deps) {\n            arrayFromSet(this.deps).forEach(dep => dep.delete(this));\n            this.deps.clear();\n            emptySetPool.push(this.deps);\n            this.deps = null;\n        }\n    }\n}\nEntry.count = 0;\nfunction rememberParent(child) {\n    const parent = parentEntrySlot.getValue();\n    if (parent) {\n        child.parents.add(parent);\n        if (!parent.childValues.has(child)) {\n            parent.childValues.set(child, []);\n        }\n        if (mightBeDirty(child)) {\n            reportDirtyChild(parent, child);\n        }\n        else {\n            reportCleanChild(parent, child);\n        }\n        return parent;\n    }\n}\nfunction reallyRecompute(entry, args) {\n    forgetChildren(entry);\n    // Set entry as the parent entry while calling recomputeNewValue(entry).\n    parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);\n    if (maybeSubscribe(entry, args)) {\n        // If we successfully recomputed entry.value and did not fail to\n        // (re)subscribe, then this Entry is no longer explicitly dirty.\n        setClean(entry);\n    }\n    return valueGet(entry.value);\n}\nfunction recomputeNewValue(entry, args) {\n    entry.recomputing = true;\n    const { normalizeResult } = entry;\n    let oldValueCopy;\n    if (normalizeResult && entry.value.length === 1) {\n        oldValueCopy = valueCopy(entry.value);\n    }\n    // Make entry.value an empty array, representing an unknown value.\n    entry.value.length = 0;\n    try {\n        // If entry.fn succeeds, entry.value will become a normal Value.\n        entry.value[0] = entry.fn.apply(null, args);\n        // If we have a viable oldValueCopy to compare with the (successfully\n        // recomputed) new entry.value, and they are not already === identical, give\n        // normalizeResult a chance to pick/choose/reuse parts of oldValueCopy[0]\n        // and/or entry.value[0] to determine the final cached entry.value.\n        if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) {\n            try {\n                entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]);\n            }\n            catch (_a) {\n                // If normalizeResult throws, just use the newer value, rather than\n                // saving the exception as entry.value[1].\n            }\n        }\n    }\n    catch (e) {\n        // If entry.fn throws, entry.value will hold that exception.\n        entry.value[1] = e;\n    }\n    // Either way, this line is always reached.\n    entry.recomputing = false;\n}\nfunction mightBeDirty(entry) {\n    return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\n}\nfunction setClean(entry) {\n    entry.dirty = false;\n    if (mightBeDirty(entry)) {\n        // This Entry may still have dirty children, in which case we can't\n        // let our parents know we're clean just yet.\n        return;\n    }\n    reportClean(entry);\n}\nfunction reportDirty(child) {\n    eachParent(child, reportDirtyChild);\n}\nfunction reportClean(child) {\n    eachParent(child, reportCleanChild);\n}\nfunction eachParent(child, callback) {\n    const parentCount = child.parents.size;\n    if (parentCount) {\n        const parents = arrayFromSet(child.parents);\n        for (let i = 0; i < parentCount; ++i) {\n            callback(parents[i], child);\n        }\n    }\n}\n// Let a parent Entry know that one of its children may be dirty.\nfunction reportDirtyChild(parent, child) {\n    // Must have called rememberParent(child) before calling\n    // reportDirtyChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(mightBeDirty(child));\n    const parentWasClean = !mightBeDirty(parent);\n    if (!parent.dirtyChildren) {\n        parent.dirtyChildren = emptySetPool.pop() || new Set;\n    }\n    else if (parent.dirtyChildren.has(child)) {\n        // If we already know this child is dirty, then we must have already\n        // informed our own parents that we are dirty, so we can terminate\n        // the recursion early.\n        return;\n    }\n    parent.dirtyChildren.add(child);\n    // If parent was clean before, it just became (possibly) dirty (according to\n    // mightBeDirty), since we just added child to parent.dirtyChildren.\n    if (parentWasClean) {\n        reportDirty(parent);\n    }\n}\n// Let a parent Entry know that one of its children is no longer dirty.\nfunction reportCleanChild(parent, child) {\n    // Must have called rememberChild(child) before calling\n    // reportCleanChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(!mightBeDirty(child));\n    const childValue = parent.childValues.get(child);\n    if (childValue.length === 0) {\n        parent.childValues.set(child, valueCopy(child.value));\n    }\n    else if (!valueIs(childValue, child.value)) {\n        parent.setDirty();\n    }\n    removeDirtyChild(parent, child);\n    if (mightBeDirty(parent)) {\n        return;\n    }\n    reportClean(parent);\n}\nfunction removeDirtyChild(parent, child) {\n    const dc = parent.dirtyChildren;\n    if (dc) {\n        dc.delete(child);\n        if (dc.size === 0) {\n            if (emptySetPool.length < POOL_TARGET_SIZE) {\n                emptySetPool.push(dc);\n            }\n            parent.dirtyChildren = null;\n        }\n    }\n}\n// Removes all children from this entry and returns an array of the\n// removed children.\nfunction forgetChildren(parent) {\n    if (parent.childValues.size > 0) {\n        parent.childValues.forEach((_value, child) => {\n            forgetChild(parent, child);\n        });\n    }\n    // Remove this parent Entry from any sets to which it was added by the\n    // addToSet method.\n    parent.forgetDeps();\n    // After we forget all our children, this.dirtyChildren must be empty\n    // and therefore must have been reset to null.\n    assert(parent.dirtyChildren === null);\n}\nfunction forgetChild(parent, child) {\n    child.parents.delete(parent);\n    parent.childValues.delete(child);\n    removeDirtyChild(parent, child);\n}\nfunction maybeSubscribe(entry, args) {\n    if (typeof entry.subscribe === \"function\") {\n        try {\n            maybeUnsubscribe(entry); // Prevent double subscriptions.\n            entry.unsubscribe = entry.subscribe.apply(null, args);\n        }\n        catch (e) {\n            // If this Entry has a subscribe function and it threw an exception\n            // (or an unsubscribe function it previously returned now throws),\n            // return false to indicate that we were not able to subscribe (or\n            // unsubscribe), and this Entry should remain dirty.\n            entry.setDirty();\n            return false;\n        }\n    }\n    // Returning true indicates either that there was no entry.subscribe\n    // function or that it succeeded.\n    return true;\n}\n//# sourceMappingURL=entry.js.map"],"names":["maybeUnsubscribe","arrayFromSet","parentEntrySlot"],"mappings":";;;;;AAEA,MAAM,YAAY,GAAG,EAAE;AACvB,MAAM,gBAAgB,GAAG,GAAG;AAC5B;AACA;AACA,SAAS,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE;AAC5C,IAAI,IAAI,CAAC,SAAS,EAAE;AACpB,QAAQ,MAAM,IAAI,KAAK,CAAC,eAAe,IAAI,mBAAmB,CAAC;AAC/D,IAAI;AACJ;AACA,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE;AACvB,IAAI,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM;AACxB,IAAI;AACJ;AACA,IAAI,GAAG,GAAG,CAAC;AACX;AACA,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM;AACxB;AACA,QAAQ,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;AACjC;AACA,SAAS,QAAQ,CAAC,KAAK,EAAE;AACzB,IAAI,QAAQ,KAAK,CAAC,MAAM;AACxB,QAAQ,KAAK,CAAC,EAAE,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC;AAChD,QAAQ,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC;AAC/B,QAAQ,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC,CAAC,CAAC;AAC9B;AACA;AACA,SAAS,SAAS,CAAC,KAAK,EAAE;AAC1B,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AACzB;AACO,MAAM,KAAK,CAAC;AACnB,IAAI,WAAW,CAAC,EAAE,EAAE;AACpB,QAAQ,IAAI,CAAC,EAAE,GAAG,EAAE;AACpB,QAAQ,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE;AAChC,QAAQ,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,EAAE;AACpC;AACA;AACA;AACA,QAAQ,IAAI,CAAC,aAAa,GAAG,IAAI;AACjC,QAAQ,IAAI,CAAC,KAAK,GAAG,IAAI;AACzB,QAAQ,IAAI,CAAC,WAAW,GAAG,KAAK;AAChC,QAAQ,IAAI,CAAC,KAAK,GAAG,EAAE;AACvB,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI;AACxB,QAAQ,EAAE,KAAK,CAAC,KAAK;AACrB,IAAI;AACJ,IAAI,IAAI,GAAG;AACX,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;AAC5D,YAAY,cAAc,CAAC,IAAI,CAAC;AAChC,YAAY,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAChC,QAAQ;AACR,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,CAAC,IAAI,EAAE;AACpB,QAAQ,MAAM,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,CAAC;AACxD,QAAQ,cAAc,CAAC,IAAI,CAAC;AAC5B,QAAQ,OAAO,YAAY,CAAC,IAAI;AAChC,cAAc,eAAe,CAAC,IAAI,EAAE,IAAI;AACxC,cAAc,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;AAClC,IAAI;AACJ,IAAI,QAAQ,GAAG;AACf,QAAQ,IAAI,IAAI,CAAC,KAAK;AACtB,YAAY;AACZ,QAAQ,IAAI,CAAC,KAAK,GAAG,IAAI;AACzB,QAAQ,WAAW,CAAC,IAAI,CAAC;AACzB;AACA;AACA;AACA,QAAQA,wBAAgB,CAAC,IAAI,CAAC;AAC9B,IAAI;AACJ,IAAI,OAAO,GAAG;AACd,QAAQ,IAAI,CAAC,QAAQ,EAAE;AACvB;AACA;AACA;AACA,QAAQ,cAAc,CAAC,IAAI,CAAC;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,UAAU,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,KAAK,KAAK;AAC5C,YAAY,MAAM,CAAC,QAAQ,EAAE;AAC7B,YAAY,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC;AACrC,QAAQ,CAAC,CAAC;AACV,IAAI;AACJ,IAAI,MAAM,GAAG;AACb;AACA;AACA;AACA,QAAQ,IAAI,CAAC,OAAO,EAAE;AACtB,IAAI;AACJ,IAAI,QAAQ,CAAC,GAAG,EAAE;AAClB,QAAQ,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;AACrB,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;AACxB,YAAY,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE;AACvD,QAAQ;AACR,QAAQ,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;AAC1B,IAAI;AACJ,IAAI,UAAU,GAAG;AACjB,QAAQ,IAAI,IAAI,CAAC,IAAI,EAAE;AACvB,YAAYC,oBAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACpE,YAAY,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;AAC7B,YAAY,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AACxC,YAAY,IAAI,CAAC,IAAI,GAAG,IAAI;AAC5B,QAAQ;AACR,IAAI;AACJ;AACA,KAAK,CAAC,KAAK,GAAG,CAAC;AACf,SAAS,cAAc,CAAC,KAAK,EAAE;AAC/B,IAAI,MAAM,MAAM,GAAGC,uBAAe,CAAC,QAAQ,EAAE;AAC7C,IAAI,IAAI,MAAM,EAAE;AAChB,QAAQ,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;AACjC,QAAQ,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;AAC5C,YAAY,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC;AAC7C,QAAQ;AACR,QAAQ,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;AACjC,YAAY,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC;AAC3C,QAAQ;AACR,aAAa;AACb,YAAY,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC;AAC3C,QAAQ;AACR,QAAQ,OAAO,MAAM;AACrB,IAAI;AACJ;AACA,SAAS,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE;AACtC,IAAI,cAAc,CAAC,KAAK,CAAC;AACzB;AACA,IAAIA,uBAAe,CAAC,SAAS,CAAC,KAAK,EAAE,iBAAiB,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACtE,IAAI,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE;AACrC;AACA;AACA,QAAQ,QAAQ,CAAC,KAAK,CAAC;AACvB,IAAI;AACJ,IAAI,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;AAChC;AACA,SAAS,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE;AACxC,IAAI,KAAK,CAAC,WAAW,GAAG,IAAI;AAC5B,IAAI,MAAM,EAAE,eAAe,EAAE,GAAG,KAAK;AACrC,IAAI,IAAI,YAAY;AACpB,IAAI,IAAI,eAAe,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACrD,QAAQ,YAAY,GAAG,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC;AAC7C,IAAI;AACJ;AACA,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;AAC1B,IAAI,IAAI;AACR;AACA,QAAQ,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;AACnD;AACA;AACA;AACA;AACA,QAAQ,IAAI,eAAe,IAAI,YAAY,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE;AACpF,YAAY,IAAI;AAChB,gBAAgB,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;AACjF,YAAY;AACZ,YAAY,OAAO,EAAE,EAAE;AACvB;AACA;AACA,YAAY;AACZ,QAAQ;AACR,IAAI;AACJ,IAAI,OAAO,CAAC,EAAE;AACd;AACA,QAAQ,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;AAC1B,IAAI;AACJ;AACA,IAAI,KAAK,CAAC,WAAW,GAAG,KAAK;AAC7B;AACA,SAAS,YAAY,CAAC,KAAK,EAAE;AAC7B,IAAI,OAAO,KAAK,CAAC,KAAK,IAAI,CAAC,EAAE,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC;AAC7E;AACA,SAAS,QAAQ,CAAC,KAAK,EAAE;AACzB,IAAI,KAAK,CAAC,KAAK,GAAG,KAAK;AACvB,IAAI,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;AAC7B;AACA;AACA,QAAQ;AACR,IAAI;AACJ,IAAI,WAAW,CAAC,KAAK,CAAC;AACtB;AACA,SAAS,WAAW,CAAC,KAAK,EAAE;AAC5B,IAAI,UAAU,CAAC,KAAK,EAAE,gBAAgB,CAAC;AACvC;AACA,SAAS,WAAW,CAAC,KAAK,EAAE;AAC5B,IAAI,UAAU,CAAC,KAAK,EAAE,gBAAgB,CAAC;AACvC;AACA,SAAS,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE;AACrC,IAAI,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI;AAC1C,IAAI,IAAI,WAAW,EAAE;AACrB,QAAQ,MAAM,OAAO,GAAGD,oBAAY,CAAC,KAAK,CAAC,OAAO,CAAC;AACnD,QAAQ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,EAAE,CAAC,EAAE;AAC9C,YAAY,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;AACvC,QAAQ;AACR,IAAI;AACJ;AACA;AACA,SAAS,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE;AACzC;AACA;AACA,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACzC,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AAC/B,IAAI,MAAM,cAAc,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC;AAChD,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE;AAC/B,QAAQ,MAAM,CAAC,aAAa,GAAG,YAAY,CAAC,GAAG,EAAE,IAAI,IAAI,GAAG;AAC5D,IAAI;AACJ,SAAS,IAAI,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;AAC9C;AACA;AACA;AACA,QAAQ;AACR,IAAI;AACJ,IAAI,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC;AACnC;AACA;AACA,IAAI,IAAI,cAAc,EAAE;AACxB,QAAQ,WAAW,CAAC,MAAM,CAAC;AAC3B,IAAI;AACJ;AACA;AACA,SAAS,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE;AACzC;AACA;AACA,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACzC,IAAI,MAAM,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AAChC,IAAI,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC;AACpD,IAAI,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;AACjC,QAAQ,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC7D,IAAI;AACJ,SAAS,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE;AAChD,QAAQ,MAAM,CAAC,QAAQ,EAAE;AACzB,IAAI;AACJ,IAAI,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC;AACnC,IAAI,IAAI,YAAY,CAAC,MAAM,CAAC,EAAE;AAC9B,QAAQ;AACR,IAAI;AACJ,IAAI,WAAW,CAAC,MAAM,CAAC;AACvB;AACA,SAAS,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE;AACzC,IAAI,MAAM,EAAE,GAAG,MAAM,CAAC,aAAa;AACnC,IAAI,IAAI,EAAE,EAAE;AACZ,QAAQ,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC;AACxB,QAAQ,IAAI,EAAE,CAAC,IAAI,KAAK,CAAC,EAAE;AAC3B,YAAY,IAAI,YAAY,CAAC,MAAM,GAAG,gBAAgB,EAAE;AACxD,gBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;AACrC,YAAY;AACZ,YAAY,MAAM,CAAC,aAAa,GAAG,IAAI;AACvC,QAAQ;AACR,IAAI;AACJ;AACA;AACA;AACA,SAAS,cAAc,CAAC,MAAM,EAAE;AAChC,IAAI,IAAI,MAAM,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,EAAE;AACrC,QAAQ,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,KAAK,KAAK;AACtD,YAAY,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC;AACtC,QAAQ,CAAC,CAAC;AACV,IAAI;AACJ;AACA;AACA,IAAI,MAAM,CAAC,UAAU,EAAE;AACvB;AACA;AACA,IAAI,MAAM,CAAC,MAAM,CAAC,aAAa,KAAK,IAAI,CAAC;AACzC;AACA,SAAS,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE;AACpC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;AAChC,IAAI,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC;AACpC,IAAI,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC;AACnC;AACA,SAAS,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE;AACrC,IAAI,IAAI,OAAO,KAAK,CAAC,SAAS,KAAK,UAAU,EAAE;AAC/C,QAAQ,IAAI;AACZ,YAAYD,wBAAgB,CAAC,KAAK,CAAC,CAAC;AACpC,YAAY,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;AACjE,QAAQ;AACR,QAAQ,OAAO,CAAC,EAAE;AAClB;AACA;AACA;AACA;AACA,YAAY,KAAK,CAAC,QAAQ,EAAE;AAC5B,YAAY,OAAO,KAAK;AACxB,QAAQ;AACR,IAAI;AACJ;AACA;AACA,IAAI,OAAO,IAAI;AACf;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/optimism/lib/helpers.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const { hasOwnProperty, } = Object.prototype;
+const arrayFromSet = Array.from ||
+    function (set) {
+        const array = [];
+        set.forEach(item => array.push(item));
+        return array;
+    };
+function maybeUnsubscribe(entryOrDep) {
+    const { unsubscribe } = entryOrDep;
+    if (typeof unsubscribe === "function") {
+        entryOrDep.unsubscribe = void 0;
+        unsubscribe();
+    }
+}
+
+exports.arrayFromSet = arrayFromSet;
+exports.hasOwnProperty = hasOwnProperty;
+exports.maybeUnsubscribe = maybeUnsubscribe;
+//# sourceMappingURL=helpers.cjs.map

package/dist/cjs/node_modules/optimism/lib/helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.cjs","sources":["../../../../../node_modules/optimism/lib/helpers.js"],"sourcesContent":["export const { hasOwnProperty, } = Object.prototype;\nexport const arrayFromSet = Array.from ||\n    function (set) {\n        const array = [];\n        set.forEach(item => array.push(item));\n        return array;\n    };\nexport function maybeUnsubscribe(entryOrDep) {\n    const { unsubscribe } = entryOrDep;\n    if (typeof unsubscribe === \"function\") {\n        entryOrDep.unsubscribe = void 0;\n        unsubscribe();\n    }\n}\n//# sourceMappingURL=helpers.js.map"],"names":[],"mappings":";;AAAY,MAAC,EAAE,cAAc,GAAG,GAAG,MAAM,CAAC;AAC9B,MAAC,YAAY,GAAG,KAAK,CAAC,IAAI;AACtC,IAAI,UAAU,GAAG,EAAE;AACnB,QAAQ,MAAM,KAAK,GAAG,EAAE;AACxB,QAAQ,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC7C,QAAQ,OAAO,KAAK;AACpB,IAAI;AACG,SAAS,gBAAgB,CAAC,UAAU,EAAE;AAC7C,IAAI,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU;AACtC,IAAI,IAAI,OAAO,WAAW,KAAK,UAAU,EAAE;AAC3C,QAAQ,UAAU,CAAC,WAAW,GAAG,MAAM;AACvC,QAAQ,WAAW,EAAE;AACrB,IAAI;AACJ;;;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/optimism/lib/index.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+var index = require('../../@wry/trie/lib/index.cjs');
+var entry = require('./entry.cjs');
+var context = require('./context.cjs');
+var strong = require('../../@wry/caches/lib/strong.cjs');
+
+// The defaultMakeCacheKey function is remarkably powerful, because it gives
+// a unique object for any shallow-identical list of arguments. If you need
+// to implement a custom makeCacheKey function, you may find it helpful to
+// delegate the final work to defaultMakeCacheKey, which is why we export it
+// here. However, you may want to avoid defaultMakeCacheKey if your runtime
+// does not support WeakMap, or you have the ability to return a string key.
+// In those cases, just write your own custom makeCacheKey functions.
+let defaultKeyTrie;
+function defaultMakeCacheKey(...args) {
+    const trie = defaultKeyTrie || (defaultKeyTrie = new index.Trie(typeof WeakMap === "function"));
+    return trie.lookupArray(args);
+}
+const caches = new Set();
+function wrap(originalFunction, { max = Math.pow(2, 16), keyArgs, makeCacheKey = defaultMakeCacheKey, normalizeResult, subscribe, cache: cacheOption = strong.StrongCache, } = Object.create(null)) {
+    const cache = typeof cacheOption === "function"
+        ? new cacheOption(max, entry => entry.dispose())
+        : cacheOption;
+    const optimistic = function () {
+        const key = makeCacheKey.apply(null, keyArgs ? keyArgs.apply(null, arguments) : arguments);
+        if (key === void 0) {
+            return originalFunction.apply(null, arguments);
+        }
+        let entry$1 = cache.get(key);
+        if (!entry$1) {
+            cache.set(key, entry$1 = new entry.Entry(originalFunction));
+            entry$1.normalizeResult = normalizeResult;
+            entry$1.subscribe = subscribe;
+            // Give the Entry the ability to trigger cache.delete(key), even though
+            // the Entry itself does not know about key or cache.
+            entry$1.forget = () => cache.delete(key);
+        }
+        const value = entry$1.recompute(Array.prototype.slice.call(arguments));
+        // Move this entry to the front of the least-recently used queue,
+        // since we just finished computing its value.
+        cache.set(key, entry$1);
+        caches.add(cache);
+        // Clean up any excess entries in the cache, but only if there is no
+        // active parent entry, meaning we're not in the middle of a larger
+        // computation that might be flummoxed by the cleaning.
+        if (!context.parentEntrySlot.hasValue()) {
+            caches.forEach(cache => cache.clean());
+            caches.clear();
+        }
+        return value;
+    };
+    Object.defineProperty(optimistic, "size", {
+        get: () => cache.size,
+        configurable: false,
+        enumerable: false,
+    });
+    Object.freeze(optimistic.options = {
+        max,
+        keyArgs,
+        makeCacheKey,
+        normalizeResult,
+        subscribe,
+        cache,
+    });
+    function dirtyKey(key) {
+        const entry = key && cache.get(key);
+        if (entry) {
+            entry.setDirty();
+        }
+    }
+    optimistic.dirtyKey = dirtyKey;
+    optimistic.dirty = function dirty() {
+        dirtyKey(makeCacheKey.apply(null, arguments));
+    };
+    function peekKey(key) {
+        const entry = key && cache.get(key);
+        if (entry) {
+            return entry.peek();
+        }
+    }
+    optimistic.peekKey = peekKey;
+    optimistic.peek = function peek() {
+        return peekKey(makeCacheKey.apply(null, arguments));
+    };
+    function forgetKey(key) {
+        return key ? cache.delete(key) : false;
+    }
+    optimistic.forgetKey = forgetKey;
+    optimistic.forget = function forget() {
+        return forgetKey(makeCacheKey.apply(null, arguments));
+    };
+    optimistic.makeCacheKey = makeCacheKey;
+    optimistic.getKey = keyArgs ? function getKey() {
+        return makeCacheKey.apply(null, keyArgs.apply(null, arguments));
+    } : makeCacheKey;
+    return Object.freeze(optimistic);
+}
+
+exports.KeyTrie = index.Trie;
+exports.defaultMakeCacheKey = defaultMakeCacheKey;
+exports.wrap = wrap;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/node_modules/optimism/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../../node_modules/optimism/lib/index.js"],"sourcesContent":["import { Trie } from \"@wry/trie\";\nimport { StrongCache } from \"@wry/caches\";\nimport { Entry } from \"./entry.js\";\nimport { parentEntrySlot } from \"./context.js\";\n// These helper functions are important for making optimism work with\n// asynchronous code. In order to register parent-child dependencies,\n// optimism needs to know about any currently active parent computations.\n// In ordinary synchronous code, the parent context is implicit in the\n// execution stack, but asynchronous code requires some extra guidance in\n// order to propagate context from one async task segment to the next.\nexport { bindContext, noContext, nonReactive, setTimeout, asyncFromGen, Slot, } from \"./context.js\";\n// A lighter-weight dependency, similar to OptimisticWrapperFunction, except\n// with only one argument, no makeCacheKey, no wrapped function to recompute,\n// and no result value. Useful for representing dependency leaves in the graph\n// of computation. Subscriptions are supported.\nexport { dep } from \"./dep.js\";\n// The defaultMakeCacheKey function is remarkably powerful, because it gives\n// a unique object for any shallow-identical list of arguments. If you need\n// to implement a custom makeCacheKey function, you may find it helpful to\n// delegate the final work to defaultMakeCacheKey, which is why we export it\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\n// does not support WeakMap, or you have the ability to return a string key.\n// In those cases, just write your own custom makeCacheKey functions.\nlet defaultKeyTrie;\nexport function defaultMakeCacheKey(...args) {\n    const trie = defaultKeyTrie || (defaultKeyTrie = new Trie(typeof WeakMap === \"function\"));\n    return trie.lookupArray(args);\n}\n// If you're paranoid about memory leaks, or you want to avoid using WeakMap\n// under the hood, but you still need the behavior of defaultMakeCacheKey,\n// import this constructor to create your own tries.\nexport { Trie as KeyTrie };\n;\nconst caches = new Set();\nexport function wrap(originalFunction, { max = Math.pow(2, 16), keyArgs, makeCacheKey = defaultMakeCacheKey, normalizeResult, subscribe, cache: cacheOption = StrongCache, } = Object.create(null)) {\n    const cache = typeof cacheOption === \"function\"\n        ? new cacheOption(max, entry => entry.dispose())\n        : cacheOption;\n    const optimistic = function () {\n        const key = makeCacheKey.apply(null, keyArgs ? keyArgs.apply(null, arguments) : arguments);\n        if (key === void 0) {\n            return originalFunction.apply(null, arguments);\n        }\n        let entry = cache.get(key);\n        if (!entry) {\n            cache.set(key, entry = new Entry(originalFunction));\n            entry.normalizeResult = normalizeResult;\n            entry.subscribe = subscribe;\n            // Give the Entry the ability to trigger cache.delete(key), even though\n            // the Entry itself does not know about key or cache.\n            entry.forget = () => cache.delete(key);\n        }\n        const value = entry.recompute(Array.prototype.slice.call(arguments));\n        // Move this entry to the front of the least-recently used queue,\n        // since we just finished computing its value.\n        cache.set(key, entry);\n        caches.add(cache);\n        // Clean up any excess entries in the cache, but only if there is no\n        // active parent entry, meaning we're not in the middle of a larger\n        // computation that might be flummoxed by the cleaning.\n        if (!parentEntrySlot.hasValue()) {\n            caches.forEach(cache => cache.clean());\n            caches.clear();\n        }\n        return value;\n    };\n    Object.defineProperty(optimistic, \"size\", {\n        get: () => cache.size,\n        configurable: false,\n        enumerable: false,\n    });\n    Object.freeze(optimistic.options = {\n        max,\n        keyArgs,\n        makeCacheKey,\n        normalizeResult,\n        subscribe,\n        cache,\n    });\n    function dirtyKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            entry.setDirty();\n        }\n    }\n    optimistic.dirtyKey = dirtyKey;\n    optimistic.dirty = function dirty() {\n        dirtyKey(makeCacheKey.apply(null, arguments));\n    };\n    function peekKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            return entry.peek();\n        }\n    }\n    optimistic.peekKey = peekKey;\n    optimistic.peek = function peek() {\n        return peekKey(makeCacheKey.apply(null, arguments));\n    };\n    function forgetKey(key) {\n        return key ? cache.delete(key) : false;\n    }\n    optimistic.forgetKey = forgetKey;\n    optimistic.forget = function forget() {\n        return forgetKey(makeCacheKey.apply(null, arguments));\n    };\n    optimistic.makeCacheKey = makeCacheKey;\n    optimistic.getKey = keyArgs ? function getKey() {\n        return makeCacheKey.apply(null, keyArgs.apply(null, arguments));\n    } : makeCacheKey;\n    return Object.freeze(optimistic);\n}\n//# sourceMappingURL=index.js.map"],"names":["Trie","StrongCache","entry","Entry","parentEntrySlot"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/prop-types/checkPropTypes.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret.cjs');
+var has = require('./lib/has.cjs');
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var checkPropTypes_1;
+var hasRequiredCheckPropTypes;
+
+function requireCheckPropTypes () {
+	if (hasRequiredCheckPropTypes) return checkPropTypes_1;
+	hasRequiredCheckPropTypes = 1;
+
+	var printWarning = function() {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactPropTypesSecret$1 = /*@__PURE__*/ ReactPropTypesSecret.__require();
+	  var loggedTypeFailures = {};
+	  var has$1 = /*@__PURE__*/ has.__require();
+
+	  printWarning = function(text) {
+	    var message = 'Warning: ' + text;
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) { /**/ }
+	  };
+	}
+
+	/**
+	 * Assert that the values match with the type specs.
+	 * Error messages are memorized and will only be shown once.
+	 *
+	 * @param {object} typeSpecs Map of name to a ReactPropType
+	 * @param {object} values Runtime values that need to be type-checked
+	 * @param {string} location e.g. "prop", "context", "child context"
+	 * @param {string} componentName Name of the component for error messages.
+	 * @param {?Function} getStack Returns the component stack.
+	 * @private
+	 */
+	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    for (var typeSpecName in typeSpecs) {
+	      if (has$1(typeSpecs, typeSpecName)) {
+	        var error;
+	        // Prop type validation may throw. In case they do, we don't want to
+	        // fail the render phase where it didn't fail before. So we log it.
+	        // After these have been cleaned up, we'll let them throw.
+	        try {
+	          // This is intentionally an invariant that gets caught. It's the same
+	          // behavior as without this statement except with a better message.
+	          if (typeof typeSpecs[typeSpecName] !== 'function') {
+	            var err = Error(
+	              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
+	              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
+	              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
+	            );
+	            err.name = 'Invariant Violation';
+	            throw err;
+	          }
+	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
+	        } catch (ex) {
+	          error = ex;
+	        }
+	        if (error && !(error instanceof Error)) {
+	          printWarning(
+	            (componentName || 'React class') + ': type specification of ' +
+	            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+	            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+	            'You may have forgotten to pass an argument to the type checker ' +
+	            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+	            'shape all require an argument).'
+	          );
+	        }
+	        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	          // Only monitor this failure once because there tends to be a lot of the
+	          // same error.
+	          loggedTypeFailures[error.message] = true;
+
+	          var stack = getStack ? getStack() : '';
+
+	          printWarning(
+	            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+	          );
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Resets warning cache when testing.
+	 *
+	 * @private
+	 */
+	checkPropTypes.resetWarningCache = function() {
+	  if (process.env.NODE_ENV !== 'production') {
+	    loggedTypeFailures = {};
+	  }
+	};
+
+	checkPropTypes_1 = checkPropTypes;
+	return checkPropTypes_1;
+}
+
+exports.__require = requireCheckPropTypes;
+//# sourceMappingURL=checkPropTypes.cjs.map

package/dist/cjs/node_modules/prop-types/checkPropTypes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPropTypes.cjs","sources":["../../../../node_modules/prop-types/checkPropTypes.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n  var has = require('./lib/has');\n\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) { /**/ }\n  };\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (has(typeSpecs, typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          if (typeof typeSpecs[typeSpecName] !== 'function') {\n            var err = Error(\n              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\n              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +\n              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'\n            );\n            err.name = 'Invariant Violation';\n            throw err;\n          }\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        if (error && !(error instanceof Error)) {\n          printWarning(\n            (componentName || 'React class') + ': type specification of ' +\n            location + ' `' + typeSpecName + '` is invalid; the type checker ' +\n            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\n            'You may have forgotten to pass an argument to the type checker ' +\n            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\n            'shape all require an argument).'\n          );\n        }\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          printWarning(\n            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Resets warning cache when testing.\n *\n * @private\n */\ncheckPropTypes.resetWarningCache = function() {\n  if (process.env.NODE_ENV !== 'production') {\n    loggedTypeFailures = {};\n  }\n}\n\nmodule.exports = checkPropTypes;\n"],"names":["ReactPropTypesSecret","require$$0","has","require$$1"],"mappings":"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","x_google_ignoreList":[0]}