{"version":3,"sources":["webpack:///./node_modules/node-libs-browser/mock/process.js","webpack:///./node_modules/path-browserify/index.js","webpack:///./node_modules/optimism/lib/bundle.esm.js"],"names":["exports","nextTick","fn","args","Array","prototype","slice","call","arguments","shift","setTimeout","apply","platform","arch","execPath","title","pid","browser","env","argv","binding","name","Error","path","cwd","chdir","dir","resolve","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","normalizeArray","parts","allowAboveRoot","up","i","length","last","splice","unshift","basename","start","end","matchedSlash","charCodeAt","filter","xs","f","res","push","resolvedPath","resolvedAbsolute","process","TypeError","charAt","split","p","join","normalize","isAbsolute","trailingSlash","substr","paths","index","relative","from","to","trim","arr","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","code","hasRoot","ext","extname","startDot","startPart","preDotState","str","len","defaultDispose","Cache","max","dispose","Infinity","this","map","Map","newest","oldest","has","key","get","entry","getEntry","value","older","newer","set","clean","size","delete","parentEntrySlot","reusableEmptyArray","emptySetPool","POOL_TARGET_SIZE","assert","condition","optionalMessage","valueIs","a","b","valueGet","valueCopy","Entry","parents","Set","childValues","dirtyChildren","dirty","recomputing","count","recompute","rememberParent","maybeReportOrphan","mightBeDirty","reallyRecompute","setDirty","reportDirty","maybeUnsubscribe","_this","forgetChildren","forEach","parent","forgetChild","child","getValue","add","reportDirtyChild","reportCleanChild","originalChildren","withValue","recomputeNewValue","maybeSubscribe","setClean","e","reportClean","pop","childValue","removeDirtyChild","dc","reportOrphan","children","_value","subscribe","unsubscribe","KeyTrie","weakness","lookup","array","_i","lookupArray","node","getChildTrie","data","Object","create","isObjRef","weak","WeakMap","strong","keyTrie","defaultMakeCacheKey","caches","wrap","originalFunction","options","cache","pow","disposable","makeCacheKey","optimistic","hasValue","clear"],"mappings":"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","file":"js/chunk-vendors~b58f7129.76b4e7e6.js","sourcesContent":["exports.nextTick = function nextTick(fn) {\n    var args = Array.prototype.slice.call(arguments);\n    args.shift();\n    setTimeout(function () {\n        fn.apply(null, args);\n    }, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\n","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","import { Slot } from '@wry/context';\nexport { asyncFromGen, bind as bindContext, noContext, setTimeout } from '@wry/context';\n\nfunction defaultDispose() { }\r\nvar Cache = /** @class */ (function () {\r\n    function Cache(max, dispose) {\r\n        if (max === void 0) { max = Infinity; }\r\n        if (dispose === void 0) { dispose = defaultDispose; }\r\n        this.max = max;\r\n        this.dispose = dispose;\r\n        this.map = new Map();\r\n        this.newest = null;\r\n        this.oldest = null;\r\n    }\r\n    Cache.prototype.has = function (key) {\r\n        return this.map.has(key);\r\n    };\r\n    Cache.prototype.get = function (key) {\r\n        var entry = this.getEntry(key);\r\n        return entry && entry.value;\r\n    };\r\n    Cache.prototype.getEntry = function (key) {\r\n        var entry = this.map.get(key);\r\n        if (entry && entry !== this.newest) {\r\n            var older = entry.older, newer = entry.newer;\r\n            if (newer) {\r\n                newer.older = older;\r\n            }\r\n            if (older) {\r\n                older.newer = newer;\r\n            }\r\n            entry.older = this.newest;\r\n            entry.older.newer = entry;\r\n            entry.newer = null;\r\n            this.newest = entry;\r\n            if (entry === this.oldest) {\r\n                this.oldest = newer;\r\n            }\r\n        }\r\n        return entry;\r\n    };\r\n    Cache.prototype.set = function (key, value) {\r\n        var entry = this.getEntry(key);\r\n        if (entry) {\r\n            return entry.value = value;\r\n        }\r\n        entry = {\r\n            key: key,\r\n            value: value,\r\n            newer: null,\r\n            older: this.newest\r\n        };\r\n        if (this.newest) {\r\n            this.newest.newer = entry;\r\n        }\r\n        this.newest = entry;\r\n        this.oldest = this.oldest || entry;\r\n        this.map.set(key, entry);\r\n        return entry.value;\r\n    };\r\n    Cache.prototype.clean = function () {\r\n        while (this.oldest && this.map.size > this.max) {\r\n            this.delete(this.oldest.key);\r\n        }\r\n    };\r\n    Cache.prototype.delete = function (key) {\r\n        var entry = this.map.get(key);\r\n        if (entry) {\r\n            if (entry === this.newest) {\r\n                this.newest = entry.older;\r\n            }\r\n            if (entry === this.oldest) {\r\n                this.oldest = entry.newer;\r\n            }\r\n            if (entry.newer) {\r\n                entry.newer.older = entry.older;\r\n            }\r\n            if (entry.older) {\r\n                entry.older.newer = entry.newer;\r\n            }\r\n            this.map.delete(key);\r\n            this.dispose(entry.value, key);\r\n            return true;\r\n        }\r\n        return false;\r\n    };\r\n    return Cache;\r\n}());\n\nvar parentEntrySlot = new Slot();\n\nvar reusableEmptyArray = [];\r\nvar emptySetPool = [];\r\nvar POOL_TARGET_SIZE = 100;\r\n// Since this package might be used browsers, we should avoid using the\r\n// Node built-in assert module.\r\nfunction assert(condition, optionalMessage) {\r\n    if (!condition) {\r\n        throw new Error(optionalMessage || \"assertion failure\");\r\n    }\r\n}\r\nfunction valueIs(a, b) {\r\n    var len = a.length;\r\n    return (\r\n    // Unknown values are not equal to each other.\r\n    len > 0 &&\r\n        // Both values must be ordinary (or both exceptional) to be equal.\r\n        len === b.length &&\r\n        // The underlying value or exception must be the same.\r\n        a[len - 1] === b[len - 1]);\r\n}\r\nfunction valueGet(value) {\r\n    switch (value.length) {\r\n        case 0: throw new Error(\"unknown value\");\r\n        case 1: return value[0];\r\n        case 2: throw value[1];\r\n    }\r\n}\r\nfunction valueCopy(value) {\r\n    return value.slice(0);\r\n}\r\nvar Entry = /** @class */ (function () {\r\n    function Entry(fn, args) {\r\n        this.fn = fn;\r\n        this.args = args;\r\n        this.parents = new Set();\r\n        this.childValues = new Map();\r\n        // When this Entry has children that are dirty, this property becomes\r\n        // a Set containing other Entry objects, borrowed from emptySetPool.\r\n        // When the set becomes empty, it gets recycled back to emptySetPool.\r\n        this.dirtyChildren = null;\r\n        this.dirty = true;\r\n        this.recomputing = false;\r\n        this.value = [];\r\n        ++Entry.count;\r\n    }\r\n    // This is the most important method of the Entry API, because it\r\n    // determines whether the cached this.value can be returned immediately,\r\n    // or must be recomputed. The overall performance of the caching system\r\n    // depends on the truth of the following observations: (1) this.dirty is\r\n    // usually false, (2) this.dirtyChildren is usually null/empty, and thus\r\n    // (3) valueGet(this.value) is usually returned without recomputation.\r\n    Entry.prototype.recompute = function () {\r\n        assert(!this.recomputing, \"already recomputing\");\r\n        if (!rememberParent(this) && maybeReportOrphan(this)) {\r\n            // The recipient of the entry.reportOrphan callback decided to dispose\r\n            // of this orphan entry by calling entry.dispose(), so we don't need to\r\n            // (and should not) proceed with the recomputation.\r\n            return void 0;\r\n        }\r\n        return mightBeDirty(this)\r\n            ? reallyRecompute(this)\r\n            : valueGet(this.value);\r\n    };\r\n    Entry.prototype.setDirty = function () {\r\n        if (this.dirty)\r\n            return;\r\n        this.dirty = true;\r\n        this.value.length = 0;\r\n        reportDirty(this);\r\n        // We can go ahead and unsubscribe here, since any further dirty\r\n        // notifications we receive will be redundant, and unsubscribing may\r\n        // free up some resources, e.g. file watchers.\r\n        maybeUnsubscribe(this);\r\n    };\r\n    Entry.prototype.dispose = function () {\r\n        var _this = this;\r\n        forgetChildren(this).forEach(maybeReportOrphan);\r\n        maybeUnsubscribe(this);\r\n        // Because this entry has been kicked out of the cache (in index.js),\r\n        // we've lost the ability to find out if/when this entry becomes dirty,\r\n        // whether that happens through a subscription, because of a direct call\r\n        // to entry.setDirty(), or because one of its children becomes dirty.\r\n        // Because of this loss of future information, we have to assume the\r\n        // worst (that this entry might have become dirty very soon), so we must\r\n        // immediately mark this entry's parents as dirty. Normally we could\r\n        // just call entry.setDirty() rather than calling parent.setDirty() for\r\n        // each parent, but that would leave this entry in parent.childValues\r\n        // and parent.dirtyChildren, which would prevent the child from being\r\n        // truly forgotten.\r\n        this.parents.forEach(function (parent) {\r\n            parent.setDirty();\r\n            forgetChild(parent, _this);\r\n        });\r\n    };\r\n    Entry.count = 0;\r\n    return Entry;\r\n}());\r\nfunction rememberParent(child) {\r\n    var parent = parentEntrySlot.getValue();\r\n    if (parent) {\r\n        child.parents.add(parent);\r\n        if (!parent.childValues.has(child)) {\r\n            parent.childValues.set(child, []);\r\n        }\r\n        if (mightBeDirty(child)) {\r\n            reportDirtyChild(parent, child);\r\n        }\r\n        else {\r\n            reportCleanChild(parent, child);\r\n        }\r\n        return parent;\r\n    }\r\n}\r\nfunction reallyRecompute(entry) {\r\n    // Since this recomputation is likely to re-remember some of this\r\n    // entry's children, we forget our children here but do not call\r\n    // maybeReportOrphan until after the recomputation finishes.\r\n    var originalChildren = forgetChildren(entry);\r\n    // Set entry as the parent entry while calling recomputeNewValue(entry).\r\n    parentEntrySlot.withValue(entry, recomputeNewValue, [entry]);\r\n    if (maybeSubscribe(entry)) {\r\n        // If we successfully recomputed entry.value and did not fail to\r\n        // (re)subscribe, then this Entry is no longer explicitly dirty.\r\n        setClean(entry);\r\n    }\r\n    // Now that we've had a chance to re-remember any children that were\r\n    // involved in the recomputation, we can safely report any orphan\r\n    // children that remain.\r\n    originalChildren.forEach(maybeReportOrphan);\r\n    return valueGet(entry.value);\r\n}\r\nfunction recomputeNewValue(entry) {\r\n    entry.recomputing = true;\r\n    // Set entry.value as unknown.\r\n    entry.value.length = 0;\r\n    try {\r\n        // If entry.fn succeeds, entry.value will become a normal Value.\r\n        entry.value[0] = entry.fn.apply(null, entry.args);\r\n    }\r\n    catch (e) {\r\n        // If entry.fn throws, entry.value will become exceptional.\r\n        entry.value[1] = e;\r\n    }\r\n    // Either way, this line is always reached.\r\n    entry.recomputing = false;\r\n}\r\nfunction mightBeDirty(entry) {\r\n    return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\r\n}\r\nfunction setClean(entry) {\r\n    entry.dirty = false;\r\n    if (mightBeDirty(entry)) {\r\n        // This Entry may still have dirty children, in which case we can't\r\n        // let our parents know we're clean just yet.\r\n        return;\r\n    }\r\n    reportClean(entry);\r\n}\r\nfunction reportDirty(child) {\r\n    child.parents.forEach(function (parent) { return reportDirtyChild(parent, child); });\r\n}\r\nfunction reportClean(child) {\r\n    child.parents.forEach(function (parent) { return reportCleanChild(parent, child); });\r\n}\r\n// Let a parent Entry know that one of its children may be dirty.\r\nfunction reportDirtyChild(parent, child) {\r\n    // Must have called rememberParent(child) before calling\r\n    // reportDirtyChild(parent, child).\r\n    assert(parent.childValues.has(child));\r\n    assert(mightBeDirty(child));\r\n    if (!parent.dirtyChildren) {\r\n        parent.dirtyChildren = emptySetPool.pop() || new Set;\r\n    }\r\n    else if (parent.dirtyChildren.has(child)) {\r\n        // If we already know this child is dirty, then we must have already\r\n        // informed our own parents that we are dirty, so we can terminate\r\n        // the recursion early.\r\n        return;\r\n    }\r\n    parent.dirtyChildren.add(child);\r\n    reportDirty(parent);\r\n}\r\n// Let a parent Entry know that one of its children is no longer dirty.\r\nfunction reportCleanChild(parent, child) {\r\n    // Must have called rememberChild(child) before calling\r\n    // reportCleanChild(parent, child).\r\n    assert(parent.childValues.has(child));\r\n    assert(!mightBeDirty(child));\r\n    var childValue = parent.childValues.get(child);\r\n    if (childValue.length === 0) {\r\n        parent.childValues.set(child, valueCopy(child.value));\r\n    }\r\n    else if (!valueIs(childValue, child.value)) {\r\n        parent.setDirty();\r\n    }\r\n    removeDirtyChild(parent, child);\r\n    if (mightBeDirty(parent)) {\r\n        return;\r\n    }\r\n    reportClean(parent);\r\n}\r\nfunction removeDirtyChild(parent, child) {\r\n    var dc = parent.dirtyChildren;\r\n    if (dc) {\r\n        dc.delete(child);\r\n        if (dc.size === 0) {\r\n            if (emptySetPool.length < POOL_TARGET_SIZE) {\r\n                emptySetPool.push(dc);\r\n            }\r\n            parent.dirtyChildren = null;\r\n        }\r\n    }\r\n}\r\n// If the given entry has a reportOrphan method, and no remaining parents,\r\n// call entry.reportOrphan and return true iff it returns true. The\r\n// reportOrphan function should return true to indicate entry.dispose()\r\n// has been called, and the entry has been removed from any other caches\r\n// (see index.js for the only current example).\r\nfunction maybeReportOrphan(entry) {\r\n    return entry.parents.size === 0 &&\r\n        typeof entry.reportOrphan === \"function\" &&\r\n        entry.reportOrphan() === true;\r\n}\r\n// Removes all children from this entry and returns an array of the\r\n// removed children.\r\nfunction forgetChildren(parent) {\r\n    var children = reusableEmptyArray;\r\n    if (parent.childValues.size > 0) {\r\n        children = [];\r\n        parent.childValues.forEach(function (_value, child) {\r\n            forgetChild(parent, child);\r\n            children.push(child);\r\n        });\r\n    }\r\n    // After we forget all our children, this.dirtyChildren must be empty\r\n    // and therefore must have been reset to null.\r\n    assert(parent.dirtyChildren === null);\r\n    return children;\r\n}\r\nfunction forgetChild(parent, child) {\r\n    child.parents.delete(parent);\r\n    parent.childValues.delete(child);\r\n    removeDirtyChild(parent, child);\r\n}\r\nfunction maybeSubscribe(entry) {\r\n    if (typeof entry.subscribe === \"function\") {\r\n        try {\r\n            maybeUnsubscribe(entry); // Prevent double subscriptions.\r\n            entry.unsubscribe = entry.subscribe.apply(null, entry.args);\r\n        }\r\n        catch (e) {\r\n            // If this Entry has a subscribe function and it threw an exception\r\n            // (or an unsubscribe function it previously returned now throws),\r\n            // return false to indicate that we were not able to subscribe (or\r\n            // unsubscribe), and this Entry should remain dirty.\r\n            entry.setDirty();\r\n            return false;\r\n        }\r\n    }\r\n    // Returning true indicates either that there was no entry.subscribe\r\n    // function or that it succeeded.\r\n    return true;\r\n}\r\nfunction maybeUnsubscribe(entry) {\r\n    var unsubscribe = entry.unsubscribe;\r\n    if (typeof unsubscribe === \"function\") {\r\n        entry.unsubscribe = void 0;\r\n        unsubscribe();\r\n    }\r\n}\n\n// A trie data structure that holds object keys weakly, yet can also hold\r\n// non-object keys, unlike the native `WeakMap`.\r\nvar KeyTrie = /** @class */ (function () {\r\n    function KeyTrie(weakness) {\r\n        this.weakness = weakness;\r\n    }\r\n    KeyTrie.prototype.lookup = function () {\r\n        var array = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            array[_i] = arguments[_i];\r\n        }\r\n        return this.lookupArray(array);\r\n    };\r\n    KeyTrie.prototype.lookupArray = function (array) {\r\n        var node = this;\r\n        array.forEach(function (key) { return node = node.getChildTrie(key); });\r\n        return node.data || (node.data = Object.create(null));\r\n    };\r\n    KeyTrie.prototype.getChildTrie = function (key) {\r\n        var map = this.weakness && isObjRef(key)\r\n            ? this.weak || (this.weak = new WeakMap())\r\n            : this.strong || (this.strong = new Map());\r\n        var child = map.get(key);\r\n        if (!child)\r\n            map.set(key, child = new KeyTrie(this.weakness));\r\n        return child;\r\n    };\r\n    return KeyTrie;\r\n}());\r\nfunction isObjRef(value) {\r\n    switch (typeof value) {\r\n        case \"object\":\r\n            if (value === null)\r\n                break;\r\n        // Fall through to return true...\r\n        case \"function\":\r\n            return true;\r\n    }\r\n    return false;\r\n}\n\n// The defaultMakeCacheKey function is remarkably powerful, because it gives\r\n// a unique object for any shallow-identical list of arguments. If you need\r\n// to implement a custom makeCacheKey function, you may find it helpful to\r\n// delegate the final work to defaultMakeCacheKey, which is why we export it\r\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\r\n// does not support WeakMap, or you have the ability to return a string key.\r\n// In those cases, just write your own custom makeCacheKey functions.\r\nvar keyTrie = new KeyTrie(typeof WeakMap === \"function\");\r\nfunction defaultMakeCacheKey() {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    return keyTrie.lookupArray(args);\r\n}\r\nvar caches = new Set();\r\nfunction wrap(originalFunction, options) {\r\n    if (options === void 0) { options = Object.create(null); }\r\n    var cache = new Cache(options.max || Math.pow(2, 16), function (entry) { return entry.dispose(); });\r\n    var disposable = !!options.disposable;\r\n    var makeCacheKey = options.makeCacheKey || defaultMakeCacheKey;\r\n    function optimistic() {\r\n        if (disposable && !parentEntrySlot.hasValue()) {\r\n            // If there's no current parent computation, and this wrapped\r\n            // function is disposable (meaning we don't care about entry.value,\r\n            // just dependency tracking), then we can short-cut everything else\r\n            // in this function, because entry.recompute() is going to recycle\r\n            // the entry object without recomputing anything, anyway.\r\n            return void 0;\r\n        }\r\n        var key = makeCacheKey.apply(null, arguments);\r\n        if (key === void 0) {\r\n            return originalFunction.apply(null, arguments);\r\n        }\r\n        var args = Array.prototype.slice.call(arguments);\r\n        var entry = cache.get(key);\r\n        if (entry) {\r\n            entry.args = args;\r\n        }\r\n        else {\r\n            entry = new Entry(originalFunction, args);\r\n            cache.set(key, entry);\r\n            entry.subscribe = options.subscribe;\r\n            if (disposable) {\r\n                entry.reportOrphan = function () { return cache.delete(key); };\r\n            }\r\n        }\r\n        var value = entry.recompute();\r\n        // Move this entry to the front of the least-recently used queue,\r\n        // since we just finished computing its value.\r\n        cache.set(key, entry);\r\n        caches.add(cache);\r\n        // Clean up any excess entries in the cache, but only if there is no\r\n        // active parent entry, meaning we're not in the middle of a larger\r\n        // computation that might be flummoxed by the cleaning.\r\n        if (!parentEntrySlot.hasValue()) {\r\n            caches.forEach(function (cache) { return cache.clean(); });\r\n            caches.clear();\r\n        }\r\n        // If options.disposable is truthy, the caller of wrap is telling us\r\n        // they don't care about the result of entry.recompute(), so we should\r\n        // avoid returning the value, so it won't be accidentally used.\r\n        return disposable ? void 0 : value;\r\n    }\r\n    optimistic.dirty = function () {\r\n        var key = makeCacheKey.apply(null, arguments);\r\n        var child = key !== void 0 && cache.get(key);\r\n        if (child) {\r\n            child.setDirty();\r\n        }\r\n    };\r\n    return optimistic;\r\n}\n\nexport { KeyTrie, defaultMakeCacheKey, wrap };\n//# sourceMappingURL=bundle.esm.js.map\n"],"sourceRoot":""}