iris-messenger/dist/sw-esm.js.map

{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///../node_modules/workbox-cacheable-response/_version.js","webpack:///../node_modules/process/browser.js","webpack:///../node_modules/workbox-routing/registerRoute.js","webpack:///../node_modules/workbox-core/_private/waitUntil.js","webpack:///../node_modules/workbox-precaching/utils/createCacheKey.js","webpack:///../node_modules/workbox-core/copyResponse.js","webpack:///../node_modules/workbox-core/_private/canConstructResponseFromBodyStream.js","webpack:///../node_modules/workbox-core/_private/cacheMatchIgnoreParams.js","webpack:///../node_modules/workbox-core/_private/timeout.js","webpack:///../node_modules/workbox-strategies/StrategyHandler.js","webpack:///../node_modules/workbox-precaching/getCacheKeyForURL.js","webpack:///../node_modules/workbox-precaching/precacheAndRoute.js","webpack:///../node_modules/workbox-precaching/precache.js","webpack:///../node_modules/workbox-precaching/addRoute.js","webpack:///./sw.js","webpack:///../node_modules/workbox-routing/utils/getOrCreateDefaultRouter.js","webpack:///../node_modules/workbox-core/models/messages/messageGenerator.js","webpack:///../node_modules/workbox-core/_private/WorkboxError.js","webpack:///../node_modules/workbox-routing/utils/normalizeHandler.js","webpack:///../node_modules/workbox-routing/Route.js","webpack:///../node_modules/workbox-routing/utils/constants.js","webpack:///../node_modules/workbox-routing/RegExpRoute.js","webpack:///../node_modules/workbox-core/_private/getFriendlyURL.js","webpack:///../node_modules/workbox-routing/Router.js","webpack:///../node_modules/workbox-core/_private/cacheNames.js","webpack:///../node_modules/workbox-precaching/utils/PrecacheInstallReportPlugin.js","webpack:///../node_modules/workbox-precaching/utils/PrecacheCacheKeyPlugin.js","webpack:///../node_modules/workbox-core/_private/Deferred.js","webpack:///../node_modules/workbox-core/models/quotaErrorCallbacks.js","webpack:///../node_modules/workbox-core/_private/executeQuotaErrorCallbacks.js","webpack:///../node_modules/workbox-strategies/Strategy.js","webpack:///../node_modules/workbox-precaching/PrecacheStrategy.js","webpack:///../node_modules/workbox-precaching/utils/getOrCreatePrecacheController.js","webpack:///../node_modules/workbox-precaching/PrecacheController.js","webpack:///../node_modules/workbox-precaching/PrecacheRoute.js","webpack:///../node_modules/workbox-precaching/utils/generateURLVariations.js","webpack:///../node_modules/workbox-precaching/utils/removeIgnoredSearchParams.js","webpack:///../node_modules/preact-cli/sw/utils.js","webpack:///../node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.js","webpack:///../node_modules/workbox-strategies/NetworkFirst.js","webpack:///../node_modules/workbox-strategies/NetworkOnly.js","webpack:///../node_modules/workbox-strategies/StaleWhileRevalidate.js","webpack:///../node_modules/workbox-core/_private/DBWrapper.js","webpack:///../node_modules/workbox-core/_private/deleteDatabase.js","webpack:///../node_modules/workbox-routing/setCatchHandler.js","webpack:///../node_modules/workbox-core/cacheNames.js","webpack:///../node_modules/workbox-cacheable-response/CacheableResponse.js","webpack:///../node_modules/preact-cli/sw/contants.js","webpack:///../node_modules/workbox-cacheable-response/CacheableResponsePlugin.js","webpack:///../node_modules/workbox-background-sync/lib/QueueStore.js","webpack:///../node_modules/workbox-background-sync/lib/StorableRequest.js","webpack:///../node_modules/workbox-background-sync/Queue.js","webpack:///../node_modules/workbox-background-sync/BackgroundSyncPlugin.js","webpack:///../node_modules/preact-cli/sw/index.js","webpack:///../node_modules/gun sync","webpack:///../node_modules/gun/browser.js","webpack:///../node_modules/workbox-precaching/_version.js","webpack:///../node_modules/workbox-routing/_version.js","webpack:///../node_modules/gun/gun.js","webpack:///../node_modules/webpack/buildin/module.js","webpack:///./js/lib/localforage.min.js","webpack:///../node_modules/setimmediate/setImmediate.js","webpack:///../node_modules/workbox-strategies/_version.js","webpack:///../node_modules/timers-browserify/main.js","webpack:///../node_modules/webpack/buildin/global.js","webpack:///../node_modules/workbox-background-sync/_version.js","webpack:///../node_modules/workbox-core/_version.js"],"names":["__webpack_require__","moduleId","installedModules","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","self","_","e","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","setTimeout","this","cleanUpNextTick","draining","currentQueue","length","queue","concat","queueIndex","drainQueue","timeout","len","run","marker","cachedClearTimeout","clearTimeout","runClearTimeout","Item","array","noop","process","nextTick","args","Array","arguments","push","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","registerRoute","capture","handler","method","route","captureUrl","URL","location","href","Route","url","RegExp","RegExpRoute","WorkboxError","moduleName","funcName","paramName","getOrCreateDefaultRouter","waitUntil","event","asyncFn","returnPromise","createCacheKey","entry","urlObject","cacheKey","revision","cacheKeyURL","originalURL","searchParams","set","copyResponse","response","modifier","origin","clonedResponse","responseInit","modifiedResponseInit","clone","headers","Headers","status","statusText","undefined","supportStatus","testResponse","Response","body","error","canConstructResponseFromBodyStream","blob","stripParams","fullURL","ignoreParams","strippedURL","delete","ms","Promise","resolve","toRequest","input","Request","getCacheKeyForURL","getOrCreatePrecacheController","precacheAndRoute","entries","options","precache","precacheController","PrecacheRoute","addRoute","getOpenClient","clients","matchAll","type","includeUncontrolled","then","clientList","client","urlToOpen","defaultRouter","messageGenerator","code","msg","JSON","stringify","errorCode","details","message","normalizeHandler","handle","match","setCatchHandler","catchHandler","regExp","result","exec","index","slice","getFriendlyURL","String","replace","Router","_routes","Map","_defaultHandlerMap","addFetchListener","addEventListener","responsePromise","handleRequest","request","respondWith","addCacheListener","data","requestPromises","all","payload","urlsToCache","map","ports","postMessage","protocol","startsWith","sameOrigin","findMatchingRoute","params","has","err","reject","_catchHandler","catch","catchErr","matchResult","isArray","constructor","keys","setDefaultHandler","unregisterRoute","routeIndex","indexOf","splice","_cacheNameDetails","googleAnalytics","prefix","runtime","suffix","registration","scope","_createCacheName","cacheName","filter","join","cacheNames","userCacheName","PrecacheInstallReportPlugin","updatedURLs","notUpdatedURLs","handlerWillStart","state","originalRequest","cachedResponseWillBeUsed","cachedResponse","PrecacheCacheKeyPlugin","cacheKeyWillBeUsed","_precacheController","Deferred","promise","quotaErrorCallbacks","Set","StrategyHandler","strategy","_cacheKeys","_strategy","_handlerDeferred","_extendLifetimePromises","_plugins","plugins","_pluginStateMap","fetch","hasCallback","pluginFilteredRequest","runCallbacks","fetchOptions","callback","fetchResponse","iterateCallbacks","thrownError","cb","possiblePreloadResponse","FetchEvent","preloadResponse","fetchAndCachePut","responseClone","cachePut","cacheMatch","effectiveRequest","multiMatchOptions","matchOptions","getCacheKey","caches","responseToCache","cache","hasCacheUpdateCallback","oldResponse","_ensureResponseSafeToCache","open","strippedRequestURL","keysOptions","strippedCacheKeyURL","ignoreSearch","cacheMatchIgnoreParams","newResponse","put","param","plugin","statefulParam","doneWaiting","shift","destroy","pluginsUsed","Strategy","handleAll","responseDone","_getResponse","_awaitComplete","_handle","waitUntilError","PrecacheStrategy","_fallbackToNetwork","fallbackToNetwork","copyRedirectedCacheableResponsesPlugin","_handleInstall","_handleFetch","_useDefaultCacheabilityPluginIfNeeded","defaultPluginIndex","cacheWillUpdatePluginCount","defaultPrecacheCacheabilityPlugin","cacheWillUpdate","redirected","PrecacheController","_urlsToCacheKeys","_urlsToCacheModes","_cacheKeysToIntegrities","install","activate","addToCacheList","_installAndActiveListenersAdded","urlsToWarnAbout","cacheMode","firstEntry","secondEntry","integrity","warningMessage","console","warn","credentials","installReportPlugin","currentlyCachedRequests","expectedCacheKeys","deletedURLs","values","getURLsToCacheKeys","getCachedURLs","matchPrecache","createHandlerBoundToURL","urlsToCacheKeys","ignoreURLParametersMatching","directoryIndex","cleanURLs","urlManipulation","hash","urlWithoutIgnoredParams","some","test","removeIgnoredSearchParams","pathname","endsWith","directoryURL","cleanURL","urlToAttempt","generateURLVariations","isNav","cacheOkAndOpaquePlugin","NetworkFirst","unshift","_networkTimeoutSeconds","networkTimeoutSeconds","logs","promises","timeoutId","networkPromise","_getTimeoutPromise","id","_getNetworkPromise","race","fetchError","NetworkOnly","timeoutPromise","StaleWhileRevalidate","fetchAndCachePromise","DBWrapper","onupgradeneeded","onversionchange","_db","_name","_version","_onupgradeneeded","_onversionchange","close","openRequestTimedOut","OPEN_TIMEOUT","openRequest","indexedDB","onerror","evt","transaction","abort","onsuccess","db","getKey","storeName","query","getAllKeys","getAll","count","getAllMatching","includeKeys","direction","txn","done","store","objectStore","target","results","openCursor","cursor","continue","storeNames","onabort","oncomplete","_call","objStore","IDBObjectStore","readonly","readwrite","_cacheNames","CacheableResponse","config","_statuses","statuses","_headers","isResponseCacheable","cacheable","includes","headerName","PRECACHING_OPTIONS","NETWORK_HANDLER","_cacheableResponse","OBJECT_STORE_NAME","INDEXED_PROP","QueueStore","queueName","_queueName","_upgradeDb","pushEntry","add","unshiftEntry","popEntry","_removeEntry","shiftEntry","IDBKeyRange","only","deleteEntry","oldVersion","objectStoreNames","contains","deleteObjectStore","createObjectStore","autoIncrement","keyPath","createIndex","unique","serializableProperties","StorableRequest","requestData","_requestData","fromRequest","prop","arrayBuffer","toObject","TAG_PREFIX","queueNames","convertEntry","queueStoreEntry","queueEntry","timestamp","metadata","Queue","onSync","maxRetentionTime","_syncInProgress","_requestsAddedDuringSync","_onSync","replayRequests","_maxRetentionTime","_queueStore","_addSyncListener","pushRequest","_addRequest","unshiftRequest","popRequest","_removeRequest","shiftRequest","allEntries","now","unexpiredEntries","Date","operation","registerSync","sync","register","tag","syncError","lastChance","fetchDidFail","_queue","precachingOptions","__WB_MANIFEST","onmessage","irisKey","localforage","setItem","ev","secret","visibilityState","getItem","showNotification","icon","json","log","from","epub","Gun","SEA","decrypt","notification","focus","openWindow","webpackEmptyContext","req","require","USE","arg","R","split","toString","mod","path","MODULE","Type","is","fn","bi","b","Boolean","num","list_is","parseFloat","Infinity","text","ify","random","charAt","Math","floor","tmp","u","charCodeAt","list","slit","sort","k","A","B","obj_map","obj","v","del","as","obj_is","parse","obj_has","to","copy","empty","x","ll","lle","f","ii","time","getTime","onto","next","be","the","last","back","setImmediate","Q","puff","go","S","STAT","Lexical","machineState","incomingState","currentState","incomingValue","currentValue","defer","historical","converge","incoming","current","Val","text_is","bi_is","num_is","link","rel","rel_","obj_put","Node","soul_","soul","text_random","node","obj_del","State","N","drift","D","perf","performance","timing","S_","navigationStart","N_","lex","obj_as","val","obj_copy","fn_is","opt","Graph","nf","g","obj_empty","at","arr","seen","shell","graph","valid","prev","invalid","root","lack","dup","max","age","check","dt","track","it","was","drop","$","chain","toJSON","HAM","ask","universe","out","gun","DBG","text_rand","_get","uc","ua","ue","ctx","lot","more","states","ERR","cut","_soul","state_","node_","val_is","ham","pe","fire","stun","ok","vertex","state_is","known","machine","MD","miss","ph","pa","pm","state_ify","super","stop","verify","diff","souls","merge","cat","async","ack","each","and","patch","_put","obj_to","_has","window","faith","ram","ga","gm","gd","peers","native","C","w","GUN","yes","output","meta","pass","eve","change","echo","not","relate","neat","reverb","via","dub","proxy","sub","use","$$","mum","rid","acks","jam","node_soul","batch","res","ref","iife","sat","pat","reverse","solve","any","uuid","fromCharCode","wait","eas","act","subs","nix","n_","item","localStorage","removeItem","gap","flush","file","disk","send","lS","debug","retry","peer","tail","raw","wire","say","mesh","pack","memory","loop","SMIA","dup_check","dup_track","hear","dam","hp","leap","ST","hd","P","y","way","pid","ps","pl","wr","hi","met","hied","bye","gets","Mesh","WebSocket","onclose","reconnect","onopen","doc","hidden","global","websocket","webkitWebSocket","mozWebSocket","document","webpackPolyfill","deprecate","paths","children","a","j","MutationObserver","WebKitMutationObserver","h","createTextNode","observe","characterData","MessageChannel","createElement","onreadystatechange","parentNode","removeChild","documentElement","appendChild","port1","port2","TypeError","outcome","onFulfilled","callFulfilled","otherCallFulfilled","onRejected","callRejected","otherCallRejected","q","webkitIndexedDB","mozIndexedDB","OIndexedDB","msIndexedDB","openDatabase","navigator","userAgent","platform","Blob","BlobBuilder","MSBlobBuilder","MozBlobBuilder","WebKitBlobBuilder","append","getBlob","ArrayBuffer","Uint8Array","va","wa","Ba","preventDefault","stopPropagation","parseInt","xa","ya","deferredOperations","dbReady","pop","newVersion","FileReader","onloadend","btoa","__local_forage_encoded_blob","readAsBinaryString","atob","_initReady","_dbInfo","z","forages","ready","_defaultConfig","Aa","E","F","za","G","H","clear","I","J","openKeyCursor","advance","K","L","deleteDatabase","onblocked","M","Da","O","substring","Ua","buffer","Ga","Ia","Ka","La","Ma","Na","Pa","Oa","Qa","Ra","Sa","onload","Ea","Ja","readAsArrayBuffer","Ha","Ta","Fa","Int8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","executeSql","description","size","serializer","Va","T","SYNTAX_ERR","rows","U","deserialize","V","W","serialize","QUOTA_ERR","X","Y","Z","aa","ba","ca","da","ea","fa","ha","keyPrefix","ia","ja","ka","la","ma","na","oa","qa","ra","sa","$a","ta","iterator","Ca","_driver","_initStorage","_support","iterate","dropInstance","stringToBuffer","bufferToString","Wa","Xa","Ya","isNaN","Za","_a","ab","bb","INDEXEDDB","WEBSQL","LOCALSTORAGE","eb","fb","driver","hb","defineDriver","_config","_driverSet","_initDriver","_ready","_wrapLibraryMethodsWithReady","setDriver","info","getDriver","getSerializer","_extend","_getSupportedDrivers","supports","createInstance","clearImmediate","tasksByHandle","runIfPresent","currentlyRunningATask","task","registerImmediate","html","channel","messagePrefix","onGlobalMessage","nextHandle","attachTo","getPrototypeOf","importScripts","postMessageIsAsynchronous","oldOnMessage","canUsePostMessage","script","source","attachEvent","Function","Timeout","clearFn","_id","_clearFn","setInterval","clearInterval","unref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout"],"mappings":"aAIE,SAAS,EAAoB,GAG5B,GAAG,EAAiB,GACnB,OAAO,EAAiB,GAAU,QAGnC,IAAI,EAAS,EAAiB,GAAY,CACzC,EAAG,EACH,GAAG,EACH,QAAS,IAUV,OANA,EAAQ,GAAU,KAAK,EAAO,QAAS,EAAQ,EAAO,QAAS,GAG/D,EAAO,GAAI,EAGJ,EAAO,QAvBf,IAAI,EAAmB,GA4BvB,EAAoB,EAAI,EAGxB,EAAoB,EAAI,EAGxB,EAAoB,EAAI,SAAS,EAAS,EAAM,GAC3C,EAAoB,EAAE,EAAS,IAClC,OAAO,eAAe,EAAS,EAAM,CAAE,YAAY,EAAM,IAAK,KAKhE,EAAoB,EAAI,SAAS,GACX,oBAAX,QAA0B,OAAO,aAC1C,OAAO,eAAe,EAAS,OAAO,YAAa,CAAE,MAAO,WAE7D,OAAO,eAAe,EAAS,aAAc,CAAE,OAAO,KAQvD,EAAoB,EAAI,SAAS,EAAO,GAEvC,GADU,EAAP,IAAU,EAAQ,EAAoB,IAC/B,EAAP,EAAU,OAAO,EACpB,GAAW,EAAP,GAA8B,iBAAV,GAAsB,GAAS,EAAM,WAAY,OAAO,EAChF,IAAI,EAAK,OAAO,OAAO,MAGvB,GAFA,EAAoB,EAAE,GACtB,OAAO,eAAe,EAAI,UAAW,CAAE,YAAY,EAAM,MAAO,IACtD,EAAP,GAA4B,iBAAT,EAAmB,IAAI,IAAI,KAAO,EAAO,EAAoB,EAAE,EAAI,EAAK,SAAS,GAAO,OAAO,EAAM,IAAQ,KAAK,KAAM,IAC9I,OAAO,GAIR,EAAoB,EAAI,SAAS,GAChC,IAAI,EAAS,GAAU,EAAO,WAC7B,WAAwB,OAAO,EAAgB,SAC/C,WAA8B,OAAO,GAEtC,OADA,EAAoB,EAAE,EAAQ,IAAK,GAC5B,GAIR,EAAoB,EAAI,SAAS,EAAQ,GAAY,OAAO,OAAO,UAAU,eAAe,KAAK,EAAQ,IAGzG,EAAoB,EAAI,IAIjB,EAAoB,EAAoB,EAAI,yCChFrD,IACI,KAAK,qCAAuC,IAEhD,MAAO,yBCMP,SAAS,IACL,MAAM,IAAI,MAAM,mCAEpB,SAAS,IACL,MAAM,IAAI,MAAM,qCAsBpB,SAAS,EAAW,GAChB,GAAI,IAAqB,WAErB,OAAO,WAAW,EAAK,GAG3B,IAAK,IAAqB,IAAqB,IAAqB,WAEhE,OADA,EAAmB,WACZ,WAAW,EAAK,GAE3B,IAEI,OAAO,EAAiB,EAAK,GAC/B,MAAM,GACJ,IAEI,OAAO,EAAiB,KAAK,KAAM,EAAK,GAC1C,MAAM,GAEJ,OAAO,EAAiB,KAAK,KAAM,EAAK,KAsCpD,SAAS,IACA,GAAa,IAGlB,GAAW,EACP,EAAa,OACb,EAAQ,EAAa,OAAO,GAE5B,GAAc,EAEd,EAAM,QACN,KAIR,SAAS,IACL,IAAI,EAAJ,CAGA,IAAI,EAAU,EAAW,GACzB,GAAW,EAGX,IADA,IAAI,EAAM,EAAM,OACV,GAAK,CAGP,IAFA,EAAe,EACf,EAAQ,KACC,EAAa,GACd,GACA,EAAa,GAAY,MAGjC,GAAc,EACd,EAAM,EAAM,OAEhB,EAAe,KACf,GAAW,EAnEf,SAAyB,GACrB,GAAI,IAAuB,aAEvB,OAAO,aAAa,GAGxB,IAAK,IAAuB,IAAwB,IAAuB,aAEvE,OADA,EAAqB,aACd,aAAa,GAExB,IAEW,EAAmB,GAC5B,MAAO,GACL,IAEI,OAAO,EAAmB,KAAK,KAAM,GACvC,MAAO,GAGL,OAAO,EAAmB,KAAK,KAAM,KAgD7C,CAAgB,IAiBpB,SAAS,EAAK,EAAK,GACf,KAAK,IAAM,EACX,KAAK,MAAQ,EAYjB,SAAS,KAhKT,IAOI,EACA,EARA,EAAU,EAAO,QAAU,IAgB9B,WACG,IAEQ,EADsB,mBAAf,WACY,WAEA,EAEzB,MAAO,GACL,EAAmB,EAEvB,IAEQ,EADwB,mBAAjB,aACc,aAEA,EAE3B,MAAO,GACL,EAAqB,GAjB5B,GAwED,IAEI,EAFA,EAAQ,GACR,GAAW,EAEX,GAAc,EAyClB,EAAQ,SAAW,SAAU,GACzB,IAAI,EAAO,IAAI,MAAM,UAAU,OAAS,GACxC,GAAI,UAAU,OAAS,EACnB,IAAK,IAAI,EAAI,EAAG,EAAI,UAAU,OAAQ,IAClC,EAAK,EAAI,GAAK,UAAU,GAGhC,EAAM,KAAK,IAAI,EAAK,EAAK,IACJ,IAAjB,EAAM,QAAiB,GACvB,EAAW,IASnB,EAAK,UAAU,IAAM,WACjB,KAAK,IAAI,MAAM,KAAM,KAAK,QAE9B,EAAQ,MAAQ,UAChB,EAAQ,SAAU,EAClB,EAAQ,IAAM,GACd,EAAQ,KAAO,GACf,EAAQ,QAAU,GAClB,EAAQ,SAAW,GAInB,EAAQ,GAAK,EACb,EAAQ,YAAc,EACtB,EAAQ,KAAO,EACf,EAAQ,IAAM,EACd,EAAQ,eAAiB,EACzB,EAAQ,mBAAqB,EAC7B,EAAQ,KAAO,EACf,EAAQ,gBAAkB,EAC1B,EAAQ,oBAAsB,EAE9B,EAAQ,UAAY,WAAkB,MAAO,IAE7C,EAAQ,QAAU,WACd,MAAM,IAAI,MAAM,qCAGpB,EAAQ,IAAM,WAAc,MAAO,KACnC,EAAQ,MAAQ,WACZ,MAAM,IAAI,MAAM,mCAEpB,EAAQ,MAAQ,WAAa,OAAO,ovFCvJpC,SAAS,EAAc,EAAS,EAAS,GACrC,IAAI,EACJ,GAAuB,iBAAZ,EAAsB,CAC7B,IAAM,EAAa,IAAI,IAAI,EAAS,SAAS,MAiC7C,EAAQ,IAAI,IAZU,SAAC,GASnB,OAT+B,EAAV,IASV,OAAS,EAAW,OAGF,EAAS,QAEzC,GAAI,aAAmB,OAExB,EAAQ,IAAI,GAAY,EAAS,EAAS,QAEzC,GAAuB,mBAAZ,EAEZ,EAAQ,IAAI,GAAM,EAAS,EAAS,OAEnC,MAAI,aAAmB,IAIxB,MAAM,IAAI,GAAa,yBAA0B,CAC7C,WAAY,kBACZ,SAAU,gBACV,UAAW,YANf,EAAQ,EAWZ,OAFsB,KACR,cAAc,GACrB,EC1EX,SAAS,EAAU,EAAO,GACtB,IAAM,EAAgB,IAEtB,OADA,EAAM,UAAU,GACT,ECCJ,SAAS,EAAe,GAC3B,IAAK,EACD,MAAM,IAAI,GAAa,oCAAqC,CAAE,UAIlE,GAAqB,iBAAV,EAAoB,CAC3B,IAAM,EAAY,IAAI,IAAI,EAAO,SAAS,MAC1C,MAAO,CACH,SAAU,EAAU,KACpB,IAAK,EAAU,MAGvB,IAAQ,EAAkB,EAAlB,SAAU,EAAQ,EAAR,IAClB,IAAK,EACD,MAAM,IAAI,GAAa,oCAAqC,CAAE,UAIlE,IAAK,EAAU,CACX,IAAM,EAAY,IAAI,IAAI,EAAK,SAAS,MACxC,MAAO,CACH,SAAU,EAAU,KACpB,IAAK,EAAU,MAKvB,IAAM,EAAc,IAAI,IAAI,EAAK,SAAS,MACpC,EAAc,IAAI,IAAI,EAAK,SAAS,MAE1C,OADA,EAAY,aAAa,IAxCC,kBAwC0B,GAC7C,CACH,SAAU,EAAY,KACtB,IAAK,EAAY,MCxBzB,SAAe,EAAa,EAAU,GAAtC,sCACQ,EASE,EAEA,EAMA,EAXN,OANI,EAAS,KAET,EAAS,MAET,EADoB,IAAI,IAAI,EAAS,KAChB,QAErB,IAAW,KAAK,SAAS,OACzB,EAAM,IAAI,GAAa,6BAA8B,CAAE,aAErD,EAAiB,EAAS,QAE1B,EAAe,CACjB,QAAS,IAAI,QAAQ,EAAe,SACpC,OAAQ,EAAe,OACvB,WAAY,EAAe,YAGzB,EAAuB,EAAW,EAAS,GAAgB,EAIpD,kDCjCjB,WACI,QAAsB,IAAlB,GAA6B,CAC7B,IAAM,EAAe,IAAI,SAAS,IAClC,GAAI,SAAU,EACV,IACI,IAAI,SAAS,EAAa,MAC1B,IAAgB,EAEpB,MAAO,GACH,IAAgB,EAGxB,IAAgB,EAEpB,OAAO,GDmBM,GAAkC,EAC3C,EAAe,MAAO,gBAAM,EAAe,QAArB,KAA2B,SADxC,MACwC,gBACrD,SAAO,IAAI,SAFE,EAEa,IAD2B,yhDE7CzD,SAAS,EAAY,EAAS,GAE1B,IADA,IACA,EADM,EAAc,IAAI,IAAI,GAC5B,IAAoB,KAApB,aAAkC,CAC9B,EAAY,aAAa,OADK,SAGlC,OAAO,EAAY,w0BCGhB,SAAS,EAAQ,GACpB,OAAO,IAAI,SAAQ,SAAC,GAAD,OAAa,WAAW,EAAS,+sDCAxD,SAAS,EAAU,GACf,MAAyB,iBAAV,EAAsB,IAAI,QAAQ,GAAS,qwJCW9D,SAAS,EAAkB,GAEvB,OAD2B,KACD,kBAAkB,GCNhD,SAAS,EAAiB,EAAS,ICInC,SAAkB,GACa,KACR,SAAS,GDL5B,CAAS,GEAb,SAAkB,GACd,IAAM,EAAqB,KAE3B,EADsB,IAAI,GAAc,EAAoB,IFD5D,CAAS,6wGGmBb,SAAS,GAAc,GACrB,OAAO,IAAI,SAAQ,SAAA,GACjB,EAAM,UACJ,KAAK,QAAQ,SAAS,CACpB,KAAM,SACN,qBAAqB,IAEtB,MAAK,SAAC,GACL,IAAK,IAAI,EAAI,EAAG,EAAI,EAAW,OAAQ,IAAK,CAC1C,IAAI,EAAS,EAAW,GACxB,GAAI,EAAO,MAAQ,IAAa,UAAW,EAAQ,OAAO,EAAQ,GAEpE,EAAQ,wBChDZ,GTDA,mDUeS,cAdI,SAAC,GAAkB,IAChC,IAAI,EAAM,EADsB,mBAAT,EAAS,iCAAT,EAAS,kBAKhC,OAHI,EAAK,OAAS,IACd,GAAO,OAAO,KAAK,UAAU,IAE1B,ICIL,eASF,WAAY,EAAW,GAAS,MACtB,EAAU,GAAiB,EAAW,GADhB,OAE5B,cAAM,IAAN,MACK,KAAO,EACZ,EAAK,QAAU,EAJa,sGATT,QCFd,cAAmB,SAAC,GAC7B,OAAI,GAA8B,iBAAZ,EASX,EAWA,CAAE,OAAQ,KCjBnB,cAYF,WAAY,EAAO,EAAS,QAAwB,IAAxB,MChBH,OD8BrB,KAAK,QAAU,GAAiB,GAChC,KAAK,MAAQ,EACb,KAAK,OAAS,qBAOlB,gBAAA,SAAgB,GACZ,KAAK,aAAe,GAAiB,SEhCvC,eAcF,WAAY,EAAQ,EAAS,GAAQ,OAiCjC,aAxBc,SAAC,GAAY,IAAV,EAAU,EAAV,IACP,EAAS,EAAO,KAAK,EAAI,MAE/B,GAAK,IAOA,EAAI,SAAW,SAAS,QAA6B,IAAjB,EAAO,OAYhD,OAAO,EAAO,MAAM,KAEX,EAAS,IAjCW,uGAdf,IChBpB,GAAiB,SAAC,GAIpB,OAHe,IAAI,IAAI,OAAO,GAAM,SAAS,MAG/B,KAAK,QAAQ,IAAI,OAAJ,IAAe,SAAS,QAAW,KCmB5D,cAIF,aACI,KAAK,QAAU,IAAI,IACnB,KAAK,mBAAqB,IAAI,qCAclC,iBAAA,WAAmB,WAEf,KAAK,iBAAiB,SAAU,SAAC,GAC7B,IACM,EAAkB,EAAK,cAAc,CAAE,QADzB,EAAZ,QAC8C,UAClD,GACA,EAAM,YAAY,SA0B9B,iBAAA,WAAmB,WAEf,KAAK,iBAAiB,WAAY,SAAC,GAC/B,GAAI,EAAM,MAA4B,eAApB,EAAM,KAAK,KAAuB,CAE5C,EAGJ,IAAM,EAAkB,QAAQ,IAJZ,EAAM,KAAlB,QAIoC,YAAY,KAAI,SAAC,GACpC,iBAAV,IACP,EAAQ,CAAC,IAEb,IAAM,EAAU,EAAI,QAAW,GAC/B,OAAO,EAAK,cAAc,CAAE,UAAS,cAKzC,EAAM,UAAU,GAEZ,EAAM,OAAS,EAAM,MAAM,IAC3B,EAAgB,MAAK,kBAAM,EAAM,MAAM,GAAG,aAAY,aAiBtE,cAAA,YAAkC,WAAlB,EAAkB,EAAlB,QAAS,EAAS,EAAT,MASrB,IAAM,EAAM,IAAI,IAAI,EAAQ,IAAK,SAAS,MAC1C,GAAK,EAAI,SAAS,WAAW,QAA7B,CAMA,IAAM,EAAa,EAAI,SAAW,SAAS,OAC3C,EAA0B,KAAK,kBAAkB,CAC7C,QACA,UACA,aACA,QAJI,EAAR,EAAQ,OAAQ,EAAhB,EAAgB,MAMZ,EAAU,GAAS,EAAM,QAEzB,EAcJ,IAAM,EAAS,EAAQ,OAQvB,IAPK,GAAW,KAAK,mBAAmB,IAAI,KAKxC,EAAU,KAAK,mBAAmB,IAAI,IAErC,EAAL,CAwBA,IAAI,EAhBA,EAiBJ,IACI,EAAkB,EAAQ,OAAO,CAAE,MAAK,UAAS,QAAO,WAE5D,MAAO,GACH,EAAkB,QAAQ,OAAO,GAGrC,IAAM,EAAe,GAAS,EAAM,aAoCpC,OAnCI,aAA2B,UAAY,KAAK,eAAiB,KAC7D,EAAkB,EAAgB,OAAM,SAAO,GAAP,+CAmBpC,OAAI,EAAK,cAUL,EAAO,EAAK,cAAc,OAAO,CAAE,MAAK,UAAS,WAErD,EAAM,GA7BN,GAAI,EAAc,CACV,EADU,sFAaP,GAAU,WACb,EAAM,EADO,2BAHjB,IACW,uBAAM,EAAa,OAAO,CAAE,MAAK,UAAS,QAAO,YAAjD,KAA0D,KAErE,MAAO,GAAU,EAAV,IAfyB,2BAkCrC,OAiBX,kBAAA,YAEI,IAFmD,IAEnD,EAFgB,EAAmC,EAAnC,IAAK,EAA8B,EAA9B,WAAY,EAAkB,EAAlB,QAAS,EAAS,EAAT,MAE1C,IADe,KAAK,QAAQ,IAAI,EAAQ,SAAW,MACnD,aAA4B,KAAjB,EAAiB,QACpB,OAAM,EACJ,EAAc,EAAM,MAAM,CAAE,MAAK,aAAY,UAAS,UAC5D,GAAI,EA4BA,OAjBA,EAAS,GACL,MAAM,QAAQ,IAAuC,IAAvB,EAAY,QAIpC,EAAY,cAAgB,QACE,IAApC,OAAO,KAAK,GAAa,QAIG,kBAAhB,KAPZ,OAAS,GAcN,CAAE,QAAO,UAIxB,MAAO,MAgBX,kBAAA,SAAkB,EAAS,QAAwB,IAAxB,MHlSF,OGmSrB,KAAK,mBAAmB,IAAI,EAAQ,GAAiB,OASzD,gBAAA,SAAgB,GACZ,KAAK,cAAgB,GAAiB,MAO1C,cAAA,SAAc,GAiCL,KAAK,QAAQ,IAAI,EAAM,SACxB,KAAK,QAAQ,IAAI,EAAM,OAAQ,IAInC,KAAK,QAAQ,IAAI,EAAM,QAAQ,KAAK,MAOxC,gBAAA,SAAgB,GACZ,IAAK,KAAK,QAAQ,IAAI,EAAM,QACxB,MAAM,IAAI,GAAa,6CAA8C,CACjE,OAAQ,EAAM,SAGtB,IAAM,EAAa,KAAK,QAAQ,IAAI,EAAM,QAAQ,QAAQ,GAC1D,KAAI,GAAc,GAId,MAAM,IAAI,GAAa,yCAHvB,KAAK,QAAQ,IAAI,EAAM,QAAQ,OAAO,EAAY,8BA7U1D,WACI,OAAO,KAAK,6CR5BP,GAA2B,WAOpC,OANK,MACD,GAAgB,IAAI,IAEN,mBACd,GAAc,oBAEX,IShBL,GAAoB,CACtB,gBAAiB,kBACjB,SAAU,cACV,OAAQ,UACR,QAAS,UACT,OAAgC,oBAAjB,aAA+B,aAAa,MAAQ,IAEjE,GAAmB,SAAC,GACtB,MAAO,CAAC,GAAkB,OAAQ,EAAW,GAAkB,QAC1D,QAAO,SAAC,GAAD,OAAW,GAAS,EAAM,OAAS,KAC1C,KAAK,MAOD,GAQe,SAAC,GACrB,OAAO,GAAiB,GAAiB,GAAkB,kBATtD,GAWQ,SAAC,GACd,OAAO,GAAiB,GAAiB,GAAkB,WAZtD,GAcE,WACP,OAAO,GAAkB,QAfpB,GAiBO,SAAC,GACb,OAAO,GAAiB,GAAiB,GAAkB,UAlBtD,GAoBE,WACP,OAAO,GAAkB,QChC3B,cACF,WAAc,WACV,KAAK,YAAc,GACnB,KAAK,eAAiB,GACtB,KAAK,iBAAmB,gDAAkB,EAAlB,EAAkB,MAAlB,OAEhB,IACA,EAAM,gBAHU,EAAS,SAAT,QAMxB,KAAK,yBAA2B,gDAAuB,EAAvB,EAAuB,eACnD,GAAmB,YADS,EAAS,MAC3B,KAAoB,CAE1B,IAAM,EAHkB,EAAgB,MAGtB,gBAAgB,IAC9B,EACA,EAAK,eAAe,KAAK,GAGzB,EAAK,YAAY,KAAK,GAG9B,SAAO,SCrBb,GACF,YAAoC,WAAtB,EAAsB,EAAtB,mBACV,KAAK,mBAAqB,gDAAS,EAAT,EAAS,QAAS,EAAlB,EAAkB,OAClC,EAAW,GAAU,EAAO,UAC9B,EAAK,oBAAoB,kBAAkB,EAAQ,KACvD,SAAO,EAAW,IAAI,QAAQ,GAAY,OAE9C,KAAK,oBAAsB,GCL7B,GAIF,WAAc,WACV,KAAK,QAAU,IAAI,SAAQ,SAAC,EAAS,GACjC,EAAK,QAAU,EACf,EAAK,OAAS,MCdpB,GAAsB,IAAI,InBmB1B,yBAkBF,WAAY,EAAU,GAClB,KAAK,WAAa,GA8ClB,EAAc,KAAM,GACpB,KAAK,MAAQ,EAAQ,MACrB,KAAK,UAAY,EACjB,KAAK,iBAAmB,IAAI,GAC5B,KAAK,wBAA0B,GAG/B,KAAK,SAAL,UAAoB,EAAS,SAC7B,KAAK,gBAAkB,IAAI,IAC3B,cAAqB,KAAK,YAA1B,aAAoC,CAChC,KAAK,gBAAgB,IADW,QACC,IAErC,KAAK,MAAM,UAAU,KAAK,iBAAiB,oCAezC,qHAAN,SAAY,GAAZ,8CAkBU,EAAkB,KAAK,YAAY,gBACrC,EAAQ,QAAU,KAnB1B,qBAiCU,EAAwB,EAAQ,QAjC1C,eAqDW,GAAO,IAOV,GAAI,EACA,uBAAM,KAAK,aAAa,eAAgB,CACpC,QACA,QACA,gBAAiB,EAAgB,QACjC,QAAS,EAAsB,WAJnC,KAKE,wEAbI,aAeV,MAAM,EAfI,2CArDlB,WAkCI,IAGoB,uBAAM,MAAM,EAA0B,aAAjB,EAAQ,UACzC,EAAY,KAAK,UAAU,eADf,KAC4B,2DAOxB,iBADT,EANiC,SAOT,CAC3B,QACA,QAAS,EACT,SAAU,KAHE,MAId,uBAJF,EAAgB,EAId,6BAXsC,OAD5C,EAAgB,EAC4B,IAMrB,KAAK,iBAAiB,qBAND,6LAa5C,SAAO,KAbqC,qCAehD,MAAO,GAAO,EAAP,IArDX,6CAyBW,GAAK,IACR,MAAM,IAAI,GAAa,kCAAmC,CACtD,YAAa,IAFT,uBALZ,IAAI,0CAEc,iBADH,EADX,SAEuB,CAAE,QAAS,EAAQ,QAAS,WAArC,MAA6C,uBAAvD,EAAU,EAA6C,6BAF3D,WACiB,KAAK,iBAAiB,sBADvC,yMAKJ,MAAO,GAAK,EAAL,IAzBX,MAEQ,EAIM,EAYJ,EAlBV,IAiCU,EAEE,EAnCZ,IAGI,OAFQ,EAAU,KAAV,MAEa,cADjB,EAAU,EAAU,IACZ,MACR,aAAiB,YACjB,EAAM,gBAC0B,gBAAM,EAAM,iBAAZ,KAA2B,gBAC3D,OADM,EAA0B,GAM5B,EAAO,GANgD,kDANnE,+BAiFM,iBAAN,SAAuB,GAAvB,qCACU,EACA,EADW,uBAAM,KAAK,MAAM,IAAjB,KAAuB,gBAGxC,OAFM,GADA,EAAW,GACc,QAC/B,KAAK,UAAU,KAAK,SAAS,EAAO,IACpC,EAAO,GAHiC,sCAD5C,eAkBM,WAAN,SAAiB,GAAjB,qCACU,EACF,EAFR,MAIU,EACA,EALV,IAI6B,OAHnB,EAAU,EAAU,GAElB,GAAR,EAAoC,KAAK,WAAjC,UAAW,EAAnB,EAAmB,aACM,gBAAM,KAAK,YAAY,EAAS,SAAhC,KAAuC,gBAE/C,OAFX,EAAmB,EACnB,EAAN,OAA+B,GAAiB,CAAE,cACjC,gBAAM,OAAO,MAAM,EAAkB,IAArC,KAAuD,2DAUlD,iBADX,EAT6D,SAUnC,CAC7B,YACA,eACA,iBACA,QAAS,EACT,MAAO,KAAK,SALE,MAMhB,uBANF,EAAkB,QAMX,EAAL,6BAhBkE,OAAxE,EAAiB,EAAuD,IASjD,KAAK,iBAAiB,8BAT2B,6LAkBxE,SAAO,KAlBiE,qCAFR,sCAJpE,eAyCM,SAAN,SAAe,EAAK,GAApB,qCACU,EAIA,EAkBA,EAvBV,MAgCU,EACA,EACA,EAlCV,IAII,OAHM,EAAU,EAAU,GAG1B,gBAAM,EAAQ,IAAd,KAAgB,eACS,uBAAM,KAAK,YAAY,EAAS,UAAhC,KAAwC,gBASjE,OATM,EAAmB,EASpB,EASmB,gBAAM,KAAK,2BAA2B,IAAtC,KAA+C,gBACvE,OADM,EAAkB,IAQhB,GAAR,EAAoC,KAAK,WAAjC,UAAW,EAAnB,EAAmB,aACL,gBAAM,KAAK,OAAO,KAAK,IAAvB,KAAiC,gBAE3B,OAFd,EAAQ,EACR,EAAyB,KAAK,YAAY,kBAC5B,kDAAA,EAAyB,gBF5QrD,SAAsC,EAAO,EAAS,EAAc,GAApE,sCACU,EAMA,EAPV,MAUc,EAPV,OAFM,EAAqB,EAAY,EAAQ,IAAK,GAEhD,EAAQ,MAAQ,EAChB,EAAO,EAAM,MAAM,EAAS,KAG1B,EAAN,OAAyB,GAAzB,IAAuC,cAAc,IACnC,gBAAM,EAAM,KAAK,EAAS,IAA1B,MAAsC,gBACxD,QADkB,KAClB,aAEI,GADM,EAAsB,GADrB,EAAuB,SACmB,IAAK,GAClD,IAAuB,EACvB,SAAO,EAAM,MAAM,EAAU,IAGrC,WAPwD,+BEoQD,CAInD,EAAO,EAAiB,QAAS,CAAC,mBAAoB,IAJT,KAIsB,KAJ/C,EAKhB,UALgB,KAKZ,gBALF,EAAc,EAKZ,+DAiBJ,iBADO,EAhBH,SAiBW,CACX,YACA,cACA,YAAa,EAAgB,QAC7B,QAAS,EACT,MAAO,KAAK,SALhB,MAME,mDAvBE,WAgBe,KAAK,iBAAiB,oBAhBrC,6LAyBR,UAAO,IAzBC,6CASD,GAAO,IAEV,GAAmB,uBAAf,EAAM,KACN,uBoBtShB,+DAMQ,iBADO,EALf,YAMQ,MAAgB,mDANxB,6CAK2B,KAL3B,oLpBsSgB,KAAkC,wEAH5B,aAKV,MAAM,EALI,2CATN,WAKR,IACI,uBAAM,EAAM,IAAI,EAAkB,EAC9B,EAAgB,QAAU,IAD9B,MAC8C,qDAElD,MAAO,GAAO,EAAP,IATC,qCAPuC,sCAH3C,GAAO,GAN4D,qCAJnE,EAAM,IAAI,GAAa,6BAA8B,CACjD,IAAK,GAAe,EAAiB,QAfoB,qCADjD,sCAJpB,eA6EM,YAAN,SAAkB,EAAS,GAA3B,8CAaI,SAAO,KAAK,WAAW,IAb3B,IAEY,EAFZ,IACI,IAAK,KAAK,WAAW,GAAO,2CAGS,iBADtB,EAFa,SAGwB,CACxC,OACA,QAAS,EACT,MAAO,KAAK,MACZ,OAAQ,KAAK,UAJY,MAK3B,uBALF,EAAmB,EAAU,GAK3B,6BARkB,OACpB,EAAmB,EADC,IAED,KAAK,iBAAiB,wBAFrB,oMAUxB,KAAK,WAAW,GAAQ,EAVA,cADhC,oCAsBA,YAAA,SAAY,GACR,cAAqB,KAAK,UAAU,WAApC,aAA6C,CACzC,GAAI,KADqC,QAErC,OAAO,EAGf,OAAO,KAkBL,aAAN,SAAmB,EAAM,GAAzB,qEAIQ,iBAHO,EADf,SAIuB,IAAf,MAAqB,mDAJ7B,6CAC2B,KAAK,iBAAiB,KADjD,gMAgBC,iBAAD,UAAkB,GACd,IADoB,IACpB,EADoB,yBACT,EADS,QAEhB,GAA4B,mBAAjB,EAAO,GAAsB,CACpC,IAAM,EAAQ,EAAK,gBAAgB,IAAI,SACd,SAAC,GACtB,IAAM,EAAgB,OAAK,GAAR,IAAe,UAGlC,OAAO,EAAO,GAAM,MAPhC,IAAqB,KAAK,UAAU,WAApC,mBAA6C,OA0BjD,UAAA,SAAU,GAEN,OADA,KAAK,wBAAwB,KAAK,GAC3B,KAYL,YAAN,gEAEW,EAAU,KAAK,wBAAwB,SAC1C,gBAAM,GAAN,MAAa,mDAHrB,gCACQ,EADR,yMAUA,QAAA,WACI,KAAK,iBAAiB,aAYpB,2BAAN,SAAiC,GAAjC,iEAWY,IAPe,iBADZ,EAHf,SAI0C,CAC9B,QAAS,KAAK,QACd,SAAU,EACV,MAAO,KAAK,SAHG,MAIjB,gBAEF,OADA,GAAc,GALd,EAAmB,QAIZ,GAAL,EAGE,IAHF,2BARV,aAmCI,OArBK,GACG,GAA8C,MAA3B,EAAgB,SACnC,OAAkB,GAmB1B,EAAO,GAnCX,IACQ,EACA,EAFR,aACQ,EAAkB,EAClB,GAAc,EAFtB,IAG2B,KAAK,iBAAiB,qBAHjD,oMqB7bE,cAuBF,WAAY,QAAc,IAAd,MAAU,IAQlB,KAAK,UAAY,GAA0B,EAAQ,WAQnD,KAAK,QAAU,EAAQ,SAAW,GAQlC,KAAK,aAAe,EAAQ,aAQ5B,KAAK,aAAe,EAAQ,wCAqBhC,OAAA,SAAO,GAEH,OADuB,KAAK,UAAU,GAAtC,MAyBJ,UAAA,SAAU,GAEF,aAAmB,aACnB,EAAU,CACN,MAAO,EACP,QAAS,EAAQ,UAGzB,IAAM,EAAQ,EAAQ,MAChB,EAAqC,iBAApB,EAAQ,QAC3B,IAAI,QAAQ,EAAQ,SACpB,EAAQ,QAEN,EAAU,IAAI,GAAgB,KAAM,CAAE,QAAO,UAAS,OAD7C,WAAY,EAAU,EAAQ,YAAS,IAEhD,EAAe,KAAK,aAAa,EAAS,EAAS,GAGzD,MAAO,CAAC,EAFY,KAAK,eAAe,EAAc,EAAS,EAAS,OAItE,aAAN,SAAmB,EAAS,EAAS,GAArC,qCAEQ,EAFR,QACI,uBAAM,EAAQ,aAAa,mBAAoB,CAAE,QAAO,aAAxD,KAAkE,eAC9D,OAAW,EADmD,+DA4BnD,iBADJ,EA3BuD,SA4BpC,CAAE,QAAO,UAAS,cAAjC,MAA4C,uBAAvD,EAAW,EAA4C,6BA5BO,WA2B3C,EAAQ,iBAAiB,wBA3BkB,6LA8BlE,SAAO,IA9B2D,kCAW3D,GAAO,2CAIF,IAFO,iBADJ,EADD,SAEoB,CAAE,QAAO,QAAO,aAA/B,MAAyC,gBACpD,OADA,EAAW,GAEP,IAFgD,6BAF9C,WACa,EAAQ,iBAAiB,qBADtC,6LAOV,IAAK,EACD,MAAM,EARA,oCAXoD,WAElE,IACe,uBAAM,KAAK,QAAQ,EAAS,IAA5B,MAAoC,gBAI/C,KAJA,EAAW,IAIwB,UAAlB,EAAS,KACtB,MAAM,IAAI,GAAa,cAAe,CAAE,IAAK,EAAQ,MALV,sCAQnD,MAAO,GAAO,EAAP,IAX2D,sCADtE,eAiCM,eAAN,SAAqB,EAAc,EAAS,EAAS,GAArD,sCACQ,EACA,EAFR,sCAsBI,uBAAM,EAAQ,aAAa,qBAAsB,CAC7C,QACA,UACA,WACA,WAJJ,MAKE,eAEF,OADA,EAAQ,UACJ,EACA,EAAM,GAHR,+BA3BN,kCAmBW,GAAgB,WACnB,EAAQ,EADW,2BARvB,IACI,uBAAM,EAAQ,aAAa,oBAAqB,CAC5C,QACA,UACA,cAHJ,MAIE,eACF,uBAAM,EAAQ,eAAd,MAA2B,qDADzB,2BAGN,MAAO,GAAgB,EAAhB,IAnBX,oCAMkB,sCAHd,IACe,uBAAM,GAAN,MAAkB,uBAA7B,EAAW,EAAkB,8BAEjC,MAAO,GAAO,cCxJhB,eAkBF,WAAY,GAAc,sBAAd,MAAU,IAClB,EAAQ,UAAY,GAA2B,EAAQ,YACvD,cAAM,IAAN,MACK,oBAAmD,IAA9B,EAAQ,kBAKlC,EAAK,QAAQ,KAAK,EAAiB,wCARb,qHAiBpB,QAAN,SAAc,EAAS,GAAvB,qCACU,EAAW,uBAAM,EAAQ,WAAW,IAAzB,KAAiC,gBAClD,OADM,EAAW,GAUjB,EAAO,GALC,EAAQ,OAAgC,YAAvB,EAAQ,MAAM,KACxB,gBAAM,KAAK,eAAe,EAAS,IAAnC,KAA2C,KAE/C,gBAAM,KAAK,aAAa,EAAS,IAAjC,KAAyC,KARF,sCADtD,eAaM,aAAN,SAAmB,EAAS,GAA5B,gEAoCI,SAAO,IApCX,eACQ,EAGJ,OAAI,KAAK,mBAMM,gBAAM,EAAQ,MAAM,IAApB,KAA4B,uBAAvC,EAAW,EAA4B,kDAKvC,EAAM,IAAI,GAAa,yBAA0B,CAC7C,UAAW,KAAK,UAChB,IAAK,EAAQ,QAjBzB,eAsCM,eAAN,SAAqB,EAAS,GAA9B,qCAEU,EAAW,OADjB,KAAK,wCACY,gBAAM,EAAQ,MAAM,IAApB,MAA4B,gBAG3B,OAHZ,EAAW,EAGC,gBAAM,EAAQ,SAAS,EAAS,EAAS,UAAzC,MAAiD,gBACnE,OADkB,EASlB,EAAO,GALH,EAAM,IAAI,GAAa,0BAA2B,CAC9C,IAAK,EAAQ,IACb,OAAQ,EAAS,UAN0C,2BAHtB,4BAFjD,eA2CA,sCAAA,WAGI,IAFA,IAEA,EAFI,EAAqB,KACrB,EAA6B,EACjC,IAA8B,KAAK,QAAQ,aAA3C,aAAsD,eAAnC,EAAmC,KAE9C,IAAW,EAAiB,yCAI5B,IAAW,EAAiB,oCAC5B,EAP8C,MAS9C,EAAO,iBACP,KAG2B,IAA/B,EACA,KAAK,QAAQ,KAAK,EAAiB,mCAE9B,EAA6B,GAA4B,OAAvB,GAEvC,KAAK,QAAQ,OAAO,EAAoB,OAtJrB,IA2J/B,GAAiB,kCAAoC,CAC3C,gBAD2C,gDACzB,EADyB,EACzB,SACpB,OACI,GADC,GAAY,EAAS,QAAU,IACzB,KAEJ,QAGf,GAAiB,uCAAyC,CAChD,gBADgD,oDAE3C,OADa,EAD8B,EAC9B,SACb,kDAAA,EAAS,WAAa,gBAAM,EAAa,IAAnB,KAA4B,KAAlD,EAAqD,OAArD,KAA6D,cCtLxE,GCeE,cAWF,cAAwE,iBAAJ,GAAI,EAA1D,EAA0D,EAA1D,UAA0D,IAA/C,eAA+C,MAArC,GAAqC,MAAjC,yBAAiC,SACpE,KAAK,iBAAmB,IAAI,IAC5B,KAAK,kBAAoB,IAAI,IAC7B,KAAK,wBAA0B,IAAI,IACnC,KAAK,UAAY,IAAI,GAAiB,CAClC,UAAW,GAA2B,GACtC,QAAS,GAAF,OACA,EADA,CAEH,IAAI,GAAuB,CAAE,mBAAoB,SAErD,sBAGJ,KAAK,QAAU,KAAK,QAAQ,KAAK,MACjC,KAAK,SAAW,KAAK,SAAS,KAAK,uCAmBvC,SAAA,SAAS,GACL,KAAK,eAAe,GACf,KAAK,kCACN,KAAK,iBAAiB,UAAW,KAAK,SACtC,KAAK,iBAAiB,WAAY,KAAK,UACvC,KAAK,iCAAkC,MAU/C,eAAA,SAAe,GAUX,IADA,IACA,EADM,EAAkB,GACxB,IAAoB,KAApB,aAA6B,KAAlB,EAAkB,QAEJ,iBAAV,EACP,EAAgB,KAAK,GAEhB,QAA4B,IAAnB,EAAM,UACpB,EAAgB,KAAK,EAAM,KAE/B,MAA0B,EAAe,GAAjC,EAAR,EAAQ,SAAU,EAAlB,EAAkB,IACZ,EAA8B,iBAAV,GAAsB,EAAM,SAClD,SAAW,UACf,GAAI,KAAK,iBAAiB,IAAI,IAC1B,KAAK,iBAAiB,IAAI,KAAS,EACnC,MAAM,IAAI,GAAa,wCAAyC,CAC5D,WAAY,KAAK,iBAAiB,IAAI,GACtC,YAAa,IAGrB,GAAqB,iBAAV,GAAsB,EAAM,UAAW,CAC9C,GAAI,KAAK,wBAAwB,IAAI,IACjC,KAAK,wBAAwB,IAAI,KAAc,EAAM,UACrD,MAAM,IAAI,GAAa,4CAA6C,CAChE,QAGR,KAAK,wBAAwB,IAAI,EAAU,EAAM,WAIrD,GAFA,KAAK,iBAAiB,IAAI,EAAK,GAC/B,KAAK,kBAAkB,IAAI,EAAK,GAC5B,EAAgB,OAAS,EAAG,CAC5B,IAAM,EAAiB,qDACV,EAAgB,KAAK,MADX,yEAMnB,QAAQ,KAAK,QAkB7B,QAAA,SAAQ,GAAO,WACX,OAAO,EAAU,GAAO,kFAKR,GALQ,cAMV,EAAY,EAAK,wBAAwB,IADlC,EALG,MAOV,EAAY,EAAK,kBAAkB,IAAI,GACvC,EAAU,IAAI,QAAQ,EAAK,CAC7B,YACA,MAAO,EACP,YAAa,gBAEjB,gBAAM,QAAQ,IAAI,EAAK,SAAS,UAAU,CACtC,OAAQ,CAAE,YACV,UACA,YAHJ,MAIG,oDAjBa,aAuBpB,SAAO,CAAE,YAJ+B,EAAhC,YAIc,eAJkB,EAAnB,iBAnBD,IACd,EADc,UAMV,EACA,EACA,EARU,SACd,EAAsB,IAAI,GAChC,EAAK,SAAS,QAAQ,KAAK,GAFP,IAKU,EAAK,mBALf,yLAoC5B,SAAA,SAAS,GAAO,WACZ,OAAO,EAAU,GAAO,iDACd,EACA,EACA,EACA,EAJc,MACN,uBAAM,KAAK,OAAO,KAAK,EAAK,SAAS,YAArC,KAA+C,gBAC7B,OAD1B,EAAQ,EACkB,gBAAM,EAAM,QAAZ,KAAkB,+DAI9C,IAAK,EAAkB,KADhB,EAHuC,SAIX,KAC/B,uBAAM,EAAM,OAAO,IAAnB,KAA2B,sBAC3B,EAAY,KAAK,EAAQ,KADE,kDALe,kDAA5C,EAA0B,EAC1B,EAAoB,IAAI,IAAI,EAAK,iBAAiB,UAClD,EAAc,GAF8B,IAG5B,IAH4B,6LAYlD,SAAO,CAAE,kBAZyC,qCADW,8CAsBrE,mBAAA,WACI,OAAO,KAAK,oBAQhB,cAAA,WACI,gBAAW,KAAK,iBAAiB,WAWrC,kBAAA,SAAkB,GACd,IAAM,EAAY,IAAI,IAAI,EAAK,SAAS,MACxC,OAAO,KAAK,iBAAiB,IAAI,EAAU,SAoBzC,cAAN,SAAoB,GAApB,qCACU,EACA,EACN,OAFM,EAAM,aAAmB,QAAU,EAAQ,IAAM,GACjD,EAAW,KAAK,kBAAkB,IAEtB,gBAAM,KAAK,OAAO,KAAK,KAAK,SAAS,YAArC,MAA+C,gBAC7D,SADc,EACD,MAAM,IAD0C,2BAGjE,OAAO,IAPX,eAiBA,wBAAA,SAAwB,GAAK,WACnB,EAAW,KAAK,kBAAkB,GACxC,IAAK,EACD,MAAM,IAAI,GAAa,oBAAqB,CAAE,QAElD,OAAO,SAAC,GAGJ,OAFA,EAAQ,QAAU,IAAI,QAAQ,GAC9B,EAAQ,sWAAR,EAAmB,YAAa,EAAQ,QACjC,EAAK,SAAS,OAAO,iCA7NpC,WACI,OAAO,KAAK,+CD1CP,GAAgC,WAIzC,OAHK,KACD,GAAqB,IAAI,IAEtB,IEGL,eAiBF,WAAY,EAAoB,GAAS,OAerC,aAdc,SAAC,GAEX,IAF2B,IAE3B,EAFa,EAAc,EAAd,QACP,EAAkB,EAAmB,qBAC3C,ICtBL,UAAgC,EAAhC,GAAsK,iBAAJ,GAAI,MAA/H,mCAA+H,MAAjG,CAAC,QAAS,YAAuF,MAA1E,sBAA0E,MAAzD,aAAyD,MAA3C,iBAA2C,SAAzB,EAAyB,EAAzB,gBAC1I,EAAY,IAAI,IAAI,EAAK,SAAS,MACxC,EAAU,KAAO,SACX,EAAU,KAChB,IAAM,ECHH,SAAmC,EAAW,QAAkC,IAAlC,MAA8B,IAG/E,IAHmF,iBAG9E,IAAM,EAAS,KACZ,EAA4B,MAAK,SAAC,GAAD,OAAY,EAAO,KAAK,OACzD,EAAU,aAAa,OAAO,IAFtC,gBAA4B,EAAU,aAAa,QAAnD,eAA4D,IAK5D,OAAO,EDLyB,CAA0B,EAAW,GAErE,SADM,EAAwB,KAC1B,GAAkB,EAAwB,SAAS,SAAS,KAAM,CAClE,IAAM,EAAe,IAAI,IAAI,EAAwB,MACrD,EAAa,UAAY,QACnB,EAAa,KAEvB,GAAI,EAAW,CACX,IAAM,EAAW,IAAI,IAAI,EAAwB,MACjD,EAAS,UAAY,cACf,EAAS,KAEnB,GAAI,EAEA,IADA,IACA,MADuB,EAAgB,CAAE,IAAK,OAC9C,aAA2C,KAAhC,EAAgC,cACjC,EAAa,MDGO,CAAsB,EAAQ,IAAK,MAA7D,aAAuE,KAC7D,EAAW,EAAgB,IADkC,SAEnE,GAAI,EACA,MAAO,CAAE,eASR,EAAmB,WAfK,uGAjBjB,IGrBf,GAAQ,SAAA,GAAK,MAA2B,aAAvB,EAAM,QAAQ,MCQ/B,GAAyB,CAWlC,gBAAiB,gDAAS,EAAT,EAAS,SACtB,OACI,EADoB,MAApB,EAAS,QAAsC,IAApB,EAAS,OAC7B,EAEJ,WCOT,eAoBF,WAAY,GAAc,sBAAd,MAAU,KAClB,cAAM,IAAN,MAGU,QAAQ,MAAK,SAAC,GAAD,MAAO,oBAAqB,MAC/C,EAAK,QAAQ,QAAQ,IAEzB,EAAK,uBAAyB,EAAQ,uBAAyB,EAPzC,qHA0BpB,QAAN,SAAc,EAAS,GAAvB,qCACU,EASA,EACF,EAXR,EAiBU,EAEA,EAAW,OAlBX,EAAO,GASP,EAAW,GAEb,KAAK,yBAEL,GADA,EAAwB,KAAK,mBAAmB,CAAE,UAAS,OAAM,aAAzD,GAER,EAAS,KAFT,EAAY,UAIV,EAAiB,KAAK,mBAAmB,CAAE,YAAW,UAAS,OAAM,YAC3E,EAAS,KAAK,GACG,gBAAM,EAAQ,UAAW,2BAE/B,+EAAM,EAAQ,UAAU,QAAQ,KAAK,KAArC,KAA+C,uBAA/C,GAMH,uBAAM,GAAN,KAAoB,yBAApB,EAAoB,kDAN8B,sFAA/C,KAMiB,UARX,KASZ,gBASL,OAlBM,EAAW,GAqBjB,EAAO,GAFH,EAAM,IAAI,GAAa,cAAe,CAAE,IAAK,EAAQ,OAVpD,sCA5BT,eAmDA,mBAAA,YAA+C,IACvC,EADuC,OAA1B,EAA0B,EAA1B,QAAe,EAAW,EAAX,QAYhC,MAAO,CACH,QAXmB,IAAI,SAAQ,SAAC,GAQhC,EAAY,YAPa,6CAKb,uBAAM,EAAQ,WAAW,IAAzB,MAAiC,uBAAzC,EAAQ,GAAiC,oCAE0B,IAA9B,EAAK,2BAI9C,GAAI,MAaN,mBAAN,uDACQ,EACA,EAFmB,EAA3B,EAA2B,UAAW,EAAtC,EAAsC,QAAe,EAArD,EAAqD,QAArD,qBAqBI,GAZI,GACA,aAAa,GAWb,IAAU,EACC,uBAAM,EAAQ,WAAW,IAAzB,KAAiC,uBAA5C,EAAW,EAAiC,kDAtBpD,aAiCI,SAAO,GAjCX,iEAMW,GAAY,WACf,EAAQ,EADO,2BAHnB,IACe,uBAAM,EAAQ,iBAAiB,IAA/B,MAAuC,uBAAlD,EAAW,EAAuC,+BAEtD,MAAO,GAAY,EAAZ,KANX,gBA5HuB,ICHrB,eAYF,WAAY,GAAc,sBAAd,MAAU,KAClB,cAAM,IAAN,MACK,uBAAyB,EAAQ,uBAAyB,EAFzC,6GAWpB,QAAN,SAAc,EAAS,GAAvB,qCASQ,EACA,EAEM,EAEI,EALV,OAAQ,EAThB,qBAqCI,OAAK,EAGL,EAAO,GAFH,EAAM,IAAI,GAAa,cAAe,CAAE,IAAK,EAAQ,IAAK,WAtClE,6CAuBW,GAAK,WACR,EAAQ,EADA,2BAZZ,IAMe,OALL,EAAW,CAAC,EAAQ,MAAM,IAC5B,KAAK,yBACC,EAAiB,EAAsC,IAA9B,KAAK,wBACpC,EAAS,KAAK,IAEP,gBAAM,QAAQ,KAAK,IAAnB,KAA4B,gBACvC,KADA,EAAW,GAEP,MAAM,IAAI,MAAM,wCACT,KAAK,uBADI,aAFmB,gDAM3C,MAAO,GAAK,EAAL,KAvBX,gBAvBsB,ICQpB,eAcF,WAAY,GAAS,aACjB,cAAM,IAAN,MAGU,QAAQ,MAAK,SAAC,GAAD,MAAO,oBAAqB,MAC/C,EAAK,QAAQ,QAAQ,IALR,8GAef,QAAN,SAAc,EAAS,GAAvB,qCAUU,EAMF,EACA,EADW,MAfF,GASP,EAAuB,EACxB,iBAAiB,GACjB,OAAM,eAII,gBAAM,EAAQ,WAAW,IAAzB,KAAiC,gBAEhD,GAFI,EAAW,EAED,oBAMT,sFAUM,GAAK,WACR,EAAQ,EADA,2BALZ,IAGe,uBAAM,GAAN,MAA0B,uBAArC,EAAW,EAA0B,+BAEzC,MAAO,GAAK,EAAL,GAlBqC,aA8BhD,OAAK,EAGL,EAAO,GAFH,EAAM,IAAI,GAAa,cAAe,CAAE,IAAK,EAAQ,IAAK,YA/Bd,sCAhBpD,gBA7B+B,ICpBtB,GAAb,WAUI,WAAY,EAAM,EAAlB,GAAuE,wBAAJ,GAAI,EAA1C,EAA0C,EAA1C,gBAAiB,EAAyB,EAAzB,gBAC1C,KAAK,IAAM,KACX,KAAK,MAAQ,EACb,KAAK,SAAW,EAChB,KAAK,iBAAmB,EACxB,KAAK,iBAAmB,GAAoB,kBAAM,EAAK,SAf/D,UAAA,uBAiCU,KAAN,kDACI,OADJ,OACQ,KAAK,IACL,IACO,gBAAM,IAAI,SAAQ,SAAC,EAAS,GAMnC,IAAI,GAAsB,EAC1B,YAAW,WACP,GAAsB,EACtB,EAAO,IAAI,MAAM,iDAClB,EAAK,cACR,IAAM,EAAc,UAAU,KAAK,EAAK,MAAO,EAAK,UACpD,EAAY,QAAU,kBAAM,EAAO,EAAY,QAC/C,EAAY,gBAAkB,SAAC,GACvB,GACA,EAAY,YAAY,QACxB,EAAY,OAAO,SAEmB,mBAA1B,EAAK,kBACjB,EAAK,iBAAiB,IAG9B,EAAY,UAAY,WACpB,IAAM,EAAK,EAAY,OACnB,EACA,EAAG,SAGH,EAAG,gBAAkB,EAAK,iBAAiB,KAAK,GAChD,EAAQ,SA7BT,KAgCT,gBACF,OAjCA,KAAK,IAAM,EAiCX,EAAO,MADL,sCAnCN,aAjCJ,EAgFU,OAAN,SAAa,EAAW,GAAxB,iCACY,uBAAM,KAAK,WAAW,EAAW,EAAO,IAAxC,MAA0C,gBAAlD,SAAQ,EAA4C,IAAF,4BADtD,aAhFJ,EA6FU,OAAN,SAAa,EAAW,EAAO,GAA/B,iCACW,uBAAM,KAAK,eAAe,EAAW,CAAE,QAAO,WAA9C,KAAsD,MADjE,aA7FJ,EA0GU,WAAN,SAAiB,EAAW,EAAO,GAAnC,iCACoB,uBAAM,KAAK,eAAe,EAAW,CAAE,QAAO,QAAO,aAAa,KAAlE,MAAyE,gBACzF,SADgB,EACD,KAAI,SAAC,GAAD,OAAW,EAAM,QADqD,4BAD7F,aA1GJ,EA+HU,eAAN,SAAqB,EAArB,0DAEW,OAFuB,GAAlC,aACoD,GADpD,GAAkC,MAAO,OAAzC,SAAyC,OAAQ,KAAjD,EACA,OADA,SACA,WAAY,OADZ,EACoB,EADpB,EACoB,MAAO,OAD3B,SAC2B,cAD3B,EAEW,gBAAM,KAAK,YAAY,CAAC,GAAY,YAAY,SAAC,EAAK,GACzD,IAAM,EAAQ,EAAI,YAAY,GACxB,EAAS,EAAQ,EAAM,MAAM,GAAS,EACtC,EAAU,GACV,EAAU,EAAO,WAAW,EAAO,GACzC,EAAQ,UAAY,WAChB,IAAM,EAAS,EAAQ,OACnB,GACA,EAAQ,KAAK,EAAc,EAAS,EAAO,OACvC,GAAS,EAAQ,QAAU,EAC3B,EAAK,GAGL,EAAO,YAIX,EAAK,QAjBV,KAoBL,MAtBN,aA/HJ,EAwKU,YAAN,SAAkB,EAAY,EAAM,GAApC,uCACI,OADJ,OACI,gBAAM,KAAK,QAAX,MAAiB,eACV,uBAAM,IAAI,SAAQ,SAAC,EAAS,GAC/B,IAAM,EAAM,EAAK,IAAI,YAAY,EAAY,GAC7C,EAAI,QAAU,kBAAM,EAAO,EAAI,QAC/B,EAAI,WAAa,kBAAM,KACvB,EAAS,GAAK,SAAC,GAAD,OAAW,EAAQ,UAJ9B,KAKL,KANe,4BADrB,aAxKJ,EA2LU,MAAN,SAAY,EAAQ,EAAW,GAA/B,0EAAwC,EAAxC,iCAAwC,EAAxC,UAQW,uBAAM,KAAK,YAAY,CAAC,GAAY,GAP1B,SAAC,EAAK,GACnB,IAAM,EAAW,EAAI,YAAY,GAG3B,EAAU,EAAS,GAAQ,MAAM,EAAU,GACjD,EAAQ,UAAY,kBAAM,EAAK,EAAQ,aAEpC,KAAmD,MAR9D,aA3LJ,EAkNI,MAAA,WACQ,KAAK,MACL,KAAK,IAAI,QACT,KAAK,IAAM,SArNvB,KAAA,eAuBI,WACI,OAAO,KAAK,sCAxBpB,KA2NA,GAAU,UAAU,aAAe,IAMnC,IAJA,kBAKI,IADC,IACD,EADC,SAAO,EAAP,sBACU,UACH,KAAU,eAAe,YAEzB,GAAU,UAAU,GAChB,SAAgB,GAAhB,0EAA8B,EAA9B,iCAA8B,EAA9B,UACW,uBAAM,KAAK,MAAL,MAAA,KAAA,CAAW,EAAQ,EAAW,GAA9B,OAAuC,KAA7C,KAAkD,MAD7D,eAJZ,KADC,QACD,aAA8B,KADlC,QAA8B,OAAO,QAJf,CAClB,SAAU,CAAC,MAAO,QAAS,SAAU,SAAU,cAC/C,UAAW,CAAC,MAAO,MAAO,QAAS,YAEvC,kBAA6D,KC/NtD,ICCkB,GCMnB,GAAa,CACf,sBACI,OAAO,MAEX,eACI,OAAO,MAEX,aACI,OAAO,MAEX,cACI,OAAO,MAEX,aACI,OAAO,OClBT,yBAeF,WAAY,QAAa,IAAb,MAAS,IA0BjB,KAAK,UAAY,EAAO,SACxB,KAAK,SAAW,EAAO,2BAW3B,oBAAA,SAAoB,GAAU,WAS1B,IAAI,GAAY,EAoChB,OAnCI,KAAK,YACL,EAAY,KAAK,UAAU,SAAS,EAAS,SAE7C,KAAK,UAAY,IACjB,EAAY,OAAO,KAAK,KAAK,UAAU,MAAK,SAAC,GACzC,OAAO,EAAS,QAAQ,IAAI,KAAgB,EAAK,SAAS,OA8B3D,SClHF,GAAqB,GAErB,GAAkB,IAAI,GAAa,CAE/C,UAAW,GAAW,SACtB,sBAAuB,EACvB,QAAS,CACR,ICoBE,SAAY,GAAQ,WAOhB,KAAK,gBAAkB,gDAAS,EAAT,EAAS,SAC5B,OAAI,EAAK,mBAAmB,oBAAoB,GAC5C,EAAO,GAEX,EAAO,UAEX,KAAK,mBAAqB,IAAI,GAAkB,GDjCtD,CAA4B,CAC3B,SAAU,CAAC,UEAR,cAAoB,YACpB,GAAe,YAOR,GAAb,WAQI,WAAY,GACR,KAAK,WAAa,EAClB,KAAK,IAAM,IAAI,GAnBP,0BADG,EAoBmC,CAC1C,gBAAiB,KAAK,aAXlC,2BAuBU,UAAN,SAAgB,GAAhB,iCAkBI,cAFO,EAAM,GACb,EAAM,UAAY,KAAK,WACvB,gBAAM,KAAK,IAAI,IAAI,GAAmB,IAAtC,MAA4C,sDAlBhD,aAvBJ,EAoDU,aAAN,SAAmB,GAAnB,uCAeyB,uBAAM,KAAK,IAAI,eAAe,GAAmB,CAClE,MAAO,KADU,KAEnB,gBAUF,OAZO,EAAc,EAArB,IAKI,EAAM,GAAK,EAAW,GAAK,SAIpB,EAAM,GAEjB,EAAM,UAAY,KAAK,WACvB,gBAAM,KAAK,IAAI,IAAI,GAAmB,IAAtC,MAA4C,qDAV1C,sCAjBN,aApDJ,EAuFU,SAAN,0CACI,SAAO,KAAK,aAAa,CAAE,UAAW,WAD1C,aAvFJ,EAgGU,WAAN,0CACI,SAAO,KAAK,aAAa,CAAE,UAAW,WAD1C,aAhGJ,EA0GU,OAAN,4CACW,uBAAM,KAAK,IAAI,eAAe,GAAmB,CACpD,MAAO,GACP,MAAO,YAAY,KAAK,KAAK,eAF1B,KAGL,MAJN,aA1GJ,EA2HU,YAAN,SAAkB,GAAlB,iCACI,uBAAM,KAAK,IAAI,OAAO,GAAmB,IAAzC,MAA4C,sDADhD,aA3HJ,EAqIU,aAAN,mDACoB,uBAAM,KAAK,IAAI,eAAe,GAAmB,CAC7D,UAFR,EAAqB,UAGb,MAAO,GACP,MAAO,YAAY,KAAK,KAAK,YAC7B,MAAO,KAJK,KAKd,gBACF,OANO,EAAS,EAAhB,IAOI,gBAAM,KAAK,YAAY,EAAM,KAA7B,MAAgC,eAChC,SAAO,GADyB,2BAFlC,0CANN,aArIJ,EAuJI,WAAA,SAAW,GACP,IAAM,EAAK,EAAM,OAAO,OACpB,EAAM,WAAa,GAAK,EAAM,WAnKvB,GAoKH,EAAG,iBAAiB,SAAS,KAC7B,EAAG,kBAAkB,IAGZ,EAAG,kBAAkB,GAAmB,CACrD,eAAe,EACf,QAAS,OAEJ,YAAY,GAAc,GAAc,CAAE,QAAQ,KAlKnE,KCXM,GAAyB,CAC3B,SACA,WACA,iBACA,OACA,cACA,QACA,WACA,YACA,aAQE,cAUF,WAAY,GAiBoB,aAAxB,EAAW,OACX,EAAW,KAAW,eAE1B,KAAK,aAAe,IAWX,YAAb,SAAyB,GAAzB,+CAcI,SAA2B,EAAQ,QAAQ,aAA3C,aACI,EAAY,SADsC,oBAItD,SAAmB,MAAnB,kBAC0B,IAAlB,EADG,EAAgC,WAEnC,EAAY,GAAQ,EAAQ,IAGpC,SAAO,IAAI,EAAgB,IAvB/B,IACU,EADV,YAMI,OALM,EAAc,CAChB,IAAK,EAAQ,IACb,QAAS,IAGU,QAAnB,EAAQ,OAKW,gBAAM,EAAQ,QAAQ,eAAtB,KAAmC,uBAAtD,EAAY,KAAO,EAAmC,kDAX9D,4CAgCA,SAAA,WACI,IAAM,EAAc,GAAc,GAAI,KAAK,cAK3C,OAJA,EAAY,QAAU,GAAc,GAAI,KAAK,aAAa,SACtD,EAAY,OACZ,EAAY,KAAO,EAAY,KAAK,MAAM,IAEvC,KASX,UAAA,WACI,OAAO,IAAI,QAAQ,KAAK,aAAa,IAAK,KAAK,iBASnD,MAAA,WACI,OAAO,IAAI,EAAgB,KAAK,kBC/GlC,GAAa,0BAEb,GAAa,IAAI,IAUjB,GAAe,SAAC,GAClB,IAAM,EAAa,CACf,QAAS,IAAI,GAAgB,EAAgB,aAAa,YAC1D,UAAW,EAAgB,WAK/B,OAHI,EAAgB,WAChB,EAAW,SAAW,EAAgB,UAEnC,GASL,cAoBF,WAAY,EAAZ,GAAqD,iBAAJ,GAAI,EAAjC,EAAiC,EAAjC,OAAQ,EAAyB,EAAzB,iBAIxB,GAHA,KAAK,iBAAkB,EACvB,KAAK,0BAA2B,EAE5B,GAAW,IAAI,GACf,MAAM,IAAI,GAAa,uBAAwB,CAAE,SAGjD,GAAW,IAAI,GAEnB,KAAK,MAAQ,EACb,KAAK,QAAU,GAAU,KAAK,eAC9B,KAAK,kBAAoB,GA5DN,MA6DnB,KAAK,YAAc,IAAI,GAAW,KAAK,OACvC,KAAK,oDAwBH,YAAN,SAAkB,GAAlB,iCAeI,uBAAM,KAAK,YAAY,EAAO,SAA9B,MAAqC,sDAfzC,eAiCM,eAAN,SAAqB,GAArB,iCAeI,uBAAM,KAAK,YAAY,EAAO,YAA9B,MAAwC,sDAf5C,eAwBM,WAAN,0CACI,SAAO,KAAK,eAAe,SAD/B,eAUM,aAAN,0CACI,SAAO,KAAK,eAAe,WAD/B,eASM,OAAN,gDACU,EACA,EACA,EAHV,MACuB,uBAAM,KAAK,YAAY,UAAvB,KAA+B,+DAO9C,OAAI,GAJG,EAHuC,SAO9B,UADsC,GAAzB,KAAK,kBAAyB,IAEvD,gBAAM,KAAK,YAAY,YAAY,EAAM,KAAzC,KAA4C,yEAG5C,EAAiB,KAAK,GAAa,IADlC,cAVyC,+BAA5C,EAAa,EACb,EAAM,KAAK,MACX,EAAmB,GAFyB,KAG9B,IAH8B,6LAclD,SAAO,KAd2C,sCADtD,eA2BM,YAAN,WAAkE,GAAlE,6CAEU,EADkB,OADR,EAApB,EAAoB,QAAS,EAA7B,EAA6B,SAAU,OAAvC,SAAuC,WAAY,KAAK,MAAxD,EAC4B,gBAAM,GAAgB,YAAY,EAAQ,UAA1C,KAAkD,gBAS1E,OARM,EAAQ,CACV,YAFoB,EAES,WAC7B,aAGA,IACA,EAAM,SAAW,GAErB,gBAAM,KAAK,YAAe,EAApB,SAAsC,IAA5C,KAAkD,eAQlD,OAAI,KAAK,iBACL,KAAK,0BAA2B,EADV,cAItB,gBAAM,KAAK,gBAAX,KAAyB,wEAZqB,8DATwB,sCAD9E,eAiCM,eAAN,SAAqB,GAArB,qCACU,EACA,EAAQ,OADR,EAAM,KAAK,MACH,gBAAM,KAAK,YAAe,EAApB,YAAN,KAA6C,gBAC3D,OAKQ,GANF,EAAQ,GAKN,EAAM,EAAM,UADsC,GAAzB,KAAK,kBAAyB,IAEhD,KAAK,eAAe,GAExB,GAAa,QAGb,GAXgD,sCAF/D,eAqBM,eAAN,yDAEoB,uBAAM,KAAK,gBAAX,KAAyB,qBAAjC,EAAQ,GAAyB,2BAQvB,IACV,uBAAM,KAAK,eAAe,IAA1B,KAAgC,eAKhC,MAAM,IAAI,GAAa,sBAAuB,CAAE,KAAM,KAAK,QAL3B,qCADtB,uBARuB,WACrC,IACI,uBAAM,MAAM,EAAM,QAAQ,UAA1B,KAAkC,sBAFD,8CAEC,wCAMtC,MAAO,GAAO,EAAP,IAR8B,qCAF7C,4BACQ,EADR,yMA2BM,aAAN,oEACI,GAAI,SAAU,KAAK,aAAc,yFAIjB,sCAJiB,WAC7B,IACI,uBAAM,KAAK,aAAa,KAAK,SAAY,GAAnC,IAAiD,KAAK,QAA5D,MAAoE,qDAExE,MAAO,GAAK,EAAL,IALf,oCAqBA,iBAAA,WAAmB,WACX,SAAU,KAAK,aACf,KAAK,iBAAiB,QAAQ,SAAC,GAC3B,GAAI,EAAM,MAAW,GAAjB,IAA+B,EAAK,MAAS,CACzC,EA8BJ,EAAM,UA1Be,+BAEb,EAFa,mCAkBb,GAAI,EAAK,4BACH,GAAc,EAAM,YACtB,uBAAM,EAAK,gBAAX,KAAyB,wEApBhB,aAsBb,EAAK,iBAAkB,EACvB,EAAK,0BAA2B,EAvBnB,kEACjB,EAAK,iBAAkB,EADN,kEAMV,GAAO,IAIV,MAHA,EAAY,EADF,0BAHd,IACI,uBAAM,EAAK,QAAQ,CAAE,MAAO,KAA5B,MAAmC,wDAEvC,MAAO,GAAO,EAAP,YA8BnB,KAAK,QAAQ,CAAE,MAAO,sCAW9B,WACI,OAAO,0BAxRX,WACI,OAAO,KAAK,6CrCxEpB,EACC,kDACA,IAAI,GAAY,CACf,QAAS,CAPU,IsCgBjB,SAAY,EAAM,GAAS,WAMvB,KAAK,aAAe,8CAChB,uBAAM,EAAK,OAAO,YAAY,CAAE,QADhB,EAAS,WACzB,MAA0C,yDAE9C,KAAK,OAAS,IAAI,GAAM,EAAM,GtCzBjB,CAAyB,cAAe,CAC5D,iBAAkB,WAQlB,QAED,GACE,kBAAM,IACN,IAAI,IuCFL,GAAc,mBAAe,GAAf,EAAG,SAA0B,ITAnB,GSER,YACf,OAAI,GAD0B,EAAZ,OAEV,OAAO,MACb,EAAkB,cAAgB,EAAkB,gBAG/C,SAAS,STPQ,KACR,gBAAgB,I9BIlC,IuCf+C,GvCezC,GuClBE,usEAAK,cAIZ,EvCee,GuCfiB,IAAqB,IvCiBtD,IAAM,GAAY,IAAI,IAAI,IAAK,KAAK,SAAS,QAAQ,KAWrD,KAAK,UAAY,SAAS,GACpB,OAAO,UAAU,eAAe,KAAK,EAAK,SAC5C,KAAK,QAAU,EAAI,KAAK,IACxB,KAAY,QAAQ,YAAa,KAAK,WAsB1C,KAAK,iBAAiB,QAAQ,SAAM,GAAN,sCACtB,EAKA,EAKE,EAVO,uBAAM,GAAc,IAApB,KAAuB,gBACtC,IADM,EAAS,IAC0B,YAA3B,EAAO,gBAA+B,WACpD,IAAK,KAAK,QACR,uBAtCJ,gDAME,SAAO,KAAK,SANd,kCAGW,GAAK,WACZ,QAAQ,MAAM,yBAA0B,GAD5B,2BAFd,IACiB,uBAAM,KAAY,QAAQ,cAA1B,MAAsC,uBAArD,KAAK,QAAU,EAAsC,+BACrD,MAAO,GAAK,EAAL,QAmCP,KAAmB,wEAHiB,iCAclC,EAAK,OAAwC,IAA/B,EAAK,MAAM,QAAQ,UACnC,EAAK,MAAQ,GACb,EAAK,KAAO,qBAEd,KAAK,aAAa,iBAAiB,EAAK,OAAS,WAAY,CAC3D,KAAM,EAAK,MAAQ,UACnB,KAAM,sBApB8B,IAStC,OAJM,EAAO,EAAG,KAAK,QACX,OAAU,EAAK,MACvB,QAAQ,IAAI,QAAS,GAEnB,KAAK,SAAW,EAAK,MAAQ,EAAK,KAAK,KAC1B,gBAAM,KAAI,IAAI,OAAO,EAAK,KAAK,KAAM,KAAK,UAA1C,KAAkD,gBACpD,OADP,EAAS,EACF,gBAAM,KAAI,IAAI,QAAQ,EAAK,MAAO,IAAlC,KAAyC,gBAC1C,OADZ,EAAK,MAAQ,EACD,gBAAM,KAAI,IAAI,QAAQ,EAAK,KAAM,IAAjC,KAAwC,uBAApD,EAAK,KAAO,EAAwC,kDADE,qCADW,qCAV7B,4EAwBxC,KAAK,iBAAiB,qBAAqB,SAAO,GAAP,sCAKnC,EAAS,OAFf,EAAM,aAAa,QAEJ,gBAAM,GAAc,IAApB,MAA0B,uBAAnC,EAAS,GAEb,EAAO,QAEP,KAAK,QAAQ,YAAc,KAAK,QAAQ,WAAW,IAJZ,uDwC7F3C,SAAS,EAAoB,GAC5B,IAAI,EAAI,IAAI,MAAM,uBAAyB,EAAM,KAEjD,MADA,EAAE,KAAO,mBACH,EAEP,EAAoB,KAAO,WAAa,MAAO,IAC/C,EAAoB,QAAU,EAC9B,EAAO,QAAU,EACjB,EAAoB,GAAK,6BCRzB,EAAO,QAAU,EAAQ,sCCEzB,IACI,KAAK,6BAA+B,IAExC,MAAO,mCCHP,IACI,KAAK,0BAA4B,IAErC,MAAO,8BCLP,iBAAE,WAGA,SAAS,EAAI,EAAK,GAKhB,SAAS,EAAE,GACT,OAAO,EAAE,MAAM,KAAK,OAAO,GAAG,WAAW,QAAQ,MAAM,IALzD,OAAO,EAAK,UAAQ,GAAO,EAAI,MAAO,EAAI,EAAE,IAAQ,SAAS,EAAK,GAChE,EAAI,EAAM,CAAC,QAAS,KACpB,EAAI,EAAE,IAAS,EAAI,SAMY,IAAI,EAAS,EAGhD,GAAI,SAAS,GAEb,IAAI,EAAO,CAEX,GAAU,CAAC,GAAI,SAAS,GAAK,QAAU,GAAM,mBAAqB,KAClE,EAAK,GAAK,CAAC,GAAI,SAAS,GAAI,OAAQ,aAAa,SAAuB,kBAAL,IACnE,EAAK,IAAM,CAAC,GAAI,SAAS,GAAI,OAAQ,EAAQ,KAAQ,EAAI,WAAW,GAAK,GAAM,GAAK,MAAa,IAAM,MAAa,KACpH,EAAK,KAAO,CAAC,GAAI,SAAS,GAAI,MAAoB,iBAAL,IAC7C,EAAK,KAAK,IAAM,SAAS,GACxB,OAAG,EAAK,KAAK,GAAG,GAAY,EACT,oBAAT,KAA8B,KAAK,UAAU,GAC/C,GAAK,EAAE,SAAW,EAAE,WAAa,GAE1C,EAAK,KAAK,OAAS,SAAS,EAAG,GAC9B,IAAI,EAAI,GAGR,IAFA,EAAI,GAAK,GACT,EAAI,GAAK,gEACH,EAAI,GAAI,GAAK,EAAE,OAAO,KAAK,MAAM,KAAK,SAAW,EAAE,SAAU,IACnE,OAAO,GAER,EAAK,KAAK,MAAQ,SAAS,EAAG,GAAI,IAAI,EAAK,EAC1C,MAAG,iBAAoB,IACpB,iBAAmB,IAAI,EAAI,CAAC,IAAK,IAGjC,KADH,GADA,EAAI,GAAK,IACA,MAAQ,EAAE,MAAQ,EAAE,MAAQ,EAAE,OAEpC,IAAM,EAAE,OAER,EAAE,MAAM,IADX,EAAO,EAAE,MAAQ,EAAE,MAAQ,EAAE,OACT,IAAI,UAAY,GACjC,IAAM,EAAE,OACR,IAAM,EAAE,MAAQ,IAAM,EAAE,KAClB,GAAK,EAAE,MAAQ,GAAK,EAAE,KAE5B,IAAM,EAAE,MAAQ,GAAK,EAAE,MACvB,IAAM,EAAE,MAAQ,GAAK,EAAE,SAG3B,EAAK,KAAK,KAAO,SAAS,EAAG,GAC5B,GAAgB,iBAAN,EAAV,CAEE,GADA,EAAI,GAAK,GACL,EAAE,OAAS,OAAO,EACtB,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAU,EAAE,IAAK,EAE/B,GAAM,GAAG,GAAG,EADR,EAAE,WAAW,GAEjB,GAAK,EAEP,OAAO,IAEV,EAAK,KAAO,CAAC,GAAI,SAAS,GAAI,OAAQ,aAAa,QACnD,EAAK,KAAK,KAAO,MAAM,UAAU,MACjC,EAAK,KAAK,KAAO,SAAS,GACzB,OAAO,SAAS,EAAE,GACjB,OAAI,GAAM,GAAe,EAAI,EAAE,KAAI,EAAI,EAAE,KACtB,EAAW,EAAI,EAAW,EAC/B,EAFO,IAKvB,EAAK,KAAK,IAAM,SAAS,EAAG,EAAG,GAAI,OAAO,EAAQ,EAAG,EAAG,IACxD,EAAK,KAAK,MAAQ,EAClB,EAAK,IAAM,CAAC,GAAI,SAAS,GAAI,QAAO,IAAI,aAAa,QAAU,EAAE,cAAgB,QAAgF,WAArE,OAAO,UAAU,SAAS,KAAK,GAAG,MAAM,sBAAsB,MAC1J,EAAK,IAAI,IAAM,SAAS,EAAG,EAAG,GAAI,OAAQ,GAAG,IAAI,GAAK,EAAG,GACzD,EAAK,IAAI,IAAM,SAAS,EAAG,GAAI,OAAO,GAAK,OAAO,UAAU,eAAe,KAAK,EAAG,IACnF,EAAK,IAAI,IAAM,SAAS,EAAG,GAC1B,GAAI,EAGJ,OAFA,EAAE,GAAK,YACA,EAAE,GACF,GAER,EAAK,IAAI,GAAK,SAAS,EAAG,EAAG,EAAG,GAAI,OAAO,EAAE,GAAK,EAAE,KAAO,IAAM,EAAG,GAAK,IACzE,EAAK,IAAI,IAAM,SAAS,GACvB,GAAG,EAAO,GAAK,OAAO,EACtB,IAAI,EAAI,KAAK,MAAM,GAClB,MAAM,GAAG,EAAE,GACZ,OAAO,GAEN,WACD,SAAS,EAAI,EAAE,GACX,EAAQ,KAAK,IAFA,YAEY,KAAK,KACjC,KAAK,GAAK,GAEX,EAAK,IAAI,GAAK,SAAS,EAAM,GAG5B,OADA,EAAQ,EAAM,EADd,EAAK,GAAM,IAEJ,GARP,GAWF,EAAK,IAAI,KAAO,SAAS,GACxB,OAAQ,EAAO,KAAK,MAAM,KAAK,UAAU,IAA9B,GAEV,WACD,SAAS,EAAM,EAAE,GAAI,IAAI,EAAI,KAAK,EACjC,IAAG,KAAM,IAAM,GAAM,EAAO,IAAM,EAAQ,EAAG,IAC7C,OAFoC,YAE3B,QAAT,EAED,EAAK,IAAI,MAAQ,SAAS,EAAG,GAC5B,OAAI,IACG,EAAQ,EAAE,EAAM,CAAC,EAAE,KAP1B,GAUA,WACD,SAAS,EAAE,EAAE,GACT,IAAM,UAAU,QAIjB,EAAE,EAAI,EAAE,GAAK,IACX,KAAK,IAJR,EAAE,EAAI,EAAE,GAAK,IACT,GAAK,EAKX,IAAwB,EAApB,EAAO,OAAO,KAClB,OAAO,KAAO,OAAO,MAAQ,SAAS,GAAI,OAAO,EAAI,GAAG,SAAS,EAAE,EAAE,GAAG,EAAE,OAC1E,EAAK,IAAI,IAAM,EAAM,SAAS,EAAG,EAAG,GACnC,IAAI,EAAU,EAAG,EAAG,EAAI,EAAjB,EAAI,EAAkB,EAAI,mBAAqB,EAMtD,GALA,EAAE,EAAI,EACH,GAAQ,EAAO,KACjB,EAAK,EAAK,GAAI,GAAM,GAErB,EAAI,GAAK,GACN,EAAQ,IAAM,EAEhB,IADA,GAAK,GAAM,GAAG,OACT,EAAI,EAAG,IAAI,CACf,IAAI,EAAM,EAAI,EAAK,KAAK,MACxB,GAAG,GAEF,IADA,EAAI,EAAK,EAAE,KAAK,EAAG,EAAE,EAAG,IAAK,EAAG,GAAI,GAAK,EAAE,KAAK,EAAG,EAAE,GAAI,EAAI,MACpD,EAAI,OAAO,OAGpB,GAAG,IAAM,EAAE,EAAK,EAAG,GAAK,GAAK,OAAO,EAAI,EAAG,GAAK,OAIlD,IAAI,KAAK,EACR,GAAG,GACF,GAAG,EAAQ,EAAE,KACZ,EAAI,EAAG,EAAE,KAAK,EAAG,EAAE,GAAI,EAAG,GAAK,EAAE,EAAE,GAAI,EAAG,MACjC,EAAI,OAAO,OAIrB,GAAG,IAAM,EAAE,GAAK,OAAO,EAI1B,OAAO,EAAG,EAAE,EAAI,EAAK,KAAK,MAAO,GAAK,GA3CtC,GA8CF,EAAK,KAAO,GACZ,EAAK,KAAK,GAAK,SAAS,GAAI,OAAO,EAAG,aAAa,OAAS,IAAI,MAAO,WAEvE,IACI,EAAU,EAAK,KAAK,GACpB,EAAM,EAAK,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAAK,EAAU,EAAI,IACtE,EAAO,QAAU,IAvJjB,CAwJE,EAAK,UAEP,GAAI,SAAS,GAEb,EAAO,QAAU,SAAS,EAAK,EAAK,EAAK,GACxC,IAAI,EAAM,MAAO,CAAC,GAAI,GACf,GAAO,KAAK,MAAQ,KAAK,IAAM,KAAK,KAC1C,KAAK,IAAI,GAAO,CAAC,IAAK,EAAK,GAAI,EAAK,EAAI,CACxC,KAAM,SAAS,GAAM,IAAI,GACpB,EAAM,KAAK,KACd,EAAI,KAAK,OAGZ,GAAG,mBAAqB,EAAI,CAC3B,IAAI,EAAK,CACR,IAAK,EAAK,MACT,EAAK,IAAM,WACX,GAAG,KAAK,OAAS,EAAK,EAAE,KAAO,OAAO,EACnC,OAAS,KAAK,IAAI,OACpB,KAAK,IAAI,KAAO,KAAK,MAEtB,KAAK,GAAG,KAAO,KAAK,KACpB,KAAK,KAAO,EAAK,EAAE,KACnB,KAAK,KAAK,GAAK,KAAK,GACjB,KAAK,IAAI,OAAS,KAAK,YAClB,KAAK,GAAG,IAAI,KAAK,IAAI,OAG9B,GAAI,EAAK,EACT,KAAM,EACN,IAAK,EACL,GAAI,KACJ,GAAI,GAGL,OADC,EAAG,KAAO,EAAI,MAAQ,GAAK,GAAK,EAC1B,EAAI,KAAO,EAGnB,OADI,EAAM,EAAI,KA/BV,YA+BuB,GAAM,EAAI,KAAK,GACnC,KApCR,CAsCE,EAAK,UAEP,GAAI,SAAS,GACb,IAAI,OAA8B,IAAjB,EAA+B,EAAe,WAS5D,EAAI,GACP,EAAO,QAAU,WAAW,KAVsD,SAAS,GACvF,EAAE,OAAS,EAAE,KAAK,IAAc,EAAI,CAAC,GACxC,GAAG,SAAS,EAAG,GAAI,EAAI,IAAM,IAAI,KACjB,IAAf,IAAW,EAAP,EAAI,EAAa,EAAI,IAAM,EAAK,EAAE,OAAQ,IAE9C,GADA,QAAQ,MAAQ,QAAQ,KAAK,GAAI,IAAI,KAAO,EAAG,QAC5C,MAAS,IAAI,KAAO,GAAK,OAAO,EAAG,IACjC,EAAI,EAAE,MAAM,IAAI,QACrB,EAAG,EAAI,KACL,OATJ,CAYE,EAAK,UAEP,GAAI,SAAS,GAqCb,GAAmB,oBAAT,KACT,MAAM,IAAI,MACT,gHAIF,IAAI,EAAU,KAAK,UACnB,EAAO,QA1CP,SAAa,EAAc,EAAe,EAAc,EAAe,GACtE,GAAG,EAAe,EACjB,MAAO,CAAC,OAAO,GAEhB,GAAG,EAAgB,EAClB,MAAO,CAAC,YAAY,GAGrB,GAAG,EAAe,EACjB,MAAO,CAAC,UAAU,EAAM,UAAU,GAGnC,GAAG,IAAkB,EAAa,CAGjC,IAFA,EAAgB,EAAQ,IAAkB,OAC1C,EAAe,EAAQ,IAAiB,IAEvC,MAAO,CAAC,OAAO,GAUhB,GAAG,EAAgB,EAClB,MAAO,CAAC,UAAU,EAAM,SAAS,GAElC,GAAG,EAAe,EACjB,MAAO,CAAC,UAAU,EAAM,UAAU,GAGpC,MAAO,CAAC,IAAK,sBAAuB,EAAe,OAAQ,EAAc,OAAQ,EAAe,OAAQ,EAAc,QAnCvH,CA6CE,EAAK,SAEP,GAAI,SAAS,GACb,IAAI,EAAO,EAAI,UACX,EAAM,CACV,GAAS,SAAS,GACjB,OAiCsB,YAjCnB,IACM,OAAN,GACA,IAAM,SACN,EAAQ,IACR,EAAM,IACN,EAAO,MAGH,EAAI,KAAK,GAAG,KAAM,OAE1B,EAAI,KAAO,EAAI,IAAM,CAAC,EAAG,KACvB,WAWD,SAAS,EAAI,EAAG,GAAI,IAAI,EAAI,KAC3B,OAAG,EAAE,GAAY,EAAE,IAAK,EACrB,GAAK,GAAQ,EAAQ,QACvB,EAAE,GAAK,GAEA,EAAE,IAAK,EAfhB,EAAI,KAAK,GAAK,SAAS,GACtB,GAAG,GAAK,EAAE,KAAU,EAAE,GAAK,EAAO,GAAG,CACpC,IAAI,EAAI,GAER,GADA,EAAQ,EAAG,EAAK,GACb,EAAE,GACJ,OAAO,EAAE,GAGX,OAAO,GATP,GAoBF,EAAI,KAAK,IAAM,SAAS,GAAI,OAAO,EAAQ,GAAI,EAAM,IACrD,EAAK,IAAI,IAAI,EAAI,IACjB,IAAI,EAAO,EAAI,KAAK,EAChB,EAAQ,EAAK,GAAG,GAChB,EAAS,EAAK,IAAI,GAClB,EAAU,EAAK,KAAK,GACpB,EAAM,EAAK,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAAK,EAAU,EAAI,IACtE,EAAO,QAAU,IA1CjB,CA2CE,EAAK,SAEP,GAAI,SAAS,GACb,IAAI,EAAO,EAAI,UACX,EAAM,EAAI,SACV,EAAO,CAAC,EAAG,IACf,KAAY,SAAS,EAAG,GAAI,OAAQ,GAAK,EAAE,GAAK,EAAE,EAAE,GAAK,KACzD,EAAK,KAAK,IAAM,SAAS,EAAG,GAK3B,OAJA,EAAkB,iBAAN,EAAiB,CAAC,KAAM,GAAK,GAAK,IAC9C,EAAI,GAAK,IACP,EAAI,EAAE,GAAK,GACb,EAAE,EAAE,GAAS,EAAE,MAAQ,EAAE,EAAE,IAAU,IAC9B,GAER,EAAK,KAAK,EAAI,EAAI,KAAK,EACrB,WAQD,SAAS,EAAI,EAAG,GACf,GAAG,IAAM,EAAK,EACd,OAAI,EAAI,GAAG,SACR,KAAK,IAAK,KAAK,GAAG,KAAK,KAAK,GAAI,EAAG,EAAG,KAAK,EAAG,KAAK,IAVvD,EAAK,GAAK,SAAS,EAAG,EAAI,GAAK,IAAI,EAClC,QAAI,EAAO,QACR,EAAI,EAAK,KAAK,MACR,EAAQ,EAAG,EAAK,CAAC,GAAG,EAAG,GAAG,EAAG,EAAE,EAAE,EAAE,MAJ5C,GAcA,WAWD,SAAS,EAAI,EAAG,GAAI,IAAgB,EAAZ,EAAI,KAAK,EAC7B,EAAE,IADmC,aAEvC,EAAM,EAAE,IAAI,KAAK,KAAK,GAAI,EAAG,GAAG,EAAG,EAAE,OAEpC,EAAQ,EAAE,KAAM,GAEd,EAAE,OAAO,EAAE,KAAK,GAAK,GAGtB,EAAI,GAAG,KACT,EAAE,KAAK,GAAK,GApBd,EAAK,IAAM,SAAS,EAAK,EAAG,GAQ3B,OAPI,EACiB,iBAAN,EAAiB,EAAI,CAAC,KAAM,GACnC,mBAAqB,IAAI,EAAI,CAAC,IAAK,IAFnC,EAAI,GAGT,EAAE,MAAM,EAAE,KAAO,EAAE,IAAI,KAAK,EAAI,EAuBjC,UAvByC,EAAE,MAAQ,MAClD,EAAE,KAAO,EAAK,KAAK,IAAI,EAAE,MAAQ,GAAI,KACvC,EAAQ,EAAK,EAAK,CAAC,EAAE,EAAE,GAAG,IAEpB,EAAE,MATT,GAyBF,IAAI,EAAM,EAAK,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAAK,EAAU,EAAI,IAChD,EAAX,EAAK,KAAyB,OACrC,EAAQ,EAAK,KAAK,EAEtB,EAAO,QAAU,IAxDjB,CAyDE,EAAK,UAEP,GAAI,SAAS,GAGb,SAAS,IACR,IAAI,EAMJ,OAFC,GAAK,IAAI,KAEP,EAAO,GACF,EAAI,EAAG,EAAO,EAAI,EAAM,OAEzB,EAAO,GAAM,GAAK,GAAK,EAAK,EAAM,MAZ1C,IAAI,EAAO,EAAI,UACX,EAAO,EAAI,UAaU,GAAQ,IAAU,EAAI,EAAG,EAAI,IAClD,EAA+B,oBAAhB,cAA+B,YAAY,QAAU,aACpE,GADmG,GAAQ,EAAK,QAAU,EAAK,OAAO,kBAAqB,GAAO,GAC7J,EAAM,EAAI,KACnB,EAAM,MAAQ,EACd,EAAM,GAAK,SAAS,EAAG,EAAG,GACzB,IAAI,EAAO,GAAK,GAAK,EAAE,IAAO,EAAE,GAAI,IAAQ,EAC5C,GAAI,EACJ,OAAO,EAAO,EAAM,EAAI,IAAK,GAAO,KAErC,EAAM,IAAM,WAAY,OAAO,IAAQ,SAAS,IAAI,QAAQ,IAAI,KAChE,EAAM,IAAM,SAAS,EAAG,EAAG,EAAG,EAAG,GAChC,IAAI,IAAM,EAAE,GAAI,CACf,IAAI,EACH,OAED,EAAI,EAAK,KAAK,IAAI,EAAG,GAEtB,IAAI,EAAM,EAAO,EAAE,GAAK,GASxB,OARG,IAAM,GAAK,IAAM,IAChB,EAAO,KACT,EAAI,GAAK,GAEP,IAAM,IACR,EAAE,GAAK,IAGF,GAER,EAAM,GAAK,SAAS,EAAM,EAAG,GAC5B,IAAI,GAAO,GAAM,IAAI,GAIrB,OAHG,EAAO,KACT,EAAM,EAAS,IAET,EAAM,IAAI,EAAI,EAAG,EAAM,GAAG,EAAM,GAAI,EAAK,EAAK,KAAK,KAEzD,WAsBD,SAAS,EAAI,EAAE,GACX,IAAO,GACV,EAAM,IAAI,KAAK,EAAG,EAAG,KAAK,GAvB3B,EAAM,IAAM,SAAS,EAAI,EAAG,GAAK,IAAI,EAChC,EAAI,EAAO,EAAI,GAAM,GAAI,EAAI,KAEjC,OADA,EAAK,EAAM,EAAK,GAAM,GAAI,EAAK,KAC5B,IAAM,GACR,EAAI,EAAO,GAAI,EAAI,IACnB,EAAE,GAAM,EAAE,IAAO,GACjB,EAAQ,EAAG,EAAK,CAAC,EAAE,EAAE,EAAE,IAChB,IAER,EAAK,GAAM,EAAO,GAAI,EAAI,EAC1B,EAAI,EAAO,GAAI,EAAI,IACZ,SAAS,EAAG,EAAG,EAAG,GACxB,IAAI,EAEH,OADA,EAAI,KAAK,CAAC,EAAG,EAAG,EAAG,GAAI,EAAE,GAClB,EAER,EAAG,KAAK,GAAM,MAAQ,GAAI,EAAG,EAAG,EAAG,GAChC,EAAQ,EAAE,IAAM,IAAM,EAAE,IAC3B,EAAI,KAAK,CAAC,EAAG,EAAG,EAAG,GAAI,EAAE,MAnB1B,GA2BF,IAGiB,EAHb,EAAM,EAAK,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAAK,EAAW,EAAI,KACvF,EAAV,EAAK,IAAkB,GACf,EAAT,EAAK,GAAe,GACzB,EAAK,EAAK,EACd,EAAO,QAAU,IAjFjB,CAkFE,EAAK,WAEP,GAAI,SAAS,GACb,IAAI,EAAO,EAAI,UACX,EAAM,EAAI,SACV,EAAO,EAAI,UACX,EAAQ,IACV,WAKD,SAAS,EAAI,EAAG,GACf,IAAI,GAAK,IAAM,EAAK,KAAK,KAAO,EAAK,GAAG,EAAG,KAAK,GAAI,KAAK,IAAM,OAAO,EAClE,KAAK,KACT,EAAG,EAAI,EACP,KAAK,GAAG,KADE,EAAG,GAAK,KAAK,GACH,EAAG,EAAG,IAE3B,SAAS,EAAG,GACR,GAAK,EAAK,GAAG,EAAG,EAAG,EAAI,EAAG,IAX9B,EAAM,GAAK,SAAS,EAAG,EAAI,EAAI,GAC9B,SAAI,IAAM,EAAO,IAAM,EAAU,MACzB,EAAQ,EAAG,EAAK,CAAC,GAAG,EAAG,GAAG,EAAG,GAAG,KAHxC,GAeA,WA2BD,SAAS,EAAK,EAAK,GAAK,IAAI,EAC3B,OAAG,EAkEJ,SAAc,EAAK,GAClB,IAAoC,EAAhC,EAAM,EAAI,KAAM,EAAI,EAAI,OAC5B,KAAM,KACL,GAAG,EAAG,OADK,EAAM,EAAI,IACH,IAAM,OAAO,EAEhC,EAAI,KAAK,GAvEA,CAAK,EAAK,IAAa,GAChC,EAAG,IAAM,EACT,EAAG,KAAO,EACP,EAAK,IAAI,EAAG,IAAK,EAAK,KACxB,EAAG,KAAO,EAAG,MAAQ,EAAI,KAAK,IAAI,EAAK,KAAK,EAAG,OAC5C,EAAG,MAAQ,EAAI,QACjB,EAAI,MAAM,EAAI,KAAK,GAAG,EAAG,OAAS,EAAG,OAGhC,GAER,SAAS,EAAI,EAAE,EAAE,GAChB,IAA6B,EAAI,EAA7B,EAAK,KAAM,EAAM,EAAG,IACxB,GAAG,EAAK,IAAM,GAAK,EAAQ,EAAE,EAAI,KAAK,GACrC,OAAO,EAAE,EAEV,GAAK,EAAK,EAAM,EAAE,EAAE,EAAG,EAAG,GAA1B,CASA,GARI,IACH,EAAG,KAAO,EAAG,MAAQ,GAAK,GACvB,EAAQ,EAAG,EAAK,IAAM,EAAK,KAAK,KAClC,EAAG,KAAK,EAAI,EAAS,EAAE,IAExB,EAAG,KAAO,EAAK,KAAK,IAAI,EAAG,KAAM,EAAI,KAAK,GAAG,EAAG,OAChD,EAAG,KAAO,EAAG,MAAQ,EAAI,KAAK,IAAI,EAAK,KAAK,EAAG,SAE7C,EAAM,EAAI,OACZ,EAAI,KAAK,EAAI,IAAM,GAAI,EAAE,EAAE,EAAG,GAC3B,EAAQ,EAAE,IAAG,CAEf,GAAG,KADH,EAAI,EAAE,IAGL,YADA,EAAQ,EAAG,GAGZ,KAAK,EAAK,EAAM,EAAE,EAAE,EAAG,EAAG,IAAQ,OAGpC,IAAI,EAAI,OAAO,EAAG,KAClB,IAAG,IAAS,EACX,OAAO,EAGR,IADA,EAAM,EAAK,EAAK,CAAC,IAAK,EAAG,KAAM,EAAG,KAAK,OAAO,MACtC,KACR,OAAO,EAAI,MAEZ,SAAS,EAAK,GAAK,IAAI,EAAK,KACvB,EAAO,EAAI,KAAK,GAAG,EAAG,MAAO,EAAQ,EAAG,IAAI,MAChD,EAAG,KAAO,EAAG,MAAQ,EAAI,KAAK,IAAI,GAClC,EAAG,KAAK,EAAI,KAAK,GAAK,EACnB,EAAG,MAAQ,EAAG,KAAK,EAAK,KAC1B,EAAG,KAAK,EAAK,GAAG,EAAI,KAAK,GAAK,GAE5B,EAAQ,EAAO,KACjB,EAAM,GAAM,EAAM,GAClB,EAAQ,EAAO,IAGjB,SAAS,EAAM,EAAE,EAAE,EAAG,EAAG,GAAM,IAAI,EAClC,QAAG,EAAI,GAAG,KACP,EAAO,GAAY,GACnB,EAAM,EAAI,SAEL,EADP,EAAI,EAAI,KAAK,EAAI,IAAM,GAAI,EAAE,EAAE,GAChB,EAAE,EAAG,EAAG,IAExB,EAAI,IAAM,qBAAuB,EAAG,KAAK,OAAO,GAAG,KAAK,KAAO,UAC5D,EAAK,KAAK,GAAG,KAAK,EAAI,KAAO,6CA3FjC,EAAM,IAAM,SAAS,EAAK,EAAK,GAC9B,IAAI,EAAK,CAAC,KAAM,GAAI,IAAK,GAuBzB,OAtBI,EAGc,iBAAR,EACT,EAAM,CAAC,KAAM,GAEX,mBAAqB,IACvB,EAAI,IAAM,GANV,EAAM,GAQU,iBAAP,IACT,EAAI,KAAO,EAAI,MAAQ,EACvB,EAAK,GAEH,EAAI,OACN,EAAG,KAAO,EAAI,KAAK,IAAI,EAAI,OAE5B,EAAI,OAAS,GAAI,IAAI,MACrB,EAAI,MAAQ,EAAI,OAAS,GACzB,EAAI,KAAO,EAAI,MAAQ,GACvB,EAAI,GAAK,EAAI,IAAM,EACnB,EAAK,EAAK,GACV,EAAI,KAAO,EAAG,KACP,EAAI,OAzBX,GAsGF,EAAM,KAAO,SAAS,GACrB,IAAI,EAAO,EAAK,KAAK,GACrB,GAAI,EACJ,OAAO,EAAQ,GAAI,EAAM,IAExB,WAQD,SAAS,EAAI,EAAE,GAAI,IAAI,EAAK,EAC3B,GAAG,EAAK,IAAM,EAYb,KAAK,IAAI,IALL,EAAM,EAAI,KAAK,GAAG,KAIpB,EAAM,KAAK,IAAI,KAAK,IACR,EAGD,KAAK,IAAI,KAAK,GAAO,EAAM,GAAG,KAAK,MAAO,EAAK,KAAK,KAPnD,MARf,CACC,GAAG,EAAU,EAAG,EAAI,KAAK,GACxB,OAED,KAAK,IAAI,GAAK,EAAS,IAZzB,EAAM,GAAK,SAAS,EAAO,EAAM,GAChC,GAAI,EAAJ,CACA,IAAI,EAAM,GAGV,OADA,EAAQ,EAAM,GAAO,EAAK,CAAC,IAAI,EAAK,MAAO,EAAO,IADlD,EAAM,GAAO,CAAC,KAAM,MAEb,IANP,GA2BF,IAEI,EADA,EAAM,EAAK,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAAK,EAAU,EAAI,IAAK,EAAY,EAAI,MAAO,EAAU,EAAI,IAAK,EAAU,EAAI,IAAK,EAAW,EAAI,KAEvJ,EAAO,QAAU,IA7JjB,CA8JE,EAAK,WAEP,GAAI,SAAS,GAEb,EAAI,UACJ,EAAO,QAAU,SAAa,EAAI,GACjC,GAAI,KAAK,GAAT,CACA,GAAK,mBAAqB,EAAI,CAC7B,IAAI,IAAO,EAAK,OAChB,IAAwB,GAAO,KAAK,KAAK,IAArC,EAAK,EAAG,MAAQ,GACpB,IAAI,EAAM,OAGV,OAFA,EAAM,KAAK,GAAG,EAAI,GAClB,aAAa,EAAI,MACV,EAER,IAAI,EAAM,GAAM,EAAG,MAAS,KAAK,SAAS,SAAS,IAAI,MAAM,GAC7D,IAAI,EAAK,OAAO,EAChB,IAAI,EAAK,KAAK,GAAG,EAAI,EAAI,GAKzB,OAJA,EAAG,IAAM,EAAG,KAAO,YAAW,WAC7B,EAAG,KAAK,CAAC,IAAK,qBAAsB,MAAM,IAC1C,EAAG,SACA,KAAK,KAAK,IAAI,MAAQ,KACnB,MApBR,CAsBE,EAAK,SAEP,GAAI,SAAS,GACb,IAAI,EAAO,EAAI,UAyBf,EAAO,QAxBP,SAAa,GACZ,IAAI,EAAM,CAAC,EAAE,IAAK,EAAI,EAAI,EAC1B,EAAM,GAAO,CAAC,IAAK,IAAM,IAAsB,MAC/C,EAAI,MAAQ,SAAS,GACpB,QAAI,EAAE,IACC,EAAG,IAEX,IAAI,EAAK,EAAI,MAAQ,SAAS,GAC7B,IAAI,EAAK,EAAE,KAAQ,EAAE,GAAM,IAG3B,OAFA,EAAG,KAAO,IAAI,KACV,EAAI,KAAK,EAAI,GAAK,WAAW,EAAI,KAAM,EAAI,IAAM,IAC9C,GAWR,OATA,EAAI,KAAO,SAAS,GACnB,IAAI,GAAO,IAAI,KACf,EAAK,IAAI,IAAI,GAAG,SAAS,EAAI,GACzB,IAAO,GAAO,EAAI,KAAQ,EAAM,EAAG,YAC/B,EAAE,MAEV,EAAI,GAAK,KACT,QAAQ,OAAS,GAAO,IAAI,KAAO,GAAO,GAAK,QAAQ,KAAK,EAAK,EAAK,aAEhE,KAxBR,CA2BE,EAAK,SAEP,GAAI,SAAS,GAEb,SAAS,EAAI,GACZ,OAAG,aAAa,GAAc,KAAK,EAAI,CAAC,EAAG,OAAO,EAC7C,gBAAgB,EACd,EAAI,OAAO,KAAK,EAAI,CAAC,EAAG,KAAM,IAAK,IADP,IAAI,EAAI,GAI5C,EAAI,GAAK,SAAS,GAAI,OAAQ,aAAa,GAAS,GAAK,EAAE,GAAM,IAAM,EAAE,EAAE,IAAO,GAElF,EAAI,QAAU,MAEd,EAAI,MAAQ,EAAI,WACN,OAAS,aAEnB,IAAI,EAAO,EAAI,UACf,EAAK,IAAI,GAAG,EAAM,GAClB,EAAI,IAAM,EAAI,SACd,EAAI,IAAM,EAAI,SACd,EAAI,KAAO,EAAI,UACf,EAAI,MAAQ,EAAI,WAChB,EAAI,MAAQ,EAAI,WAChB,EAAI,GAAK,EAAI,UACb,EAAI,IAAM,EAAI,SACd,EAAI,IAAM,EAAI,SACd,EAAI,KAAO,EAAI,UAEb,WAkBD,SAAS,EAAS,GACjB,GAAI,EACJ,GAAG,EAAI,MAAQ,EAAf,CACA,IAAyE,EAAzD,EAAN,KAAe,GAAI,EAAK,EAAG,IAAM,EAAI,EAAM,EAAG,EAAG,EAAM,EAAG,IAAU,EAAM,EAAI,KACvF,EAAM,EAAI,QAAU,EAAM,EAAI,KAAO,EAAU,IAC7C,EAAI,MAAM,KAAgB,EAAI,MAAM,GAC1B,EAAI,EAAK,mBAAtB,EAAM,EAAI,GAAuC,EAAM,aACtD,EAAI,GAAM,EAAI,KAAO,EAAI,EAAE,GAAG,IAAI,IAAQ,EAAI,EAAI,GAC/C,EAAG,IAAI,EAAI,KAAM,KACpB,IAAQ,EAAI,GAAK,IAAI,MAClB,EAAI,KAAM,EAAI,GAAG,KAAK,EAAK,IAC3B,EAAI,MAER,IAAQ,EAAI,IAAM,IAAI,MAVZ,KAWN,GAAG,KAAK,GACZ,IAAQ,EAAI,IAAM,IAAI,MACtB,EAAI,IAAM,EAAU,EAAG,GAAG,MAAO,GACjC,IAAQ,EAAI,IAAM,IAAI,OANR,EAAI,SATQ,KAAK,GAAG,KAAK,GAiBxC,SAAS,EAAI,GACZ,GAAI,EAAJ,CACA,IACkC,EAAK,EADnC,EAAM,EAAI,GAAG,GAAI,EAAO,EAAI,OAAS,EAAI,EAAI,EAAI,GAAG,IAAI,GAAG,IAAI,KAC/D,EAAM,EAAI,IAAK,EAAK,EAAI,KACxB,EAAM,EAAI,IAAM,EAAI,IACxB,GAAG,EAAI,MAAQ,EAAI,KAAO,EAAK,GAAG,MAAO,OAAzC,CAIA,EAAI,IAAM,EACV,EAAI,IAAM,CAAC,EAAG,EAAG,KAAM,GACvB,IAAI,GAAK,IAAI,KAEb,IAAI,IAAI,KADR,IAAQ,EAAI,EAAI,GACA,EAAI,CACnB,IAAsB,EAAlB,EAAO,EAAI,GACf,IAAI,EAAK,CAAE,EAAM,EAAI,EAAI,GAAM,WAAY,MAC3C,KAAK,EAAM,EAAK,GAAG,CAAE,EAAM,EAAI,EAAI,GAAM,WAAY,MACrD,GAAG,IAAS,EAAI,GAAO,CAAE,EAAM,EAAI,EAAI,GAAM,iBAAkB,MAC/D,KAAK,EAAS,EAAI,IAAS,CAAE,EAAM,EAAI,EAAI,GAAM,YAAa,MAC9D,IAAI,IAAI,KAAO,EACd,GAAG,IAAU,EAAb,CACA,IAAI,EAAM,EAAK,GAAM,EAAQ,EAAO,GACpC,GAAG,IAAM,EAAM,CAAE,EAAM,EAAI,EAAI,GAAK,KAAK,EAAI,GAAM,YAAa,MAChE,IAAI,EAAO,GAAK,CAAE,EAAM,EAAI,EAAI,GAAK,KAAK,EAAI,GAAM,cAAe,EAAK,EAAI,GAAM,MAClF,EAAI,EAAK,EAAK,EAAM,EAAO,GAE5B,GAAG,EAAM,MAEV,IAAQ,EAAI,IAAM,IAAI,MACnB,QAAQ,OAAO,QAAQ,KAAK,GAAI,IAAI,KAAO,EAAG,OAAO,QAAQ,KAAK,EAAG,EAAI,IAAI,EAAG,WAChF,EAAI,IAAM,GAAM,EAAK,GAAG,KAAM,CAAC,IAAK,EAAI,IAAK,EAAI,IAAI,QACjD,EAAI,IAAI,MAAQ,EAAK,GACxB,EAAI,MAAS,EAAI,MAAO,EAAK,GAAG,KAAM,CAAC,IAAK,EAAI,IAAK,OAE1D,SAAS,EAAI,EAAK,EAAK,EAAM,EAAO,GACnC,IAA0D,EAAtD,EAAM,EAAI,GAAG,GAAI,EAAO,EAAI,KAC5B,EAD0C,EAAK,MAChC,IAAS,EAAO,EAAM,EAAS,EAAQ,EAAK,GAAI,EAAQ,EAAO,GAC9E,EAAU,IAAS,EAAK,EAAI,EAAS,EAAO,EAAK,EAAK,GAC1D,IAAI,EAAG,SAAS,CACf,GAAG,EAAG,MAAM,CACX,IAAI,EAAK,EAAQ,EAKjB,OAJA,YAAW,WACV,EAAI,EAAK,EAAK,EAAM,EAAO,KACzB,EAAK,EAAI,EAAK,GACb,EAAI,IAAK,EAAK,GAAG,KAAM,CAAC,IAAK,EAAI,KAAM,IAAK,IAAO,EAAI,GAAK,EACzD,EAGR,IAAI,EAAI,KAAO,QAEf,EAAM,EAAI,KAAK,IAAI,IAAK,EAAI,QAC5B,EAAI,OAAS,EAAI,KAAO,KAAK,EAAK,GAAO,EAC1C,IAAI,EAAM,EAAI,IAAK,IAAQ,EAAI,GAAK,EAAI,KAAO,IAAI,MACnD,EAAK,GAAG,MAAO,CAAC,IAAK,EAAI,KAAM,IAAK,EAAI,KAAM,IAAK,CAAC,IAAK,EAAM,IAAK,EAAK,IAAK,EAAK,IAAK,GAAQ,EAAG,IAEpG,SAAS,EAAI,GACZ,IAAI,GAAQ,GAAO,EAAI,GAAG,IAAI,OAAM,EAAI,IAAM,IAAI,KAAM,EAAI,GAAK,EAAI,KAAO,IAAI,MAC7E,IAAiK,EAAlI,EAArB,KAAiB,GAAiB,MAAO,EAAM,EAAI,EAAG,EAAM,EAAI,IAAK,EAAO,EAAI,KAAM,EAAM,EAAI,KAAM,EAAM,EAAI,KAAM,EAAQ,EAAI,KAC/I,EAAM,GAAQ,EAAU,EAAM,GAAO,EAAK,EAAO,EAAK,GAQvD,SAAe,EAAK,EAAM,EAAI,EAAK,GAClC,IAAqB,EAAK,EAAtB,EAAO,EAAI,KAEf,IADC,EAAK,KAAK,IAAI,OAAS,EAAK,EAAE,IAAI,KAC/B,IAAU,EAAM,EAAK,QAAW,EAAM,EAAI,KAAW,EAAI,GAAI,QAChE,EAAM,EAAI,MAAQ,EAAI,IAAM,KAAK,GAAQ,EAAU,EAAI,GAAO,EAAK,EAAO,EAAK,GAChF,EAAI,IAAM,EAAU,EAAI,IAAK,EAAK,EAAO,EAAK,GAZ9C,CAAM,EAAK,EAAM,EAAM,KAAO,EAAM,EAAI,MAAQ,EAAM,EAAK,IACvD,EAAM,EAAI,OAAS,EAAM,EAAI,OAChC,EAAI,GAAQ,EAAU,EAAI,GAAO,EAAK,EAAO,EAAK,MAE5C,EAAI,IAAI,MAAQ,EAAK,GANf,KAOT,GAAG,KAAK,GASb,SAAS,EAAK,GACb,IAAG,EAAI,IAAP,CACA,IACgF,EAD5E,EAAO,GACP,IAAS,EAAI,GAAG,IAAI,GAAG,IAAI,KAAM,GAAQ,GAAM,IAAI,MAAM,GAAI,EAAM,EAAI,IACvE,GAAK,IAAI,KAEb,IAAI,IAAI,KAAQ,EAAI,CAAE,IAAI,EAAO,EAAI,IAC/B,EAAM,EAAK,KAAW,EAAI,IAC/B,EAAK,KAAO,EACZ,EAAI,GAAG,KAAM,CAAC,EAAG,EAAI,EAAG,IAAK,EAAM,IAAK,IACxC,EAAK,KAAO,MAEb,QAAQ,MAAQ,QAAQ,KAAK,GAAI,IAAI,KAAO,EAAG,QAC/C,EAAI,MAAQ,EAAI,IAAI,GAAK,IAAI,OACxB,EAAM,EAAI,OACf,EAAI,IAAM,EACV,EAAK,GAAG,MAAO,KA7HhB,EAAI,OAAS,SAAS,GACrB,EAAG,KAAO,EAAG,MAAQ,EACrB,EAAG,MAAQ,EAAG,OAAS,GACvB,EAAG,GAAK,EAAG,IAAM,EAAI,GACrB,EAAG,IAAM,EAAG,KAAO,EAAI,IACvB,EAAG,IAAM,EAAG,KAAO,EAAI,MACvB,IAAI,EAAM,EAAG,EAAE,IAAI,EAAG,KAStB,OARI,EAAG,OACN,EAAG,GAAG,KAAM,EAAU,GACtB,EAAG,GAAG,MAAO,EAAU,GACvB,EAAG,GAAG,MAAO,EAAK,GAClB,EAAI,GAAG,SAAU,GACjB,EAAG,GAAG,SAAU,IAEjB,EAAG,KAAO,EACH,GAsDN,EAAI,GAAG,IAAM,EA0Df,IAAI,EAAM,wBACN,EAAM,SAAS,GAAI,MAAO,MAAM,GAAG,GAAG,MAAM,EAAE,GAAG,SACjD,EAAM,EAAI,IAAK,EAAK,WAAY,EAAQ,EAAI,MAlI/C,GAqIA,WAiBD,SAAS,EAAO,EAAK,EAAK,EAAM,GAAO,IAAI,EAAM,KAC5C,EAAQ,EAAI,MAAM,GAAG,EAAM,GAC/B,IAAI,EAAQ,OAAO,EAAI,IAAM,uBAAuB,EAAI,cAAc,EAAK,KAC3E,IAAI,EAAS,EAAI,MAAM,IAAS,EAAO,EAAM,EAAI,MAAM,GAAG,EAAQ,GAAK,GACnE,EAAM,EAAI,IAAI,EAAI,QAAS,EAAO,EAAK,EAD2C,EAAO,IAEzF,EAAI,UAMR,EAAI,IAAI,GAAQ,EAAI,MAAM,GAAG,EAAM,EAAK,EAAI,IAAI,KAC/C,EAAI,OAAS,EAAI,KAAO,KAAK,GAAQ,EAAI,MAAM,GAAG,EAAM,EAAK,EAAI,KAAK,IACvE,EAAI,MAAM,IAAQ,GAPd,EAAI,QACN,EAAI,MAAS,GAAS,EAAI,OAAS,KAAY,EAAQ,EAAI,OAQ9D,SAAS,EAAM,EAAM,GACpB,IAAI,EAAM,KAAM,EAAM,EAAI,EAAE,EAAG,GAAM,EAAI,MAAQ,GAAO,GACxD,IAAI,EAAG,CACN,KAAK,EAAI,KAAK,GAAO,MAEpB,YADA,EAAI,MAAM,IAAQ,GAGnB,EAAM,EAAI,EAAE,IAAI,GAAM,EAEvB,IAAI,EAAM,EAAI,IAAI,GAAQ,CACzB,IAAK,EACL,IAAK,EACL,EAAG,EAAG,GACJ,EAAK,CAAC,IAAK,EAAK,IAAK,GACxB,EAAI,QAAU,EAAI,IAAI,KACnB,EAAI,MAAM,EAAI,KAAO,EAAI,KAC5B,EAAQ,EAAM,EAAM,GAChB,EAAI,QACJ,EAAI,KAEP,EAAI,GAAG,QAAQ,SAAS,GACvB,KAAK,GAAG,KAAK,GACV,IAAM,EAAI,IAAI,EAAE,OACnB,EAAI,MAAM,EAAE,MAAO,EACnB,EAAQ,EAAE,IAAK,EAAO,GACnB,EAAQ,EAAI,OAAO,SAAS,GAAI,GAAG,EAAI,OAAO,MAC9C,EAAI,IAAa,EAAI,EAAI,EAC5B,KAAK,MACL,EAAQ,EAAI,IAAK,EAAK,QAGxB,EAAI,KAAM,EACV,EAAI,GAAG,OAAQ,IAEhB,SAAS,EAAK,EAAK,GAClB,IAAI,EAAM,KAAK,IAAK,EAAQ,EAAI,MAAO,EAAM,KAAK,IAAK,EAAO,EAAI,IAAK,EAAO,EAAI,IAAK,EAAM,EAAI,EAAE,EACnG,EAAM,GAAQ,EAAI,MAAM,GAAG,EAAM,EAAK,EAAM,IACzC,EAAI,QACP,EAAG,IAAM,EAAI,MAAM,GAAG,EAAM,EAAK,EAAG,MAErC,SAAS,EAAM,EAAK,GACnB,IAAgC,EAAtB,KAAgC,EAAE,EAC5C,EAAG,IAAM,EAAI,MAAM,GADT,KAAiB,IACC,EAAK,EAAG,KAErC,SAAS,EAAI,GACR,EAAI,IACR,KAAK,IAAI,KAAO,KAAK,KACpB,EAAI,EAAE,EAAG,GAAG,KAAM,GACnB,KAAK,IAAI,KAAO,MAEjB,SAAS,EAAK,EAAM,GAAO,GAAG,IAAS,KAAK,MAAM,GAAQ,OAAO,EAjFjE,EAAI,GAAG,KAAO,SAAS,EAAK,GAC3B,IAAI,EAAK,EAAI,EAAG,EAAM,CAAC,EAAG,EAAK,MAAO,EAAG,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,GAAI,QAAS,EAAI,QAAS,IAAK,EAAI,KAAM,IAAK,EAAI,KAAM,IACjI,GAAI,EAAI,IAAI,IAAI,EAAI,IAAK,EAAM,GAA/B,CAEA,GADI,EAAI,MAAM,GAAG,EAAI,IAAK,KAAM,EAAQ,KAAO,EAAI,IAAM,yBACtD,EAAI,IAAM,OAAO,EAAG,GAAG,KAAM,CAAC,IAAK,EAAI,KAAM,IAAK,EAAI,IAAI,EAAI,OAGjE,GAFA,EAAQ,EAAI,IAAK,EAAO,GACpB,EAAI,OAAQ,EAAQ,EAAI,IAAK,EAAK,GACnC,IAAM,EAAI,MAAM,CAClB,IAAI,EAAK,EAAI,MAAQ,EAAI,QACzB,YAAW,WACV,EAAI,GAAG,KAAK,EAAK,KACf,EAAK,GAAI,GAAK,GAEd,EAAI,MACR,EAAG,GAAG,MAAO,EAAO,EAAK,CAAC,IAAK,EAAI,UAqEpC,EAAI,GAAG,KAAO,SAAS,EAAK,GAC3B,IAAI,EAAO,EAAI,EAAG,EAAM,EAAI,IAAK,EAAO,EAAI,GAAQ,EAAO,EAAK,MAAM,GAAO,EAAM,EAAI,GAC7C,GAA/B,EAAK,OAAS,EAAK,KAAO,KAAe,GAE/B,GAAX,EAAI,GAAG,IAAc,IAAM,EAAI,IAEzC,GADA,IAAQ,EAAI,GAAK,IAAI,OACjB,EAAO,OAAO,EAAK,GAAG,MAAO,GACjC,GAAG,EAAI,CACN,GAAG,iBAAmB,IAAQ,EAAQ,EAAM,GAAO,OAAO,EAAK,GAAG,MAAO,GACzE,EAAO,EAAI,MAAM,GAAG,EAAM,QAK1B,EAAO,EAAI,OAAQ,EAAI,IAAI,KAAK,GAAQ,EAEzC,EAAO,EAAI,MAAM,KAAK,GAEtB,IAAI,EAAQ,aAAc,EAAM,IAAM,EAAM,OAAQ,EACpD,EAAM,EAAI,EAAI,EACd,IAAQ,EAAI,IAAM,IAAI,MACtB,EAAK,GAAG,KAAM,CACb,IAAK,EAAI,KACT,IAAK,EACL,IAAK,EACL,EAAG,EACH,EAAG,IAEJ,IAAQ,EAAI,IAAM,IAAI,MAEtB,EAAK,GAAG,MAAO,GACf,IAAQ,EAAI,IAAM,IAAI,OAnHtB,GAwHD,EAAI,MAAM,IAAM,SAAS,GAExB,IAAgB,EAAN,KAAe,EAAG,GAD5B,EAAM,GAAO,IACyB,OAAS,EAoB/C,OAnBI,EAAO,KAAO,EAAM,IACpB,EAAO,EAAG,OAAO,EAAG,IAAM,GAC3B,EAAQ,KAAO,EAAM,CAAC,IACtB,EAAQ,KACV,EAAM,EAAQ,GAAK,SAAS,EAAK,EAAG,IACnC,EAAI,IAAM,GAAK,EAAE,IAAM,EAAK,EAAI,EAAK,MAElC,EAAO,EAAG,IAAI,SAAS,EAAG,IAAI,MAAQ,IAC1C,EAAG,IAAI,MAAQ,EAAO,EAAK,EAAG,IAAI,QAEnC,EAAG,IAAI,MAAQ,EAAG,IAAI,OAAS,GAC/B,EAAQ,GAAK,SAAS,EAAK,EAAE,IACxB,EAAQ,KAAM,IAAM,EAAK,GAAG,IAAM,EAAI,MAAM,GAAK,KAAK,GAAK,EAC5D,GAAK,EAAE,cAAgB,SAAW,EAAQ,IAC7C,EAAQ,EAAG,EAAM,KAAK,MACpB,EAAG,KACN,EAAI,GAAG,MAAO,GAEd,EAAI,IAAI,SAnBE,MAuBZ,EAAI,IAAI,OAAS,WAAY,IAAI,EAAI,OAAO,UAAW,IAAI,IAAI,KAAK,EAAI,QAAQ,IAAI,8CAA+C,UAAW,EAAE,IAEhJ,IAIgB,EACZ,EALA,EAAU,EAAI,KAAK,GACnB,EAAO,EAAI,KAAM,EAAU,EAAK,GAAI,EAAY,EAAK,OACrD,EAAM,EAAI,IAA4B,EAAS,EAAI,GAAI,EAAU,EAAI,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAC9E,EAAY,EAAI,MAAM,IAAK,EAAW,EAAI,MAAM,GAAI,EAAQ,EAAI,IAAI,KAAK,EAAG,EAAO,IAAK,EAAQ,EAAI,KAAK,EAAG,EAAS,EAAI,IAAI,GAA8B,EAAS,EAAI,MAAM,EACzM,EAAQ,IAGZ,EAAI,IAAM,WAAY,OAAS,EAAI,IAAI,KAAO,EAAE,IAAI,MAAM,EAAG,WAAa,GAAG,MAAM,KAAK,WAAW,KAAK,OAChG,KAAO,SAAS,EAAE,EAAE,GAAI,OAAQ,EAAI,EAAI,IAAI,MAAM,GAAK,EAAE,IAAM,EAAG,EAAE,MAAQ,EAAI,IAAI,IAEvE,oBAAX,UAA0B,OAAO,IAAM,OAAO,IAAM,GAAK,OAAS,QAC5E,SAA0B,IAAX,IAAyB,EAAO,QAAU,GAAO,MAAM,IACtE,EAAO,QAAU,GAEhB,EAAI,QAAQ,IAAI,SAAW,EAAI,QAAQ,IAAI,SAAW,CAAC,IAAK,eAC5D,EAAI,SAAS,KAAO,SAAS,EAAG,GAAI,OAAQ,EAAE,KAAK,GAAK,IAAM,EAAE,KAAK,GAAK,EAAE,KAAK,MAAS,EAAE,IAAI,MAAM,EAAG,YAAc,IAGxH,EAAI,IAAI,KAAK,UAAW,uJArUxB,CAsUE,EAAK,UAEP,GAAI,WACJ,IAAI,EAAM,EAAI,UACd,EAAI,MAAM,KAAO,SAAS,EAAG,GAE5B,IAAI,KADJ,EAAI,GAAK,IACM,MAAa,EAC3B,OAAO,KAAK,EAAE,KAAK,EAEpB,GAAG,IAAM,EACR,OAAQ,KAAK,EAAE,MAAQ,KAAK,GAAG,EAEhC,IAAgB,EAAN,KAAe,EAIzB,GAHgB,iBAAN,IACT,EAAI,EAAE,MAAM,MAEV,aAAa,MAAM,CAErB,IADA,IAAI,EAAI,EAAG,EAAI,EAAE,OAAQ,EAAM,EACxB,EAAI,EAAG,IACb,GAAO,GAAK,GAAO,EAAE,IAEtB,OAAG,IAAM,EACD,EAVC,KAUU,GAEf,EAAM,EAAG,MACL,EAAI,EAAE,KAAK,EAAG,QAEtB,EAED,GAAG,mBAAqB,EAAE,CACzB,IAAI,EACJ,IADS,EAAM,CAAC,KAAM,IACf,EAAM,EAAI,OACd,KAAO,EAAM,EAAE,EAAK,MACvB,OAAO,EAER,OAAG,EAAI,IAAI,GAAG,IACL,EAAG,MAAQ,GAAI,EAAE,KAAK,EAAI,GAE5B,MAER,IAAgB,EAAZ,EAAQ,KAtCZ,CAuCE,EAAK,UAEP,GAAI,WAgBJ,SAAS,EAAO,GACf,IAAS,EAAmD,EAA9C,EAAK,KAAK,GAAI,EAAO,EAAG,KAAM,EAAO,EAAG,KAGtD,GAFI,EAAI,IAAI,EAAI,EAAI,EAAG,GACvB,KAAK,GAAG,KAAK,GACV,EAAM,EAAI,IAAI,CAMhB,GADG,EAAG,MAAM,EAAI,IAAM,EAAO,EAAG,IAAK,EAAI,MACtC,EAAI,MAAQ,EAAG,KAAK,CAItB,GAHA,EAAI,KAAO,EAAI,MAAQ,EAAG,KAC1B,EAAI,OAAS,EAAI,KAAO,EAAU,IAClC,EAAQ,EAAK,EAAE,IAAI,EAAI,MAAM,EACxB,EAAM,EAAI,MASf,GAAG,EAAQ,EAAK,IAAK,IAQpB,IANK,GADL,EAAO,EAAK,EAAE,IAAI,GAAK,GACR,OAAO,EAAI,KAAO,GACjC,EAAK,GAAG,KAAM,CACb,EAAG,EAAK,EACR,IAAK,EAAI,MAAM,GAAG,EAAK,IAAK,GAC5B,IAAK,EAAK,MAER,EAAM,YAEV,GAAG,iBAAmB,EAAI,CACzB,IAAI,EAAM,GAAI,GAAQ,EAAK,KAAK,IAAI,EASpC,GARA,EAAI,IAAI,IAAI,EAAK,KAAK,SAAS,EAAE,GAC5B,EAAI,KAAK,MAAM,EAAG,KACtB,EAAI,GAAK,MAEN,EAAI,IAAI,MAAM,KACjB,EAAI,EAAI,EACR,EAAK,GAAG,KAAM,CAAC,EAAG,EAAK,EAAG,IAAK,EAAK,IAAK,EAAK,OAE5C,EAAM,EAAG,IAAI,CAGf,GAFA,EAAO,EAAI,IAAO,EAAI,EAAI,cACvB,EAAK,IAAM,EAAI,MAAM,EAAI,IAAM,EAAK,KACpC,EAAI,IAAM,OACb,EAAI,IAAM,QAjCS,CAMpB,IALA,EAAM,EAAK,OACD,EAAK,KAAO,GACnB,EAAQ,EAAM,QAChB,EAAK,GAAG,KAAM,GAEZ,GAAO,IAAM,EAAK,IAAM,OAC3B,EAAI,EAAI,EAAK,EA8Bd,OADA,EAAK,IAAI,EAAK,GACP,EAAK,GAAG,KAAM,GAGtB,GADG,EAAK,MAAM,EAAK,IAAI,EAAG,IAAM,EAAK,IAAI,EAAG,MAAO,EAAM,EAAG,KAAO,IAChE,EAAI,KACN,OAAG,EAAG,KACL,EAAM,CAAC,IAAK,CAAC,IAAK,EAAG,KAAM,EAAG,EAAG,GAEhC,EAAK,MAAQ,EAAK,IAAM,IACzB,EAAK,IAAI,EAAG,KAAO,EAAI,EAAE,EAClB,EAAK,GAAG,MAAO,IAGhB,EAAK,GAAG,MADf,EAAM,CAAC,IAAK,GAAI,EAAG,EAAG,IAIvB,GADA,EAAG,IAAM,EAAG,MAAQ,EACjB,EAAG,IAIL,OAHA,EAAI,EAAI,EAAG,EACX,EAAI,KAAO,EAAG,KACb,EAAK,MAAQ,EAAK,IAAM,KAAK,EAAG,KAAO,EAAI,EAAE,EACvC,EAAK,GAAG,MAAO,GAGxB,OAAO,EAAK,GAAG,MAAO,GAGvB,SAAS,EAAM,GACd,IAA4G,EAAK,EAA7G,EAAM,KAAM,EAAM,EAAI,GAAI,EAAO,EAAI,KAAmB,GAAP,EAAI,GAAc,GAAO,GAAK,EAAO,EAAS,EAAI,IAWvG,GAVG,EAAI,KAAO,EAAI,MAAQ,EAAI,MAC7B,EAAM,EAAO,EAAK,CAAC,IAAK,EAAI,OAE1B,EAAI,KAAO,IAAO,IACpB,EAAM,EAAO,EAAK,CAAC,EAAG,EAAI,IACvB,EAAG,MACL,EAAI,IAAM,EAAG,MAIZ,IAAM,EAAO,CAGf,GAFA,EAAM,EAAG,IACT,EAAI,GAAG,KAAK,GACT,EAAI,KAAO,OACd,GAAG,IAAM,GAAO,IAAM,EAAG,IAAM,OAO/B,OANA,EAAK,EAAK,EAAK,GACZ,EAAI,KACN,EAAI,EAAK,GAEV,EAAQ,EAAG,KAAM,EAAI,SACrB,EAAQ,EAAI,IAAK,EAAG,IAGrB,GAAG,EAAI,KAIN,OAHA,EAAI,GAAG,KAAK,GACZ,EAAK,EAAK,EAAK,QACZ,EAAI,MAAO,EAAQ,EAAQ,EAAK,CAAC,IAAK,EAAK,IAAK,KAGpD,KAAK,EAAM,EAAI,IAAI,KAAK,GAAG,IAC1B,OAAG,EAAI,IAAI,GAAG,IACV,EAAI,KAAO,EAAI,KACjB,EAAI,EAAK,IAEP,EAAG,KAAO,EAAG,SACd,EAAG,OAAS,EAAG,KAAO,KAAK,EAAI,IAAM,EAAG,KAAK,EAAG,KAAO,GACvD,EAAI,MAAQ,EAAI,IAAM,KAAK,EAAG,IAAM,EAAI,IAAI,EAAG,KAAO,CAAC,GAAI,IAG7D,EAAI,GAAG,KAAK,QACZ,EAAK,EAAK,EAAK,KAGb,EAAI,KAAO,IAAO,GAAO,EAAQ,EAAI,SACvC,EAAI,IAAM,EAAG,MAEV,EAAM,EAAI,KAAK,KAAK,KAAY,EAAG,MACtC,EAAG,IAAO,EAAI,KAAK,EAAE,IAAI,GAAK,EAAG,KAElC,GAAO,EAAK,MAAQ,IAAI,EAAG,IAE1B,EAAI,GAAG,KAAK,GAEb,EAAO,EAAK,EAAK,EAAI,GACrB,EAAK,EAAK,EAAK,QACZ,EAAI,MAAO,EAAQ,EAAQ,EAAK,CAAC,IAAK,EAAK,IAAK,OAKpD,GADA,EAAM,EAAK,MAAQ,IACT,EAAG,MAAQ,EAAI,EAAG,IAAM,KAE9B,GAAK,EAAI,IAAM,EAAG,IACtB,EAAI,EAAI,IAAM,EAAG,MAAO,EAEvB,EAAI,GAAG,KAAK,GAEb,EAAO,EAAK,EAAK,EAAI,GACrB,EAAK,EAAK,EAAK,GAGhB,SAAS,EAAO,EAAI,EAAK,EAAM,GAC9B,GAAI,GAAO,IAAU,EAAG,IAAxB,CACA,IAAI,EAAO,EAAG,KAAK,EAAE,IAAI,GAAK,EAC3B,EAAG,IACL,EAAO,EAEL,EAAK,KACP,EAAO,EAAM,EAAK,EAAM,GAEtB,IAAS,IACR,EAAK,IAAI,EAAO,KACnB,EAAK,OAAS,EAAK,KAAO,KAAK,EAAG,IAAM,EAAK,KAAK,EAAG,KAAO,EAC1D,EAAG,OAAS,EAAG,KAAK,GAAO,EAAK,KAClC,EAAI,EAAI,IAGN,KADH,EAAM,EAAK,IAAM,EAAG,MAAQ,EAAG,IAAM,KAAK,EAAK,IAAM,EAAG,IAAI,EAAK,KAAO,CAAC,GAAI,GAAS,IACvE,MACT,EAAI,MAAQ,EAAG,QAIlB,EAAG,OACL,EAAI,IAAI,IAAI,EAAG,KAAK,SAAS,GAAM,EAAI,MAAO,KAC9C,EAAQ,EAAI,SAEV,EAAI,MAAO,EAAQ,EAAK,QACxB,EAAG,MAAM,EAAG,KAAO,GAyEvB,SAAa,EAAI,GAChB,IAAI,EAAO,EAAG,KAAK,EAAE,IAAI,GAAM,EAAI,EAAM,EAAG,IAC5C,IAAG,EAAG,KAAO,MACX,EAAM,GAAK,IAAI,KAAO,EACvB,EAAI,GAAG,MAAO,CAAC,IAAK,KAChB,EAAG,KAAM,OAEd,EAAM,EAAG,IAAK,EAAI,IAAI,IAAI,EAAI,OAC9B,EAAQ,GAAO,EAAG,MAAM,SAAS,EAAM,GACtC,IAAI,EAAM,EAAK,KAAO,GAAI,EAAI,KAAO,EAAM,EAAI,KAAO,EAAI,MAAQ,EAClE,EAAK,GAAG,MAAO,CAAC,IAAK,OAEtB,EAAI,IAAI,IAAI,EAAI,OApFhB,CAAI,EAAI,EAAI,KAAO,MAEpB,SAAS,EAAK,EAAI,GACb,EAAG,MAEP,EAAQ,EAAG,KAAM,EAAQ,GAE1B,SAAS,EAAO,GACX,GAAO,EAAG,IACd,EAAG,GAAG,KAAM,MAEb,SAAS,EAAI,EAAM,GAClB,IAA8D,EAAO,EAAI,EAArD,EAAV,KAAK,IAAgB,MAAQ,EAAO,EAAM,KAAK,KACtD,IAAU,GAAQ,EAAK,MACrB,EAAK,EAAK,MAMZ,EAAG,KAEF,IAAM,EAAG,KAAQ,EAAI,IAAI,KAAK,GAAG,KACnC,EAAG,IAAM,GAEV,EAAQ,EAAG,IAET,EAAM,EAAI,KACZ,GAAO,EAAQ,EAAI,EAAE,IAAI,IAAM,EAC5B,IAAM,EAAI,KAAQ,EAAI,IAAI,KAAK,GAAG,KACpC,EAAI,IAAM,IAGZ,EAAG,GAAG,KAAM,CACX,IAAK,EACL,IAAK,EACL,EAAG,EACH,IAAK,KAGP,SAAS,EAAI,EAAI,GAChB,GAAK,EAAG,KAAO,EAAG,KAAlB,CACA,IAAI,EAAM,EAAG,IACb,EAAG,IAAM,KACN,EAAG,MACF,EAAG,KAAO,EAAG,KAAK,OAAO,EAAG,IAAM,MACrC,EAAG,KAAO,OAGP,EAAG,MACD,EAAI,MAAS,OAAS,KAGzB,IAAM,GAAO,EAAI,IAAI,KAAK,GAAG,EAAG,OACnC,EAAQ,GAAK,SAAS,IAChB,EAAQ,EAAM,KACnB,EAAQ,EAAM,KAAM,EAAG,OAExB,EAAM,EAAG,IACT,EAAQ,EAAG,MAAM,SAAS,EAAM,GAC/B,GAAG,IAAM,GAAO,IAAM,EAAG,IAAM,OAAO,EACtC,EAAK,IAAM,EACR,EAAK,MACP,EAAK,KAAO,GAEb,EAAK,GAAG,KAAM,CACb,IAAK,EACL,EAAG,EAAK,EACR,IAAK,UAkBR,SAAS,EAAI,GACZ,IAAI,EAAK,KAAK,GAAI,EAAM,EAAG,KAAK,GAAI,EAAK,EAAG,EAAE,EAAG,GAAO,EAAI,KAAK,IAAI,EAAI,MAEzE,GADG,EAAG,MAAM,EAAG,IAAO,EAAG,IAAM,GAAM,GACjC,EAAI,MAAQ,iBAAmB,EAAI,MAAS,EAAQ,EAAK,EAAG,MAU7D,GAAS,EAAI,MAIb,EAAG,KAAO,EAAI,GAAG,IAAI,IACtB,EAAI,EAAG,KAAQ,EAAG,MAAQ,GAE5B,EAAI,GAAG,IAAI,IANV,EAAG,GAAG,KAAM,CAAC,IAAK,EAAG,IAAK,IAAK,EAAI,IAAI,KAAK,IAAI,EAAI,MAAO,EAAG,EAAG,EAAG,IAAK,EAAI,WAX9E,CACC,GAAG,EAAG,MAAQ,EAAI,OAClB,EAAG,GAAG,KAAM,CACX,IAAK,EAAG,IACR,IAAK,EAAG,IAAM,EACd,EAAG,EAAG,EACN,IAAK,EAAI,QA3RZ,IAAI,EAAM,EAAI,UACd,EAAI,MAAM,MAAQ,SAAS,GAC1B,IAAsF,EAAlF,EAAM,KAAM,EAAK,EAAI,EAAG,EAAQ,IAAK,GAAO,GAAK,YAAY,GAAM,EAAM,EAAM,EAOnF,OANA,EAAI,KAAO,EAAO,EAAG,KACrB,EAAI,KAAO,EAAK,KAChB,EAAI,KAAO,EAAI,EACf,EAAI,GAAK,EAAI,GACb,EAAI,GAAG,KAAM,EAAO,GACpB,EAAI,GAAG,MAAO,EAAQ,GACf,GA+RR,IAAgB,EAAZ,EAAQ,GACR,EAAM,EAAI,IAAK,EAAU,EAAI,IAAwB,EAAU,EAAI,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IACvG,EAAY,EAAI,KAAK,OACG,EAAQ,EAAI,KAAK,IA/S7C,CAgTE,EAAK,WAEP,GAAI,WA4FJ,SAAS,EAAI,GACZ,IAA0H,EAAtH,EAAM,KAAM,EAAK,EAAI,GAAiB,EAAP,EAAG,GAAe,KAAmB,GAAP,EAAI,GAAc,IAAI,GAAK,GAAI,EAAO,EAAI,KAAO,EAAG,IACrH,IAAI,EAAM,EAAK,MAAQ,IAAQ,EAAI,EAAG,KAAO,OAAO,EAAI,GAAG,KAAK,GAUhE,GAAG,EAAI,MAAQ,EAAG,IAAM,EAAI,KAAK,EAAG,IAAM,OAAO,EAAI,GAAG,KAAK,GAQ7D,IANI,EAAM,IAAS,EAAI,EAAI,KAAO,EAAM,EAAI,GAAG,MAC9C,GAAQ,EAAI,GAAK,EAAG,KAAK,EAAE,IAAI,IAAM,EAClC,IAAM,EAAI,MACZ,EAAM,EAAO,EAAK,CAAC,IAAK,EAAO,EAAI,SAGjC,EAAM,EAAK,MAAQ,EAAG,GAAG,CAC5B,IAAI,EAAK,EAAG,IAAM,EAAI,KAAO,EAAI,GAAK,EAAI,KAAK,OAAO,KACtD,GAAG,EAAI,GAAM,OACV,IAAM,GAAS,EAAI,GAAG,KAAQ,EAAI,IAAM,GAE5C,EAAG,IAAI,EAAK,GACT,EAAI,KACN,EAAI,KAAO,KAGZ,EAAI,GAAG,KAAK,GAEb,SAAS,EAAI,GACZ,IAAI,EAAM,KAAK,GACf,IAAI,GAAM,EAAI,MAAQ,EAAI,IAAM,OAAO,KAAK,MAC5C,GAAK,GAAM,GAAM,EAAK,EAAG,GAAK,GAAI,GAAK,GAAI,GAA3C,CACA,IAAwB,EAExB,IAAU,EAAO,KAAK,OAAS,KAAK,KAAO,KAAK,GAAM,OAAO,EAC7D,EAAK,IAAM,GAlIZ,IAAI,EAAM,EAAI,UACd,EAAI,MAAM,IAAM,SAAS,EAAK,EAAI,GACjC,IAAI,EACJ,GAAkB,iBAAR,EAYV,IAAG,mBAAqB,EAAI,CAC3B,IAAG,IAAS,EAAK,OAuDnB,SAAc,EAAK,EAAI,EAAK,GAC3B,IAA2B,EAAvB,EAAM,EAAI,EAAG,EAAO,GACrB,EAAM,EAAI,MAAQ,EAAI,MAAQ,EAAI,KAAa,EAAG,EAAK,EAAI,GAC3D,EAAI,IAAa,EAAI,IAAI,KAAK,CAAC,EAAI,KACtC,EAAI,IAAM,CAAC,CAAC,EAAG,IACf,EAAI,KAAI,SAAY,EAAK,GACxB,KAAG,IAAM,EAAI,MAAQ,EAAI,KAAK,IAAI,QAAU,EAAM,OAAO,KAAK,EAAI,KAAK,IAAI,OAAO,WAAa,GAAQ,GAAvG,CAGA,EAAI,IAAI,GACR,IAA8C,EAA1C,GAAO,EAAK,EAAI,IAAM,EAAG,GAAM,GAAI,EAAI,EAG3C,IAFA,EAAM,EAAI,WAAY,EAAI,IAEpB,EAAK,EAAI,MAAK,CACnB,IAAI,EAAK,EAAG,GAAQ,EAAK,EAAG,GAC5B,GAAM,EAAQ,EAAG,MAAQ,EAAG,MAAQ,EAAI,GAAG,EAAI,MAAQ,EAAU,EAAI,MAAQ,EAAG,IAAK,EAAI,EAAK,OAE7F,CAAC,IAAK,CAAC,IAAK,CAAC,KAAI,OAxEK,CAAK,KAAM,EAAK,EAAI,GAAK,KAEjD,IAAgD,EAA5C,GADJ,EAAM,MACO,EAAG,EAAO,EAAG,KAAM,EAAM,EAAK,KAC3C,EAAK,GAAM,IACR,GAAK,EACR,EAAG,IAAM,EACT,EAAG,IAAM,EAAG,KAAO,GACnB,EAAG,IAAI,IAAM,EAAG,IAAI,KAAO,IAC1B,EAAK,EAAG,GAAG,KAAM,EAAK,IAAK,IAAM,GACjC,EAAK,IAAM,CAAC,EAAE,IAAI,EAAG,IAAM,EAAG,IAAM,EACrC,IAAI,EAAM,EAAK,IAIf,OAJoB,EAAK,IAAM,GAC/B,EAAG,GAAG,MAAO,EAAG,KAChB,EAAK,IAAM,EACX,EAAK,IAAM,EACJ,EAER,OAAG,EAAO,GACF,KAAK,IAAI,GAAG,EAAK,EAAI,IAE1B,EAAM,EAAI,GAAG,IACR,KAAK,IAAI,EAAK,EAAI,GAEvB,EAAI,GAAG,IACT,EAAM,MACH,IAAQ,EAAM,EAAI,OAAO,GAAO,MAAQ,KAAM,EAAM,EAAI,IAAI,IAC/D,EAAI,EAAE,IAAM,EACL,KAEN,EAAK,KAAK,SAAS,EAAE,IAAM,CAAC,IAAK,EAAI,IAAI,uBAAwB,IAC/D,GAAK,EAAG,KAAK,EAAI,EAAG,EAAE,KAClB,GA1CA,GAAiB,GAAd,EAAI,OAED,OADC,EAAK,KAAK,SAAS,EAAE,IAAM,CAAC,IAAK,EAAI,IAAI,kCAAmC,IACtE,KAgDrB,OA5CM,GAFM,KAAiB,EACb,MAAQ,GACP,MACf,EA6CH,SAAe,EAAK,GACnB,IAAI,EAAM,EAAK,EAAG,EAAO,EAAI,KAA0B,EAAd,EAAK,QAAkB,EAYhE,OAXI,IAAO,EAAO,EAAI,KAAO,IAC7B,EAAK,EAAG,IAAM,GAAO,EAClB,IAAS,EAAI,KAAK,EACpB,EAAG,KAAO,GAER,EAAI,MAAQ,EAAI,OAClB,EAAG,IAAM,GAKH,EA1DC,CAAM,EAHF,OAKX,EAAM,EAAI,GAmCR,EAAM,KAAK,EAAE,QACf,EAAI,EAAE,KAAO,EAAI,EAAE,MAAQ,GAEzB,GAAM,mBAAqB,GAC7B,EAAI,IAAI,EAAI,GAEN,GAkFR,IAGgB,EAHZ,EAAM,EAAI,IAA2C,EAAS,EAAI,IAAI,GACtE,EAAS,EAAI,IAAI,GACjB,EAAM,EAAI,IAAI,KAAM,EAAY,EAAI,KAAK,KACzC,EAAQ,KA5IZ,CA6IE,EAAK,SAEP,GAAI,WAmFJ,SAAS,EAAK,GACV,GAAK,IAeT,SAAS,IAAS,IAAI,EAAK,KACtB,EAAG,OAAU,EAAU,EAAG,QAC9B,EAAG,IAAM,EAAG,KAAO,SAAS,GAAQ,GAAK,KACzC,EAAG,KAAI,kBACC,EAAG,IAAI,EAAE,KAChB,IAAI,EAAO,EAAG,EAAE,MAAM,GAAG,EAAI,EAAM,EAAI,KAAI,SAAS,GACnD,EAAI,KAAK,GAAG,MAAO,GAChB,EAAI,KAAM,EAAI,IAAI,KAChB,GAAQ,EAAG,MAAQ,IAAK,KAAK,MAC9B,EAAG,KACP,EAAG,IAAI,EAAK,QAEV,EAAG,KAAM,EAAO,EAMf,EAAM,EAAI,KAAK,IAAK,EAAI,IAAI,EAAI,KAAM,OAC1C,IAAI,EAAM,EAAI,KAAK,IAAK,EAAI,KAAK,IAAM,GACtC,EAAG,IAAI,EAAG,GAAG,MAAO,CACpB,EAAG,EAAG,IAAK,IAAK,EAAG,IAAM,EAAG,IAAI,MAAO,IAAK,EAAG,IAAK,IAAK,IAE1D,EAAI,KAAK,IAAM,EAAK,EAAI,GAAG,EAAK,EAAI,KAAK,KAAO,EAChD,EAAI,KAAK,IAAM,EACf,EAAG,IAAI,EAAE,GAAG,MAAO,WAAY,EAAG,IAAI,EAAE,IAAI,MAC1C,GACA,EAAG,KAAM,EAAG,OAGhB,SAAS,EAAI,EAAE,EAAE,EAAG,GAAK,IAAI,EAAK,KAC7B,EAAK,EAAI,GAAG,IACb,GAAM,EAAG,KAAK,SAChB,EAAG,KAAK,IAAM,WAGd,IAFA,IAAI,EAAO,EAAG,KAAM,EAAM,EAAG,IACzB,EAAI,EAAG,EAAI,EAAK,OACb,EAAI,EAAG,IACb,EAAM,EAAI,IAAI,EAAK,IAEjB,IAAK,EAAM,GAEd,IAAI,EAAM,EAAI,EAAG,IACjB,GAAG,IAAO,EAAK,EAAI,KAAK,KAAK,EAAG,MAG/B,OAFA,EAAI,MAAM,GAAG,IAAI,QACjB,EAAG,KAAK,IAGR,EAAG,KAAO,EAAG,MAAQ,IAAI,GAAQ,EAClC,EAAI,IAAI,GAAM,EAAM,CAAC,GAAI,CAAC,GAAI,EAAI,GAAI,EAAI,EAAE,EAAM,IAAK,OACrD,CAAC,GAAI,EAAI,GAAI,IAIjB,SAAS,EAAK,EAAI,EAAI,EAAK,GACtB,EAAK,EAAG,GAAZ,IAAkE,EAArC,EAAM,EAAG,IAAK,EAAM,EAAG,GAAI,EAAM,GAAS,EAAK,EAAG,GAC/E,EAAI,MAAK,SAAS,GACjB,GAAG,EAAM,EAAG,MAAQ,EAAG,MAAQ,EAAG,IAAM,OAAO,EAC/C,EAAI,KAAK,EAAG,KAAO,EAAG,QAEvB,EAAM,CAAC,GAAO,EAAG,MAAM,OAAO,EAAI,WAClC,IAAI,IAAO,GAAO,IAAI,GAAK,IAAI,GAAK,GACpC,EAAK,EAAG,IAAM,EAAG,KAAO,GAAM,EAAI,KAAK,KAAK,EAAI,MAAQ,EAAI,KAAK,KAAK,EAAI,KAAO,EAAG,MAAQ,EAAI,IAAI,KAAK,GAAG,EAAI,KAAO,EAAG,MAAQ,EAAI,KAAK,KAGxI,IAAM,EAAI,MAAO,GAChB,EAOJ,EAAM,EAAI,EAAG,IAAM,EAAI,EAAK,GAN3B,EAAG,IAAI,KAAK,WAAZ,EAAwB,SAAS,EAAK,GACrC,GAAG,EAAM,OAAO,EAAI,IAAI,GACxB,EAAM,EAAI,EAAG,IAAM,EAAG,KAAO,EAAI,EAAK,MAOzC,SAAS,EAAM,EAAI,EAAI,EAAK,GAC3B,EAAG,EAAE,MAAM,GAAG,IAAI,GAClB,EAAI,KAAK,UACF,EAAG,KAAK,EAAI,MACnB,EAAG,QAGJ,SAAS,EAAI,EAAM,EAAI,EAAK,GAE3B,GADA,EAAK,EAAG,GACJ,EAAI,GAAM,EAAI,EAAE,EACpB,GAAG,EAAI,IACN,EAAI,IAAI,mDADT,CAIA,IAA2D,EAAvD,EAAM,EAAI,EAAE,EAAI,EAAO,EAAG,IAAK,EAAM,EAAG,KAAK,GACjD,KAAI,EAAM,EAAG,OAAQ,EAAI,EAAE,IAA3B,CAEA,GADG,IAAM,EAAI,MAAO,GACjB,EAAG,MAAQ,EAAG,EAAE,CAElB,KADA,EAAO,EAAG,EAAE,EAAG,KAAO,EAAG,KAIxB,cAFO,EAAG,IAAI,EAAE,UAChB,EAAI,IAAI,8CAGT,EAAG,KAAO,EAAQ,GAAI,EAAK,EAAG,MAC9B,EAAM,KAEP,GAmCG,YAnCM,EAAK,CACb,IAAI,EAAG,IAA4B,mBAAf,EAAG,IAAI,EAAE,KACzB,IACH,EAAM,EAAG,EAAE,MAAK,SAAS,GACxB,GAAG,EAAG,MAAQ,EAAG,KAAO,OAAO,EAAG,MAAQ,EAAG,KAC7C,EAAG,KAAO,EAAQ,GAAI,EAAG,IAAK,EAAG,SAElC,EAAG,KAAM,GAGV,GADA,EAAM,GAAO,EAAG,MAAQ,EAAG,MAAQ,EAAG,KAC3B,EAAG,KAAK,EAAE,IAAI,GAAK,EAAK,EACnC,EAAG,KAAO,EACV,EAAO,EAAG,KAEP,EAAG,MAAS,EAAG,KAAO,EAAG,MAAQ,KACjC,EAAG,MAAQ,EAAO,EAAG,MACvB,EAAG,MAAQ,EAAI,MAAQ,EAAG,IAAI,KAAK,aAAe,EAAI,KAAK,WAGxD,GAAS,EAAG,MACd,EAAG,MAAQ,EAAG,KAAK,GAAO,MAAQ,EAAG,KAEtC,EAAG,KAAO,EAAG,MAAQ,EAAG,MAAQ,EAAG,OAAS,EAAI,MAAQ,EAAG,IAAI,KAAK,aAAe,EAAI,KAAK,WAEzF,EAAG,MAQR,EAAG,IAAI,IAAI,EAAG,KAAM,EAAG,KAAM,GAP3B,EAAG,IAAI,KAAK,WAAZ,EAAwB,SAAS,EAAK,GACrC,GAAG,EAA4B,cAAf,EAAG,IAAI,EAAE,KAAa,EAAI,IAAI,GAC9C,EAAG,IAAI,IAAI,EAAG,KAAM,EAAG,KAAO,EAAM,QAnOxC,IAAI,EAAM,EAAI,UACd,EAAI,MAAM,IAAM,SAAS,EAAM,EAAI,GAClC,IAAuE,EAAnE,EAAM,KAAM,EAAM,EAAI,EAAI,EAAO,EAAG,KAAK,EAY7C,OAXA,EAAK,GAAM,IACR,KAAO,EACV,EAAG,IAAM,EAAG,EAAI,EAAG,KAAO,EAAG,GAAK,EACjB,iBAAP,EACT,EAAG,KAAO,EAEV,EAAG,IAAM,EAAG,KAAO,EAEjB,EAAG,OACL,EAAG,KAAO,EAAG,MAEX,EAAG,MAAQ,IAAS,EAClB,EAAO,EAAG,OAKd,EAAG,KAAO,EAAG,OAAS,EAAG,IAAM,EAAI,KAAK,KAAK,EAAG,QAAU,EAAG,IAAI,KAAK,aAAe,EAAI,KAAK,WAC9F,EAAG,IAAI,EAAE,KAAO,GACZ,EAAG,MAOP,EAAG,EAAI,EAAK,IAAI,EAAG,MACnB,EAAG,IAAM,EAAG,EAuCd,SAAa,GACZ,EAAG,MAAQ,EACX,IAAsB,EAAM,EAAG,IAAM,EAAI,MAAM,IAAI,GAAzC,EAAG,KAAK,IAA0C,OAG5D,GAFA,EAAI,KAAO,EAAG,KACd,EAAG,MAAQ,EAAI,MAAM,IAAI,EAAG,KAAM,EAAK,GACpC,EAAI,IAGN,OAFC,EAAG,KAAK,GAAM,KAAK,EAAI,EAAG,IAAM,CAAC,IAAK,EAAI,IAAI,EAAI,YAChD,EAAG,KAAM,EAAG,OAGhB,EAAG,QAhDF,CAAI,GACG,IATN,EAAG,IAAI,KAAK,WAAZ,EAAwB,SAAS,EAAK,GACrC,GAAG,EAAM,OAAO,EAAI,IAAI,IACvB,EAAG,KAAK,EAAG,GAAG,IAAI,EAAG,KAAM,EAAG,KAAO,EAAM,MAEtC,MAXN,EAAG,KAAK,GAAM,KAAK,EAAI,EAAG,IAAM,CAAC,IAAK,EAAI,IAAI,qFAAuF,EAAG,KAAO,OAAS,EAAG,KAAO,QAChK,EAAG,KAAM,EAAG,MACR,IAgBT,EAAG,IAAI,EAAE,KAAO,GACb,EAAI,GAAG,IACT,EAAK,KAAI,SAAS,EAAM,EAAG,GAC1B,IAAI,EAEH,cADO,EAAG,IAAI,EAAE,KACT,EAAI,IAAI,2CAA4C,EAAI,IAAK,IAAK,EAAI,IAAK,2BAEnF,EAAI,IAAI,EAAI,IAAI,KAAK,IAAI,GAAO,EAAI,MAClC,GACI,IAEL,EAAG,MAAQ,EAAM,EAAI,IAAI,KAAK,GAAG,MAAS,EAAG,IAAM,GACtD,EAAG,IAAM,EAAG,KAAQ,EAAK,KAAO,EAAM,EAAG,MAAQ,EAAM,EAAI,EACxD,EAAG,IAAI,EAAE,MAAQ,EAAI,IAAI,GAAG,EAAG,OAAS,EAAG,KAC7C,EAAG,KAAO,EAAQ,GAAI,EAAG,IAAK,EAAG,MACjC,EAAG,IAAI,IAAI,EAAG,KAAM,EAAG,KAAM,GACtB,IAER,EAAG,IAAI,IAAI,GAAK,EAAM,CAAC,GAAI,IACvB,EAAG,MAEN,EAAG,IAAM,EAAG,KAAO,EACnB,EAAG,EAAE,EAAE,KAAO,EAAG,IAAI,EAAE,MAEjB,MA4FA,OAAO,aAAa,IAA5B,IAoFI,EAAM,EAAI,IAAK,EAAS,EAAI,GAAI,EAAU,EAAI,IAAwB,EAAY,EAAI,MACnF,EAAQ,GAAI,EAAO,aAAc,EAAO,SAAS,EAAG,GAAI,EAAG,KAAK,GAAI,IACvE,EAAQ,EAAI,KAAK,IA7OrB,CA8OE,EAAK,SAEP,GAAI,SAAS,GACb,IAAI,EAAM,EAAI,UACd,EAAI,WACJ,EAAI,UACJ,EAAI,SACJ,EAAI,SACJ,EAAO,QAAU,IANjB,CAOE,EAAK,WAEP,GAAI,WAqBJ,SAAS,EAAG,EAAK,GAAK,IAC4D,EADxD,EAAM,KAC3B,EAAM,EAAI,EAA2B,IAAlB,GAAK,IAAI,GAAK,IAAc,KAAO,EAAI,IAC9D,GAAG,IAAM,EAAT,CAGA,GAAG,EAAM,EAAI,GAAG,CAEf,GAAG,KADH,EAAO,EAAI,GAAG,GACD,IACZ,OAED,EAAO,EAAI,IAET,EAAI,SACN,EAAO,EAAI,KAQT,EAAI,GACN,EAAI,GAAG,KAAK,EAAI,GAAI,EAAK,GAEzB,EAAI,GAAG,KAAK,EAAK,EAAM,EAAI,IAAK,EAAK,IA+BvC,SAAS,EAAI,EAAK,EAAK,GACtB,GAAI,EAAI,EAAR,CACA,IAAoF,EAAM,EAAtF,EAAM,KAAK,GAAkB,EAAM,EAAI,EAAG,EAAK,EAAI,EAAG,EAAO,EAAG,KAAO,EAAI,KAC5E,EAAM,EAAI,MACZ,EAAO,EAAO,EAAI,GAAG,EAClB,IAAM,EAAK,MACb,EAAO,EAAK,OAGV,EAAM,EAAI,QAAU,EAAM,EAAI,EAAG,MAAO,aAAa,GACzD,EAAI,KAAO,EAAI,KAAK,GAAG,GAEnB,GAAM,IAAM,IAAS,EAAG,KAAK,IAAI,OAAS,EAAI,MAAQ,EAAI,MAAQ,OAAO,KAAK,EAAG,KAAK,IAAI,OAAO,WAChG,IAAO,IAAM,GAAQ,EAAG,MAAQ,EAAG,MAAS,KAAU,EAAI,EAAK,OAChE,IAAM,IAAS,EAAG,KAAK,IAAI,QAAU,EAAM,OAAO,KAAK,EAAG,KAAK,IAAI,OAAO,UAAa,IAAO,GAAM,GAAI,IAAM,EACjH,GAAO,EAAI,KAAO,IAAI,EAAG,IAAM,YAAW,WACzC,EAAI,KAAK,CAAC,GAAG,GAAM,EAAK,EAAK,GAAO,KAClC,EAAI,MAAQ,KAGb,GAAQ,IAAM,EAAK,MAAQ,EAAM,EAAI,GAAG,MAAS,EAAO,EAAI,KAAK,IAAI,GAAI,IAC5E,EAAI,IAAK,EAAI,IAAI,GAAO,EAAI,MAC5B,EAAI,GAAG,KAAK,GAAO,EAAI,EAAG,EAAM,EAAI,YArBxB,EAAI,MA5EjB,IAAI,EAAM,EAAI,WACd,EAAI,MAAM,GAAK,SAAS,EAAK,EAAK,EAAK,GACtC,IAAiC,EAA7B,EAAM,KAAM,EAAK,EAAI,EACzB,GAAkB,iBAAR,EACT,OAAI,GACJ,EAAM,EAAG,GAAG,EAAK,EAAK,GAAO,EAAI,GAC9B,GAAO,EAAI,IACZ,EAAI,OAAS,EAAI,KAAO,KAAK,KAAK,GAE7B,GALU,EAAG,GAAG,GAOxB,IAAI,EAAM,EAMV,OALA,GAAO,IAAS,EAAM,CAAC,QAAQ,GAAQ,GAAO,IAC1C,GAAK,EACT,EAAI,GAAK,EAET,EAAI,IAAI,EAAI,GACL,GA+BR,EAAI,MAAM,IAAM,SAAS,EAAI,GAE5B,OADA,EAAI,IAAI,KAAK,UAAW,oEACjB,KAAK,KAAK,EAAI,IAEtB,EAAI,MAAM,KAAO,SAAS,EAAI,GAC7B,IAAI,EAAM,KAAM,EAAK,EAAI,EAAG,EAAO,EAAG,IACtC,GAAG,EAAI,EAAG,KAAO,IAAM,EAEtB,OADC,GAAM,GAAM,KAAK,EAAK,EAAM,EAAG,KACzB,EAER,IAAG,EAMI,CACN,EAAI,IAAI,KAAK,UAAW,sJACxB,IAAI,EAAQ,EAAI,QAIhB,OAHA,EAAM,EAAE,IAAM,EAAI,MAAK,WACtB,EAAM,EAAE,GAAG,KAAM,EAAI,MAEf,EAER,OAbE,EAAM,GAAO,IAAI,GAAK,EACvB,EAAI,GAAK,EACT,EAAI,IAAM,CAAC,IAAK,EAAI,KAAK,OAAO,IAChC,EAAI,IAAI,EAAK,CAAC,GAAI,IAClB,EAAI,OAAQ,EASN,GA4BR,EAAI,MAAM,IAAM,WAEf,IAA4B,EAAZ,EAAN,KAAe,EACrB,EAAM,EAAG,KACb,GAAI,EA+BJ,OA9BA,EAAG,IAAM,GACN,EAAM,EAAI,OACT,EAAI,EAAG,MACT,EAAQ,EAAK,EAAG,MAKf,EAAM,EAAI,MACZ,EAAQ,EAAK,EAAG,MAEd,EAAM,EAAI,MACZ,EAAQ,EAAK,EAAG,MAEd,EAAM,EAAG,OACX,EAAQ,EAAI,KAAK,MAAO,IAEtB,EAAM,EAAG,MACX,EAAQ,GAAK,SAAS,GAClB,EAAG,MACL,EAAI,KAAK,EAAE,IAAI,EAAG,MAAM,UAIxB,EAAM,EAAG,OACX,EAAQ,GAAK,SAAS,GACrB,EAAK,EAAE,SAGT,EAAG,GAAG,MAAO,IAhCH,MAmCX,IAEqC,EAFjC,EAAM,EAAI,IAAK,EAAU,EAAI,IAAwB,EAAU,EAAI,IACnE,EAAM,EAAI,IAAI,KACF,EAAO,eA5IvB,CA6IE,EAAK,QAEP,GAAI,WAsBJ,SAAS,EAAI,GACZ,IAAI,EAAI,KAAO,EAAI,IAAI,GAAG,EAAI,KAAO,OAAO,KAAK,GAAG,KAAK,GACtD,KAAK,GAAG,KAAM,KAAK,MACtB,EAAQ,EAAI,IAAK,EAAM,CAAC,GAAI,KAAK,GAAI,IAAK,IAC1C,KAAK,GAAG,KAAK,GAEd,SAAS,EAAK,EAAE,GACf,GAAG,IAAO,EAAV,CACA,IAAoB,EAAV,KAAK,IAAe,EAAe,EAAM,KAAK,GAAI,EAAtB,EAAI,EAA2B,IAClE,IAAQ,EAAI,KAAK,MAAM,EAAG,EAAI,MAAQ,EAAI,MAAQ,OACnD,EAAM,EAAI,IAAI,GAAG,GAAG,OAAS,EAAI,KAAO,KAAK,EAAI,IAAM,EAAI,KAAK,EAAI,KAAO,IA/B9E,IAAI,EAAM,EAAI,WACd,EAAI,MAAM,IAAM,SAAS,GACxB,IAA6B,EAAzB,EAAM,KAAM,EAAM,EAAI,EAC1B,OAAI,GAOJ,EAAI,IAAI,KAAK,QAAS,yJACtB,EAAQ,EAAI,QACZ,EAAI,MAAM,IAAG,SAAS,EAAM,EAAK,EAAI,GACpC,IAAI,GAAQ,GAAI,GAAM,KAAK,KAAM,EAAM,EAAK,EAAI,GAChD,GAmBgG,YAnBvF,EACT,OAAG,IAAS,EAAc,EAAM,EAAE,GAAG,KAAM,GACxC,EAAI,GAAG,GAAe,EAAM,EAAE,GAAG,KAAM,EAAK,QAC/C,EAAM,EAAE,GAAG,KAAM,CAAC,IAAK,EAAK,IAAK,OAE3B,KAfH,EAAQ,EAAI,QACf,EAAI,KAAO,EAAQ,EAAI,QACvB,EAAM,EAAE,IAAM,EAAI,KAAK,OACvB,EAAI,GAAG,KAAM,EAAK,EAAM,IAHK,IA6B/B,IAAI,EAAU,EAAI,IAAI,IAAK,EAAO,aAA+C,EAAK,EAAI,KAAK,IAlC/F,CAmCE,EAAK,SAEP,GAAI,WAqBJ,SAAS,IAAQ,OAAO,EAAI,MAAM,MAAQ,EAAI,KAAK,OAAO,GApB1D,IAAI,EAAM,EAAI,WACd,EAAI,MAAM,IAAM,SAAS,EAAM,EAAI,GAClC,IAAgB,EAAZ,EAAM,KAIV,OAHA,EAAK,GAAM,cACX,EAAM,GAAO,IAAQ,KAAO,EAAI,MAAQ,GACrC,EAAO,EAAI,KAAK,KAAK,MAAQ,EAAO,EAAI,IAAI,IAAI,GAAI,EAAM,EAAI,IAAI,KAAK,IAAI,KAC1E,EAAI,GAAG,IAOX,EAAK,KAAI,SAAS,EAAM,EAAG,GAC1B,GAAI,IAAQ,EAAK,EAAE,KACnB,OAAI,OACJ,EAAI,IAAI,EAAI,IAAI,IAAI,GAAI,EAAM,EAAI,IAAI,KAAK,IAAI,IAAQ,EAAI,GADzC,EAAG,KAAK,EAAK,CAAC,IAAK,EAAI,IAAI,mCAAqC,EAAI,IAAM,QADlE,EAAK,EAAE,GAAG,OAAO,WAAY,KAAK,MAAO,EAAI,IAAI,EAAM,EAAI,SAGpF,GACK,IAXH,EAAI,IAAI,GAAG,KAEb,EAAO,GAAQ,EAAI,KAAK,KAAK,IAAS,KAEhC,EAAI,IAAI,GAAQ,KAAQ,IAAI,EAAM,EAAI,OAZ/C,CAsBE,EAAK,SAEP,GAAI,WACJ,GAAkB,oBAAR,IAAV,CAEA,IAA+B,EAC/B,IAAI,GAAS,IAAI,QADA,cACc,aAAa,MAAM,IAC9C,IACH,IAAI,IAAI,uDACR,EAAQ,CAAC,QAAS,SAAS,EAAE,GAAG,KAAK,GAAG,GAAI,WAAY,SAAS,UAAU,KAAK,IAAK,QAAS,SAAS,GAAG,OAAO,KAAK,MAOvH,IAAI,GAAG,UAAU,SAAS,GAkCzB,SAAS,EAAI,GACZ,IAAG,EAAI,KAAQ,EAAI,GAAnB,CACA,IAAI,EAAK,EAAI,KACb,YAAW,WACV,IAAI,IAAI,IAAI,GAAK,SAAS,EAAM,GAC/B,IAAI,IAAI,IAAI,GAAM,SAAS,EAAK,GAC5B,IAAO,UACH,EAAK,MAEV,EAAM,WACD,EAAI,MAGb,MACE,EAAI,MAAQ,IA7ChB,IAAI,EAAK,KAAK,GAAI,EAAM,EAAK,IAC7B,GAAG,EAAK,KAAO,OAAO,EAAG,KAAK,GAC9B,IAAG,IAAU,EAAI,aAAe,OAAO,EAAG,KAAK,GAC/C,EAAI,OAAS,EAAI,MAAQ,OACzB,IAC2B,EAAI,EAD3B,EAAM,IAAI,IAAI,IAAI,EAAM,QAAQ,OAAO,EAAI,UAAY,GACvD,EAAQ,IAAI,IAAI,MAEpB,IAAI,EAAM,GAAK,CACd,IAAI,EAAO,IAAI,IAAI,IAAI,EAAM,QAAQ,EAAI,UAAY,GAAI,EAAO,GAChE,IAAI,IAAI,IAAI,GAAK,SAAS,EAAM,GAC/B,IAAI,IAAI,IAAI,GAAM,SAAS,EAAK,GAC/B,EAAK,GAAQ,IAAI,MAAM,GAAG,EAAK,GAAO,EAAK,EAAK,UAGlD,YAAW,WAEV,EAAK,GAAG,MAAO,CAAC,IAAK,EAAM,IAAK,EAAK,IAAI,OACxC,GAGH,EAAK,GAAG,OAAO,SAAS,GACpB,EAAI,KACJ,IAAI,GAAG,EAAI,IAAM,EAAI,MAAQ,EAAI,OACnC,EAAK,EAAI,KACT,IAAI,MAAM,GAAG,EAAI,IAAK,KAAM,GACxB,IAAK,EAAK,WAAW,EAAO,EAAI,MAAQ,KAE7C,KAAK,GAAG,KAAK,OAEd,EAAK,GAAG,MAAO,GAkBf,EAAG,KAAK,GAER,IAAI,EAAM,SAAS,EAAK,EAAK,EAAM,IACjC,EAAI,KAAU,EAAI,GAAQ,KAAK,GAAO,GAEpC,EAAQ,WACX,aAAa,GACb,GAAK,EACL,IAAI,EAAM,QAAQ,OAAO,EAAI,OAAQ,KAAK,UAAU,IACnD,MAAM,GAAI,IAAI,IAAI,IAAM,GAAK,6BAIhC,IAAI,GAAG,UAAU,SAAS,GACzB,KAAK,GAAG,KAAK,GACb,IAAI,EAAM,EAAK,IACf,IAAG,EAAK,OACL,IAAU,EAAI,aAAjB,CACA,EAAI,OAAS,EAAI,MAAQ,OACzB,IAA8C,EAAtB,EAAO,GAAI,EAAQ,EACvC,EAAO,IAAI,IAAI,IAAI,EAAM,QAAQ,EAAI,UAAY,GAErD,EAAK,GAAG,eAAgB,GAExB,EAAK,GAAG,OAAO,SAAS,GACvB,KAAK,GAAG,KAAK,GACb,IAAsF,EAAlF,EAAM,EAAI,IAAK,EAAO,EAAI,KAI9B,GAHA,EAAK,GAAQ,IAAI,MAAM,IAAI,EAAK,GADU,EAAI,KAA8B,EAAI,KAAtB,EAAI,KACN,GACpD,EAAI,QAAQ,EAAK,EAAI,MAAS,GAAO,EAAI,GAAG,IAAI,KAAO,IAAK,IAAM,EAAI,IAAI,GAAG,IACjF,GAAS,KACI,EAAI,OAAS,KACzB,OAAO,IAEL,IACH,EAAK,WAAW,EAAO,EAAI,MAAQ,OAGpC,EAAK,GAAG,OAAO,SAAS,GAGvB,SAAS,IACT,GAAI,IAAS,EAAO,EAAI,MAAxB,CAEA,IAAI,EAAM,EAAI,MACd,EAAO,EAAK,IALmB,YAMpB,IACV,EAAO,IAAI,MAAM,GAAG,EAAM,IAG3B,EAAK,GAAG,KAAM,CAAC,IAAK,EAAI,KAAM,IAAK,IAAI,MAAM,KAAK,GAAO,GAAG,KAX5D,KAAK,GAAG,KAAK,GACb,IAAmB,EAAM,EAArB,EAAM,EAAI,IAYd,IAAI,MAAO,WAAW,EAAG,GAAK,OAG/B,IAII,EAAQ,SAAR,EAAiB,GACpB,IAAI,EACJ,EAAQ,EACR,aAAa,GACb,GAAK,EACL,IAAI,EAAM,EACV,EAAO,GACJ,IAAO,EAAO,GACjB,IAAI,EAAM,QAAQ,EAAI,OAAQ,KAAK,UAAU,IAC5C,MAAM,GACN,IAAI,IAAI,GAAO,GAAK,wBAA0B,2GAC9C,EAAK,GAAG,qBAAsB,CAAC,IAAK,EAAK,KAAM,EAAI,OAAQ,MAAO,EAAM,MAAO,KAE5E,GAAQ,IAAI,IAAI,MAAM,EAAI,SAC9B,IAAI,IAAI,IAAI,GAAK,SAAS,EAAK,GAC9B,GAAG,EAAI,CACN,GAAG,EAAI,KAAuB,YAAhB,EAAK,GAAM,GACtB,EAAI,IAAM,EAAI,KAAK,EAAM,gCAE7B,EAAK,GAAG,KAAM,CACb,IAAK,EACL,IAAK,EACL,GAAI,eAhJR,CAqJE,EAAK,2BAEP,GAAI,SAAS,GACb,IAAI,EAAO,EAAI,YA6Qb,WAQD,SAAS,EAAK,EAAG,GAAI,IAAI,EACxB,KAAK,aAAa,QAAU,OAAO,EACnC,IAAI,GAAK,IAAI,KAGb,OAFA,EAAK,IAAI,IAAI,OAAO,KAAK,GAAG,OAAQ,EAAK,CAAC,GAAI,EAAM,GAAI,GAAI,IAC5D,QAAQ,MAAQ,QAAQ,KAAK,GAAI,IAAI,KAAO,EAAG,QACxC,EAIR,SAAS,EAAI,GACZ,KAAK,GAAG,GAAK,KAAK,GAAG,GAjBtB,IAAI,EAAI,KAAK,UAEb,EAAK,IAAI,KAAO,SAAS,EAAK,GAC7B,GAAI,GAHmB,aAGJ,EAAM,EAAE,EAAK,IAChC,OAAO,EAAK,KAAK,KAAK,GAAQ,GAAO,KAUtC,EAAK,IAAI,KAAK,KAAO,EAfpB,GAwBD,IACG,EAAS,EAAK,IAAI,GAErB,IAAK,EAAO,QAtSb,SAAc,GAqJb,SAAS,EAAM,GACd,IAAI,EAAM,EAAK,MAAO,EAAI,iBAAmB,EAG7C,GAFG,IAAI,GAAO,KACd,EAAK,MAAQ,EAAK,KAAO,KACrB,KACD,EAAG,EAAI,EAAI,QAAU,EAAI,QAA5B,CACA,IAAI,EAAG,IAAI,EAAO,IAAM,EAAI,OAAQ,EAAI,GAAK,KAAK,UAAU,GAC3D,MAAM,GAAG,OAAO,EAAI,IAAI,2BAA4B,GACjD,GACJ,EAAK,EAAK,IAGX,SAAS,EAAK,EAAK,GAAO,IACzB,IAAI,EAAO,EAAK,KACb,EAAK,IACP,EAAK,IAAI,GAEP,EAAK,MACP,EAAK,KAAK,GAEX,EAAK,IAAI,GAAK,EAAI,QAAQ,IAAK,EAAK,IAAI,EACxC,MAAM,IACL,EAAK,MAAQ,EAAK,OAAS,IAAI,KAAK,IA1KtC,IAAI,EAAO,aACP,EAAM,EAAK,KAAO,GACtB,EAAI,IAAM,EAAI,KAAO,QAAQ,IAC7B,EAAI,IAAM,EAAI,KAAO,EAAI,MAAQ,EACjC,EAAI,KAAO,EAAI,MAAgE,IAAvD,EAAI,OAAsB,IAAb,EAAI,OAAgB,IAAQ,QACjE,EAAI,KAAO,EAAI,MAAQ,EACvB,IAmEc,EADT,EAGA,EArED,EAAO,WAAW,MAAQ,WAE1B,EAAM,EAAK,IAAK,EAAY,EAAI,MAAO,EAAY,EAAI,MAEvD,EAAO,EAAK,KAAO,SAAS,EAAK,GACpC,GAAI,EAAJ,CACA,GAAG,EAAI,MAAQ,EAAI,OAAS,OAAO,EAAK,IAAI,CAAC,IAAK,IAAK,IAAK,oBAAqB,GACjF,IAAI,EAAK,EAAwB,EAAd,EAAM,EAAI,GAE7B,GADG,IAAS,OAAO,EAAK,GAAK,EAAI,QAAQ,IAAM,EAAK,GACjD,MAAQ,GAmBX,GAAG,MAAQ,IAAS,EAAI,MAAQ,EAAO,MAAU,EAAM,GAAM,CAC5D,IAAI,EAAM,GAAO,KAAK,MAAM,GAC3B,MAAM,GAAG,OAAO,EAAI,IAAI,uBAAwB,GACjD,IAAI,EAAM,OAIV,GAHG,EAAI,MAAM,EAAI,IAAM,EAAM,CAAC,IAAK,EAAI,MACvC,IAAQ,EAAI,IAAM,IAAI,OACjB,EAAK,EAAI,QAAQ,EAAK,EAAI,KAAO,EAAK,KAAK,OAAO,IACpD,EAAM,EAAU,GAAM,OASzB,IADC,EAAI,EAAI,cAAc,IAAM,EAAK,KAAO,EACtC,EAAM,EAAI,IAKZ,OAJG,EAAM,EAAK,KAAK,KAClB,EAAI,EAAK,EAAM,QAEhB,EAAU,GAGX,IAAmB,EAAf,GAAK,IAAI,KACb,IAAQ,EAAI,GAAK,GACjB,EAAK,GAAG,KAAM,GAEd,IAAQ,EAAI,IAAM,IAAI,MACtB,QAAQ,OAAS,GAAM,IAAI,KAAO,GAAK,GAAK,QAAQ,KAAK,EAAG,EAAI,OAChE,EAAU,GAAI,IAAM,EACpB,EAAK,KAAO,UAjDb,CACC,IAAI,EAAM,KAAK,MAAM,GAAK,MAAM,GAAG,EAAI,IAAI,uBAAwB,GAEnE,GADA,EAAM,IACF,EAAM,OACV,QAAQ,MAAQ,QAAQ,MAAM,IAAI,KAAM,EAAI,OAAQ,mBACpD,IAAI,EAAI,EAAI,MACX,SAAS,IAGK,IAFd,IAEW,EAFP,GAAK,IAAI,KAET,EAAI,EAAY,EAAI,IAAM,EAAI,EAAI,OAAQ,EAAK,EAAG,GAEtD,EAAM,EAAI,MAAM,GAChB,QAAQ,MAAQ,QAAQ,KAAK,GAAI,IAAI,KAAO,EAAG,aAC/C,EAAM,GACF,EAAI,QACR,EAAK,EAAI,GATT,MAgDH,EAAK,EAAI,EAAK,EAAI,EAGb,EAAO,EAGP,EAAM,EAAK,IAAM,SAAS,EAAK,GAAO,IAAI,EAGzC,EAAU,EADd,IADI,EAAM,QAAU,EAAM,EAAI,KAAO,EAAI,MAAO,EAAI,KAAK,IACrD,EAAM,OAAO,EAEjB,IAAI,EAAM,EAAI,IAAY,IAAO,GAAK,IAAI,KAAO,IAAQ,EAAI,EAAI,IACjE,IAAI,EAAO,EAAI,IAAI,EAAI,EAAE,cAiBzB,IAhBK,EAAK,EAAI,QAAQ,EAAK,EAAI,KAAO,EAAK,KAAK,OAAO,KAElD,EAAM,EAAK,OACf,EAAM,EAAK,IAAI,IAShB,GAAK,QAAQ,MAAQ,QAAQ,KAAK,GAAI,IAAI,KAAO,EAAG,aACnD,GAAQ,EAAU,IAEf,IAAS,EAAM,EAAI,QAAQ,GAAS,EAAM,EAAI,EAAE,MAAU,EAAI,MAAS,EAAM,EAAI,MAAQ,EAAM,EAAI,IAAM,EAAI,MAAU,EAAK,OAC5H,GAAQ,EAAI,KAEf,OADA,QAAQ,MAAQ,QAAQ,MAAM,IAAI,OAAQ,EAAM,4BACzC,EAER,IAAI,GAAQ,EAAK,IAAM,OAAO,EAAK,IAAI,GACvC,GAAI,GAAS,EAAK,IAsBlB,IADI,EAAK,MAAQ,EAAK,MAAO,EAAK,KAAK,GACpC,IAAO,EAAK,KAAf,CACA,GAD+B,EAAK,KAAO,EACxC,IAAS,EAAK,IAAM,OAAO,EAC9B,IAAI,EAAM,EAAK,MAAQ,EAAI,EAAK,MAAQ,EAAI,EAAK,MAAQ,EAAI,EAAK,KAAiB,OAAO,EAC1F,GAAG,EAAK,MAAM,CAEb,GADA,EAAK,MAAQ,EAAM,EAAK,MAAQ,GAAK,EAAI,OACtC,EAAK,MAAQ,EAAI,KAGnB,YADA,EAAK,QAAU,EAAI,IAAI,IAAI,GAG5B,EAAM,GAGP,EAAK,MAAQ,IACb,IAAmB,EAAf,GAAK,IAAI,KACb,YAAW,WACV,QAAQ,OAAS,GAAM,IAAI,KAAO,GAAK,GAAK,QAAQ,KAAK,EAAG,EAAI,SAAU,EAAI,EAAK,IACnF,EAAM,KACJ,EAAI,KACP,EAAK,EAAK,QAzCV,CACC,IAAI,EAAK,IAAI,GAAG,GAAQ,EAAI,OAAS,OAAO,EAC5C,IAAkB,EAAK,EAAI,MAAO,EAAK,OAAO,KAAK,GAAQ,EAAI,OAAS,KACtE,SAAS,IACV,IAAI,GAAK,IAAI,KAEb,EAAO,EAAG,IAAI,EAAK,EAAK,IAAK,EAAK,IAAM,EAC1B,IAAd,IAAW,EAAP,EAAI,EAAY,EAAI,IAAM,GAAK,GAAI,IAAI,QACrC,EAAI,EAAG,KACZ,EAAI,EAAK,GAEV,EAAK,IAAM,EAAI,EAAO,EACtB,EAAK,EAAG,MAAM,GACd,QAAQ,MAAQ,QAAQ,KAAK,GAAI,IAAI,KAAO,EAAG,YAC3C,EAAG,SACP,EAAK,EAAI,GACT,EAAU,EAAI,OAbb,KAwCJ,EAAK,IAAI,EAAI,EAAK,IAAI,EAAI,EA4BzB,WAED,EAAK,IAAM,SAAS,GACnB,IAAI,EAAM,MAAO,GACjB,IAAqC,EAAjC,EAAQ,EAAI,GAAM,GACtB,GAAG,EAAM,EAAK,IAAM,OAAO,EAC3B,GAAG,iBAAmB,EAAM,OAAO,EAMnC,IAAI,EAAM,EAAE,GAWZ,OADG,IAAS,GAAK,IAAI,OAAU,MAAc,EAAK,IAAM,GACjD,GAER,IAAI,EAAI,KAAK,UAzBZ,GA6BF,EAAK,GAAK,SAAS,GAClB,IAAI,EAAM,EAAK,MAAQ,GACpB,EAAK,GACP,EAAI,MAAM,EAAK,KAAO,EAAK,IAAM,GAEjC,EAAM,EAAK,GAAK,EAAK,IAAM,EAAK,KAAK,OAAO,GAC5C,EAAK,IAAI,CAAC,IAAK,IAAK,IAAK,EAAK,IAAI,KAAM,EAAI,MAAM,GAAO,UAClD,EAAI,EAAE,EAAK,OAEnB,EAAK,IAAM,EAAK,MAAS,IAAI,KACzB,EAAI,MAAO,EAAK,GAAG,EAAI,KAAO,KAAM,GAExC,EAAM,EAAK,MAAO,EAAK,MAAQ,GAC/B,EAAK,IAAI,IAAI,GAAK,SAAS,GAC1B,EAAK,EAAK,MAEX,EAAK,IAAI,QAAU,EAAK,IAAI,UAE7B,EAAK,IAAM,SAAS,GACnB,EAAK,GAAG,MAAO,GACf,IAAI,GAAQ,IAAI,KAAO,GAAc,EAAK,KAAK,EAC/C,EAAK,IAAI,OAAS,EAAK,IAAI,MAAQ,GAAO,GAAO,GAElD,EAAK,KAAK,KAAO,SAAS,GAAY,EAAI,IAAI,SAAU,EAAI,MAC5D,EAAK,KAAK,KAAO,SAAS,EAAK,GAC3B,EAAI,MACF,EAAK,MAAM,EAAK,IAAM,EAAI,KAC3B,EAAI,QAER,EAAK,IAAI,CAAC,IAAK,IAAK,IAAK,EAAI,IAAK,IAAK,EAAI,MAAO,UAC3C,EAAI,EAAE,EAAK,QAGnB,EAAK,GAAG,UAAU,SAAS,GAC1B,EAAK,IAAI,IAAM,EAAK,IAAI,KAAO,EAAK,KAAK,OAAO,GAChD,KAAK,GAAG,KAAK,GACb,EAAK,GAAG,MAAO,EAAK,QAGrB,EAAK,GAAG,OAAO,SAAS,EAAM,GAE7B,KAAK,GAAG,KADR,EAAO,EAAI,MAAM,EAAK,IAAM,IAAS,GAErC,EAAK,IAAK,EAAK,OAAS,EAAM,EAAK,OAAS,EAAI,OAAS,EAAI,QAC7D,EAAK,IAAI,IAAI,EAAI,MAAO,EAAK,IAC7B,EAAK,KAAO,QAGb,IAAI,EAAO,GAcX,OAbA,EAAK,GAAG,OAAO,SAAS,EAAM,GAAM,KAAK,GAAG,KAAK,IAC3C,EAAM,EAAK,OAAgB,EAAK,IAAO,EAC5C,YAAW,kBAAmB,EAAK,KAAO,EAAI,MAAQ,SAEvD,EAAK,GAAG,MAAM,SAAS,EAAM,GAAM,KAAK,GAAG,KAAK,IAC1C,EAAM,EAAK,MAAS,EAAK,YAAuB,EAAK,GACvD,EAAI,OACP,EAAK,IAAI,IAAI,EAAK,MAAM,SAAS,EAAM,IACtC,EAAM,IAAQ,GAAQ,EAAK,MAAM,GACjC,EAAK,IAAI,CAAC,KAAM,EAAK,IAAI,KAAK,GAAM,IAAK,CAAC,IAAK,IAAQ,UAIlD,GA8BqB,MAAM,OAzSnC,CA2SE,EAAK,mBAEP,GAAI,WACJ,IAAI,EAAM,EAAI,YACd,EAAI,KAAO,EAAI,UAEf,EAAI,GAAG,OAAO,SAAS,GAmBtB,SAAS,EAAK,GAAO,IACpB,IAAI,IAAS,EAAK,IAAM,OAAO,GAAQ,EAAK,GAC5C,IAAI,EAAM,EAAK,IAAI,QAAQ,QAAS,MAChC,EAAO,EAAK,KAAO,IAAI,EAAI,UAAU,GAezC,OAdA,EAAK,QAAU,WACd,EAAI,KAAK,IAAI,GACb,EAAU,IAEX,EAAK,QAAU,WACd,EAAU,IAEX,EAAK,OAAS,WACb,EAAI,KAAK,GAAG,IAEb,EAAK,UAAY,SAAS,GACrB,GACJ,EAAI,KAAK,KAAK,EAAI,MAAQ,EAAK,IAEzB,EACP,MAAM,KAKP,SAAS,EAAU,GAClB,aAAa,EAAK,OACf,GAAO,EAAK,OAAS,IAAa,EAAK,OAAS,EAAK,OAAS,EAAI,OAAS,IAAM,EACpF,EAAK,MAAQ,YAAW,SAAS,IAChC,GAAG,GAAO,EAAI,OAAS,OAAO,WAAW,EALhC,KAMT,EAAK,KANI,MAzCX,KAAK,GAAG,KAAK,GACb,IAAI,EAAM,EAAK,IACf,IAAG,EAAK,OACL,IAAU,EAAI,UAAjB,CAEA,IAAI,EACiB,oBAAX,SAAyB,EAAM,aACpB,IAAX,IAAyB,EAAM,GACzC,EAAM,GAAO,GAEb,IAAI,EAAY,EAAI,WAAa,EAAI,WAAa,EAAI,iBAAmB,EAAI,aAC7E,GAAI,EAAJ,CACA,EAAI,UAAY,EAEhB,IAAI,EAAO,EAAI,KAAO,EAAI,MAAQ,EAAI,KAAK,GAG3C,EAAK,KAAO,EAAI,KAAO,EAsBvB,YAAW,WAAY,EAAK,GAAG,MAAO,CAAC,IAAI,SAAS,GAEpD,IASI,EAAM,oBAAuB,UAAY,gBAvD9C,CA0DE,EAAK,wBAp5EP,gFCAF,EAAO,QAAU,SAAS,GAoBzB,OAnBK,EAAO,kBACX,EAAO,UAAY,aACnB,EAAO,MAAQ,GAEV,EAAO,WAAU,EAAO,SAAW,IACxC,OAAO,eAAe,EAAQ,SAAU,CACvC,YAAY,EACZ,IAAK,WACJ,OAAO,EAAO,KAGhB,OAAO,eAAe,EAAQ,KAAM,CACnC,YAAY,EACZ,IAAK,WACJ,OAAO,EAAO,KAGhB,EAAO,gBAAkB,GAEnB,0BCpBR,YAMqE,EAAO,QAAiO,SAAS,EAAE,EAAE,EAAE,GAAG,SAAS,EAAE,GAAK,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAmE,GAAG,EAAE,OAAO,EAAE,GAAE,GAAI,IAAI,EAAE,IAAI,MAAM,uBAAuB,EAAE,KAAK,MAAM,EAAE,KAAK,mBAAmB,EAAE,IAAI,EAAE,EAAE,GAAG,CAAC,QAAQ,IAAI,EAAE,GAAG,GAAG,KAAK,EAAE,SAAQ,SAAS,GAAoB,OAAO,EAAlB,EAAE,GAAG,GAAG,IAAe,KAAI,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,OAAO,EAAE,GAAG,QAAQ,IAAI,IAAI,GAAE,EAAoC,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,EAAE,EAAE,IAAI,OAAO,EAAjb,CAAob,CAAC,EAAE,CAAC,SAAS,EAAE,IAAK,SAAU,GAAG,aAAa,SAAS,IAAI,GAAE,EAAG,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,OAAO,GAAE,EAAG,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,IAAI,GAAG,IAAI,IAAI,EAAE,EAAE,EAAE,kBAAkB,EAAE,uBAAuB,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,SAAS,eAAe,IAAI,EAAE,QAAQ,EAAE,CAAC,eAAc,IAAK,EAAE,WAAW,EAAE,KAAK,IAAI,EAAE,QAAQ,GAAG,EAAE,mBAAc,IAAS,EAAE,eAAe,EAAE,aAAa,GAAG,uBAAuB,EAAE,SAAS,cAAc,UAAU,WAAW,IAAI,EAAE,EAAE,SAAS,cAAc,UAAU,EAAE,mBAAmB,WAAW,IAAI,EAAE,mBAAmB,KAAK,EAAE,WAAW,YAAY,GAAG,EAAE,MAAM,EAAE,SAAS,gBAAgB,YAAY,IAAI,WAAW,WAAW,EAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,UAAU,EAAE,EAAE,WAAW,EAAE,MAAM,YAAY,IAAI,IAAI,EAAE,EAAE,GAAG,EAAE,QAAQ,IAAI,KAAK,UAAK,IAAoB,EAAO,EAAO,oBAAoB,KAAK,KAAK,oBAAoB,OAAO,OAAO,KAAK,IAAI,EAAE,CAAC,SAAS,EAAE,GAAK,aAAa,SAAS,KAAK,SAAS,EAAE,GAAG,GAAG,mBAAmB,EAAE,MAAM,IAAI,UAAU,+BAA+B,KAAK,MAAM,EAAE,KAAK,MAAM,GAAG,KAAK,aAAQ,EAAO,IAAI,GAAG,EAAE,KAAK,GAAG,SAAS,EAAE,EAAE,EAAE,GAAG,KAAK,QAAQ,EAAE,mBAAmB,IAAI,KAAK,YAAY,EAAE,KAAK,cAAc,KAAK,oBAAoB,mBAAmB,IAAI,KAAK,WAAW,EAAE,KAAK,aAAa,KAAK,mBAAmB,SAAS,EAAE,EAAE,EAAE,GAAG,GAAE,WAAW,IAAI,EAAE,IAAI,EAAE,EAAE,GAAG,MAAM,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,UAAU,uCAAuC,EAAE,QAAQ,EAAE,MAAK,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,IAAI,iBAAiB,GAAG,mBAAmB,IAAI,mBAAmB,EAAE,OAAO,WAAW,EAAE,MAAM,EAAE,YAAY,SAAS,EAAE,EAAE,GAAG,SAAS,EAAE,GAAG,IAAI,GAAE,EAAG,EAAE,OAAO,EAAE,IAAI,SAAS,EAAE,GAAG,IAAI,GAAE,EAAG,EAAE,QAAQ,EAAE,IAAI,SAAS,IAAI,EAAE,EAAE,GAAG,IAAI,GAAE,EAAG,EAAE,EAAE,GAAG,UAAU,EAAE,QAAQ,EAAE,EAAE,OAAO,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,UAAU,MAAM,GAAG,EAAE,OAAO,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,OAAO,aAAa,KAAK,EAAE,EAAE,QAAQ,IAAI,KAAK,GAAG,GAAG,SAAS,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,SAAS,EAAE,GAAG,SAAS,EAAE,EAAE,GAAG,SAAS,EAAE,GAAG,EAAE,GAAG,IAAI,IAAI,GAAG,IAAI,GAAE,EAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,KAAK,GAAE,SAAS,GAAG,IAAI,GAAE,EAAG,EAAE,OAAO,EAAE,OAAM,IAAI,EAAE,KAAK,GAAG,mBAAmB,OAAO,UAAU,SAAS,KAAK,GAAG,OAAO,KAAK,OAAO,IAAI,UAAU,qBAAqB,IAAI,EAAE,EAAE,OAAO,GAAE,EAAG,IAAI,EAAE,OAAO,KAAK,QAAQ,IAAI,IAAI,IAAI,EAAE,IAAI,MAAM,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,KAAK,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,GAAG,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,GAAG,MAAK,SAAS,GAAG,IAAI,GAAE,EAAG,EAAE,QAAQ,EAAE,OAAK,SAAS,GAAG,IAAI,GAAE,EAAG,EAAE,OAAO,EAAE,OAAM,IAAI,EAAE,KAAK,GAAG,mBAAmB,OAAO,UAAU,SAAS,KAAK,GAAG,OAAO,KAAK,OAAO,IAAI,UAAU,qBAAqB,IAAI,EAAE,EAAE,OAAO,GAAE,EAAG,IAAI,EAAE,OAAO,KAAK,QAAQ,IAAI,IAAI,IAAI,GAAG,EAAE,EAAE,IAAI,KAAK,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,YAAY,EAAE,CAAC,aAAa,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,UAAU,MAAM,SAAS,GAAG,OAAO,KAAK,KAAK,KAAK,IAAI,EAAE,UAAU,KAAK,SAAS,EAAE,GAAG,GAAG,mBAAmB,GAAG,KAAK,QAAQ,GAAG,mBAAmB,GAAG,KAAK,QAAQ,EAAE,OAAO,KAAK,IAAI,EAAE,IAAI,KAAK,YAAY,GAA8F,OAAxF,KAAK,QAAQ,EAAG,EAAE,EAAE,KAAK,QAAQ,EAAE,EAAE,EAAE,KAAK,SAAc,KAAK,MAAM,KAAK,IAAI,EAAE,EAAE,EAAE,IAAW,GAAG,EAAE,UAAU,cAAc,SAAS,GAAG,EAAE,QAAQ,KAAK,QAAQ,IAAI,EAAE,UAAU,mBAAmB,SAAS,GAAG,EAAE,KAAK,QAAQ,KAAK,YAAY,IAAI,EAAE,UAAU,aAAa,SAAS,GAAG,EAAE,OAAO,KAAK,QAAQ,IAAI,EAAE,UAAU,kBAAkB,SAAS,GAAG,EAAE,KAAK,QAAQ,KAAK,WAAW,IAAI,EAAE,QAAQ,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,GAAG,GAAG,UAAU,EAAE,OAAO,OAAO,EAAE,OAAO,EAAE,EAAE,OAAO,IAAI,EAAE,EAAE,MAAM,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,IAAI,GAAG,EAAE,EAAE,EAAE,MAAM,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,GAAG,EAAE,OAAO,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,IAAI,GAAG,EAAE,EAAE,EAAE,MAAM,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,OAAO,GAAG,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,SAAS,IAAO,SAAU,GAAG,aAAa,mBAAmB,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,KAAK,UAAK,IAAoB,EAAO,EAAO,oBAAoB,KAAK,KAAK,oBAAoB,OAAO,OAAO,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,SAAS,EAAE,GAAK,aAAa,SAAS,EAAE,EAAE,GAAG,KAAK,aAAa,GAAG,MAAM,IAAI,UAAU,qCAAqC,SAAS,IAAI,IAAI,GAAG,oBAAoB,UAAU,OAAO,UAAU,GAAG,oBAAoB,gBAAgB,OAAO,gBAAgB,GAAG,oBAAoB,aAAa,OAAO,aAAa,GAAG,oBAAoB,WAAW,OAAO,WAAW,GAAG,oBAAoB,YAAY,OAAO,YAAY,MAAM,GAAG,QAAQ,SAAS,IAAI,IAAI,IAAI,KAAK,GAAG,KAAK,OAAM,EAAG,IAAI,EAAE,oBAAoB,cAAc,4BAA4B,KAAK,UAAU,aAAa,SAAS,KAAK,UAAU,aAAa,aAAa,KAAK,UAAU,UAAU,EAAE,mBAAmB,QAAQ,IAAI,MAAM,WAAW,QAAQ,gBAAgB,QAAQ,GAAG,IAAI,oBAAoB,WAAW,oBAAoB,YAAY,MAAM,GAAG,OAAM,GAAI,SAAS,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,OAAO,IAAI,KAAK,EAAE,GAAG,MAAM,GAAG,GAAG,cAAc,EAAE,KAAK,MAAM,EAAE,IAAI,IAAsK,EAAE,IAAlK,oBAAoB,YAAY,YAAY,oBAAoB,cAAc,cAAc,oBAAoB,eAAe,eAAe,mBAA0B,EAAE,EAAE,EAAE,EAAE,OAAO,GAAG,EAAE,EAAE,OAAO,EAAE,IAAI,OAAO,EAAE,QAAQ,EAAE,OAAO,SAAS,EAAE,EAAE,GAAG,GAAG,EAAE,MAAK,SAAS,GAAG,EAAE,KAAK,MAAI,SAAS,GAAG,EAAE,MAAK,SAAS,EAAE,EAAE,EAAE,GAAG,mBAAmB,GAAG,EAAE,KAAK,GAAG,mBAAmB,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,MAAM,iBAAiB,IAAI,QAAQ,KAAK,EAAE,2CAA2C,EAAE,OAAO,IAAI,EAAE,SAAS,IAAI,GAAG,UAAU,QAAQ,mBAAmB,UAAU,UAAU,OAAO,GAAG,OAAO,UAAU,UAAU,OAAO,GAAG,SAAS,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,YAAY,GAAG,EAAE,IAAI,WAAW,GAAG,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,EAAE,SAAS,EAAE,GAAG,OAAO,IAAI,IAAG,SAAS,GAAG,IAAI,EAAE,EAAE,YAAY,GAAG,IAAI,EAAE,EAAE,CAAC,KAAK,EAAE,YAAY,IAAI,IAAI,EAAE,OAAO,EAAE,QAAQ,SAAS,GAAG,EAAE,iBAAiB,EAAE,kBAAkB,GAAE,IAAK,EAAE,WAAW,WAAW,IAAI,EAAE,UAAU,UAAU,MAAM,iBAAiB,EAAE,UAAU,UAAU,MAAM,UAAU,EAAE,IAAI,GAAG,SAAS,EAAE,GAAG,KAAK,QAAO,OAAM,WAAW,OAAM,KAAK,SAAS,EAAE,GAAG,MAAM,kBAAkB,GAAG,GAAG,QAAQ,IAAI,EAAE,GAAG,MAAK,SAAS,GAAG,OAAO,GAAG,KAAI,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,OAAO,KAAI,EAAE,mBAAmB,KAAK,GAAa,EAAE,QAAZ,EAAE,QAAkB,EAAE,QAAQ,MAAK,WAAW,OAAO,EAAE,WAAoB,EAAE,QAAQ,SAAS,EAAE,GAAG,IAAiB,EAAX,GAAG,EAAE,MAAU,mBAAmB,MAAM,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,SAAS,EAAE,EAAE,GAAG,IAAiB,EAAX,GAAG,EAAE,MAAU,mBAAmB,MAAM,GAAG,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,SAAS,EAAE,EAAE,GAAG,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,GAAG,GAAG,EAAE,MAAM,GAAG,EAAE,OAAO,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,QAAQ,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,KAAK,MAAM,GAAG,GAAG,IAAI,EAAE,gBAAgB,SAAS,GAAG,IAAI,EAAE,EAAE,OAAO,IAAI,EAAE,kBAAkB,EAAE,WAAW,EAAE,YAAY,GAAG,EAAE,kBAAkB,IAAI,MAAM,GAAG,GAAG,oBAAoB,EAAE,KAAK,MAAM,EAAE,QAAQ,KAAK,iBAAiB,EAAE,KAAK,oCAAoC,EAAE,WAAW,eAAe,EAAE,WAAW,sBAAsB,EAAE,UAAU,wBAAwB,EAAE,QAAQ,SAAS,GAAG,EAAE,iBAAiB,EAAE,EAAE,QAAQ,EAAE,UAAU,WAAW,EAAE,EAAE,QAAQ,EAAE,OAAM,SAAS,EAAE,GAAG,OAAO,EAAE,GAAE,GAAI,SAAS,EAAE,GAAG,OAAO,EAAE,GAAE,GAAI,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,OAAM,EAAG,IAAI,GAAG,EAAE,GAAG,iBAAiB,SAAS,EAAE,WAAoC,EAAE,EAAE,QAAQ,EAAE,GAAG,QAAQ,GAAhD,EAAE,QAAQ,EAAE,GAAG,UAAwC,EAAE,UAAU,GAAG,QAAQ,KAAK,iBAAiB,EAAE,KAAK,uCAAuC,EAAE,GAAG,QAAQ,eAAe,EAAE,QAAQ,KAAK,EAAE,QAAQ,EAAE,GAAG,SAAS,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,GAAG,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAM,EAAG,OAAM,EAAG,SAAS,EAAE,GAAG,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,IAAI,WAAW,EAAE,QAAQ,EAAE,EAAE,UAAU,SAAS,GAAG,IAAI,EAAE,KAAK,EAAE,OAAO,QAAQ,IAAI,EAAE,CAAC,6BAA4B,EAAG,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,mBAAmB,MAAK,SAAS,EAAE,GAAG,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,SAAS,EAAE,GAAG,OAAO,GAAG,EAAE,4BAA4B,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,aAAa,MAAK,WAAW,IAAI,EAAE,GAAG,EAAE,QAAQ,MAAM,GAAG,GAAG,EAAE,QAAQ,OAAO,EAAE,WAAU,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,IAAI,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,QAAQ,KAAK,EAAE,QAAQ,GAAG,QAAQ,EAAE,QAAQ,GAAG,MAAM,OAAO,EAAE,GAAG,KAAK,EAAE,GAAG,MAAK,SAAS,GAAG,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,KAAI,MAAK,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,EAAE,GAAG,QAAQ,GAAG,KAAI,OAAM,SAAS,GAAG,MAAM,EAAE,EAAE,GAAG,KAAI,SAAS,EAAE,EAAE,EAAE,EAAE,QAAG,IAAS,IAAI,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,GAAG,YAAY,EAAE,UAAU,GAAG,EAAE,KAAK,GAAG,MAAM,GAAG,GAAG,EAAE,KAAK,EAAE,IAAI,sBAAsB,EAAE,MAAM,kBAAkB,EAAE,MAAM,OAAO,GAAG,UAAU,MAAK,WAAW,IAAI,EAAE,IAAI,kBAAkB,EAAE,OAAO,EAAE,GAAG,iBAAiB,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,QAAQ,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ,GAAG,EAAE,MAAK,MAAK,WAAW,OAAO,EAAE,GAAG,MAAK,WAAW,EAAE,EAAE,EAAE,EAAE,EAAE,SAAO,MAAM,GAAG,EAAE,IAAI,SAAS,IAAI,MAAM,CAAC,QAAQ,GAAG,GAAG,KAAK,QAAQ,KAAK,mBAAmB,IAAI,SAAS,EAAE,GAAG,SAAS,IAAI,OAAO,GAAG,UAAU,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,GAAG,EAAE,IAAI,IAAI,KAAK,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,IAAI,EAAE,IAAI,GAAG,EAAE,MAAM,GAAG,EAAE,QAAQ,KAAK,GAAG,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,QAAQ,OAAO,IAAI,CAAC,IAAI,EAAE,EAAE,QAAQ,GAAG,IAAI,GAAG,EAAE,KAAK,EAAE,aAAa,MAAM,IAAI,IAAI,EAAE,EAAE,QAAQ,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAK,WAAW,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAK,MAAK,SAAS,GAAG,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,eAAe,SAAS,EAAE,GAAG,KAAI,MAAK,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,IAAI,IAAI,EAAE,QAAQ,GAAG,EAAE,GAAG,EAAE,QAAQ,QAAQ,EAAE,aAAY,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAyC,EAAnC,EAAE,YAAY,EAAE,QAAQ,WAAe,IAAI,GAAG,EAAE,UAAU,WAAW,IAAI,EAAE,EAAE,YAAO,IAAS,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,WAAW,EAAE,EAAE,QAAQ,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAyC,EAAnC,EAAE,YAAY,EAAE,QAAQ,WAAe,aAAa,EAAE,EAAE,EAAE,UAAU,WAAW,IAAI,EAAE,EAAE,OAAO,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,IAAI,UAAK,IAAS,EAAE,EAAE,GAAG,EAAE,gBAAgB,KAAK,EAAE,QAAQ,WAAW,EAAE,EAAE,QAAQ,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,QAAQ,MAAK,WAAW,OAAO,EAAE,EAAE,QAAQ,kBAAkB,GAAG,KAAK,GAAG,EAAE,EAAE,IAAI,MAAK,SAAS,GAAG,OAAO,EAAE,EAAE,EAAE,MAAK,KAAI,MAAK,SAAS,GAAG,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,YAAY,EAAE,QAAQ,WAAW,OAAO,IAAI,OAAE,GAAQ,IAAI,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,gBAAW,IAAS,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,WAAqD,EAApC,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAAY,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAyC,EAAnC,EAAE,YAAY,EAAE,QAAQ,WAAe,OAAO,GAAG,EAAE,WAAW,WAAW,KAAK,EAAE,QAAQ,WAAW,EAAE,EAAE,QAAQ,EAAE,QAAQ,WAAqD,EAApC,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAAY,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAyC,EAAnC,EAAE,YAAY,EAAE,QAAQ,WAAe,QAAQ,EAAE,WAAW,WAAW,KAAK,EAAE,QAAQ,EAAE,QAAQ,WAAqD,EAApC,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAAY,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAyC,EAAnC,EAAE,YAAY,EAAE,QAAQ,WAAe,QAAQ,EAAE,UAAU,WAAW,EAAE,EAAE,SAAS,EAAE,QAAQ,WAAW,EAAE,EAAE,QAAQ,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAM,EAAE,EAAc,EAAE,MAAM,EAAE,QAAQ,MAAK,WAAW,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,YAAY,EAAE,QAAQ,WAAW,GAAE,EAAG,EAAE,EAAE,gBAAgB,EAAE,UAAU,WAAW,IAAI,EAAE,EAAE,OAAW,EAAsB,IAAI,GAAW,EAAT,EAAE,EAAE,MAAiB,GAAE,EAAG,EAAE,QAAQ,IAAlD,EAAE,OAAqD,EAAE,QAAQ,WAAW,EAAE,EAAE,QAAQ,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,EAAE,EAAE,QAAQ,IAAG,SAAS,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,IAAyC,EAAnC,EAAE,YAAY,EAAE,QAAQ,WAAe,gBAAgB,EAAE,GAAG,EAAE,UAAU,WAAW,IAAI,EAAE,EAAE,OAAW,GAAmB,EAAE,KAAK,EAAE,KAAK,EAAE,YAArB,EAAE,IAA+B,EAAE,QAAQ,WAAW,EAAE,EAAE,QAAQ,MAAM,GAAG,EAAE,UAAQ,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,MAAM,KAAK,WAAW,IAAI,EAAE,KAAK,UAAS,EAAE,mBAAmB,GAAG,GAAG,IAAK,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,IAAI,EAAE,EAAE,KAAK,GAAG,EAAE,KAAK,CAAC,IAAoC,EAA9B,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAO,GAAG,QAAQ,EAAE,QAAQ,IAAI,EAAE,GAAG,MAAK,SAAS,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,EAAE,GAAG,QAAQ,GAAG,EAAE,OAAO,KAAI,EAAc,EAAE,KAAd,EAAE,UAAiB,SAAS,GAAG,GAAG,EAAE,iBAAiB,SAAS,EAAE,WAAW,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,QAAQ,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,QAAQ,GAAG,KAAK,EAAE,QAAQ,QAAQ,EAAE,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,EAAE,KAAK,GAAG,EAAE,QAAQ,SAAS,GAAG,EAAE,OAAO,QAAQ,EAAE,IAAI,EAAE,gBAAgB,WAAW,EAAE,OAAO,kBAAkB,EAAE,YAAY,EAAE,UAAU,WAAW,IAAI,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAM,MAAK,SAAS,GAAG,EAAE,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,QAAQ,GAAG,EAAE,EAAE,EAAE,aAAY,OAAM,SAAS,GAAG,MAAM,EAAE,EAAE,IAAI,GAAG,WAAW,OAAM,eAAc,OAAc,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,QAAQ,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,IAAK,EAAE,GAAG,QAAQ,GAAG,KAAK,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,eAAe,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,SAAS,GAAG,IAAI,EAAE,EAAE,OAAO,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,WAAW,IAAI,EAAE,EAAE,OAAO,GAAG,EAAE,QAAQ,EAAE,OAAM,MAAK,SAAS,GAAG,EAAE,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,IAAI,EAAE,EAAE,GAAG,YAAW,OAAM,SAAS,GAAG,MAAM,EAAE,EAAE,IAAI,GAAG,WAAW,OAAM,eAAc,YAAW,EAAE,GAAG,OAAO,qBAAqB,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,IAAI,MAAM,mBAAmB,aAAa,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,EAAE,OAAO,KAAK,IAAI,MAAM,EAAE,EAAE,OAAO,IAAI,KAAK,IAAI,EAAE,IAAI,YAAY,GAAG,EAAE,IAAI,WAAW,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,GAAG,QAAQ,EAAE,IAAI,EAAE,GAAG,QAAQ,EAAE,EAAE,IAAI,EAAE,GAAG,QAAQ,EAAE,EAAE,IAAI,EAAE,GAAG,QAAQ,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,IAAI,WAAW,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,OAAO,GAAG,EAAE,GAAG,GAAG,EAAE,IAAI,GAAG,GAAG,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,GAAG,GAAG,EAAE,EAAE,IAAI,OAAO,EAAE,OAAO,GAAG,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,OAAO,GAAG,IAAI,EAAE,OAAO,GAAG,IAAI,EAAE,EAAE,UAAU,EAAE,EAAE,OAAO,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,GAAG,IAAI,EAAE,GAAG,KAAK,IAAI,IAAI,yBAAyB,GAAG,EAAE,QAAQ,yBAAyB,GAAG,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EAAE,GAAG,aAAa,aAAa,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,OAAO,uBAAuB,EAAE,GAAG,GAAG,wBAAwB,EAAE,GAAG,GAAG,+BAA+B,EAAE,GAAG,GAAG,wBAAwB,EAAE,GAAG,GAAG,yBAAyB,EAAE,GAAG,GAAG,wBAAwB,EAAE,GAAG,GAAG,yBAAyB,EAAE,GAAG,GAAG,0BAA0B,EAAE,GAAG,GAAG,0BAA0B,EAAE,GAAG,GAAG,EAAE,IAAI,MAAM,wCAAwC,EAAE,EAAE,EAAE,SAAS,GAAG,kBAAkB,EAAE,CAAC,IAAI,EAAE,IAAI,WAAW,EAAE,OAAO,WAAW,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,GAAG,GAAG,IAAI,EAAE,kBAAkB,QAAQ,IAAI,EAAE,KAAK,UAAU,IAAI,MAAM,GAAG,QAAQ,MAAM,8CAA8C,GAAG,EAAE,KAAK,IAAI,SAAS,EAAE,GAAG,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,KAAK,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,UAAU,IAAI,EAAE,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,IAAI,GAAG,KAAK,GAAG,CAAC,IAAI,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG,QAAQ,IAAI,EAAE,EAAE,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,KAAK,GAAG,OAAO,IAAI,UAAU,GAAG,KAAK,GAAG,OAAO,IAAI,WAAW,GAAG,KAAK,GAAG,OAAO,IAAI,kBAAkB,GAAG,KAAK,GAAG,OAAO,IAAI,WAAW,GAAG,KAAK,GAAG,OAAO,IAAI,YAAY,GAAG,KAAK,GAAG,OAAO,IAAI,WAAW,GAAG,KAAK,GAAG,OAAO,IAAI,YAAY,GAAG,KAAK,GAAG,OAAO,IAAI,aAAa,GAAG,KAAK,GAAG,OAAO,IAAI,aAAa,GAAG,QAAQ,MAAM,IAAI,MAAM,gBAAgB,IAAI,SAAS,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,WAAW,8BAA8B,EAAE,UAAU,+CAA+C,GAAG,EAAE,GAAG,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,GAAG,EAAE,IAAI,IAAI,KAAK,EAAE,EAAE,GAAG,iBAAiB,EAAE,GAAG,EAAE,GAAG,WAAW,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,aAAa,EAAE,KAAK,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,MAAM,GAAG,OAAO,EAAE,GAAG,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,GAAE,WAAW,EAAE,QAAQ,EAAE,OAAK,SAAS,EAAE,GAAG,EAAE,QAAM,MAAK,OAAO,EAAE,WAAW,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,EAAE,GAAE,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,iEAAiE,CAAC,EAAE,YAAW,SAAS,EAAE,GAAG,EAAE,KAAK,OAAO,EAAE,EAAE,GAAG,EAAE,EAAE,GAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,KAAI,KAAI,GAAG,EAAE,EAAE,KAAI,GAAG,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,iBAAiB,EAAE,UAAU,yBAAyB,CAAC,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,GAAG,MAAM,KAAK,IAAI,EAAE,EAAE,WAAW,YAAY,IAAI,EAAE,MAAI,SAAS,EAAE,GAAG,EAAE,YAAS,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,iBAAiB,EAAE,UAAU,IAAG,SAAS,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,KAAK,GAAG,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,WAAW,YAAY,SAAI,KAAU,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,YAAY,EAAE,GAAG,OAAK,SAAS,EAAE,GAAG,EAAE,YAAS,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,gBAAW,IAAS,IAAI,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,WAAW,UAAU,GAAE,SAAS,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,0BAA0B,EAAE,UAAU,8BAA8B,CAAC,EAAE,IAAG,WAAW,EAAE,MAAI,SAAS,EAAE,GAAG,EAAE,SAAM,SAAS,GAAG,GAAG,EAAE,OAAO,EAAE,UAAU,CAAC,GAAG,EAAE,EAAE,YAAY,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,aAAU,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,KAAK,CAAC,EAAE,EAAE,EAAE,IAAI,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,eAAe,EAAE,UAAU,iBAAiB,CAAC,IAAG,WAAW,OAAK,SAAS,EAAE,GAAG,EAAE,YAAS,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,eAAe,EAAE,UAAU,IAAG,WAAW,OAAK,SAAS,EAAE,GAAG,EAAE,YAAS,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,+BAA+B,EAAE,UAAU,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,KAAK,KAAK,GAAG,EAAE,EAAE,MAAI,SAAS,EAAE,GAAG,EAAE,YAAS,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,mBAAmB,EAAE,UAAU,wBAAwB,CAAC,EAAE,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,GAAG,IAAI,KAAK,EAAE,MAAI,SAAS,EAAE,GAAG,EAAE,YAAS,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAG,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,aAAY,SAAS,GAAG,EAAE,EAAE,EAAE,mBAAmB,EAAE,UAAU,IAAG,SAAS,EAAE,GAAG,IAAI,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,KAAK,OAAO,IAAI,EAAE,KAAK,EAAE,KAAK,KAAK,GAAG,KAAK,EAAE,MAAI,SAAS,EAAE,GAAG,EAAE,YAAS,MAAM,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,GAAG,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,aAAY,SAAS,GAAG,EAAE,WAAW,8FAA8F,IAAG,SAAS,EAAE,GAAG,IAAI,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,KAAK,OAAO,IAAI,EAAE,KAAK,EAAE,KAAK,KAAK,GAAG,MAAM,EAAE,CAAC,GAAG,EAAE,WAAW,OAAK,SAAS,EAAE,GAAG,EAAE,SAAM,SAAS,GAAG,EAAE,SAAO,SAAS,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,KAAK,WAAW,IAAI,EAAE,KAAK,UAAS,EAAE,mBAAmB,GAAG,GAAG,IAAK,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,IAAI,EAAE,EAAE,KAAK,OAA2hB,EAAphB,EAAE,EAAE,KAAK,IAAI,IAAG,SAAS,GAAG,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,GAAG,aAAa,EAAE,KAAK,GAAG,GAAG,GAAG,EAAE,EAAE,UAAU,CAAC,GAAG,EAAE,WAAW,CAAC,EAAE,YAAY,GAAG,OAAM,MAAK,SAAS,GAAG,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,GAAG,aAAY,SAAS,GAAG,SAAS,EAAE,GAAG,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,EAAE,WAAW,wBAAwB,EAAE,IAAG,WAAW,OAAK,SAAS,EAAE,GAAG,EAAE,SAAO,IAAI,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,WAAW,OAAO,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,WAAW,KAAK,GAAG,IAAI,GAAG,MAAK,WAAW,OAAM,OAAM,SAAS,GAAG,EAAE,SAAM,SAAS,GAAG,EAAE,YAAS,GAAG,OAAO,qBAAyB,GAAG,EAAE,SAAS,KAAK,IAAI,MAAM,oBAAoB,cAAc,YAAY,gBAAgB,aAAa,QAAQ,MAAM,GAAG,OAAM,GAAI,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,KAAK,IAAI,OAAO,EAAE,YAAY,EAAE,YAAY,GAAG,EAAE,UAAU,KAAK,EAAE,SAAS,KAAK,IAAI,EAAE,4BAA4B,IAAI,OAAO,aAAa,QAAQ,GAAE,GAAI,aAAa,WAAW,IAAG,EAAG,MAAM,GAAG,OAAM,GAAI,SAAS,KAAK,OAAO,MAAM,aAAa,OAAO,EAAE,SAAS,GAAG,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,GAAG,EAAE,IAAI,IAAI,KAAK,EAAE,EAAE,GAAG,EAAE,GAAG,OAAO,EAAE,UAAU,GAAG,EAAE,EAAE,gBAAgB,MAAM,EAAE,QAAQ,EAAE,EAAE,WAAW,GAAG,GAAG,WAAW,GAAG,SAAS,SAAS,GAAG,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,QAAQ,MAAK,WAAW,IAAI,IAAI,EAAE,EAAE,QAAQ,UAAU,EAAE,aAAa,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,aAAa,IAAI,GAAG,IAAI,EAAE,QAAQ,IAAI,aAAa,WAAW,OAAM,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,QAAQ,EAAE,aAAa,QAAQ,EAAE,UAAU,GAAG,OAAO,IAAI,EAAE,EAAE,WAAW,YAAY,IAAI,KAAI,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,QAAQ,MAAK,WAAW,IAAI,IAAI,EAAE,EAAE,QAAQ,EAAE,EAAE,UAAU,EAAE,EAAE,OAAO,EAAE,aAAa,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,aAAa,IAAI,GAAG,GAAG,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,aAAa,QAAQ,GAAG,GAAG,IAAI,EAAE,EAAE,WAAW,YAAY,SAAI,KAAU,EAAE,EAAE,EAAE,EAAE,UAAU,GAAG,MAAM,OAAO,OAAM,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,QAAQ,MAAK,WAAW,IAAI,EAAE,EAAE,EAAE,QAAQ,IAAI,EAAE,aAAa,IAAI,GAAG,MAAM,GAAG,EAAE,KAAK,OAAO,IAAI,EAAE,EAAE,UAAU,EAAE,UAAU,SAAS,KAAI,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,QAAQ,MAAK,WAAW,IAAI,IAAI,EAAE,EAAE,QAAQ,EAAE,aAAa,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,aAAa,IAAI,GAAG,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,SAAS,OAAO,KAAI,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,GAAG,IAAW,EAAL,KAAS,OAAO,MAAK,SAAS,GAAG,OAAO,EAAE,UAAS,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,QAAQ,MAAK,WAA2B,aAAa,WAAvB,EAAE,QAAkC,UAAU,MAAK,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,QAAQ,MAAK,gBAAW,IAAS,IAAI,EAAE,MAAM,IAAI,EAAE,EAAE,OAAO,IAAI,IAAG,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,QAAQ,EAAE,WAAW,UAAU,GAAE,SAAS,EAAE,GAAG,GAAG,EAAE,EAAE,QAAQ,IAAI,aAAa,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,MAAM,GAAG,uBAAuB,EAAE,MAAM,+BAA+B,EAAE,MAAM,EAAE,GAAG,EAAE,aAAU,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,MAAM,KAAK,aAAW,EAAE,mBAAmB,GAAG,GAAG,IAAM,KAAK,CAAC,IAAI,EAAE,KAAK,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,IAAI,EAAE,EAAE,KAAK,OAA0P,EAAnP,EAAE,EAAE,KAAK,IAAI,IAAG,SAAS,GAAG,EAAE,EAAE,UAAU,GAAG,EAAE,EAAE,gBAAgB,EAAE,KAAK,QAAO,MAAK,SAAS,GAAG,IAAI,IAAI,EAAE,aAAa,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,aAAa,IAAI,GAAG,IAAI,EAAE,QAAQ,IAAI,aAAa,WAAW,OAAM,GAAG,OAAO,qBAAyB,GAAG,EAAE,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,WAAW,IAAI,EAAE,UAAU,OAAO,EAAE,QAAQ,MAAK,WAAW,OAAO,EAAE,GAAG,MAAM,EAAE,OAAM,SAAS,KAAK,IAAI,IAAI,EAAE,EAAE,EAAE,UAAU,OAAO,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,GAAG,EAAE,IAAI,IAAI,KAAK,EAAE,EAAE,eAAe,KAAc,UAAU,GAAG,GAAtB,GAAG,EAAE,IAAoB,EAAE,GAAG,QAAwB,EAAE,IAAI,OAAO,UAAU,GAAG,IAAI,GAAG,mBAAmB,QAAQ,iBAAiB,OAAO,SAAS,SAAS,GAAG,cAAc,GAAG,SAAS,GAAG,OAAO,GAAG,mBAAmB,QAAQ,EAAE,cAAc,QAAQ,IAAI,OAAO,UAAU,gBAAgB,GAAG,GAAG,IAAI,oBAAoB,SAAS,EAAE,GAAG,IAAI,GAAG,QAAQ,GAAG,mCAAmC,QAAG,EAAO,GAAG,GAAG,GAAG,OAAO,UAAU,SAAS,GAAG,WAAW,GAAG,YAAY,GAAG,CAAC,QAAQ,eAAe,aAAa,EAAE,SAAS,IAAI,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,GAAG,GAAG,mEAAmE,GAAG,uBAAuB,GAAG,gCAAgC,GAAG,YAAY,GAAG,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,GAAG,GAAG,OAAO,GAAG,OAAO,UAAU,SAAS,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe,GAAG,GAAG,CAAC,QAAQ,gBAAgB,aAAa,EAAE,SAAS,IAAI,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAG,aAAa,IAAI,GAAG,CAAC,QAAQ,sBAAsB,aAAa,GAAG,SAAS,KAAK,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,KAAK,GAAG,aAAa,IAAI,GAAG,SAAS,EAAE,GAAG,OAAO,IAAI,GAAG,iBAAiB,GAAG,iBAAiB,GAAG,MAAM,IAAI,MAAM,IAAI,GAAG,SAAS,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,GAAG,OAAM,EAAG,IAAI,OAAM,GAAI,GAAG,MAAM,SAAS,SAAS,GAAG,MAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,UAAU,GAAG,OAAO,GAAG,aAAa,IAAI,GAAG,CAAC,GAAG,UAAU,QAAQ,GAAG,OAAO,QAAQ,GAAG,aAAa,SAAS,GAAG,CAAC,gBAAgB,GAAG,CAAC,QAAQ,UAAU,UAAU,MAAM,OAAO,SAAS,aAAa,WAAW,OAAO,IAAI,GAAG,CAAC,YAAY,GAAG,OAAO,GAAG,QAAQ,KAAK,cAAc,KAAK,QAAQ,UAAU,gBAAgB,QAAQ,GAAg3G,GAAG,IAA72G,WAAW,SAAS,EAAE,GAAa,IAAI,IAAI,KAAlB,EAAE,KAAK,GAAgB,GAAG,GAAG,GAAG,eAAe,GAAG,CAAC,IAAI,EAAE,GAAG,GAAG,EAAE,EAAE,QAAQ,KAAK,GAAG,EAAE,GAAG,IAAI,KAAK,aAAa,GAAG,KAAK,eAAe,GAAG,GAAG,IAAI,KAAK,QAAQ,GAAG,GAAG,KAAK,eAAe,GAAG,KAAK,WAAW,KAAK,KAAK,YAAY,KAAK,KAAK,QAAO,EAAG,KAAK,QAAQ,KAAK,KAAK,+BAA+B,KAAK,UAAU,KAAK,QAAQ,QAAQ,OAAM,eAAc,OAAO,EAAE,UAAU,OAAO,SAAS,GAAG,GAAG,iBAAY,IAAS,EAAE,YAAY,GAAG,IAAI,CAAC,GAAG,KAAK,OAAO,OAAO,IAAI,MAAM,wDAAwD,IAAI,IAAI,KAAK,EAAE,CAAC,GAAG,cAAc,IAAI,EAAE,GAAG,EAAE,GAAG,QAAQ,MAAM,MAAM,YAAY,GAAG,iBAAiB,EAAE,GAAG,OAAO,IAAI,MAAM,sCAAsC,KAAK,QAAQ,GAAG,EAAE,GAAG,QAAQ,WAAW,GAAG,EAAE,SAAS,KAAK,UAAU,KAAK,QAAQ,QAAQ,MAAM,iBAAiB,EAAE,KAAK,QAAQ,GAAG,KAAK,SAAS,EAAE,UAAU,aAAa,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,IAAG,SAAS,EAAE,GAAG,IAAI,IAAI,EAAE,EAAE,QAAQ,EAAE,IAAI,MAAM,wFAAwF,IAAI,EAAE,QAAQ,YAAY,EAAE,GAAG,IAAI,IAAI,EAAE,GAAG,OAAO,gBAAgB,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI,EAAE,KAAK,mBAAmB,EAAE,GAAG,YAAY,EAAE,IAAG,WAAY,IAAI,IAAI,EAAE,SAAS,GAAG,OAAO,WAAW,IAAI,EAAE,IAAI,MAAM,UAAU,EAAE,6CAA6C,EAAE,GAAG,OAAO,GAAG,OAAO,EAAE,EAAE,UAAU,UAAU,OAAO,IAAI,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAA7O,GAAsP,IAAI,EAAE,SAAS,GAAG,GAAG,IAAI,QAAQ,KAAK,kCAAkC,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,KAAK,aAAa,EAAE,EAAE,UAAU,mBAAmB,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,GAAG,IAAI,EAAE,UAAU,GAAE,GAAI,MAAM,GAAG,EAAE,OAAM,OAAO,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,UAAU,OAAO,WAAW,OAAO,KAAK,SAAS,MAAM,EAAE,UAAU,UAAU,SAAS,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,GAAG,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,IAAI,MAAM,sBAAsB,OAAO,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,UAAU,cAAc,SAAS,GAAG,IAAI,EAAE,GAAG,QAAQ,IAAI,OAAO,EAAE,EAAE,GAAG,GAAG,EAAE,UAAU,MAAM,SAAS,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,WAAW,MAAK,WAAW,OAAO,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,UAAS,OAAO,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,UAAU,UAAU,SAAS,EAAE,EAAE,GAAG,SAAS,IAAI,EAAE,QAAQ,OAAO,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,EAAE,QAAQ,GAAG,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,OAAO,SAAS,EAAE,GAAG,OAAO,WAAW,SAAS,IAAI,KAAK,EAAE,EAAE,QAAQ,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,IAAI,EAAE,QAAQ,KAAK,EAAE,OAAO,KAAK,EAAE,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI,IAAI,EAAE,IAAI,MAAM,sCAAsC,OAAO,EAAE,WAAW,GAAG,OAAO,GAAG,EAAE,WAAW,IAAI,EAAE,EAAE,OAAO,KAAK,IAAI,EAAE,KAAK,GAAG,KAAK,EAAE,CAAC,IAAI,IAAI,EAAE,KAAK,qBAAqB,GAAG,EAAE,OAAO,KAAK,WAAW,KAAK,WAAW,OAAM,WAAW,OAAO,GAAG,aAAY,GAAG,UAAU,OAAO,KAAK,WAAW,EAAE,MAAK,WAAW,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,QAAQ,KAAK,EAAE,OAAO,KAAK,EAAE,UAAU,GAAG,MAAK,SAAS,GAAG,EAAE,QAAQ,EAAE,QAAQ,IAAI,EAAE,+BAA+B,EAAE,YAAY,EAAE,SAAO,OAAM,WAAW,IAAI,IAAI,EAAE,IAAI,MAAM,sCAAsC,OAAO,EAAE,WAAW,GAAG,OAAO,GAAG,EAAE,cAAa,EAAE,KAAK,WAAW,EAAE,GAAG,KAAK,YAAY,EAAE,UAAU,SAAS,SAAS,GAAG,QAAQ,GAAG,IAAI,EAAE,UAAU,QAAQ,SAAS,GAAG,GAAG,KAAK,IAAI,EAAE,UAAU,qBAAqB,SAAS,GAAG,IAAI,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,KAAK,SAAS,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,EAAE,UAAU,6BAA6B,WAAW,IAAI,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,IAAI,GAAG,KAAK,GAAG,KAAK,EAAE,UAAU,eAAe,SAAS,GAAG,OAAO,IAAI,EAAE,IAAI,EAAr2G,IAAo3G,EAAE,QAAQ,IAAI,CAAC,EAAE,KAAK,GAAG,CAAC,GAAh44B,CAAo44B,iDCNhr5B,wBAAU,GACP,aA6BA,SAAS,EAAe,UACb,EAAc,GAyBzB,SAAS,EAAa,GAGlB,GAAI,EAGA,WAAW,EAAc,EAAG,OACzB,CACH,IAAI,EAAO,EAAc,GACzB,GAAI,EAAM,CACN,GAAwB,EACxB,KAjCZ,SAAa,GACT,IAAI,EAAW,EAAK,SAChB,EAAO,EAAK,KAChB,OAAQ,EAAK,QACb,KAAK,EACD,IACA,MACJ,KAAK,EACD,EAAS,EAAK,IACd,MACJ,KAAK,EACD,EAAS,EAAK,GAAI,EAAK,IACvB,MACJ,KAAK,EACD,EAAS,EAAK,GAAI,EAAK,GAAI,EAAK,IAChC,MACJ,QACI,EAAS,WAnDpB,EAmDqC,IAiBlB,CAAI,GADR,QAGI,EAAe,GACf,GAAwB,KApExC,IAAI,EAAO,aAAX,CAIA,IAII,EA6HI,EAZA,EArBA,EACA,EAjGJ,EAAa,EACb,EAAgB,GAChB,GAAwB,EACxB,EAAM,EAAO,SAoJb,EAAW,OAAO,gBAAkB,OAAO,eAAe,GAC9D,EAAW,GAAY,EAAS,WAAa,EAAW,EAGf,qBAArC,GAAG,SAAS,KAAK,EAAO,SApFxB,EAAoB,SAAS,GACzB,EAAQ,UAAS,WAAc,EAAa,QAIpD,WAGI,GAAI,EAAO,cAAgB,EAAO,cAAe,CAC7C,IAAI,GAA4B,EAC5B,EAAe,EAAO,UAM1B,OALA,EAAO,UAAY,WACf,GAA4B,GAEhC,EAAO,YAAY,GAAI,KACvB,EAAO,UAAY,EACZ,GAwEJ,GAIA,EAAO,iBA9CV,EAAU,IAAI,gBACV,MAAM,UAAY,SAAS,GAE/B,EADa,EAAM,OAIvB,EAAoB,SAAS,GACzB,EAAQ,MAAM,YAAY,KA2CvB,GAAO,uBAAwB,EAAI,cAAc,WAtCpD,EAAO,EAAI,gBACf,EAAoB,SAAS,GAGzB,IAAI,EAAS,EAAI,cAAc,UAC/B,EAAO,mBAAqB,WACxB,EAAa,GACb,EAAO,mBAAqB,KAC5B,EAAK,YAAY,GACjB,EAAS,MAEb,EAAK,YAAY,KAKrB,EAAoB,SAAS,GACzB,WAAW,EAAc,EAAG,KAlD5B,EAAgB,gBAAkB,KAAK,SAAW,IAClD,EAAkB,SAAS,GACvB,EAAM,SAAW,GACK,iBAAf,EAAM,MACyB,IAAtC,EAAM,KAAK,QAAQ,IACnB,GAAc,EAAM,KAAK,MAAM,EAAc,UAIjD,EAAO,iBACP,EAAO,iBAAiB,UAAW,GAAiB,GAEpD,EAAO,YAAY,YAAa,GAGpC,EAAoB,SAAS,GACzB,EAAO,YAAY,EAAgB,EAAQ,OAgEnD,EAAS,aA1KT,SAAsB,GAEI,mBAAb,IACT,EAAW,IAAI,SAAS,GAAK,IAI/B,IADA,IAAI,EAAO,IAAI,MAAM,UAAU,OAAS,GAC/B,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC7B,EAAK,GAAK,UAAU,EAAI,GAG5B,IAAI,EAAO,CAAE,SAAU,EAAU,KAAM,GAGvC,OAFA,EAAc,GAAc,EAC5B,EAAkB,GACX,KA6JT,EAAS,eAAiB,GAxL7B,CAyLiB,oBAAT,UAAyC,IAAX,EAAyB,KAAO,EAAS,qECvLhF,IACI,KAAK,6BAA+B,IAExC,MAAO,4BCLP,YAoBA,SAAS,EAAQ,EAAI,GACnB,KAAK,IAAM,EACX,KAAK,SAAW,EAtBlB,IAAI,OAA2B,IAAX,GAA0B,GACjB,oBAAT,MAAwB,MAChC,OACR,EAAQ,SAAS,UAAU,MAI/B,EAAQ,WAAa,WACnB,OAAO,IAAI,EAAQ,EAAM,KAAK,WAAY,EAAO,WAAY,eAE/D,EAAQ,YAAc,WACpB,OAAO,IAAI,EAAQ,EAAM,KAAK,YAAa,EAAO,WAAY,gBAEhE,EAAQ,aACR,EAAQ,cAAgB,SAAS,GAC3B,GACF,EAAQ,SAQZ,EAAQ,UAAU,MAAQ,EAAQ,UAAU,IAAM,aAClD,EAAQ,UAAU,MAAQ,WACxB,KAAK,SAAS,KAAK,EAAO,KAAK,MAIjC,EAAQ,OAAS,SAAS,EAAM,GAC9B,aAAa,EAAK,gBAClB,EAAK,aAAe,GAGtB,EAAQ,SAAW,SAAS,GAC1B,aAAa,EAAK,gBAClB,EAAK,cAAgB,GAGvB,EAAQ,aAAe,EAAQ,OAAS,SAAS,GAC/C,aAAa,EAAK,gBAElB,IAAI,EAAQ,EAAK,aACb,GAAS,IACX,EAAK,eAAiB,YAAW,WAC3B,EAAK,YACP,EAAK,eACN,KAKP,EAAQ,QAIR,EAAQ,aAAgC,oBAAT,MAAwB,KAAK,mBAClB,IAAX,GAA0B,EAAO,cACxC,MAAQ,KAAK,aACrC,EAAQ,eAAkC,oBAAT,MAAwB,KAAK,qBAClB,IAAX,GAA0B,EAAO,gBACxC,MAAQ,KAAK,wDC9DvC,IAAI,EAGJ,EAAK,WACJ,OAAO,KADH,GAIL,IAEC,EAAI,GAAK,IAAI,SAAS,cAAb,GACR,MAAO,GAEc,iBAAX,SAAqB,EAAI,QAOrC,EAAO,QAAU,gCCjBjB,IACI,KAAK,kCAAoC,IAE7C,MAAO,mCCHP,IACI,KAAK,uBAAyB,IAElC,MAAO","file":"sw-esm.js","sourceRoot":"","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"9/Ks\");\n","\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:cacheable-response:6.1.5'] && _();\n}\ncatch (e) { }\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { Route } from './Route.js';\nimport { RegExpRoute } from './RegExpRoute.js';\nimport { getOrCreateDefaultRouter } from './utils/getOrCreateDefaultRouter.js';\nimport './_version.js';\n/**\n * Easily register a RegExp, string, or function with a caching\n * strategy to a singleton Router instance.\n *\n * This method will generate a Route for you if needed and\n * call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.\n *\n * @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture\n * If the capture param is a `Route`, all other arguments will be ignored.\n * @param {module:workbox-routing~handlerCallback} [handler] A callback\n * function that returns a Promise resulting in a Response. This parameter\n * is required if `capture` is not a `Route` object.\n * @param {string} [method='GET'] The HTTP method to match the Route\n * against.\n * @return {module:workbox-routing.Route} The generated `Route`(Useful for\n * unregistering).\n *\n * @memberof module:workbox-routing\n */\nfunction registerRoute(capture, handler, method) {\n    let route;\n    if (typeof capture === 'string') {\n        const captureUrl = new URL(capture, location.href);\n        if (process.env.NODE_ENV !== 'production') {\n            if (!(capture.startsWith('/') || capture.startsWith('http'))) {\n                throw new WorkboxError('invalid-string', {\n                    moduleName: 'workbox-routing',\n                    funcName: 'registerRoute',\n                    paramName: 'capture',\n                });\n            }\n            // We want to check if Express-style wildcards are in the pathname only.\n            // TODO: Remove this log message in v4.\n            const valueToCheck = capture.startsWith('http') ?\n                captureUrl.pathname : capture;\n            // See https://github.com/pillarjs/path-to-regexp#parameters\n            const wildcards = '[*:?+]';\n            if ((new RegExp(`${wildcards}`)).exec(valueToCheck)) {\n                logger.debug(`The '$capture' parameter contains an Express-style wildcard ` +\n                    `character (${wildcards}). Strings are now always interpreted as ` +\n                    `exact matches; use a RegExp for partial or wildcard matches.`);\n            }\n        }\n        const matchCallback = ({ url }) => {\n            if (process.env.NODE_ENV !== 'production') {\n                if ((url.pathname === captureUrl.pathname) &&\n                    (url.origin !== captureUrl.origin)) {\n                    logger.debug(`${capture} only partially matches the cross-origin URL ` +\n                        `${url}. This route will only handle cross-origin requests ` +\n                        `if they match the entire URL.`);\n                }\n            }\n            return url.href === captureUrl.href;\n        };\n        // If `capture` is a string then `handler` and `method` must be present.\n        route = new Route(matchCallback, handler, method);\n    }\n    else if (capture instanceof RegExp) {\n        // If `capture` is a `RegExp` then `handler` and `method` must be present.\n        route = new RegExpRoute(capture, handler, method);\n    }\n    else if (typeof capture === 'function') {\n        // If `capture` is a function then `handler` and `method` must be present.\n        route = new Route(capture, handler, method);\n    }\n    else if (capture instanceof Route) {\n        route = capture;\n    }\n    else {\n        throw new WorkboxError('unsupported-route-type', {\n            moduleName: 'workbox-routing',\n            funcName: 'registerRoute',\n            paramName: 'capture',\n        });\n    }\n    const defaultRouter = getOrCreateDefaultRouter();\n    defaultRouter.registerRoute(route);\n    return route;\n}\nexport { registerRoute };\n","/*\n  Copyright 2020 Google LLC\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * A utility method that makes it easier to use `event.waitUntil` with\n * async functions and return the result.\n *\n * @param {ExtendableEvent} event\n * @param {Function} asyncFn\n * @return {Function}\n * @private\n */\nfunction waitUntil(event, asyncFn) {\n    const returnPromise = asyncFn();\n    event.waitUntil(returnPromise);\n    return returnPromise;\n}\nexport { waitUntil };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport '../_version.js';\n// Name of the search parameter used to store revision info.\nconst REVISION_SEARCH_PARAM = '__WB_REVISION__';\n/**\n * Converts a manifest entry into a versioned URL suitable for precaching.\n *\n * @param {Object|string} entry\n * @return {string} A URL with versioning info.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function createCacheKey(entry) {\n    if (!entry) {\n        throw new WorkboxError('add-to-cache-list-unexpected-type', { entry });\n    }\n    // If a precache manifest entry is a string, it's assumed to be a versioned\n    // URL, like '/app.abcd1234.js'. Return as-is.\n    if (typeof entry === 'string') {\n        const urlObject = new URL(entry, location.href);\n        return {\n            cacheKey: urlObject.href,\n            url: urlObject.href,\n        };\n    }\n    const { revision, url } = entry;\n    if (!url) {\n        throw new WorkboxError('add-to-cache-list-unexpected-type', { entry });\n    }\n    // If there's just a URL and no revision, then it's also assumed to be a\n    // versioned URL.\n    if (!revision) {\n        const urlObject = new URL(url, location.href);\n        return {\n            cacheKey: urlObject.href,\n            url: urlObject.href,\n        };\n    }\n    // Otherwise, construct a properly versioned URL using the custom Workbox\n    // search parameter along with the revision info.\n    const cacheKeyURL = new URL(url, location.href);\n    const originalURL = new URL(url, location.href);\n    cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);\n    return {\n        cacheKey: cacheKeyURL.href,\n        url: originalURL.href,\n    };\n}\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { canConstructResponseFromBodyStream } from './_private/canConstructResponseFromBodyStream.js';\nimport { WorkboxError } from './_private/WorkboxError.js';\nimport './_version.js';\n/**\n * Allows developers to copy a response and modify its `headers`, `status`,\n * or `statusText` values (the values settable via a\n * [`ResponseInit`]{@link https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax}\n * object in the constructor).\n * To modify these values, pass a function as the second argument. That\n * function will be invoked with a single object with the response properties\n * `{headers, status, statusText}`. The return value of this function will\n * be used as the `ResponseInit` for the new `Response`. To change the values\n * either modify the passed parameter(s) and return it, or return a totally\n * new object.\n *\n * This method is intentionally limited to same-origin responses, regardless of\n * whether CORS was used or not.\n *\n * @param {Response} response\n * @param {Function} modifier\n * @memberof module:workbox-core\n */\nasync function copyResponse(response, modifier) {\n    let origin = null;\n    // If response.url isn't set, assume it's cross-origin and keep origin null.\n    if (response.url) {\n        const responseURL = new URL(response.url);\n        origin = responseURL.origin;\n    }\n    if (origin !== self.location.origin) {\n        throw new WorkboxError('cross-origin-copy-response', { origin });\n    }\n    const clonedResponse = response.clone();\n    // Create a fresh `ResponseInit` object by cloning the headers.\n    const responseInit = {\n        headers: new Headers(clonedResponse.headers),\n        status: clonedResponse.status,\n        statusText: clonedResponse.statusText,\n    };\n    // Apply any user modifications.\n    const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;\n    // Create the new response from the body stream and `ResponseInit`\n    // modifications. Note: not all browsers support the Response.body stream,\n    // so fall back to reading the entire body into memory as a blob.\n    const body = canConstructResponseFromBodyStream() ?\n        clonedResponse.body : await clonedResponse.blob();\n    return new Response(body, modifiedResponseInit);\n}\nexport { copyResponse };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nlet supportStatus;\n/**\n * A utility function that determines whether the current browser supports\n * constructing a new `Response` from a `response.body` stream.\n *\n * @return {boolean} `true`, if the current browser can successfully\n *     construct a `Response` from a `response.body` stream, `false` otherwise.\n *\n * @private\n */\nfunction canConstructResponseFromBodyStream() {\n    if (supportStatus === undefined) {\n        const testResponse = new Response('');\n        if ('body' in testResponse) {\n            try {\n                new Response(testResponse.body);\n                supportStatus = true;\n            }\n            catch (error) {\n                supportStatus = false;\n            }\n        }\n        supportStatus = false;\n    }\n    return supportStatus;\n}\nexport { canConstructResponseFromBodyStream };\n","/*\n  Copyright 2020 Google LLC\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nfunction stripParams(fullURL, ignoreParams) {\n    const strippedURL = new URL(fullURL);\n    for (const param of ignoreParams) {\n        strippedURL.searchParams.delete(param);\n    }\n    return strippedURL.href;\n}\n/**\n * Matches an item in the cache, ignoring specific URL params. This is similar\n * to the `ignoreSearch` option, but it allows you to ignore just specific\n * params (while continuing to match on the others).\n *\n * @private\n * @param {Cache} cache\n * @param {Request} request\n * @param {Object} matchOptions\n * @param {Array<string>} ignoreParams\n * @return {Promise<Response|undefined>}\n */\nasync function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) {\n    const strippedRequestURL = stripParams(request.url, ignoreParams);\n    // If the request doesn't include any ignored params, match as normal.\n    if (request.url === strippedRequestURL) {\n        return cache.match(request, matchOptions);\n    }\n    // Otherwise, match by comparing keys\n    const keysOptions = { ...matchOptions, ignoreSearch: true };\n    const cacheKeys = await cache.keys(request, keysOptions);\n    for (const cacheKey of cacheKeys) {\n        const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams);\n        if (strippedRequestURL === strippedCacheKeyURL) {\n            return cache.match(cacheKey, matchOptions);\n        }\n    }\n    return;\n}\nexport { cacheMatchIgnoreParams };\n","/*\n  Copyright 2019 Google LLC\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * Returns a promise that resolves and the passed number of milliseconds.\n * This utility is an async/await-friendly version of `setTimeout`.\n *\n * @param {number} ms\n * @return {Promise}\n * @private\n */\nexport function timeout(ms) {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n}\n","/*\n  Copyright 2020 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { cacheMatchIgnoreParams } from 'workbox-core/_private/cacheMatchIgnoreParams.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport { executeQuotaErrorCallbacks } from 'workbox-core/_private/executeQuotaErrorCallbacks.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { timeout } from 'workbox-core/_private/timeout.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport './_version.js';\nfunction toRequest(input) {\n    return (typeof input === 'string') ? new Request(input) : input;\n}\n/**\n * A class created every time a Strategy instance instance calls\n * [handle()]{@link module:workbox-strategies.Strategy~handle} or\n * [handleAll()]{@link module:workbox-strategies.Strategy~handleAll} that wraps all fetch and\n * cache actions around plugin callbacks and keeps track of when the strategy\n * is \"done\" (i.e. all added `event.waitUntil()` promises have resolved).\n *\n * @memberof module:workbox-strategies\n */\nclass StrategyHandler {\n    /**\n     * Creates a new instance associated with the passed strategy and event\n     * that's handling the request.\n     *\n     * The constructor also initializes the state that will be passed to each of\n     * the plugins handling this request.\n     *\n     * @param {module:workbox-strategies.Strategy} strategy\n     * @param {Object} options\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {ExtendableEvent} options.event The event associated with the\n     *     request.\n     * @param {URL} [options.url]\n     * @param {*} [options.params]\n     *     [match callback]{@link module:workbox-routing~matchCallback},\n     *     (if applicable).\n     */\n    constructor(strategy, options) {\n        this._cacheKeys = {};\n        /**\n         * The request the strategy is performing (passed to the strategy's\n         * `handle()` or `handleAll()` method).\n         * @name request\n         * @instance\n         * @type {Request}\n         * @memberof module:workbox-strategies.StrategyHandler\n         */\n        /**\n         * The event associated with this request.\n         * @name event\n         * @instance\n         * @type {ExtendableEvent}\n         * @memberof module:workbox-strategies.StrategyHandler\n         */\n        /**\n         * A `URL` instance of `request.url` (if passed to the strategy's\n         * `handle()` or `handleAll()` method).\n         * Note: the `url` param will be present if the strategy was invoked\n         * from a workbox `Route` object.\n         * @name url\n         * @instance\n         * @type {URL|undefined}\n         * @memberof module:workbox-strategies.StrategyHandler\n         */\n        /**\n         * A `param` value (if passed to the strategy's\n         * `handle()` or `handleAll()` method).\n         * Note: the `param` param will be present if the strategy was invoked\n         * from a workbox `Route` object and the\n         * [match callback]{@link module:workbox-routing~matchCallback} returned\n         * a truthy value (it will be that value).\n         * @name params\n         * @instance\n         * @type {*|undefined}\n         * @memberof module:workbox-strategies.StrategyHandler\n         */\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(options.event, ExtendableEvent, {\n                moduleName: 'workbox-strategies',\n                className: 'StrategyHandler',\n                funcName: 'constructor',\n                paramName: 'options.event',\n            });\n        }\n        Object.assign(this, options);\n        this.event = options.event;\n        this._strategy = strategy;\n        this._handlerDeferred = new Deferred();\n        this._extendLifetimePromises = [];\n        // Copy the plugins list (since it's mutable on the strategy),\n        // so any mutations don't affect this handler instance.\n        this._plugins = [...strategy.plugins];\n        this._pluginStateMap = new Map();\n        for (const plugin of this._plugins) {\n            this._pluginStateMap.set(plugin, {});\n        }\n        this.event.waitUntil(this._handlerDeferred.promise);\n    }\n    /**\n     * Fetches a given request (and invokes any applicable plugin callback\n     * methods) using the `fetchOptions` (for non-navigation requests) and\n     * `plugins` defined on the `Strategy` object.\n     *\n     * The following plugin lifecycle methods are invoked when using this method:\n     * - `requestWillFetch()`\n     * - `fetchDidSucceed()`\n     * - `fetchDidFail()`\n     *\n     * @param {Request|string} input The URL or request to fetch.\n     * @return {Promise<Response>}\n     */\n    async fetch(input) {\n        const { event } = this;\n        let request = toRequest(input);\n        if (request.mode === 'navigate' &&\n            event instanceof FetchEvent &&\n            event.preloadResponse) {\n            const possiblePreloadResponse = await event.preloadResponse;\n            if (possiblePreloadResponse) {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.log(`Using a preloaded navigation response for ` +\n                        `'${getFriendlyURL(request.url)}'`);\n                }\n                return possiblePreloadResponse;\n            }\n        }\n        // If there is a fetchDidFail plugin, we need to save a clone of the\n        // original request before it's either modified by a requestWillFetch\n        // plugin or before the original request's body is consumed via fetch().\n        const originalRequest = this.hasCallback('fetchDidFail') ?\n            request.clone() : null;\n        try {\n            for (const cb of this.iterateCallbacks('requestWillFetch')) {\n                request = await cb({ request: request.clone(), event });\n            }\n        }\n        catch (err) {\n            throw new WorkboxError('plugin-error-request-will-fetch', {\n                thrownError: err,\n            });\n        }\n        // The request can be altered by plugins with `requestWillFetch` making\n        // the original request (most likely from a `fetch` event) different\n        // from the Request we make. Pass both to `fetchDidFail` to aid debugging.\n        const pluginFilteredRequest = request.clone();\n        try {\n            let fetchResponse;\n            // See https://github.com/GoogleChrome/workbox/issues/1796\n            fetchResponse = await fetch(request, request.mode === 'navigate' ?\n                undefined : this._strategy.fetchOptions);\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Network request for ` +\n                    `'${getFriendlyURL(request.url)}' returned a response with ` +\n                    `status '${fetchResponse.status}'.`);\n            }\n            for (const callback of this.iterateCallbacks('fetchDidSucceed')) {\n                fetchResponse = await callback({\n                    event,\n                    request: pluginFilteredRequest,\n                    response: fetchResponse,\n                });\n            }\n            return fetchResponse;\n        }\n        catch (error) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.log(`Network request for ` +\n                    `'${getFriendlyURL(request.url)}' threw an error.`, error);\n            }\n            // `originalRequest` will only exist if a `fetchDidFail` callback\n            // is being used (see above).\n            if (originalRequest) {\n                await this.runCallbacks('fetchDidFail', {\n                    error,\n                    event,\n                    originalRequest: originalRequest.clone(),\n                    request: pluginFilteredRequest.clone(),\n                });\n            }\n            throw error;\n        }\n    }\n    /**\n     * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on\n     * the response generated by `this.fetch()`.\n     *\n     * The call to `this.cachePut()` automatically invokes `this.waitUntil()`,\n     * so you do not have to manually call `waitUntil()` on the event.\n     *\n     * @param {Request|string} input The request or URL to fetch and cache.\n     * @return {Promise<Response>}\n     */\n    async fetchAndCachePut(input) {\n        const response = await this.fetch(input);\n        const responseClone = response.clone();\n        this.waitUntil(this.cachePut(input, responseClone));\n        return response;\n    }\n    /**\n     * Matches a request from the cache (and invokes any applicable plugin\n     * callback methods) using the `cacheName`, `matchOptions`, and `plugins`\n     * defined on the strategy object.\n     *\n     * The following plugin lifecycle methods are invoked when using this method:\n     * - cacheKeyWillByUsed()\n     * - cachedResponseWillByUsed()\n     *\n     * @param {Request|string} key The Request or URL to use as the cache key.\n     * @return {Promise<Response|undefined>} A matching response, if found.\n     */\n    async cacheMatch(key) {\n        const request = toRequest(key);\n        let cachedResponse;\n        const { cacheName, matchOptions } = this._strategy;\n        const effectiveRequest = await this.getCacheKey(request, 'read');\n        const multiMatchOptions = { ...matchOptions, ...{ cacheName } };\n        cachedResponse = await caches.match(effectiveRequest, multiMatchOptions);\n        if (process.env.NODE_ENV !== 'production') {\n            if (cachedResponse) {\n                logger.debug(`Found a cached response in '${cacheName}'.`);\n            }\n            else {\n                logger.debug(`No cached response found in '${cacheName}'.`);\n            }\n        }\n        for (const callback of this.iterateCallbacks('cachedResponseWillBeUsed')) {\n            cachedResponse = (await callback({\n                cacheName,\n                matchOptions,\n                cachedResponse,\n                request: effectiveRequest,\n                event: this.event,\n            })) || undefined;\n        }\n        return cachedResponse;\n    }\n    /**\n     * Puts a request/response pair in the cache (and invokes any applicable\n     * plugin callback methods) using the `cacheName` and `plugins` defined on\n     * the strategy object.\n     *\n     * The following plugin lifecycle methods are invoked when using this method:\n     * - cacheKeyWillByUsed()\n     * - cacheWillUpdate()\n     * - cacheDidUpdate()\n     *\n     * @param {Request|string} key The request or URL to use as the cache key.\n     * @param {Response} response The response to cache.\n     * @return {Promise<boolean>} `false` if a cacheWillUpdate caused the response\n     * not be cached, and `true` otherwise.\n     */\n    async cachePut(key, response) {\n        const request = toRequest(key);\n        // Run in the next task to avoid blocking other cache reads.\n        // https://github.com/w3c/ServiceWorker/issues/1397\n        await timeout(0);\n        const effectiveRequest = await this.getCacheKey(request, 'write');\n        if (process.env.NODE_ENV !== 'production') {\n            if (effectiveRequest.method && effectiveRequest.method !== 'GET') {\n                throw new WorkboxError('attempt-to-cache-non-get-request', {\n                    url: getFriendlyURL(effectiveRequest.url),\n                    method: effectiveRequest.method,\n                });\n            }\n        }\n        if (!response) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.error(`Cannot cache non-existent response for ` +\n                    `'${getFriendlyURL(effectiveRequest.url)}'.`);\n            }\n            throw new WorkboxError('cache-put-with-no-response', {\n                url: getFriendlyURL(effectiveRequest.url),\n            });\n        }\n        const responseToCache = await this._ensureResponseSafeToCache(response);\n        if (!responseToCache) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' ` +\n                    `will not be cached.`, responseToCache);\n            }\n            return false;\n        }\n        const { cacheName, matchOptions } = this._strategy;\n        const cache = await self.caches.open(cacheName);\n        const hasCacheUpdateCallback = this.hasCallback('cacheDidUpdate');\n        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(\n        // TODO(philipwalton): the `__WB_REVISION__` param is a precaching\n        // feature. Consider into ways to only add this behavior if using\n        // precaching.\n        cache, effectiveRequest.clone(), ['__WB_REVISION__'], matchOptions) :\n            null;\n        if (process.env.NODE_ENV !== 'production') {\n            logger.debug(`Updating the '${cacheName}' cache with a new Response ` +\n                `for ${getFriendlyURL(effectiveRequest.url)}.`);\n        }\n        try {\n            await cache.put(effectiveRequest, hasCacheUpdateCallback ?\n                responseToCache.clone() : responseToCache);\n        }\n        catch (error) {\n            // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError\n            if (error.name === 'QuotaExceededError') {\n                await executeQuotaErrorCallbacks();\n            }\n            throw error;\n        }\n        for (const callback of this.iterateCallbacks('cacheDidUpdate')) {\n            await callback({\n                cacheName,\n                oldResponse,\n                newResponse: responseToCache.clone(),\n                request: effectiveRequest,\n                event: this.event,\n            });\n        }\n        return true;\n    }\n    /**\n     * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and\n     * executes any of those callbacks found in sequence. The final `Request`\n     * object returned by the last plugin is treated as the cache key for cache\n     * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have\n     * been registered, the passed request is returned unmodified\n     *\n     * @param {Request} request\n     * @param {string} mode\n     * @return {Promise<Request>}\n     */\n    async getCacheKey(request, mode) {\n        if (!this._cacheKeys[mode]) {\n            let effectiveRequest = request;\n            for (const callback of this.iterateCallbacks('cacheKeyWillBeUsed')) {\n                effectiveRequest = toRequest(await callback({\n                    mode,\n                    request: effectiveRequest,\n                    event: this.event,\n                    params: this.params,\n                }));\n            }\n            this._cacheKeys[mode] = effectiveRequest;\n        }\n        return this._cacheKeys[mode];\n    }\n    /**\n     * Returns true if the strategy has at least one plugin with the given\n     * callback.\n     *\n     * @param {string} name The name of the callback to check for.\n     * @return {boolean}\n     */\n    hasCallback(name) {\n        for (const plugin of this._strategy.plugins) {\n            if (name in plugin) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /**\n     * Runs all plugin callbacks matching the given name, in order, passing the\n     * given param object (merged ith the current plugin state) as the only\n     * argument.\n     *\n     * Note: since this method runs all plugins, it's not suitable for cases\n     * where the return value of a callback needs to be applied prior to calling\n     * the next callback. See\n     * [`iterateCallbacks()`]{@link module:workbox-strategies.StrategyHandler#iterateCallbacks}\n     * below for how to handle that case.\n     *\n     * @param {string} name The name of the callback to run within each plugin.\n     * @param {Object} param The object to pass as the first (and only) param\n     *     when executing each callback. This object will be merged with the\n     *     current plugin state prior to callback execution.\n     */\n    async runCallbacks(name, param) {\n        for (const callback of this.iterateCallbacks(name)) {\n            // TODO(philipwalton): not sure why `any` is needed. It seems like\n            // this should work with `as WorkboxPluginCallbackParam[C]`.\n            await callback(param);\n        }\n    }\n    /**\n     * Accepts a callback and returns an iterable of matching plugin callbacks,\n     * where each callback is wrapped with the current handler state (i.e. when\n     * you call each callback, whatever object parameter you pass it will\n     * be merged with the plugin's current state).\n     *\n     * @param {string} name The name fo the callback to run\n     * @return {Array<Function>}\n     */\n    *iterateCallbacks(name) {\n        for (const plugin of this._strategy.plugins) {\n            if (typeof plugin[name] === 'function') {\n                const state = this._pluginStateMap.get(plugin);\n                const statefulCallback = (param) => {\n                    const statefulParam = { ...param, state };\n                    // TODO(philipwalton): not sure why `any` is needed. It seems like\n                    // this should work with `as WorkboxPluginCallbackParam[C]`.\n                    return plugin[name](statefulParam);\n                };\n                yield statefulCallback;\n            }\n        }\n    }\n    /**\n     * Adds a promise to the\n     * [extend lifetime promises]{@link https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises}\n     * of the event event associated with the request being handled (usually a\n     * `FetchEvent`).\n     *\n     * Note: you can await\n     * [`doneWaiting()`]{@link module:workbox-strategies.StrategyHandler~doneWaiting}\n     * to know when all added promises have settled.\n     *\n     * @param {Promise} promise A promise to add to the extend lifetime promises\n     *     of the event that triggered the request.\n     */\n    waitUntil(promise) {\n        this._extendLifetimePromises.push(promise);\n        return promise;\n    }\n    /**\n     * Returns a promise that resolves once all promises passed to\n     * [`waitUntil()`]{@link module:workbox-strategies.StrategyHandler~waitUntil}\n     * have settled.\n     *\n     * Note: any work done after `doneWaiting()` settles should be manually\n     * passed to an event's `waitUntil()` method (not this handler's\n     * `waitUntil()` method), otherwise the service worker thread my be killed\n     * prior to your work completing.\n     */\n    async doneWaiting() {\n        let promise;\n        while (promise = this._extendLifetimePromises.shift()) {\n            await promise;\n        }\n    }\n    /**\n     * Stops running the strategy and immediately resolves any pending\n     * `waitUntil()` promises.\n     */\n    destroy() {\n        this._handlerDeferred.resolve();\n    }\n    /**\n     * This method will call cacheWillUpdate on the available plugins (or use\n     * status === 200) to determine if the Response is safe and valid to cache.\n     *\n     * @param {Request} options.request\n     * @param {Response} options.response\n     * @return {Promise<Response|undefined>}\n     *\n     * @private\n     */\n    async _ensureResponseSafeToCache(response) {\n        let responseToCache = response;\n        let pluginsUsed = false;\n        for (const callback of this.iterateCallbacks('cacheWillUpdate')) {\n            responseToCache = (await callback({\n                request: this.request,\n                response: responseToCache,\n                event: this.event,\n            })) || undefined;\n            pluginsUsed = true;\n            if (!responseToCache) {\n                break;\n            }\n        }\n        if (!pluginsUsed) {\n            if (responseToCache && responseToCache.status !== 200) {\n                responseToCache = undefined;\n            }\n            if (process.env.NODE_ENV !== 'production') {\n                if (responseToCache) {\n                    if (responseToCache.status !== 200) {\n                        if (responseToCache.status === 0) {\n                            logger.warn(`The response for '${this.request.url}' ` +\n                                `is an opaque response. The caching strategy that you're ` +\n                                `using will not cache opaque responses by default.`);\n                        }\n                        else {\n                            logger.debug(`The response for '${this.request.url}' ` +\n                                `returned a status code of '${response.status}' and won't ` +\n                                `be cached as a result.`);\n                        }\n                    }\n                }\n            }\n        }\n        return responseToCache;\n    }\n}\nexport { StrategyHandler };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Takes in a URL, and returns the corresponding URL that could be used to\n * lookup the entry in the precache.\n *\n * If a relative URL is provided, the location of the service worker file will\n * be used as the base.\n *\n * For precached entries without revision information, the cache key will be the\n * same as the original URL.\n *\n * For precached entries with revision information, the cache key will be the\n * original URL with the addition of a query parameter used for keeping track of\n * the revision info.\n *\n * @param {string} url The URL whose cache key to look up.\n * @return {string} The cache key that corresponds to that URL.\n *\n * @memberof module:workbox-precaching\n */\nfunction getCacheKeyForURL(url) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.getCacheKeyForURL(url);\n}\nexport { getCacheKeyForURL };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { addRoute } from './addRoute.js';\nimport { precache } from './precache.js';\nimport './_version.js';\n/**\n * This method will add entries to the precache list and add a route to\n * respond to fetch events.\n *\n * This is a convenience method that will call\n * [precache()]{@link module:workbox-precaching.precache} and\n * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n * @param {Object} [options] See\n * [PrecacheRoute options]{@link module:workbox-precaching.PrecacheRoute}.\n *\n * @memberof module:workbox-precaching\n */\nfunction precacheAndRoute(entries, options) {\n    precache(entries);\n    addRoute(options);\n}\nexport { precacheAndRoute };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Adds items to the precache list, removing any duplicates and\n * stores the files in the\n * [\"precache cache\"]{@link module:workbox-core.cacheNames} when the service\n * worker installs.\n *\n * This method can be called multiple times.\n *\n * Please note: This method **will not** serve any of the cached files for you.\n * It only precaches files. To respond to a network request you call\n * [addRoute()]{@link module:workbox-precaching.addRoute}.\n *\n * If you have a single array of files to precache, you can just call\n * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.\n *\n * @param {Array<Object|string>} [entries=[]] Array of entries to precache.\n *\n * @memberof module:workbox-precaching\n */\nfunction precache(entries) {\n    const precacheController = getOrCreatePrecacheController();\n    precacheController.precache(entries);\n}\nexport { precache };\n","/*\n  Copyright 2019 Google LLC\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { registerRoute } from 'workbox-routing/registerRoute.js';\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport { PrecacheRoute } from './PrecacheRoute.js';\nimport './_version.js';\n/**\n * Add a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * @param {Object} [options] See\n * [PrecacheRoute options]{@link module:workbox-precaching.PrecacheRoute}.\n *\n * @memberof module:workbox-precaching\n */\nfunction addRoute(options) {\n    const precacheController = getOrCreatePrecacheController();\n    const precacheRoute = new PrecacheRoute(precacheController, options);\n    registerRoute(precacheRoute);\n}\nexport { addRoute };\n","import Gun from 'gun';\nimport localforage from './js/lib/localforage.min.js';\nimport { getFiles, setupPrecaching, setupRouting } from 'preact-cli/sw';\nimport { registerRoute } from 'workbox-routing';\nimport {StaleWhileRevalidate, NetworkOnly} from 'workbox-strategies';\nimport { BackgroundSyncPlugin } from 'workbox-background-sync';\n\nconst bgSyncPlugin = new BackgroundSyncPlugin('apiRequests', {\n\tmaxRetentionTime: 14 * 24 * 60\n});\n\nregisterRoute(\n\t'https://iris-notifications.herokuapp.com/notify',\n\tnew NetworkOnly({\n\t\tplugins: [bgSyncPlugin]\n\t}),\n\t'POST'\n);\nregisterRoute(\n  () => true,\n  new StaleWhileRevalidate()\n);\nsetupRouting();\n\nconst urlsToCache = getFiles();\nsetupPrecaching(urlsToCache);\n\nconst urlToOpen = new URL('/', self.location.origin).href;\n\nasync function getSavedKey() {\n  try {\n    self.irisKey = await localforage.getItem('swIrisKey');\n  } catch (err) {\n    console.error('error loading iris key', err);\n  }\n  return self.irisKey;\n}\n\nself.onmessage = function(msg) {\n  if (Object.prototype.hasOwnProperty.call(msg, 'key')) {\n    self.irisKey = msg.data.key;\n    localforage.setItem('swIrisKey', self.irisKey);\n  }\n}\n\nfunction getOpenClient(event) {\n  return new Promise(resolve => {\n    event.waitUntil(\n      self.clients.matchAll({\n        type: \"window\",\n        includeUncontrolled: true\n      })\n      .then((clientList) => {\n        for (let i = 0; i < clientList.length; i++) {\n          let client = clientList[i];\n          if (client.url === urlToOpen && 'focus' in client) return resolve(client);\n        }\n        resolve(null);\n      })\n    );\n  });\n}\n\nself.addEventListener('push', async ev => {\n  const client = await getOpenClient(ev);\n  if (client && client.visibilityState === 'visible') return;\n  if (!self.irisKey) {\n    await getSavedKey();\n  }\n  const data = ev.data.json();\n  if (!data.title || !data.body) {\n    console.log('what?', data);\n  }\n  if (self.irisKey && data.from && data.from.epub) {\n    const secret = await Gun.SEA.secret(data.from.epub, self.irisKey);\n    data.title = await Gun.SEA.decrypt(data.title, secret);\n    data.body = await Gun.SEA.decrypt(data.body, secret);\n  }\n  if (data.title && data.title.indexOf('SEA{') === 0) {\n    data.title = '';\n    data.body = 'Encrypted message';\n  }\n  self.registration.showNotification(data.title || 'No title', {\n    body: data.body || 'No text',\n    icon: './img/icon128.png'\n  });\n});\n\nself.addEventListener('notificationclick', async (event) => {\n  // Android doesn't close the notification when you click on it\n  // See: http://crbug.com/463146\n  event.notification.close();\n\n  const client = await getOpenClient(event);\n  if (client) {\n    client.focus();\n  } else {\n    self.clients.openWindow && self.clients.openWindow(urlToOpen);\n  }\n});\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { Router } from '../Router.js';\nimport '../_version.js';\nlet defaultRouter;\n/**\n * Creates a new, singleton Router instance if one does not exist. If one\n * does already exist, that instance is returned.\n *\n * @private\n * @return {Router}\n */\nexport const getOrCreateDefaultRouter = () => {\n    if (!defaultRouter) {\n        defaultRouter = new Router();\n        // The helpers that use the default Router assume these listeners exist.\n        defaultRouter.addFetchListener();\n        defaultRouter.addCacheListener();\n    }\n    return defaultRouter;\n};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { messages } from './messages.js';\nimport '../../_version.js';\nconst fallback = (code, ...args) => {\n    let msg = code;\n    if (args.length > 0) {\n        msg += ` :: ${JSON.stringify(args)}`;\n    }\n    return msg;\n};\nconst generatorFunction = (code, details = {}) => {\n    const message = messages[code];\n    if (!message) {\n        throw new Error(`Unable to find message for code '${code}'.`);\n    }\n    return message(details);\n};\nexport const messageGenerator = (process.env.NODE_ENV === 'production') ?\n    fallback : generatorFunction;\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { messageGenerator } from '../models/messages/messageGenerator.js';\nimport '../_version.js';\n/**\n * Workbox errors should be thrown with this class.\n * This allows use to ensure the type easily in tests,\n * helps developers identify errors from workbox\n * easily and allows use to optimise error\n * messages correctly.\n *\n * @private\n */\nclass WorkboxError extends Error {\n    /**\n     *\n     * @param {string} errorCode The error code that\n     * identifies this particular error.\n     * @param {Object=} details Any relevant arguments\n     * that will help developers identify issues should\n     * be added as a key on the context object.\n     */\n    constructor(errorCode, details) {\n        const message = messageGenerator(errorCode, details);\n        super(message);\n        this.name = errorCode;\n        this.details = details;\n    }\n}\nexport { WorkboxError };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport '../_version.js';\n/**\n * @param {function()|Object} handler Either a function, or an object with a\n * 'handle' method.\n * @return {Object} An object with a handle method.\n *\n * @private\n */\nexport const normalizeHandler = (handler) => {\n    if (handler && typeof handler === 'object') {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.hasMethod(handler, 'handle', {\n                moduleName: 'workbox-routing',\n                className: 'Route',\n                funcName: 'constructor',\n                paramName: 'handler',\n            });\n        }\n        return handler;\n    }\n    else {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(handler, 'function', {\n                moduleName: 'workbox-routing',\n                className: 'Route',\n                funcName: 'constructor',\n                paramName: 'handler',\n            });\n        }\n        return { handle: handler };\n    }\n};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { defaultMethod, validMethods } from './utils/constants.js';\nimport { normalizeHandler } from './utils/normalizeHandler.js';\nimport './_version.js';\n/**\n * A `Route` consists of a pair of callback functions, \"match\" and \"handler\".\n * The \"match\" callback determine if a route should be used to \"handle\" a\n * request by returning a non-falsy value if it can. The \"handler\" callback\n * is called when there is a match and should return a Promise that resolves\n * to a `Response`.\n *\n * @memberof module:workbox-routing\n */\nclass Route {\n    /**\n     * Constructor for Route class.\n     *\n     * @param {module:workbox-routing~matchCallback} match\n     * A callback function that determines whether the route matches a given\n     * `fetch` event by returning a non-falsy value.\n     * @param {module:workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resolving to a Response.\n     * @param {string} [method='GET'] The HTTP method to match the Route\n     * against.\n     */\n    constructor(match, handler, method = defaultMethod) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(match, 'function', {\n                moduleName: 'workbox-routing',\n                className: 'Route',\n                funcName: 'constructor',\n                paramName: 'match',\n            });\n            if (method) {\n                assert.isOneOf(method, validMethods, { paramName: 'method' });\n            }\n        }\n        // These values are referenced directly by Router so cannot be\n        // altered by minificaton.\n        this.handler = normalizeHandler(handler);\n        this.match = match;\n        this.method = method;\n    }\n    /**\n     *\n     * @param {module:workbox-routing-handlerCallback} handler A callback\n     * function that returns a Promise resolving to a Response\n     */\n    setCatchHandler(handler) {\n        this.catchHandler = normalizeHandler(handler);\n    }\n}\nexport { Route };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * The default HTTP method, 'GET', used when there's no specific method\n * configured for a route.\n *\n * @type {string}\n *\n * @private\n */\nexport const defaultMethod = 'GET';\n/**\n * The list of valid HTTP methods associated with requests that could be routed.\n *\n * @type {Array<string>}\n *\n * @private\n */\nexport const validMethods = [\n    'DELETE',\n    'GET',\n    'HEAD',\n    'PATCH',\n    'POST',\n    'PUT',\n];\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { Route } from './Route.js';\nimport './_version.js';\n/**\n * RegExpRoute makes it easy to create a regular expression based\n * [Route]{@link module:workbox-routing.Route}.\n *\n * For same-origin requests the RegExp only needs to match part of the URL. For\n * requests against third-party servers, you must define a RegExp that matches\n * the start of the URL.\n *\n * [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}\n *\n * @memberof module:workbox-routing\n * @extends module:workbox-routing.Route\n */\nclass RegExpRoute extends Route {\n    /**\n     * If the regular expression contains\n     * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},\n     * the captured values will be passed to the\n     * [handler's]{@link module:workbox-routing~handlerCallback} `params`\n     * argument.\n     *\n     * @param {RegExp} regExp The regular expression to match against URLs.\n     * @param {module:workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resulting in a Response.\n     * @param {string} [method='GET'] The HTTP method to match the Route\n     * against.\n     */\n    constructor(regExp, handler, method) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(regExp, RegExp, {\n                moduleName: 'workbox-routing',\n                className: 'RegExpRoute',\n                funcName: 'constructor',\n                paramName: 'pattern',\n            });\n        }\n        const match = ({ url }) => {\n            const result = regExp.exec(url.href);\n            // Return immediately if there's no match.\n            if (!result) {\n                return;\n            }\n            // Require that the match start at the first character in the URL string\n            // if it's a cross-origin request.\n            // See https://github.com/GoogleChrome/workbox/issues/281 for the context\n            // behind this behavior.\n            if ((url.origin !== location.origin) && (result.index !== 0)) {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.debug(`The regular expression '${regExp}' only partially matched ` +\n                        `against the cross-origin URL '${url}'. RegExpRoute's will only ` +\n                        `handle cross-origin requests if they match the entire URL.`);\n                }\n                return;\n            }\n            // If the route matches, but there aren't any capture groups defined, then\n            // this will return [], which is truthy and therefore sufficient to\n            // indicate a match.\n            // If there are capture groups, then it will return their values.\n            return result.slice(1);\n        };\n        super(match, handler, method);\n    }\n}\nexport { RegExpRoute };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nconst getFriendlyURL = (url) => {\n    const urlObj = new URL(String(url), location.href);\n    // See https://github.com/GoogleChrome/workbox/issues/2323\n    // We want to include everything, except for the origin if it's same-origin.\n    return urlObj.href.replace(new RegExp(`^${location.origin}`), '');\n};\nexport { getFriendlyURL };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { defaultMethod } from './utils/constants.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { normalizeHandler } from './utils/normalizeHandler.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport './_version.js';\n/**\n * The Router can be used to process a FetchEvent through one or more\n * [Routes]{@link module:workbox-routing.Route} responding  with a Request if\n * a matching route exists.\n *\n * If no route matches a given a request, the Router will use a \"default\"\n * handler if one is defined.\n *\n * Should the matching Route throw an error, the Router will use a \"catch\"\n * handler if one is defined to gracefully deal with issues and respond with a\n * Request.\n *\n * If a request matches multiple routes, the **earliest** registered route will\n * be used to respond to the request.\n *\n * @memberof module:workbox-routing\n */\nclass Router {\n    /**\n     * Initializes a new Router.\n     */\n    constructor() {\n        this._routes = new Map();\n        this._defaultHandlerMap = new Map();\n    }\n    /**\n     * @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP\n     * method name ('GET', etc.) to an array of all the corresponding `Route`\n     * instances that are registered.\n     */\n    get routes() {\n        return this._routes;\n    }\n    /**\n     * Adds a fetch event listener to respond to events when a route matches\n     * the event's request.\n     */\n    addFetchListener() {\n        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n        self.addEventListener('fetch', ((event) => {\n            const { request } = event;\n            const responsePromise = this.handleRequest({ request, event });\n            if (responsePromise) {\n                event.respondWith(responsePromise);\n            }\n        }));\n    }\n    /**\n     * Adds a message event listener for URLs to cache from the window.\n     * This is useful to cache resources loaded on the page prior to when the\n     * service worker started controlling it.\n     *\n     * The format of the message data sent from the window should be as follows.\n     * Where the `urlsToCache` array may consist of URL strings or an array of\n     * URL string + `requestInit` object (the same as you'd pass to `fetch()`).\n     *\n     * ```\n     * {\n     *   type: 'CACHE_URLS',\n     *   payload: {\n     *     urlsToCache: [\n     *       './script1.js',\n     *       './script2.js',\n     *       ['./script3.js', {mode: 'no-cors'}],\n     *     ],\n     *   },\n     * }\n     * ```\n     */\n    addCacheListener() {\n        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n        self.addEventListener('message', ((event) => {\n            if (event.data && event.data.type === 'CACHE_URLS') {\n                const { payload } = event.data;\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.debug(`Caching URLs from the window`, payload.urlsToCache);\n                }\n                const requestPromises = Promise.all(payload.urlsToCache.map((entry) => {\n                    if (typeof entry === 'string') {\n                        entry = [entry];\n                    }\n                    const request = new Request(...entry);\n                    return this.handleRequest({ request, event });\n                    // TODO(philipwalton): TypeScript errors without this typecast for\n                    // some reason (probably a bug). The real type here should work but\n                    // doesn't: `Array<Promise<Response> | undefined>`.\n                })); // TypeScript\n                event.waitUntil(requestPromises);\n                // If a MessageChannel was used, reply to the message on success.\n                if (event.ports && event.ports[0]) {\n                    requestPromises.then(() => event.ports[0].postMessage(true));\n                }\n            }\n        }));\n    }\n    /**\n     * Apply the routing rules to a FetchEvent object to get a Response from an\n     * appropriate Route's handler.\n     *\n     * @param {Object} options\n     * @param {Request} options.request The request to handle.\n     * @param {ExtendableEvent} options.event The event that triggered the\n     *     request.\n     * @return {Promise<Response>|undefined} A promise is returned if a\n     *     registered route can handle the request. If there is no matching\n     *     route and there's no `defaultHandler`, `undefined` is returned.\n     */\n    handleRequest({ request, event }) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'handleRequest',\n                paramName: 'options.request',\n            });\n        }\n        const url = new URL(request.url, location.href);\n        if (!url.protocol.startsWith('http')) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Workbox Router only supports URLs that start with 'http'.`);\n            }\n            return;\n        }\n        const sameOrigin = url.origin === location.origin;\n        const { params, route } = this.findMatchingRoute({\n            event,\n            request,\n            sameOrigin,\n            url,\n        });\n        let handler = route && route.handler;\n        const debugMessages = [];\n        if (process.env.NODE_ENV !== 'production') {\n            if (handler) {\n                debugMessages.push([\n                    `Found a route to handle this request:`, route,\n                ]);\n                if (params) {\n                    debugMessages.push([\n                        `Passing the following params to the route's handler:`, params,\n                    ]);\n                }\n            }\n        }\n        // If we don't have a handler because there was no matching route, then\n        // fall back to defaultHandler if that's defined.\n        const method = request.method;\n        if (!handler && this._defaultHandlerMap.has(method)) {\n            if (process.env.NODE_ENV !== 'production') {\n                debugMessages.push(`Failed to find a matching route. Falling ` +\n                    `back to the default handler for ${method}.`);\n            }\n            handler = this._defaultHandlerMap.get(method);\n        }\n        if (!handler) {\n            if (process.env.NODE_ENV !== 'production') {\n                // No handler so Workbox will do nothing. If logs is set of debug\n                // i.e. verbose, we should print out this information.\n                logger.debug(`No route found for: ${getFriendlyURL(url)}`);\n            }\n            return;\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            // We have a handler, meaning Workbox is going to handle the route.\n            // print the routing details to the console.\n            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);\n            debugMessages.forEach((msg) => {\n                if (Array.isArray(msg)) {\n                    logger.log(...msg);\n                }\n                else {\n                    logger.log(msg);\n                }\n            });\n            logger.groupEnd();\n        }\n        // Wrap in try and catch in case the handle method throws a synchronous\n        // error. It should still callback to the catch handler.\n        let responsePromise;\n        try {\n            responsePromise = handler.handle({ url, request, event, params });\n        }\n        catch (err) {\n            responsePromise = Promise.reject(err);\n        }\n        // Get route's catch handler, if it exists\n        const catchHandler = route && route.catchHandler;\n        if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {\n            responsePromise = responsePromise.catch(async (err) => {\n                // If there's a route catch handler, process that first\n                if (catchHandler) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        // Still include URL here as it will be async from the console group\n                        // and may not make sense without the URL\n                        logger.groupCollapsed(`Error thrown when responding to: ` +\n                            ` ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);\n                        logger.error(`Error thrown by:`, route);\n                        logger.error(err);\n                        logger.groupEnd();\n                    }\n                    try {\n                        return await catchHandler.handle({ url, request, event, params });\n                    }\n                    catch (catchErr) {\n                        err = catchErr;\n                    }\n                }\n                if (this._catchHandler) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        // Still include URL here as it will be async from the console group\n                        // and may not make sense without the URL\n                        logger.groupCollapsed(`Error thrown when responding to: ` +\n                            ` ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);\n                        logger.error(`Error thrown by:`, route);\n                        logger.error(err);\n                        logger.groupEnd();\n                    }\n                    return this._catchHandler.handle({ url, request, event });\n                }\n                throw err;\n            });\n        }\n        return responsePromise;\n    }\n    /**\n     * Checks a request and URL (and optionally an event) against the list of\n     * registered routes, and if there's a match, returns the corresponding\n     * route along with any params generated by the match.\n     *\n     * @param {Object} options\n     * @param {URL} options.url\n     * @param {boolean} options.sameOrigin The result of comparing `url.origin`\n     *     against the current origin.\n     * @param {Request} options.request The request to match.\n     * @param {Event} options.event The corresponding event.\n     * @return {Object} An object with `route` and `params` properties.\n     *     They are populated if a matching route was found or `undefined`\n     *     otherwise.\n     */\n    findMatchingRoute({ url, sameOrigin, request, event }) {\n        const routes = this._routes.get(request.method) || [];\n        for (const route of routes) {\n            let params;\n            const matchResult = route.match({ url, sameOrigin, request, event });\n            if (matchResult) {\n                if (process.env.NODE_ENV !== 'production') {\n                    // Warn developers that using an async matchCallback is almost always\n                    // not the right thing to do. \n                    if (matchResult instanceof Promise) {\n                        logger.warn(`While routing ${getFriendlyURL(url)}, an async ` +\n                            `matchCallback function was used. Please convert the ` +\n                            `following route to use a synchronous matchCallback function:`, route);\n                    }\n                }\n                // See https://github.com/GoogleChrome/workbox/issues/2079\n                params = matchResult;\n                if (Array.isArray(matchResult) && matchResult.length === 0) {\n                    // Instead of passing an empty array in as params, use undefined.\n                    params = undefined;\n                }\n                else if ((matchResult.constructor === Object &&\n                    Object.keys(matchResult).length === 0)) {\n                    // Instead of passing an empty object in as params, use undefined.\n                    params = undefined;\n                }\n                else if (typeof matchResult === 'boolean') {\n                    // For the boolean value true (rather than just something truth-y),\n                    // don't set params.\n                    // See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353\n                    params = undefined;\n                }\n                // Return early if have a match.\n                return { route, params };\n            }\n        }\n        // If no match was found above, return and empty object.\n        return {};\n    }\n    /**\n     * Define a default `handler` that's called when no routes explicitly\n     * match the incoming request.\n     *\n     * Each HTTP method ('GET', 'POST', etc.) gets its own default handler.\n     *\n     * Without a default handler, unmatched requests will go against the\n     * network as if there were no service worker present.\n     *\n     * @param {module:workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resulting in a Response.\n     * @param {string} [method='GET'] The HTTP method to associate with this\n     * default handler. Each method has its own default.\n     */\n    setDefaultHandler(handler, method = defaultMethod) {\n        this._defaultHandlerMap.set(method, normalizeHandler(handler));\n    }\n    /**\n     * If a Route throws an error while handling a request, this `handler`\n     * will be called and given a chance to provide a response.\n     *\n     * @param {module:workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resulting in a Response.\n     */\n    setCatchHandler(handler) {\n        this._catchHandler = normalizeHandler(handler);\n    }\n    /**\n     * Registers a route with the router.\n     *\n     * @param {module:workbox-routing.Route} route The route to register.\n     */\n    registerRoute(route) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(route, 'object', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route',\n            });\n            assert.hasMethod(route, 'match', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route',\n            });\n            assert.isType(route.handler, 'object', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route',\n            });\n            assert.hasMethod(route.handler, 'handle', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route.handler',\n            });\n            assert.isType(route.method, 'string', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route.method',\n            });\n        }\n        if (!this._routes.has(route.method)) {\n            this._routes.set(route.method, []);\n        }\n        // Give precedence to all of the earlier routes by adding this additional\n        // route to the end of the array.\n        this._routes.get(route.method).push(route);\n    }\n    /**\n     * Unregisters a route with the router.\n     *\n     * @param {module:workbox-routing.Route} route The route to unregister.\n     */\n    unregisterRoute(route) {\n        if (!this._routes.has(route.method)) {\n            throw new WorkboxError('unregister-route-but-not-found-with-method', {\n                method: route.method,\n            });\n        }\n        const routeIndex = this._routes.get(route.method).indexOf(route);\n        if (routeIndex > -1) {\n            this._routes.get(route.method).splice(routeIndex, 1);\n        }\n        else {\n            throw new WorkboxError('unregister-route-route-not-registered');\n        }\n    }\n}\nexport { Router };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nconst _cacheNameDetails = {\n    googleAnalytics: 'googleAnalytics',\n    precache: 'precache-v2',\n    prefix: 'workbox',\n    runtime: 'runtime',\n    suffix: typeof registration !== 'undefined' ? registration.scope : '',\n};\nconst _createCacheName = (cacheName) => {\n    return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix]\n        .filter((value) => value && value.length > 0)\n        .join('-');\n};\nconst eachCacheNameDetail = (fn) => {\n    for (const key of Object.keys(_cacheNameDetails)) {\n        fn(key);\n    }\n};\nexport const cacheNames = {\n    updateDetails: (details) => {\n        eachCacheNameDetail((key) => {\n            if (typeof details[key] === 'string') {\n                _cacheNameDetails[key] = details[key];\n            }\n        });\n    },\n    getGoogleAnalyticsName: (userCacheName) => {\n        return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);\n    },\n    getPrecacheName: (userCacheName) => {\n        return userCacheName || _createCacheName(_cacheNameDetails.precache);\n    },\n    getPrefix: () => {\n        return _cacheNameDetails.prefix;\n    },\n    getRuntimeName: (userCacheName) => {\n        return userCacheName || _createCacheName(_cacheNameDetails.runtime);\n    },\n    getSuffix: () => {\n        return _cacheNameDetails.suffix;\n    },\n};\n","/*\n  Copyright 2020 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * A plugin, designed to be used with PrecacheController, to determine the\n * of assets that were updated (or not updated) during the install event.\n *\n * @private\n */\nclass PrecacheInstallReportPlugin {\n    constructor() {\n        this.updatedURLs = [];\n        this.notUpdatedURLs = [];\n        this.handlerWillStart = async ({ request, state, }) => {\n            // TODO: `state` should never be undefined...\n            if (state) {\n                state.originalRequest = request;\n            }\n        };\n        this.cachedResponseWillBeUsed = async ({ event, state, cachedResponse, }) => {\n            if (event.type === 'install') {\n                // TODO: `state` should never be undefined...\n                const url = state.originalRequest.url;\n                if (cachedResponse) {\n                    this.notUpdatedURLs.push(url);\n                }\n                else {\n                    this.updatedURLs.push(url);\n                }\n            }\n            return cachedResponse;\n        };\n    }\n}\nexport { PrecacheInstallReportPlugin };\n","/*\n  Copyright 2020 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * A plugin, designed to be used with PrecacheController, to translate URLs into\n * the corresponding cache key, based on the current revision info.\n *\n * @private\n */\nclass PrecacheCacheKeyPlugin {\n    constructor({ precacheController }) {\n        this.cacheKeyWillBeUsed = async ({ request, params, }) => {\n            const cacheKey = params && params.cacheKey ||\n                this._precacheController.getCacheKeyForURL(request.url);\n            return cacheKey ? new Request(cacheKey) : request;\n        };\n        this._precacheController = precacheController;\n    }\n}\nexport { PrecacheCacheKeyPlugin };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * The Deferred class composes Promises in a way that allows for them to be\n * resolved or rejected from outside the constructor. In most cases promises\n * should be used directly, but Deferreds can be necessary when the logic to\n * resolve a promise must be separate.\n *\n * @private\n */\nclass Deferred {\n    /**\n     * Creates a promise and exposes its resolve and reject functions as methods.\n     */\n    constructor() {\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n    }\n}\nexport { Deferred };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n// Callbacks to be executed whenever there's a quota error.\nconst quotaErrorCallbacks = new Set();\nexport { quotaErrorCallbacks };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { logger } from '../_private/logger.js';\nimport { quotaErrorCallbacks } from '../models/quotaErrorCallbacks.js';\nimport '../_version.js';\n/**\n * Runs all of the callback functions, one at a time sequentially, in the order\n * in which they were registered.\n *\n * @memberof module:workbox-core\n * @private\n */\nasync function executeQuotaErrorCallbacks() {\n    if (process.env.NODE_ENV !== 'production') {\n        logger.log(`About to run ${quotaErrorCallbacks.size} ` +\n            `callbacks to clean up caches.`);\n    }\n    for (const callback of quotaErrorCallbacks) {\n        await callback();\n        if (process.env.NODE_ENV !== 'production') {\n            logger.log(callback, 'is complete.');\n        }\n    }\n    if (process.env.NODE_ENV !== 'production') {\n        logger.log('Finished running callbacks.');\n    }\n}\nexport { executeQuotaErrorCallbacks };\n","/*\n  Copyright 2020 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { StrategyHandler } from './StrategyHandler.js';\nimport './_version.js';\n/**\n * An abstract base class that all other strategy classes must extend from:\n *\n * @memberof module:workbox-strategies\n */\nclass Strategy {\n    /**\n     * Creates a new instance of the strategy and sets all documented option\n     * properties as public instance properties.\n     *\n     * Note: if a custom strategy class extends the base Strategy class and does\n     * not need more than these properties, it does not need to define its own\n     * constructor.\n     *\n     * @param {Object} [options]\n     * @param {string} [options.cacheName] Cache name to store and retrieve\n     * requests. Defaults to the cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} [options.fetchOptions] Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n     * `fetch()` requests made by this strategy.\n     * @param {Object} [options.matchOptions] The\n     * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions}\n     * for any `cache.match()` or `cache.put()` calls made by this strategy.\n     */\n    constructor(options = {}) {\n        /**\n         * Cache name to store and retrieve\n         * requests. Defaults to the cache names provided by\n         * [workbox-core]{@link module:workbox-core.cacheNames}.\n         *\n         * @type {string}\n         */\n        this.cacheName = cacheNames.getRuntimeName(options.cacheName);\n        /**\n         * The list\n         * [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n         * used by this strategy.\n         *\n         * @type {Array<Object>}\n         */\n        this.plugins = options.plugins || [];\n        /**\n         * Values passed along to the\n         * [`init`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters}\n         * of all fetch() requests made by this strategy.\n         *\n         * @type {Object}\n         */\n        this.fetchOptions = options.fetchOptions;\n        /**\n         * The\n         * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions}\n         * for any `cache.match()` or `cache.put()` calls made by this strategy.\n         *\n         * @type {Object}\n         */\n        this.matchOptions = options.matchOptions;\n    }\n    /**\n     * Perform a request strategy and returns a `Promise` that will resolve with\n     * a `Response`, invoking all relevant plugin callbacks.\n     *\n     * When a strategy instance is registered with a Workbox\n     * [route]{@link module:workbox-routing.Route}, this method is automatically\n     * called when the route matches.\n     *\n     * Alternatively, this method can be used in a standalone `FetchEvent`\n     * listener by passing it to `event.respondWith()`.\n     *\n     * @param {FetchEvent|Object} options A `FetchEvent` or an object with the\n     *     properties listed below.\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {ExtendableEvent} options.event The event associated with the\n     *     request.\n     * @param {URL} [options.url]\n     * @param {*} [options.params]\n     */\n    handle(options) {\n        const [responseDone] = this.handleAll(options);\n        return responseDone;\n    }\n    /**\n     * Similar to [`handle()`]{@link module:workbox-strategies.Strategy~handle}, but\n     * instead of just returning a `Promise` that resolves to a `Response` it\n     * it will return an tuple of [response, done] promises, where the former\n     * (`response`) is equivalent to what `handle()` returns, and the latter is a\n     * Promise that will resolve once any promises that were added to\n     * `event.waitUntil()` as part of performing the strategy have completed.\n     *\n     * You can await the `done` promise to ensure any extra work performed by\n     * the strategy (usually caching responses) completes successfully.\n     *\n     * @param {FetchEvent|Object} options A `FetchEvent` or an object with the\n     *     properties listed below.\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {ExtendableEvent} options.event The event associated with the\n     *     request.\n     * @param {URL} [options.url]\n     * @param {*} [options.params]\n     * @return {Array<Promise>} A tuple of [response, done]\n     *     promises that can be used to determine when the response resolves as\n     *     well as when the handler has completed all its work.\n     */\n    handleAll(options) {\n        // Allow for flexible options to be passed.\n        if (options instanceof FetchEvent) {\n            options = {\n                event: options,\n                request: options.request,\n            };\n        }\n        const event = options.event;\n        const request = typeof options.request === 'string' ?\n            new Request(options.request) :\n            options.request;\n        const params = 'params' in options ? options.params : undefined;\n        const handler = new StrategyHandler(this, { event, request, params });\n        const responseDone = this._getResponse(handler, request, event);\n        const handlerDone = this._awaitComplete(responseDone, handler, request, event);\n        // Return an array of promises, suitable for use with Promise.all().\n        return [responseDone, handlerDone];\n    }\n    async _getResponse(handler, request, event) {\n        await handler.runCallbacks('handlerWillStart', { event, request });\n        let response = undefined;\n        try {\n            response = await this._handle(request, handler);\n            // The \"official\" Strategy subclasses all throw this error automatically,\n            // but in case a third-party Strategy doesn't, ensure that we have a\n            // consistent failure when there's no response or an error response.\n            if (!response || response.type === 'error') {\n                throw new WorkboxError('no-response', { url: request.url });\n            }\n        }\n        catch (error) {\n            for (const callback of handler.iterateCallbacks('handlerDidError')) {\n                response = await callback({ error, event, request });\n                if (response) {\n                    break;\n                }\n            }\n            if (!response) {\n                throw error;\n            }\n            else if (process.env.NODE_ENV !== 'production') {\n                logger.log(`While responding to '${getFriendlyURL(request.url)}', ` +\n                    `an ${error} error occurred. Using a fallback response provided by ` +\n                    `a handlerDidError plugin.`);\n            }\n        }\n        for (const callback of handler.iterateCallbacks('handlerWillRespond')) {\n            response = await callback({ event, request, response });\n        }\n        return response;\n    }\n    async _awaitComplete(responseDone, handler, request, event) {\n        let response;\n        let error;\n        try {\n            response = await responseDone;\n        }\n        catch (error) {\n            // Ignore errors, as response errors should be caught via the `response`\n            // promise above. The `done` promise will only throw for errors in\n            // promises passed to `handler.waitUntil()`.\n        }\n        try {\n            await handler.runCallbacks('handlerDidRespond', {\n                event,\n                request,\n                response,\n            });\n            await handler.doneWaiting();\n        }\n        catch (waitUntilError) {\n            error = waitUntilError;\n        }\n        await handler.runCallbacks('handlerDidComplete', {\n            event,\n            request,\n            response,\n            error,\n        });\n        handler.destroy();\n        if (error) {\n            throw error;\n        }\n    }\n}\nexport { Strategy };\n/**\n * Classes extending the `Strategy` based class should implement this method,\n * and leverage the [`handler`]{@link module:workbox-strategies.StrategyHandler}\n * arg to perform all fetching and cache logic, which will ensure all relevant\n * cache, cache options, fetch options and plugins are used (per the current\n * strategy instance).\n *\n * @name _handle\n * @instance\n * @abstract\n * @function\n * @param {Request} request\n * @param {module:workbox-strategies.StrategyHandler} handler\n * @return {Promise<Response>}\n *\n * @memberof module:workbox-strategies.Strategy\n */\n","/*\n  Copyright 2020 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { copyResponse } from 'workbox-core/copyResponse.js';\nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { Strategy } from 'workbox-strategies/Strategy.js';\nimport './_version.js';\n/**\n * A [Strategy]{@link module:workbox-strategies.Strategy} implementation\n * specifically designed to work with\n * [PrecacheController]{@link module:workbox-precaching.PrecacheController}\n * to both cache and fetch precached assets.\n *\n * Note: an instance of this class is created automatically when creating a\n * `PrecacheController`; it's generally not necessary to create this yourself.\n *\n * @extends module:workbox-strategies.Strategy\n * @memberof module:workbox-precaching\n */\nclass PrecacheStrategy extends Strategy {\n    /**\n     *\n     * @param {Object} [options]\n     * @param {string} [options.cacheName] Cache name to store and retrieve\n     * requests. Defaults to the cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} [options.fetchOptions] Values passed along to the\n     * [`init`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters}\n     * of all fetch() requests made by this strategy.\n     * @param {Object} [options.matchOptions] The\n     * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions}\n     * for any `cache.match()` or `cache.put()` calls made by this strategy.\n     * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to\n     * get the response from the network if there's a precache miss.\n     */\n    constructor(options = {}) {\n        options.cacheName = cacheNames.getPrecacheName(options.cacheName);\n        super(options);\n        this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true;\n        // Redirected responses cannot be used to satisfy a navigation request, so\n        // any redirected response must be \"copied\" rather than cloned, so the new\n        // response doesn't contain the `redirected` flag. See:\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1\n        this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);\n    }\n    /**\n     * @private\n     * @param {Request|string} request A request to run this strategy for.\n     * @param {module:workbox-strategies.StrategyHandler} handler The event that\n     *     triggered the request.\n     * @return {Promise<Response>}\n     */\n    async _handle(request, handler) {\n        const response = await handler.cacheMatch(request);\n        if (!response) {\n            // If this is an `install` event then populate the cache. If this is a\n            // `fetch` event (or any other event) then respond with the cached\n            // response.\n            if (handler.event && handler.event.type === 'install') {\n                return await this._handleInstall(request, handler);\n            }\n            return await this._handleFetch(request, handler);\n        }\n        return response;\n    }\n    async _handleFetch(request, handler) {\n        let response;\n        // Fall back to the network if we don't have a cached response\n        // (perhaps due to manual cache cleanup).\n        if (this._fallbackToNetwork) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.warn(`The precached response for ` +\n                    `${getFriendlyURL(request.url)} in ${this.cacheName} was not ` +\n                    `found. Falling back to the network instead.`);\n            }\n            response = await handler.fetch(request);\n        }\n        else {\n            // This shouldn't normally happen, but there are edge cases:\n            // https://github.com/GoogleChrome/workbox/issues/1441\n            throw new WorkboxError('missing-precache-entry', {\n                cacheName: this.cacheName,\n                url: request.url,\n            });\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            const cacheKey = handler.params && handler.params.cacheKey ||\n                await handler.getCacheKey(request, 'read');\n            // Workbox is going to handle the route.\n            // print the routing details to the console.\n            logger.groupCollapsed(`Precaching is responding to: ` +\n                getFriendlyURL(request.url));\n            logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey.url)}`);\n            logger.groupCollapsed(`View request details here.`);\n            logger.log(request);\n            logger.groupEnd();\n            logger.groupCollapsed(`View response details here.`);\n            logger.log(response);\n            logger.groupEnd();\n            logger.groupEnd();\n        }\n        return response;\n    }\n    async _handleInstall(request, handler) {\n        this._useDefaultCacheabilityPluginIfNeeded();\n        const response = await handler.fetch(request);\n        // Make sure we defer cachePut() until after we know the response\n        // should be cached; see https://github.com/GoogleChrome/workbox/issues/2737\n        const wasCached = await handler.cachePut(request, response.clone());\n        if (!wasCached) {\n            // Throwing here will lead to the `install` handler failing, which\n            // we want to do if *any* of the responses aren't safe to cache.\n            throw new WorkboxError('bad-precaching-response', {\n                url: request.url,\n                status: response.status,\n            });\n        }\n        return response;\n    }\n    /**\n     * This method is complex, as there a number of things to account for:\n     *\n     * The `plugins` array can be set at construction, and/or it might be added to\n     * to at any time before the strategy is used.\n     *\n     * At the time the strategy is used (i.e. during an `install` event), there\n     * needs to be at least one plugin that implements `cacheWillUpdate` in the\n     * array, other than `copyRedirectedCacheableResponsesPlugin`.\n     *\n     * - If this method is called and there are no suitable `cacheWillUpdate`\n     * plugins, we need to add `defaultPrecacheCacheabilityPlugin`.\n     *\n     * - If this method is called and there is exactly one `cacheWillUpdate`, then\n     * we don't have to do anything (this might be a previously added\n     * `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin).\n     *\n     * - If this method is called and there is more than one `cacheWillUpdate`,\n     * then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so,\n     * we need to remove it. (This situation is unlikely, but it could happen if\n     * the strategy is used multiple times, the first without a `cacheWillUpdate`,\n     * and then later on after manually adding a custom `cacheWillUpdate`.)\n     *\n     * See https://github.com/GoogleChrome/workbox/issues/2737 for more context.\n     *\n     * @private\n     */\n    _useDefaultCacheabilityPluginIfNeeded() {\n        let defaultPluginIndex = null;\n        let cacheWillUpdatePluginCount = 0;\n        for (const [index, plugin] of this.plugins.entries()) {\n            // Ignore the copy redirected plugin when determining what to do.\n            if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {\n                continue;\n            }\n            // Save the default plugin's index, in case it needs to be removed.\n            if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {\n                defaultPluginIndex = index;\n            }\n            if (plugin.cacheWillUpdate) {\n                cacheWillUpdatePluginCount++;\n            }\n        }\n        if (cacheWillUpdatePluginCount === 0) {\n            this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);\n        }\n        else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {\n            // Only remove the default plugin; multiple custom plugins are allowed.\n            this.plugins.splice(defaultPluginIndex, 1);\n        }\n        // Nothing needs to be done if cacheWillUpdatePluginCount is 1\n    }\n}\nPrecacheStrategy.defaultPrecacheCacheabilityPlugin = {\n    async cacheWillUpdate({ response }) {\n        if (!response || response.status >= 400) {\n            return null;\n        }\n        return response;\n    }\n};\nPrecacheStrategy.copyRedirectedCacheableResponsesPlugin = {\n    async cacheWillUpdate({ response }) {\n        return response.redirected ? await copyResponse(response) : response;\n    }\n};\nexport { PrecacheStrategy };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { PrecacheController } from '../PrecacheController.js';\nimport '../_version.js';\nlet precacheController;\n/**\n * @return {PrecacheController}\n * @private\n */\nexport const getOrCreatePrecacheController = () => {\n    if (!precacheController) {\n        precacheController = new PrecacheController();\n    }\n    return precacheController;\n};\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { waitUntil } from 'workbox-core/_private/waitUntil.js';\nimport { createCacheKey } from './utils/createCacheKey.js';\nimport { PrecacheInstallReportPlugin } from './utils/PrecacheInstallReportPlugin.js';\nimport { PrecacheCacheKeyPlugin } from './utils/PrecacheCacheKeyPlugin.js';\nimport { printCleanupDetails } from './utils/printCleanupDetails.js';\nimport { printInstallDetails } from './utils/printInstallDetails.js';\nimport { PrecacheStrategy } from './PrecacheStrategy.js';\nimport './_version.js';\n/**\n * Performs efficient precaching of assets.\n *\n * @memberof module:workbox-precaching\n */\nclass PrecacheController {\n    /**\n     * Create a new PrecacheController.\n     *\n     * @param {Object} [options]\n     * @param {string} [options.cacheName] The cache to use for precaching.\n     * @param {string} [options.plugins] Plugins to use when precaching as well\n     * as responding to fetch events for precached assets.\n     * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to\n     * get the response from the network if there's a precache miss.\n     */\n    constructor({ cacheName, plugins = [], fallbackToNetwork = true } = {}) {\n        this._urlsToCacheKeys = new Map();\n        this._urlsToCacheModes = new Map();\n        this._cacheKeysToIntegrities = new Map();\n        this._strategy = new PrecacheStrategy({\n            cacheName: cacheNames.getPrecacheName(cacheName),\n            plugins: [\n                ...plugins,\n                new PrecacheCacheKeyPlugin({ precacheController: this }),\n            ],\n            fallbackToNetwork,\n        });\n        // Bind the install and activate methods to the instance.\n        this.install = this.install.bind(this);\n        this.activate = this.activate.bind(this);\n    }\n    /**\n     * @type {module:workbox-precaching.PrecacheStrategy} The strategy created by this controller and\n     * used to cache assets and respond to fetch events.\n     */\n    get strategy() {\n        return this._strategy;\n    }\n    /**\n     * Adds items to the precache list, removing any duplicates and\n     * stores the files in the\n     * [\"precache cache\"]{@link module:workbox-core.cacheNames} when the service\n     * worker installs.\n     *\n     * This method can be called multiple times.\n     *\n     * @param {Array<Object|string>} [entries=[]] Array of entries to precache.\n     */\n    precache(entries) {\n        this.addToCacheList(entries);\n        if (!this._installAndActiveListenersAdded) {\n            self.addEventListener('install', this.install);\n            self.addEventListener('activate', this.activate);\n            this._installAndActiveListenersAdded = true;\n        }\n    }\n    /**\n     * This method will add items to the precache list, removing duplicates\n     * and ensuring the information is valid.\n     *\n     * @param {Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string>} entries\n     *     Array of entries to precache.\n     */\n    addToCacheList(entries) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isArray(entries, {\n                moduleName: 'workbox-precaching',\n                className: 'PrecacheController',\n                funcName: 'addToCacheList',\n                paramName: 'entries',\n            });\n        }\n        const urlsToWarnAbout = [];\n        for (const entry of entries) {\n            // See https://github.com/GoogleChrome/workbox/issues/2259\n            if (typeof entry === 'string') {\n                urlsToWarnAbout.push(entry);\n            }\n            else if (entry && entry.revision === undefined) {\n                urlsToWarnAbout.push(entry.url);\n            }\n            const { cacheKey, url } = createCacheKey(entry);\n            const cacheMode = (typeof entry !== 'string' && entry.revision) ?\n                'reload' : 'default';\n            if (this._urlsToCacheKeys.has(url) &&\n                this._urlsToCacheKeys.get(url) !== cacheKey) {\n                throw new WorkboxError('add-to-cache-list-conflicting-entries', {\n                    firstEntry: this._urlsToCacheKeys.get(url),\n                    secondEntry: cacheKey,\n                });\n            }\n            if (typeof entry !== 'string' && entry.integrity) {\n                if (this._cacheKeysToIntegrities.has(cacheKey) &&\n                    this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {\n                    throw new WorkboxError('add-to-cache-list-conflicting-integrities', {\n                        url,\n                    });\n                }\n                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);\n            }\n            this._urlsToCacheKeys.set(url, cacheKey);\n            this._urlsToCacheModes.set(url, cacheMode);\n            if (urlsToWarnAbout.length > 0) {\n                const warningMessage = `Workbox is precaching URLs without revision ` +\n                    `info: ${urlsToWarnAbout.join(', ')}\\nThis is generally NOT safe. ` +\n                    `Learn more at https://bit.ly/wb-precache`;\n                if (process.env.NODE_ENV === 'production') {\n                    // Use console directly to display this warning without bloating\n                    // bundle sizes by pulling in all of the logger codebase in prod.\n                    console.warn(warningMessage);\n                }\n                else {\n                    logger.warn(warningMessage);\n                }\n            }\n        }\n    }\n    /**\n     * Precaches new and updated assets. Call this method from the service worker\n     * install event.\n     *\n     * Note: this method calls `event.waitUntil()` for you, so you do not need\n     * to call it yourself in your event handlers.\n     *\n     * @param {ExtendableEvent} event\n     * @return {Promise<module:workbox-precaching.InstallResult>}\n     */\n    install(event) {\n        return waitUntil(event, async () => {\n            const installReportPlugin = new PrecacheInstallReportPlugin();\n            this.strategy.plugins.push(installReportPlugin);\n            // Cache entries one at a time.\n            // See https://github.com/GoogleChrome/workbox/issues/2528\n            for (const [url, cacheKey] of this._urlsToCacheKeys) {\n                const integrity = this._cacheKeysToIntegrities.get(cacheKey);\n                const cacheMode = this._urlsToCacheModes.get(url);\n                const request = new Request(url, {\n                    integrity,\n                    cache: cacheMode,\n                    credentials: 'same-origin',\n                });\n                await Promise.all(this.strategy.handleAll({\n                    params: { cacheKey },\n                    request,\n                    event,\n                }));\n            }\n            const { updatedURLs, notUpdatedURLs } = installReportPlugin;\n            if (process.env.NODE_ENV !== 'production') {\n                printInstallDetails(updatedURLs, notUpdatedURLs);\n            }\n            return { updatedURLs, notUpdatedURLs };\n        });\n    }\n    /**\n     * Deletes assets that are no longer present in the current precache manifest.\n     * Call this method from the service worker activate event.\n     *\n     * Note: this method calls `event.waitUntil()` for you, so you do not need\n     * to call it yourself in your event handlers.\n     *\n     * @param {ExtendableEvent} event\n     * @return {Promise<module:workbox-precaching.CleanupResult>}\n     */\n    activate(event) {\n        return waitUntil(event, async () => {\n            const cache = await self.caches.open(this.strategy.cacheName);\n            const currentlyCachedRequests = await cache.keys();\n            const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());\n            const deletedURLs = [];\n            for (const request of currentlyCachedRequests) {\n                if (!expectedCacheKeys.has(request.url)) {\n                    await cache.delete(request);\n                    deletedURLs.push(request.url);\n                }\n            }\n            if (process.env.NODE_ENV !== 'production') {\n                printCleanupDetails(deletedURLs);\n            }\n            return { deletedURLs };\n        });\n    }\n    /**\n     * Returns a mapping of a precached URL to the corresponding cache key, taking\n     * into account the revision information for the URL.\n     *\n     * @return {Map<string, string>} A URL to cache key mapping.\n     */\n    getURLsToCacheKeys() {\n        return this._urlsToCacheKeys;\n    }\n    /**\n     * Returns a list of all the URLs that have been precached by the current\n     * service worker.\n     *\n     * @return {Array<string>} The precached URLs.\n     */\n    getCachedURLs() {\n        return [...this._urlsToCacheKeys.keys()];\n    }\n    /**\n     * Returns the cache key used for storing a given URL. If that URL is\n     * unversioned, like `/index.html', then the cache key will be the original\n     * URL with a search parameter appended to it.\n     *\n     * @param {string} url A URL whose cache key you want to look up.\n     * @return {string} The versioned URL that corresponds to a cache key\n     * for the original URL, or undefined if that URL isn't precached.\n     */\n    getCacheKeyForURL(url) {\n        const urlObject = new URL(url, location.href);\n        return this._urlsToCacheKeys.get(urlObject.href);\n    }\n    /**\n     * This acts as a drop-in replacement for\n     * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)\n     * with the following differences:\n     *\n     * - It knows what the name of the precache is, and only checks in that cache.\n     * - It allows you to pass in an \"original\" URL without versioning parameters,\n     * and it will automatically look up the correct cache key for the currently\n     * active revision of that URL.\n     *\n     * E.g., `matchPrecache('index.html')` will find the correct precached\n     * response for the currently active service worker, even if the actual cache\n     * key is `'/index.html?__WB_REVISION__=1234abcd'`.\n     *\n     * @param {string|Request} request The key (without revisioning parameters)\n     * to look up in the precache.\n     * @return {Promise<Response|undefined>}\n     */\n    async matchPrecache(request) {\n        const url = request instanceof Request ? request.url : request;\n        const cacheKey = this.getCacheKeyForURL(url);\n        if (cacheKey) {\n            const cache = await self.caches.open(this.strategy.cacheName);\n            return cache.match(cacheKey);\n        }\n        return undefined;\n    }\n    /**\n     * Returns a function that looks up `url` in the precache (taking into\n     * account revision information), and returns the corresponding `Response`.\n     *\n     * @param {string} url The precached URL which will be used to lookup the\n     * `Response`.\n     * @return {module:workbox-routing~handlerCallback}\n     */\n    createHandlerBoundToURL(url) {\n        const cacheKey = this.getCacheKeyForURL(url);\n        if (!cacheKey) {\n            throw new WorkboxError('non-precached-url', { url });\n        }\n        return (options) => {\n            options.request = new Request(url);\n            options.params = { cacheKey, ...options.params };\n            return this.strategy.handle(options);\n        };\n    }\n}\nexport { PrecacheController };\n","/*\n  Copyright 2020 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { Route } from 'workbox-routing/Route.js';\nimport { generateURLVariations } from './utils/generateURLVariations.js';\nimport './_version.js';\n/**\n * A subclass of [Route]{@link module:workbox-routing.Route} that takes a\n * [PrecacheController]{@link module:workbox-precaching.PrecacheController}\n * instance and uses it to match incoming requests and handle fetching\n * responses from the precache.\n *\n * @memberof module:workbox-precaching\n * @extends module:workbox-routing.Route\n */\nclass PrecacheRoute extends Route {\n    /**\n     * @param {PrecacheController} precacheController A `PrecacheController`\n     * instance used to both match requests and respond to fetch events.\n     * @param {Object} [options] Options to control how requests are matched\n     * against the list of precached URLs.\n     * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n     * check cache entries for a URLs ending with '/' to see if there is a hit when\n     * appending the `directoryIndex` value.\n     * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/, /^fbclid$/]] An\n     * array of regex's to remove search params when looking for a cache match.\n     * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n     * check the cache for the URL with a `.html` added to the end of the end.\n     * @param {module:workbox-precaching~urlManipulation} [options.urlManipulation]\n     * This is a function that should take a URL and return an array of\n     * alternative URLs that should be checked for precache matches.\n     */\n    constructor(precacheController, options) {\n        const match = ({ request }) => {\n            const urlsToCacheKeys = precacheController.getURLsToCacheKeys();\n            for (const possibleURL of generateURLVariations(request.url, options)) {\n                const cacheKey = urlsToCacheKeys.get(possibleURL);\n                if (cacheKey) {\n                    return { cacheKey };\n                }\n            }\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Precaching did not find a match for ` +\n                    getFriendlyURL(request.url));\n            }\n            return;\n        };\n        super(match, precacheController.strategy);\n    }\n}\nexport { PrecacheRoute };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { removeIgnoredSearchParams } from './removeIgnoredSearchParams.js';\nimport '../_version.js';\n/**\n * Generator function that yields possible variations on the original URL to\n * check, one at a time.\n *\n * @param {string} url\n * @param {Object} options\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function* generateURLVariations(url, { ignoreURLParametersMatching = [/^utm_/, /^fbclid$/], directoryIndex = 'index.html', cleanURLs = true, urlManipulation, } = {}) {\n    const urlObject = new URL(url, location.href);\n    urlObject.hash = '';\n    yield urlObject.href;\n    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);\n    yield urlWithoutIgnoredParams.href;\n    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {\n        const directoryURL = new URL(urlWithoutIgnoredParams.href);\n        directoryURL.pathname += directoryIndex;\n        yield directoryURL.href;\n    }\n    if (cleanURLs) {\n        const cleanURL = new URL(urlWithoutIgnoredParams.href);\n        cleanURL.pathname += '.html';\n        yield cleanURL.href;\n    }\n    if (urlManipulation) {\n        const additionalURLs = urlManipulation({ url: urlObject });\n        for (const urlToAttempt of additionalURLs) {\n            yield urlToAttempt.href;\n        }\n    }\n}\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * Removes any URL search parameters that should be ignored.\n *\n * @param {URL} urlObject The original URL.\n * @param {Array<RegExp>} ignoreURLParametersMatching RegExps to test against\n * each search parameter name. Matches mean that the search parameter should be\n * ignored.\n * @return {URL} The URL with any ignored search parameters removed.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {\n    // Convert the iterable into an array at the start of the loop to make sure\n    // deletion doesn't mess up iteration.\n    for (const paramName of [...urlObject.searchParams.keys()]) {\n        if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) {\n            urlObject.searchParams.delete(paramName);\n        }\n    }\n    return urlObject;\n}\n","export const isNav = event => event.request.mode === 'navigate';\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nexport const cacheOkAndOpaquePlugin = {\n    /**\n     * Returns a valid response (to allow caching) if the status is 200 (OK) or\n     * 0 (opaque).\n     *\n     * @param {Object} options\n     * @param {Response} options.response\n     * @return {Response|null}\n     *\n     * @private\n     */\n    cacheWillUpdate: async ({ response }) => {\n        if (response.status === 200 || response.status === 0) {\n            return response;\n        }\n        return null;\n    },\n};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';\nimport { Strategy } from './Strategy.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [network first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-falling-back-to-cache}\n * request strategy.\n *\n * By default, this strategy will cache responses with a 200 status code as\n * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.\n * Opaque responses are are cross-origin requests where the response doesn't\n * support [CORS]{@link https://enable-cors.org/}.\n *\n * If the network request fails, and there is no cache match, this will throw\n * a `WorkboxError` exception.\n *\n * @extends module:workbox-strategies.Strategy\n * @memberof module:workbox-strategies\n */\nclass NetworkFirst extends Strategy {\n    /**\n     * @param {Object} [options]\n     * @param {string} [options.cacheName] Cache name to store and retrieve\n     * requests. Defaults to cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} [options.fetchOptions] Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n     * `fetch()` requests made by this strategy.\n     * @param {Object} [options.matchOptions] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n     * @param {number} [options.networkTimeoutSeconds] If set, any network requests\n     * that fail to respond within the timeout will fallback to the cache.\n     *\n     * This option can be used to combat\n     * \"[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}\"\n     * scenarios.\n     */\n    constructor(options = {}) {\n        super(options);\n        // If this instance contains no plugins with a 'cacheWillUpdate' callback,\n        // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list.\n        if (!this.plugins.some((p) => 'cacheWillUpdate' in p)) {\n            this.plugins.unshift(cacheOkAndOpaquePlugin);\n        }\n        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;\n        if (process.env.NODE_ENV !== 'production') {\n            if (this._networkTimeoutSeconds) {\n                assert.isType(this._networkTimeoutSeconds, 'number', {\n                    moduleName: 'workbox-strategies',\n                    className: this.constructor.name,\n                    funcName: 'constructor',\n                    paramName: 'networkTimeoutSeconds',\n                });\n            }\n        }\n    }\n    /**\n     * @private\n     * @param {Request|string} request A request to run this strategy for.\n     * @param {module:workbox-strategies.StrategyHandler} handler The event that\n     *     triggered the request.\n     * @return {Promise<Response>}\n     */\n    async _handle(request, handler) {\n        const logs = [];\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: this.constructor.name,\n                funcName: 'handle',\n                paramName: 'makeRequest',\n            });\n        }\n        const promises = [];\n        let timeoutId;\n        if (this._networkTimeoutSeconds) {\n            const { id, promise } = this._getTimeoutPromise({ request, logs, handler });\n            timeoutId = id;\n            promises.push(promise);\n        }\n        const networkPromise = this._getNetworkPromise({ timeoutId, request, logs, handler });\n        promises.push(networkPromise);\n        const response = await handler.waitUntil((async () => {\n            // Promise.race() will resolve as soon as the first promise resolves.\n            return await handler.waitUntil(Promise.race(promises)) ||\n                // If Promise.race() resolved with null, it might be due to a network\n                // timeout + a cache miss. If that were to happen, we'd rather wait until\n                // the networkPromise resolves instead of returning null.\n                // Note that it's fine to await an already-resolved promise, so we don't\n                // have to check to see if it's still \"in flight\".\n                await networkPromise;\n        })());\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));\n            for (const log of logs) {\n                logger.log(log);\n            }\n            messages.printFinalResponse(response);\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url });\n        }\n        return response;\n    }\n    /**\n     * @param {Object} options\n     * @param {Request} options.request\n     * @param {Array} options.logs A reference to the logs array\n     * @param {Event} options.event\n     * @return {Promise<Response>}\n     *\n     * @private\n     */\n    _getTimeoutPromise({ request, logs, handler }) {\n        let timeoutId;\n        const timeoutPromise = new Promise((resolve) => {\n            const onNetworkTimeout = async () => {\n                if (process.env.NODE_ENV !== 'production') {\n                    logs.push(`Timing out the network response at ` +\n                        `${this._networkTimeoutSeconds} seconds.`);\n                }\n                resolve(await handler.cacheMatch(request));\n            };\n            timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);\n        });\n        return {\n            promise: timeoutPromise,\n            id: timeoutId,\n        };\n    }\n    /**\n     * @param {Object} options\n     * @param {number|undefined} options.timeoutId\n     * @param {Request} options.request\n     * @param {Array} options.logs A reference to the logs Array.\n     * @param {Event} options.event\n     * @return {Promise<Response>}\n     *\n     * @private\n     */\n    async _getNetworkPromise({ timeoutId, request, logs, handler }) {\n        let error;\n        let response;\n        try {\n            response = await handler.fetchAndCachePut(request);\n        }\n        catch (fetchError) {\n            error = fetchError;\n        }\n        if (timeoutId) {\n            clearTimeout(timeoutId);\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            if (response) {\n                logs.push(`Got response from network.`);\n            }\n            else {\n                logs.push(`Unable to get a response from the network. Will respond ` +\n                    `with a cached response.`);\n            }\n        }\n        if (error || !response) {\n            response = await handler.cacheMatch(request);\n            if (process.env.NODE_ENV !== 'production') {\n                if (response) {\n                    logs.push(`Found a cached response in the '${this.cacheName}'` +\n                        ` cache.`);\n                }\n                else {\n                    logs.push(`No response found in the '${this.cacheName}' cache.`);\n                }\n            }\n        }\n        return response;\n    }\n}\nexport { NetworkFirst };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { timeout } from 'workbox-core/_private/timeout.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { Strategy } from './Strategy.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [network-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only}\n * request strategy.\n *\n * This class is useful if you want to take advantage of any\n * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.\n *\n * If the network request fails, this will throw a `WorkboxError` exception.\n *\n * @extends module:workbox-strategies.Strategy\n * @memberof module:workbox-strategies\n */\nclass NetworkOnly extends Strategy {\n    /**\n     * @param {Object} [options]\n     * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} [options.fetchOptions] Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n     * `fetch()` requests made by this strategy.\n     * @param {number} [options.networkTimeoutSeconds] If set, any network requests\n     * that fail to respond within the timeout will result in a network error.\n     */\n    constructor(options = {}) {\n        super(options);\n        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;\n    }\n    /**\n     * @private\n     * @param {Request|string} request A request to run this strategy for.\n     * @param {module:workbox-strategies.StrategyHandler} handler The event that\n     *     triggered the request.\n     * @return {Promise<Response>}\n     */\n    async _handle(request, handler) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: this.constructor.name,\n                funcName: '_handle',\n                paramName: 'request',\n            });\n        }\n        let error = undefined;\n        let response;\n        try {\n            const promises = [handler.fetch(request)];\n            if (this._networkTimeoutSeconds) {\n                const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000);\n                promises.push(timeoutPromise);\n            }\n            response = await Promise.race(promises);\n            if (!response) {\n                throw new Error(`Timed out the network response after ` +\n                    `${this._networkTimeoutSeconds} seconds.`);\n            }\n        }\n        catch (err) {\n            error = err;\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));\n            if (response) {\n                logger.log(`Got response from network.`);\n            }\n            else {\n                logger.log(`Unable to get a response from the network.`);\n            }\n            messages.printFinalResponse(response);\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url, error });\n        }\n        return response;\n    }\n}\nexport { NetworkOnly };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';\nimport { Strategy } from './Strategy.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [stale-while-revalidate]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#stale-while-revalidate}\n * request strategy.\n *\n * Resources are requested from both the cache and the network in parallel.\n * The strategy will respond with the cached version if available, otherwise\n * wait for the network response. The cache is updated with the network response\n * with each successful request.\n *\n * By default, this strategy will cache responses with a 200 status code as\n * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.\n * Opaque responses are cross-origin requests where the response doesn't\n * support [CORS]{@link https://enable-cors.org/}.\n *\n * If the network request fails, and there is no cache match, this will throw\n * a `WorkboxError` exception.\n *\n * @extends module:workbox-strategies.Strategy\n * @memberof module:workbox-strategies\n */\nclass StaleWhileRevalidate extends Strategy {\n    /**\n     * @param {Object} [options]\n     * @param {string} [options.cacheName] Cache name to store and retrieve\n     * requests. Defaults to cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} [options.fetchOptions] Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n     * `fetch()` requests made by this strategy.\n     * @param {Object} [options.matchOptions] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n     */\n    constructor(options) {\n        super(options);\n        // If this instance contains no plugins with a 'cacheWillUpdate' callback,\n        // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list.\n        if (!this.plugins.some((p) => 'cacheWillUpdate' in p)) {\n            this.plugins.unshift(cacheOkAndOpaquePlugin);\n        }\n    }\n    /**\n     * @private\n     * @param {Request|string} request A request to run this strategy for.\n     * @param {module:workbox-strategies.StrategyHandler} handler The event that\n     *     triggered the request.\n     * @return {Promise<Response>}\n     */\n    async _handle(request, handler) {\n        const logs = [];\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: this.constructor.name,\n                funcName: 'handle',\n                paramName: 'request',\n            });\n        }\n        const fetchAndCachePromise = handler\n            .fetchAndCachePut(request)\n            .catch(() => {\n            // Swallow this error because a 'no-response' error will be thrown in\n            // main handler return flow. This will be in the `waitUntil()` flow.\n        });\n        let response = await handler.cacheMatch(request);\n        let error;\n        if (response) {\n            if (process.env.NODE_ENV !== 'production') {\n                logs.push(`Found a cached response in the '${this.cacheName}'` +\n                    ` cache. Will update with the network response in the background.`);\n            }\n        }\n        else {\n            if (process.env.NODE_ENV !== 'production') {\n                logs.push(`No response found in the '${this.cacheName}' cache. ` +\n                    `Will wait for the network response.`);\n            }\n            try {\n                // NOTE(philipwalton): Really annoying that we have to type cast here.\n                // https://github.com/microsoft/TypeScript/issues/20006\n                response = await fetchAndCachePromise;\n            }\n            catch (err) {\n                error = err;\n            }\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));\n            for (const log of logs) {\n                logger.log(log);\n            }\n            messages.printFinalResponse(response);\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url, error });\n        }\n        return response;\n    }\n}\nexport { StaleWhileRevalidate };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * A class that wraps common IndexedDB functionality in a promise-based API.\n * It exposes all the underlying power and functionality of IndexedDB, but\n * wraps the most commonly used features in a way that's much simpler to use.\n *\n * @private\n */\nexport class DBWrapper {\n    /**\n     * @param {string} name\n     * @param {number} version\n     * @param {Object=} [callback]\n     * @param {!Function} [callbacks.onupgradeneeded]\n     * @param {!Function} [callbacks.onversionchange] Defaults to\n     *     DBWrapper.prototype._onversionchange when not specified.\n     * @private\n     */\n    constructor(name, version, { onupgradeneeded, onversionchange, } = {}) {\n        this._db = null;\n        this._name = name;\n        this._version = version;\n        this._onupgradeneeded = onupgradeneeded;\n        this._onversionchange = onversionchange || (() => this.close());\n    }\n    /**\n     * Returns the IDBDatabase instance (not normally needed).\n     * @return {IDBDatabase|undefined}\n     *\n     * @private\n     */\n    get db() {\n        return this._db;\n    }\n    /**\n     * Opens a connected to an IDBDatabase, invokes any onupgradedneeded\n     * callback, and added an onversionchange callback to the database.\n     *\n     * @return {IDBDatabase}\n     * @private\n     */\n    async open() {\n        if (this._db)\n            return;\n        this._db = await new Promise((resolve, reject) => {\n            // This flag is flipped to true if the timeout callback runs prior\n            // to the request failing or succeeding. Note: we use a timeout instead\n            // of an onblocked handler since there are cases where onblocked will\n            // never never run. A timeout better handles all possible scenarios:\n            // https://github.com/w3c/IndexedDB/issues/223\n            let openRequestTimedOut = false;\n            setTimeout(() => {\n                openRequestTimedOut = true;\n                reject(new Error('The open request was blocked and timed out'));\n            }, this.OPEN_TIMEOUT);\n            const openRequest = indexedDB.open(this._name, this._version);\n            openRequest.onerror = () => reject(openRequest.error);\n            openRequest.onupgradeneeded = (evt) => {\n                if (openRequestTimedOut) {\n                    openRequest.transaction.abort();\n                    openRequest.result.close();\n                }\n                else if (typeof this._onupgradeneeded === 'function') {\n                    this._onupgradeneeded(evt);\n                }\n            };\n            openRequest.onsuccess = () => {\n                const db = openRequest.result;\n                if (openRequestTimedOut) {\n                    db.close();\n                }\n                else {\n                    db.onversionchange = this._onversionchange.bind(this);\n                    resolve(db);\n                }\n            };\n        });\n        return this;\n    }\n    /**\n     * Polyfills the native `getKey()` method. Note, this is overridden at\n     * runtime if the browser supports the native method.\n     *\n     * @param {string} storeName\n     * @param {*} query\n     * @return {Array}\n     * @private\n     */\n    async getKey(storeName, query) {\n        return (await this.getAllKeys(storeName, query, 1))[0];\n    }\n    /**\n     * Polyfills the native `getAll()` method. Note, this is overridden at\n     * runtime if the browser supports the native method.\n     *\n     * @param {string} storeName\n     * @param {*} query\n     * @param {number} count\n     * @return {Array}\n     * @private\n     */\n    async getAll(storeName, query, count) {\n        return await this.getAllMatching(storeName, { query, count });\n    }\n    /**\n     * Polyfills the native `getAllKeys()` method. Note, this is overridden at\n     * runtime if the browser supports the native method.\n     *\n     * @param {string} storeName\n     * @param {*} query\n     * @param {number} count\n     * @return {Array}\n     * @private\n     */\n    async getAllKeys(storeName, query, count) {\n        const entries = await this.getAllMatching(storeName, { query, count, includeKeys: true });\n        return entries.map((entry) => entry.key);\n    }\n    /**\n     * Supports flexible lookup in an object store by specifying an index,\n     * query, direction, and count. This method returns an array of objects\n     * with the signature .\n     *\n     * @param {string} storeName\n     * @param {Object} [opts]\n     * @param {string} [opts.index] The index to use (if specified).\n     * @param {*} [opts.query]\n     * @param {IDBCursorDirection} [opts.direction]\n     * @param {number} [opts.count] The max number of results to return.\n     * @param {boolean} [opts.includeKeys] When true, the structure of the\n     *     returned objects is changed from an array of values to an array of\n     *     objects in the form {key, primaryKey, value}.\n     * @return {Array}\n     * @private\n     */\n    async getAllMatching(storeName, { index, query = null, // IE/Edge errors if query === `undefined`.\n    direction = 'next', count, includeKeys = false, } = {}) {\n        return await this.transaction([storeName], 'readonly', (txn, done) => {\n            const store = txn.objectStore(storeName);\n            const target = index ? store.index(index) : store;\n            const results = [];\n            const request = target.openCursor(query, direction);\n            request.onsuccess = () => {\n                const cursor = request.result;\n                if (cursor) {\n                    results.push(includeKeys ? cursor : cursor.value);\n                    if (count && results.length >= count) {\n                        done(results);\n                    }\n                    else {\n                        cursor.continue();\n                    }\n                }\n                else {\n                    done(results);\n                }\n            };\n        });\n    }\n    /**\n     * Accepts a list of stores, a transaction type, and a callback and\n     * performs a transaction. A promise is returned that resolves to whatever\n     * value the callback chooses. The callback holds all the transaction logic\n     * and is invoked with two arguments:\n     *   1. The IDBTransaction object\n     *   2. A `done` function, that's used to resolve the promise when\n     *      when the transaction is done, if passed a value, the promise is\n     *      resolved to that value.\n     *\n     * @param {Array<string>} storeNames An array of object store names\n     *     involved in the transaction.\n     * @param {string} type Can be `readonly` or `readwrite`.\n     * @param {!Function} callback\n     * @return {*} The result of the transaction ran by the callback.\n     * @private\n     */\n    async transaction(storeNames, type, callback) {\n        await this.open();\n        return await new Promise((resolve, reject) => {\n            const txn = this._db.transaction(storeNames, type);\n            txn.onabort = () => reject(txn.error);\n            txn.oncomplete = () => resolve();\n            callback(txn, (value) => resolve(value));\n        });\n    }\n    /**\n     * Delegates async to a native IDBObjectStore method.\n     *\n     * @param {string} method The method name.\n     * @param {string} storeName The object store name.\n     * @param {string} type Can be `readonly` or `readwrite`.\n     * @param {...*} args The list of args to pass to the native method.\n     * @return {*} The result of the transaction.\n     * @private\n     */\n    async _call(method, storeName, type, ...args) {\n        const callback = (txn, done) => {\n            const objStore = txn.objectStore(storeName);\n            // TODO(philipwalton): Fix this underlying TS2684 error.\n            // @ts-ignore\n            const request = objStore[method].apply(objStore, args);\n            request.onsuccess = () => done(request.result);\n        };\n        return await this.transaction([storeName], type, callback);\n    }\n    /**\n     * Closes the connection opened by `DBWrapper.open()`. Generally this method\n     * doesn't need to be called since:\n     *   1. It's usually better to keep a connection open since opening\n     *      a new connection is somewhat slow.\n     *   2. Connections are automatically closed when the reference is\n     *      garbage collected.\n     * The primary use case for needing to close a connection is when another\n     * reference (typically in another tab) needs to upgrade it and would be\n     * blocked by the current, open connection.\n     *\n     * @private\n     */\n    close() {\n        if (this._db) {\n            this._db.close();\n            this._db = null;\n        }\n    }\n}\n// Exposed on the prototype to let users modify the default timeout on a\n// per-instance or global basis.\nDBWrapper.prototype.OPEN_TIMEOUT = 2000;\n// Wrap native IDBObjectStore methods according to their mode.\nconst methodsToWrap = {\n    readonly: ['get', 'count', 'getKey', 'getAll', 'getAllKeys'],\n    readwrite: ['add', 'put', 'clear', 'delete'],\n};\nfor (const [mode, methods] of Object.entries(methodsToWrap)) {\n    for (const method of methods) {\n        if (method in IDBObjectStore.prototype) {\n            // Don't use arrow functions here since we're outside of the class.\n            DBWrapper.prototype[method] =\n                async function (storeName, ...args) {\n                    return await this._call(method, storeName, mode, ...args);\n                };\n        }\n    }\n}\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * Deletes the database.\n * Note: this is exported separately from the DBWrapper module because most\n * usages of IndexedDB in workbox dont need deleting, and this way it can be\n * reused in tests to delete databases without creating DBWrapper instances.\n *\n * @param {string} name The database name.\n * @private\n */\nexport const deleteDatabase = async (name) => {\n    await new Promise((resolve, reject) => {\n        const request = indexedDB.deleteDatabase(name);\n        request.onerror = () => {\n            reject(request.error);\n        };\n        request.onblocked = () => {\n            reject(new Error('Delete blocked'));\n        };\n        request.onsuccess = () => {\n            resolve();\n        };\n    });\n};\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { getOrCreateDefaultRouter } from './utils/getOrCreateDefaultRouter.js';\nimport './_version.js';\n/**\n * If a Route throws an error while handling a request, this `handler`\n * will be called and given a chance to provide a response.\n *\n * @param {module:workbox-routing~handlerCallback} handler A callback\n * function that returns a Promise resulting in a Response.\n *\n * @memberof module:workbox-routing\n */\nfunction setCatchHandler(handler) {\n    const defaultRouter = getOrCreateDefaultRouter();\n    defaultRouter.setCatchHandler(handler);\n}\nexport { setCatchHandler };\n","/*\n  Copyright 2019 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { cacheNames as _cacheNames } from './_private/cacheNames.js';\nimport './_version.js';\n/**\n * Get the current cache names and prefix/suffix used by Workbox.\n *\n * `cacheNames.precache` is used for precached assets,\n * `cacheNames.googleAnalytics` is used by `workbox-google-analytics` to\n * store `analytics.js`, and `cacheNames.runtime` is used for everything else.\n *\n * `cacheNames.prefix` can be used to retrieve just the current prefix value.\n * `cacheNames.suffix` can be used to retrieve just the current suffix value.\n *\n * @return {Object} An object with `precache`, `runtime`, `prefix`, and\n *     `googleAnalytics` properties.\n *\n * @memberof module:workbox-core\n */\nconst cacheNames = {\n    get googleAnalytics() {\n        return _cacheNames.getGoogleAnalyticsName();\n    },\n    get precache() {\n        return _cacheNames.getPrecacheName();\n    },\n    get prefix() {\n        return _cacheNames.getPrefix();\n    },\n    get runtime() {\n        return _cacheNames.getRuntimeName();\n    },\n    get suffix() {\n        return _cacheNames.getSuffix();\n    },\n};\nexport { cacheNames };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport './_version.js';\n/**\n * This class allows you to set up rules determining what\n * status codes and/or headers need to be present in order for a\n * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n * to be considered cacheable.\n *\n * @memberof module:workbox-cacheable-response\n */\nclass CacheableResponse {\n    /**\n     * To construct a new CacheableResponse instance you must provide at least\n     * one of the `config` properties.\n     *\n     * If both `statuses` and `headers` are specified, then both conditions must\n     * be met for the `Response` to be considered cacheable.\n     *\n     * @param {Object} config\n     * @param {Array<number>} [config.statuses] One or more status codes that a\n     * `Response` can have and be considered cacheable.\n     * @param {Object<string,string>} [config.headers] A mapping of header names\n     * and expected values that a `Response` can have and be considered cacheable.\n     * If multiple headers are provided, only one needs to be present.\n     */\n    constructor(config = {}) {\n        if (process.env.NODE_ENV !== 'production') {\n            if (!(config.statuses || config.headers)) {\n                throw new WorkboxError('statuses-or-headers-required', {\n                    moduleName: 'workbox-cacheable-response',\n                    className: 'CacheableResponse',\n                    funcName: 'constructor',\n                });\n            }\n            if (config.statuses) {\n                assert.isArray(config.statuses, {\n                    moduleName: 'workbox-cacheable-response',\n                    className: 'CacheableResponse',\n                    funcName: 'constructor',\n                    paramName: 'config.statuses',\n                });\n            }\n            if (config.headers) {\n                assert.isType(config.headers, 'object', {\n                    moduleName: 'workbox-cacheable-response',\n                    className: 'CacheableResponse',\n                    funcName: 'constructor',\n                    paramName: 'config.headers',\n                });\n            }\n        }\n        this._statuses = config.statuses;\n        this._headers = config.headers;\n    }\n    /**\n     * Checks a response to see whether it's cacheable or not, based on this\n     * object's configuration.\n     *\n     * @param {Response} response The response whose cacheability is being\n     * checked.\n     * @return {boolean} `true` if the `Response` is cacheable, and `false`\n     * otherwise.\n     */\n    isResponseCacheable(response) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(response, Response, {\n                moduleName: 'workbox-cacheable-response',\n                className: 'CacheableResponse',\n                funcName: 'isResponseCacheable',\n                paramName: 'response',\n            });\n        }\n        let cacheable = true;\n        if (this._statuses) {\n            cacheable = this._statuses.includes(response.status);\n        }\n        if (this._headers && cacheable) {\n            cacheable = Object.keys(this._headers).some((headerName) => {\n                return response.headers.get(headerName) === this._headers[headerName];\n            });\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            if (!cacheable) {\n                logger.groupCollapsed(`The request for ` +\n                    `'${getFriendlyURL(response.url)}' returned a response that does ` +\n                    `not meet the criteria for being cached.`);\n                logger.groupCollapsed(`View cacheability criteria here.`);\n                logger.log(`Cacheable statuses: ` +\n                    JSON.stringify(this._statuses));\n                logger.log(`Cacheable headers: ` +\n                    JSON.stringify(this._headers, null, 2));\n                logger.groupEnd();\n                const logFriendlyHeaders = {};\n                response.headers.forEach((value, key) => {\n                    logFriendlyHeaders[key] = value;\n                });\n                logger.groupCollapsed(`View response status and headers here.`);\n                logger.log(`Response status: ` + response.status);\n                logger.log(`Response headers: ` +\n                    JSON.stringify(logFriendlyHeaders, null, 2));\n                logger.groupEnd();\n                logger.groupCollapsed(`View full response details here.`);\n                logger.log(response.headers);\n                logger.log(response);\n                logger.groupEnd();\n                logger.groupEnd();\n            }\n        }\n        return cacheable;\n    }\n}\nexport { CacheableResponse };\n","import { NetworkFirst } from 'workbox-strategies';\nimport { cacheNames } from 'workbox-core';\nimport { CacheableResponsePlugin } from 'workbox-cacheable-response';\n\nexport const PRECACHING_OPTIONS = {};\n\nexport const NETWORK_HANDLER = new NetworkFirst({\n\t// this cache is plunged with every new service worker deploy so we dont need to care about purging the cache.\n\tcacheName: cacheNames.precache,\n\tnetworkTimeoutSeconds: 5, // if u dont start getting headers within 5 sec fallback to cache.\n\tplugins: [\n\t\tnew CacheableResponsePlugin({\n\t\t\tstatuses: [200], // only cache valid responses, not opaque responses e.g. wifi portal.\n\t\t}),\n\t],\n});\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { CacheableResponse } from './CacheableResponse.js';\nimport './_version.js';\n/**\n * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it\n * easier to add in cacheability checks to requests made via Workbox's built-in\n * strategies.\n *\n * @memberof module:workbox-cacheable-response\n */\nclass CacheableResponsePlugin {\n    /**\n     * To construct a new CacheableResponsePlugin instance you must provide at\n     * least one of the `config` properties.\n     *\n     * If both `statuses` and `headers` are specified, then both conditions must\n     * be met for the `Response` to be considered cacheable.\n     *\n     * @param {Object} config\n     * @param {Array<number>} [config.statuses] One or more status codes that a\n     * `Response` can have and be considered cacheable.\n     * @param {Object<string,string>} [config.headers] A mapping of header names\n     * and expected values that a `Response` can have and be considered cacheable.\n     * If multiple headers are provided, only one needs to be present.\n     */\n    constructor(config) {\n        /**\n         * @param {Object} options\n         * @param {Response} options.response\n         * @return {Response|null}\n         * @private\n         */\n        this.cacheWillUpdate = async ({ response }) => {\n            if (this._cacheableResponse.isResponseCacheable(response)) {\n                return response;\n            }\n            return null;\n        };\n        this._cacheableResponse = new CacheableResponse(config);\n    }\n}\nexport { CacheableResponsePlugin };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { DBWrapper } from 'workbox-core/_private/DBWrapper.js';\nimport '../_version.js';\nconst DB_VERSION = 3;\nconst DB_NAME = 'workbox-background-sync';\nconst OBJECT_STORE_NAME = 'requests';\nconst INDEXED_PROP = 'queueName';\n/**\n * A class to manage storing requests from a Queue in IndexedDB,\n * indexed by their queue name for easier access.\n *\n * @private\n */\nexport class QueueStore {\n    /**\n     * Associates this instance with a Queue instance, so entries added can be\n     * identified by their queue name.\n     *\n     * @param {string} queueName\n     * @private\n     */\n    constructor(queueName) {\n        this._queueName = queueName;\n        this._db = new DBWrapper(DB_NAME, DB_VERSION, {\n            onupgradeneeded: this._upgradeDb,\n        });\n    }\n    /**\n     * Append an entry last in the queue.\n     *\n     * @param {Object} entry\n     * @param {Object} entry.requestData\n     * @param {number} [entry.timestamp]\n     * @param {Object} [entry.metadata]\n     * @private\n     */\n    async pushEntry(entry) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(entry, 'object', {\n                moduleName: 'workbox-background-sync',\n                className: 'QueueStore',\n                funcName: 'pushEntry',\n                paramName: 'entry',\n            });\n            assert.isType(entry.requestData, 'object', {\n                moduleName: 'workbox-background-sync',\n                className: 'QueueStore',\n                funcName: 'pushEntry',\n                paramName: 'entry.requestData',\n            });\n        }\n        // Don't specify an ID since one is automatically generated.\n        delete entry.id;\n        entry.queueName = this._queueName;\n        await this._db.add(OBJECT_STORE_NAME, entry);\n    }\n    /**\n     * Prepend an entry first in the queue.\n     *\n     * @param {Object} entry\n     * @param {Object} entry.requestData\n     * @param {number} [entry.timestamp]\n     * @param {Object} [entry.metadata]\n     * @private\n     */\n    async unshiftEntry(entry) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(entry, 'object', {\n                moduleName: 'workbox-background-sync',\n                className: 'QueueStore',\n                funcName: 'unshiftEntry',\n                paramName: 'entry',\n            });\n            assert.isType(entry.requestData, 'object', {\n                moduleName: 'workbox-background-sync',\n                className: 'QueueStore',\n                funcName: 'unshiftEntry',\n                paramName: 'entry.requestData',\n            });\n        }\n        const [firstEntry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {\n            count: 1,\n        });\n        if (firstEntry) {\n            // Pick an ID one less than the lowest ID in the object store.\n            entry.id = firstEntry.id - 1;\n        }\n        else {\n            // Otherwise let the auto-incrementor assign the ID.\n            delete entry.id;\n        }\n        entry.queueName = this._queueName;\n        await this._db.add(OBJECT_STORE_NAME, entry);\n    }\n    /**\n     * Removes and returns the last entry in the queue matching the `queueName`.\n     *\n     * @return {Promise<Object>}\n     * @private\n     */\n    async popEntry() {\n        return this._removeEntry({ direction: 'prev' });\n    }\n    /**\n     * Removes and returns the first entry in the queue matching the `queueName`.\n     *\n     * @return {Promise<Object>}\n     * @private\n     */\n    async shiftEntry() {\n        return this._removeEntry({ direction: 'next' });\n    }\n    /**\n     * Returns all entries in the store matching the `queueName`.\n     *\n     * @param {Object} options See {@link module:workbox-background-sync.Queue~getAll}\n     * @return {Promise<Array<Object>>}\n     * @private\n     */\n    async getAll() {\n        return await this._db.getAllMatching(OBJECT_STORE_NAME, {\n            index: INDEXED_PROP,\n            query: IDBKeyRange.only(this._queueName),\n        });\n    }\n    /**\n     * Deletes the entry for the given ID.\n     *\n     * WARNING: this method does not ensure the deleted enry belongs to this\n     * queue (i.e. matches the `queueName`). But this limitation is acceptable\n     * as this class is not publicly exposed. An additional check would make\n     * this method slower than it needs to be.\n     *\n     * @private\n     * @param {number} id\n     */\n    async deleteEntry(id) {\n        await this._db.delete(OBJECT_STORE_NAME, id);\n    }\n    /**\n     * Removes and returns the first or last entry in the queue (based on the\n     * `direction` argument) matching the `queueName`.\n     *\n     * @return {Promise<Object>}\n     * @private\n     */\n    async _removeEntry({ direction }) {\n        const [entry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {\n            direction,\n            index: INDEXED_PROP,\n            query: IDBKeyRange.only(this._queueName),\n            count: 1,\n        });\n        if (entry) {\n            await this.deleteEntry(entry.id);\n            return entry;\n        }\n    }\n    /**\n     * Upgrades the database given an `upgradeneeded` event.\n     *\n     * @param {Event} event\n     * @private\n     */\n    _upgradeDb(event) {\n        const db = event.target.result;\n        if (event.oldVersion > 0 && event.oldVersion < DB_VERSION) {\n            if (db.objectStoreNames.contains(OBJECT_STORE_NAME)) {\n                db.deleteObjectStore(OBJECT_STORE_NAME);\n            }\n        }\n        const objStore = db.createObjectStore(OBJECT_STORE_NAME, {\n            autoIncrement: true,\n            keyPath: 'id',\n        });\n        objStore.createIndex(INDEXED_PROP, INDEXED_PROP, { unique: false });\n    }\n}\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport '../_version.js';\nconst serializableProperties = [\n    'method',\n    'referrer',\n    'referrerPolicy',\n    'mode',\n    'credentials',\n    'cache',\n    'redirect',\n    'integrity',\n    'keepalive',\n];\n/**\n * A class to make it easier to serialize and de-serialize requests so they\n * can be stored in IndexedDB.\n *\n * @private\n */\nclass StorableRequest {\n    /**\n     * Accepts an object of request data that can be used to construct a\n     * `Request` but can also be stored in IndexedDB.\n     *\n     * @param {Object} requestData An object of request data that includes the\n     *     `url` plus any relevant properties of\n     *     [requestInit]{@link https://fetch.spec.whatwg.org/#requestinit}.\n     * @private\n     */\n    constructor(requestData) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(requestData, 'object', {\n                moduleName: 'workbox-background-sync',\n                className: 'StorableRequest',\n                funcName: 'constructor',\n                paramName: 'requestData',\n            });\n            assert.isType(requestData.url, 'string', {\n                moduleName: 'workbox-background-sync',\n                className: 'StorableRequest',\n                funcName: 'constructor',\n                paramName: 'requestData.url',\n            });\n        }\n        // If the request's mode is `navigate`, convert it to `same-origin` since\n        // navigation requests can't be constructed via script.\n        if (requestData['mode'] === 'navigate') {\n            requestData['mode'] = 'same-origin';\n        }\n        this._requestData = requestData;\n    }\n    /**\n     * Converts a Request object to a plain object that can be structured\n     * cloned or JSON-stringified.\n     *\n     * @param {Request} request\n     * @return {Promise<StorableRequest>}\n     *\n     * @private\n     */\n    static async fromRequest(request) {\n        const requestData = {\n            url: request.url,\n            headers: {},\n        };\n        // Set the body if present.\n        if (request.method !== 'GET') {\n            // Use ArrayBuffer to support non-text request bodies.\n            // NOTE: we can't use Blobs becuse Safari doesn't support storing\n            // Blobs in IndexedDB in some cases:\n            // https://github.com/dfahlander/Dexie.js/issues/618#issuecomment-398348457\n            requestData.body = await request.clone().arrayBuffer();\n        }\n        // Convert the headers from an iterable to an object.\n        for (const [key, value] of request.headers.entries()) {\n            requestData.headers[key] = value;\n        }\n        // Add all other serializable request properties\n        for (const prop of serializableProperties) {\n            if (request[prop] !== undefined) {\n                requestData[prop] = request[prop];\n            }\n        }\n        return new StorableRequest(requestData);\n    }\n    /**\n     * Returns a deep clone of the instances `_requestData` object.\n     *\n     * @return {Object}\n     *\n     * @private\n     */\n    toObject() {\n        const requestData = Object.assign({}, this._requestData);\n        requestData.headers = Object.assign({}, this._requestData.headers);\n        if (requestData.body) {\n            requestData.body = requestData.body.slice(0);\n        }\n        return requestData;\n    }\n    /**\n     * Converts this instance to a Request.\n     *\n     * @return {Request}\n     *\n     * @private\n     */\n    toRequest() {\n        return new Request(this._requestData.url, this._requestData);\n    }\n    /**\n     * Creates and returns a deep clone of the instance.\n     *\n     * @return {StorableRequest}\n     *\n     * @private\n     */\n    clone() {\n        return new StorableRequest(this.toObject());\n    }\n}\nexport { StorableRequest };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { QueueStore } from './lib/QueueStore.js';\nimport { StorableRequest } from './lib/StorableRequest.js';\nimport './_version.js';\nconst TAG_PREFIX = 'workbox-background-sync';\nconst MAX_RETENTION_TIME = 60 * 24 * 7; // 7 days in minutes\nconst queueNames = new Set();\n/**\n * Converts a QueueStore entry into the format exposed by Queue. This entails\n * converting the request data into a real request and omitting the `id` and\n * `queueName` properties.\n *\n * @param {Object} queueStoreEntry\n * @return {Object}\n * @private\n */\nconst convertEntry = (queueStoreEntry) => {\n    const queueEntry = {\n        request: new StorableRequest(queueStoreEntry.requestData).toRequest(),\n        timestamp: queueStoreEntry.timestamp,\n    };\n    if (queueStoreEntry.metadata) {\n        queueEntry.metadata = queueStoreEntry.metadata;\n    }\n    return queueEntry;\n};\n/**\n * A class to manage storing failed requests in IndexedDB and retrying them\n * later. All parts of the storing and replaying process are observable via\n * callbacks.\n *\n * @memberof module:workbox-background-sync\n */\nclass Queue {\n    /**\n     * Creates an instance of Queue with the given options\n     *\n     * @param {string} name The unique name for this queue. This name must be\n     *     unique as it's used to register sync events and store requests\n     *     in IndexedDB specific to this instance. An error will be thrown if\n     *     a duplicate name is detected.\n     * @param {Object} [options]\n     * @param {Function} [options.onSync] A function that gets invoked whenever\n     *     the 'sync' event fires. The function is invoked with an object\n     *     containing the `queue` property (referencing this instance), and you\n     *     can use the callback to customize the replay behavior of the queue.\n     *     When not set the `replayRequests()` method is called.\n     *     Note: if the replay fails after a sync event, make sure you throw an\n     *     error, so the browser knows to retry the sync event later.\n     * @param {number} [options.maxRetentionTime=7 days] The amount of time (in\n     *     minutes) a request may be retried. After this amount of time has\n     *     passed, the request will be deleted from the queue.\n     */\n    constructor(name, { onSync, maxRetentionTime } = {}) {\n        this._syncInProgress = false;\n        this._requestsAddedDuringSync = false;\n        // Ensure the store name is not already being used\n        if (queueNames.has(name)) {\n            throw new WorkboxError('duplicate-queue-name', { name });\n        }\n        else {\n            queueNames.add(name);\n        }\n        this._name = name;\n        this._onSync = onSync || this.replayRequests;\n        this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME;\n        this._queueStore = new QueueStore(this._name);\n        this._addSyncListener();\n    }\n    /**\n     * @return {string}\n     */\n    get name() {\n        return this._name;\n    }\n    /**\n     * Stores the passed request in IndexedDB (with its timestamp and any\n     * metadata) at the end of the queue.\n     *\n     * @param {Object} entry\n     * @param {Request} entry.request The request to store in the queue.\n     * @param {Object} [entry.metadata] Any metadata you want associated with the\n     *     stored request. When requests are replayed you'll have access to this\n     *     metadata object in case you need to modify the request beforehand.\n     * @param {number} [entry.timestamp] The timestamp (Epoch time in\n     *     milliseconds) when the request was first added to the queue. This is\n     *     used along with `maxRetentionTime` to remove outdated requests. In\n     *     general you don't need to set this value, as it's automatically set\n     *     for you (defaulting to `Date.now()`), but you can update it if you\n     *     don't want particular requests to expire.\n     */\n    async pushRequest(entry) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(entry, 'object', {\n                moduleName: 'workbox-background-sync',\n                className: 'Queue',\n                funcName: 'pushRequest',\n                paramName: 'entry',\n            });\n            assert.isInstance(entry.request, Request, {\n                moduleName: 'workbox-background-sync',\n                className: 'Queue',\n                funcName: 'pushRequest',\n                paramName: 'entry.request',\n            });\n        }\n        await this._addRequest(entry, 'push');\n    }\n    /**\n     * Stores the passed request in IndexedDB (with its timestamp and any\n     * metadata) at the beginning of the queue.\n     *\n     * @param {Object} entry\n     * @param {Request} entry.request The request to store in the queue.\n     * @param {Object} [entry.metadata] Any metadata you want associated with the\n     *     stored request. When requests are replayed you'll have access to this\n     *     metadata object in case you need to modify the request beforehand.\n     * @param {number} [entry.timestamp] The timestamp (Epoch time in\n     *     milliseconds) when the request was first added to the queue. This is\n     *     used along with `maxRetentionTime` to remove outdated requests. In\n     *     general you don't need to set this value, as it's automatically set\n     *     for you (defaulting to `Date.now()`), but you can update it if you\n     *     don't want particular requests to expire.\n     */\n    async unshiftRequest(entry) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(entry, 'object', {\n                moduleName: 'workbox-background-sync',\n                className: 'Queue',\n                funcName: 'unshiftRequest',\n                paramName: 'entry',\n            });\n            assert.isInstance(entry.request, Request, {\n                moduleName: 'workbox-background-sync',\n                className: 'Queue',\n                funcName: 'unshiftRequest',\n                paramName: 'entry.request',\n            });\n        }\n        await this._addRequest(entry, 'unshift');\n    }\n    /**\n     * Removes and returns the last request in the queue (along with its\n     * timestamp and any metadata). The returned object takes the form:\n     * `{request, timestamp, metadata}`.\n     *\n     * @return {Promise<Object>}\n     */\n    async popRequest() {\n        return this._removeRequest('pop');\n    }\n    /**\n     * Removes and returns the first request in the queue (along with its\n     * timestamp and any metadata). The returned object takes the form:\n     * `{request, timestamp, metadata}`.\n     *\n     * @return {Promise<Object>}\n     */\n    async shiftRequest() {\n        return this._removeRequest('shift');\n    }\n    /**\n     * Returns all the entries that have not expired (per `maxRetentionTime`).\n     * Any expired entries are removed from the queue.\n     *\n     * @return {Promise<Array<Object>>}\n     */\n    async getAll() {\n        const allEntries = await this._queueStore.getAll();\n        const now = Date.now();\n        const unexpiredEntries = [];\n        for (const entry of allEntries) {\n            // Ignore requests older than maxRetentionTime. Call this function\n            // recursively until an unexpired request is found.\n            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;\n            if (now - entry.timestamp > maxRetentionTimeInMs) {\n                await this._queueStore.deleteEntry(entry.id);\n            }\n            else {\n                unexpiredEntries.push(convertEntry(entry));\n            }\n        }\n        return unexpiredEntries;\n    }\n    /**\n     * Adds the entry to the QueueStore and registers for a sync event.\n     *\n     * @param {Object} entry\n     * @param {Request} entry.request\n     * @param {Object} [entry.metadata]\n     * @param {number} [entry.timestamp=Date.now()]\n     * @param {string} operation ('push' or 'unshift')\n     * @private\n     */\n    async _addRequest({ request, metadata, timestamp = Date.now(), }, operation) {\n        const storableRequest = await StorableRequest.fromRequest(request.clone());\n        const entry = {\n            requestData: storableRequest.toObject(),\n            timestamp,\n        };\n        // Only include metadata if it's present.\n        if (metadata) {\n            entry.metadata = metadata;\n        }\n        await this._queueStore[`${operation}Entry`](entry);\n        if (process.env.NODE_ENV !== 'production') {\n            logger.log(`Request for '${getFriendlyURL(request.url)}' has ` +\n                `been added to background sync queue '${this._name}'.`);\n        }\n        // Don't register for a sync if we're in the middle of a sync. Instead,\n        // we wait until the sync is complete and call register if\n        // `this._requestsAddedDuringSync` is true.\n        if (this._syncInProgress) {\n            this._requestsAddedDuringSync = true;\n        }\n        else {\n            await this.registerSync();\n        }\n    }\n    /**\n     * Removes and returns the first or last (depending on `operation`) entry\n     * from the QueueStore that's not older than the `maxRetentionTime`.\n     *\n     * @param {string} operation ('pop' or 'shift')\n     * @return {Object|undefined}\n     * @private\n     */\n    async _removeRequest(operation) {\n        const now = Date.now();\n        const entry = await this._queueStore[`${operation}Entry`]();\n        if (entry) {\n            // Ignore requests older than maxRetentionTime. Call this function\n            // recursively until an unexpired request is found.\n            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;\n            if (now - entry.timestamp > maxRetentionTimeInMs) {\n                return this._removeRequest(operation);\n            }\n            return convertEntry(entry);\n        }\n        else {\n            return undefined;\n        }\n    }\n    /**\n     * Loops through each request in the queue and attempts to re-fetch it.\n     * If any request fails to re-fetch, it's put back in the same position in\n     * the queue (which registers a retry for the next sync event).\n     */\n    async replayRequests() {\n        let entry;\n        while ((entry = await this.shiftRequest())) {\n            try {\n                await fetch(entry.request.clone());\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` +\n                        `has been replayed in queue '${this._name}'`);\n                }\n            }\n            catch (error) {\n                await this.unshiftRequest(entry);\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` +\n                        `failed to replay, putting it back in queue '${this._name}'`);\n                }\n                throw new WorkboxError('queue-replay-failed', { name: this._name });\n            }\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.log(`All requests in queue '${this.name}' have successfully ` +\n                `replayed; the queue is now empty!`);\n        }\n    }\n    /**\n     * Registers a sync event with a tag unique to this instance.\n     */\n    async registerSync() {\n        if ('sync' in self.registration) {\n            try {\n                await self.registration.sync.register(`${TAG_PREFIX}:${this._name}`);\n            }\n            catch (err) {\n                // This means the registration failed for some reason, possibly due to\n                // the user disabling it.\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.warn(`Unable to register sync event for '${this._name}'.`, err);\n                }\n            }\n        }\n    }\n    /**\n     * In sync-supporting browsers, this adds a listener for the sync event.\n     * In non-sync-supporting browsers, this will retry the queue on service\n     * worker startup.\n     *\n     * @private\n     */\n    _addSyncListener() {\n        if ('sync' in self.registration) {\n            self.addEventListener('sync', (event) => {\n                if (event.tag === `${TAG_PREFIX}:${this._name}`) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        logger.log(`Background sync for tag '${event.tag}' ` +\n                            `has been received`);\n                    }\n                    const syncComplete = async () => {\n                        this._syncInProgress = true;\n                        let syncError;\n                        try {\n                            await this._onSync({ queue: this });\n                        }\n                        catch (error) {\n                            syncError = error;\n                            // Rethrow the error. Note: the logic in the finally clause\n                            // will run before this gets rethrown.\n                            throw syncError;\n                        }\n                        finally {\n                            // New items may have been added to the queue during the sync,\n                            // so we need to register for a new sync if that's happened...\n                            // Unless there was an error during the sync, in which\n                            // case the browser will automatically retry later, as long\n                            // as `event.lastChance` is not true.\n                            if (this._requestsAddedDuringSync &&\n                                !(syncError && !event.lastChance)) {\n                                await this.registerSync();\n                            }\n                            this._syncInProgress = false;\n                            this._requestsAddedDuringSync = false;\n                        }\n                    };\n                    event.waitUntil(syncComplete());\n                }\n            });\n        }\n        else {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.log(`Background sync replaying without background sync event`);\n            }\n            // If the browser doesn't support background sync, retry\n            // every time the service worker starts up as a fallback.\n            this._onSync({ queue: this });\n        }\n    }\n    /**\n     * Returns the set of queue names. This is primarily used to reset the list\n     * of queue names in tests.\n     *\n     * @return {Set}\n     *\n     * @private\n     */\n    static get _queueNames() {\n        return queueNames;\n    }\n}\nexport { Queue };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { Queue } from './Queue.js';\nimport './_version.js';\n/**\n * A class implementing the `fetchDidFail` lifecycle callback. This makes it\n * easier to add failed requests to a background sync Queue.\n *\n * @memberof module:workbox-background-sync\n */\nclass BackgroundSyncPlugin {\n    /**\n     * @param {string} name See the [Queue]{@link module:workbox-background-sync.Queue}\n     *     documentation for parameter details.\n     * @param {Object} [options] See the\n     *     [Queue]{@link module:workbox-background-sync.Queue} documentation for\n     *     parameter details.\n     */\n    constructor(name, options) {\n        /**\n         * @param {Object} options\n         * @param {Request} options.request\n         * @private\n         */\n        this.fetchDidFail = async ({ request }) => {\n            await this._queue.pushRequest({ request });\n        };\n        this._queue = new Queue(name, options);\n    }\n}\nexport { BackgroundSyncPlugin };\n","import { registerRoute, setCatchHandler } from 'workbox-routing';\nimport { precacheAndRoute, getCacheKeyForURL } from 'workbox-precaching';\nimport { isNav } from './utils';\nimport { NETWORK_HANDLER, PRECACHING_OPTIONS } from './contants';\n\nexport function getFiles() {\n\treturn self.__WB_MANIFEST;\n}\n\nexport function setupPrecaching(precacheFiles, precachingOptions) {\n\tprecacheAndRoute(precacheFiles, precachingOptions || PRECACHING_OPTIONS);\n}\n\nexport function setupRouting() {\n\t/**\n\t * Adding this before `precacheAndRoute` lets us handle all\n\t * the navigation requests even if they are in precache.\n\t */\n\tregisterRoute(({ event }) => isNav(event), NETWORK_HANDLER);\n\n\tsetCatchHandler(({ event }) => {\n\t\tif (isNav(event)) {\n\t\t\treturn caches.match(\n\t\t\t\tgetCacheKeyForURL('/200.html') || getCacheKeyForURL('/index.html')\n\t\t\t);\n\t\t}\n\t\treturn Response.error();\n\t});\n}\n\nexport { PRECACHING_OPTIONS };\n","function webpackEmptyContext(req) {\n\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\te.code = 'MODULE_NOT_FOUND';\n\tthrow e;\n}\nwebpackEmptyContext.keys = function() { return []; };\nwebpackEmptyContext.resolve = webpackEmptyContext;\nmodule.exports = webpackEmptyContext;\nwebpackEmptyContext.id = \"FWJg\";","module.exports = require('./gun.js')","\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:precaching:6.1.5'] && _();\n}\ncatch (e) { }\n","\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:routing:6.1.5'] && _();\n}\ncatch (e) { }\n",";(function(){\n\n  /* UNBUILD */\n  function USE(arg, req){\n    return req? require(arg) : arg.slice? USE[R(arg)] : function(mod, path){\n      arg(mod = {exports: {}});\n      USE[R(path)] = mod.exports;\n    }\n    function R(p){\n      return p.split('/').slice(-1).toString().replace('.js','');\n    }\n  }\n  if(typeof module !== \"undefined\"){ var MODULE = module }\n  /* UNBUILD */\n\n\t;USE(function(module){\n\t\t// Generic javascript utilities.\n\t\tvar Type = {};\n\t\t//Type.fns = Type.fn = {is: function(fn){ return (!!fn && fn instanceof Function) }}\n\t\tType.fn = {is: function(fn){ return (!!fn && 'function' == typeof fn) }}\n\t\tType.bi = {is: function(b){ return (b instanceof Boolean || typeof b == 'boolean') }}\n\t\tType.num = {is: function(n){ return !list_is(n) && ((n - parseFloat(n) + 1) >= 0 || Infinity === n || -Infinity === n) }}\n\t\tType.text = {is: function(t){ return (typeof t == 'string') }}\n\t\tType.text.ify = function(t){\n\t\t\tif(Type.text.is(t)){ return t }\n\t\t\tif(typeof JSON !== \"undefined\"){ return JSON.stringify(t) }\n\t\t\treturn (t && t.toString)? t.toString() : t;\n\t\t}\n\t\tType.text.random = function(l, c){\n\t\t\tvar s = '';\n\t\t\tl = l || 24; // you are not going to make a 0 length random number, so no need to check type\n\t\t\tc = c || '0123456789ABCDEFGHIJKLMNOPQRSTUVWXZabcdefghijklmnopqrstuvwxyz';\n\t\t\twhile(l > 0){ s += c.charAt(Math.floor(Math.random() * c.length)); l-- }\n\t\t\treturn s;\n\t\t}\n\t\tType.text.match = function(t, o){ var tmp, u;\n\t\t\tif('string' !== typeof t){ return false }\n\t\t\tif('string' == typeof o){ o = {'=': o} }\n\t\t\to = o || {};\n\t\t\ttmp = (o['='] || o['*'] || o['>'] || o['<']);\n\t\t\tif(t === tmp){ return true }\n\t\t\tif(u !== o['=']){ return false }\n\t\t\ttmp = (o['*'] || o['>'] || o['<']);\n\t\t\tif(t.slice(0, (tmp||'').length) === tmp){ return true }\n\t\t\tif(u !== o['*']){ return false }\n\t\t\tif(u !== o['>'] && u !== o['<']){\n\t\t\t\treturn (t >= o['>'] && t <= o['<'])? true : false;\n\t\t\t}\n\t\t\tif(u !== o['>'] && t >= o['>']){ return true }\n\t\t\tif(u !== o['<'] && t <= o['<']){ return true }\n\t\t\treturn false;\n\t\t}\n\t\tType.text.hash = function(s, c){ // via SO\n\t\t\tif(typeof s !== 'string'){ return }\n\t    c = c || 0;\n\t    if(!s.length){ return c }\n\t    for(var i=0,l=s.length,n; i<l; ++i){\n\t      n = s.charCodeAt(i);\n\t      c = ((c<<5)-c)+n;\n\t      c |= 0;\n\t    }\n\t    return c;\n\t  }\n\t\tType.list = {is: function(l){ return (l instanceof Array) }}\n\t\tType.list.slit = Array.prototype.slice;\n\t\tType.list.sort = function(k){ // creates a new sort function based off some key\n\t\t\treturn function(A,B){\n\t\t\t\tif(!A || !B){ return 0 } A = A[k]; B = B[k];\n\t\t\t\tif(A < B){ return -1 }else if(A > B){ return 1 }\n\t\t\t\telse { return 0 }\n\t\t\t}\n\t\t}\n\t\tType.list.map = function(l, c, _){ return obj_map(l, c, _) }\n\t\tType.list.index = 1; // change this to 0 if you want non-logical, non-mathematical, non-matrix, non-convenient array notation\n\t\tType.obj = {is: function(o){ return o? (o instanceof Object && o.constructor === Object) || Object.prototype.toString.call(o).match(/^\\[object (\\w+)\\]$/)[1] === 'Object' : false }}\n\t\tType.obj.put = function(o, k, v){ return (o||{})[k] = v, o }\n\t\tType.obj.has = function(o, k){ return o && Object.prototype.hasOwnProperty.call(o, k) }\n\t\tType.obj.del = function(o, k){\n\t\t\tif(!o){ return }\n\t\t\to[k] = null;\n\t\t\tdelete o[k];\n\t\t\treturn o;\n\t\t}\n\t\tType.obj.as = function(o, k, v, u){ return o[k] = o[k] || (u === v? {} : v) }\n\t\tType.obj.ify = function(o){\n\t\t\tif(obj_is(o)){ return o }\n\t\t\ttry{o = JSON.parse(o);\n\t\t\t}catch(e){o={}};\n\t\t\treturn o;\n\t\t}\n\t\t;(function(){ var u;\n\t\t\tfunction map(v,k){\n\t\t\t\tif(obj_has(this,k) && u !== this[k]){ return }\n\t\t\t\tthis[k] = v;\n\t\t\t}\n\t\t\tType.obj.to = function(from, to){\n\t\t\t\tto = to || {};\n\t\t\t\tobj_map(from, map, to);\n\t\t\t\treturn to;\n\t\t\t}\n\t\t}());\n\t\tType.obj.copy = function(o){ // because http://web.archive.org/web/20140328224025/http://jsperf.com/cloning-an-object/2\n\t\t\treturn !o? o : JSON.parse(JSON.stringify(o)); // is shockingly faster than anything else, and our data has to be a subset of JSON anyways!\n\t\t}\n\t\t;(function(){\n\t\t\tfunction empty(v,i){ var n = this.n, u;\n\t\t\t\tif(n && (i === n || (obj_is(n) && obj_has(n, i)))){ return }\n\t\t\t\tif(u !== i){ return true }\n\t\t\t}\n\t\t\tType.obj.empty = function(o, n){\n\t\t\t\tif(!o){ return true }\n\t\t\t\treturn obj_map(o,empty,{n:n})? false : true;\n\t\t\t}\n\t\t}());\n\t\t;(function(){\n\t\t\tfunction t(k,v){\n\t\t\t\tif(2 === arguments.length){\n\t\t\t\t\tt.r = t.r || {};\n\t\t\t\t\tt.r[k] = v;\n\t\t\t\t\treturn;\n\t\t\t\t} t.r = t.r || [];\n\t\t\t\tt.r.push(k);\n\t\t\t};\n\t\t\tvar keys = Object.keys, map, u;\n\t\t\tObject.keys = Object.keys || function(o){ return map(o, function(v,k,t){t(k)}) }\n\t\t\tType.obj.map = map = function(l, c, _){\n\t\t\t\tvar u, i = 0, x, r, ll, lle, f = 'function' == typeof c;\n\t\t\t\tt.r = u;\n\t\t\t\tif(keys && obj_is(l)){\n\t\t\t\t\tll = keys(l); lle = true;\n\t\t\t\t}\n\t\t\t\t_ = _ || {};\n\t\t\t\tif(list_is(l) || ll){\n\t\t\t\t\tx = (ll || l).length;\n\t\t\t\t\tfor(;i < x; i++){\n\t\t\t\t\t\tvar ii = (i + Type.list.index);\n\t\t\t\t\t\tif(f){\n\t\t\t\t\t\t\tr = lle? c.call(_, l[ll[i]], ll[i], t) : c.call(_, l[i], ii, t);\n\t\t\t\t\t\t\tif(r !== u){ return r }\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t//if(Type.test.is(c,l[i])){ return ii } // should implement deep equality testing!\n\t\t\t\t\t\t\tif(c === l[lle? ll[i] : i]){ return ll? ll[i] : ii } // use this for now\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tfor(i in l){\n\t\t\t\t\t\tif(f){\n\t\t\t\t\t\t\tif(obj_has(l,i)){\n\t\t\t\t\t\t\t\tr = _? c.call(_, l[i], i, t) : c(l[i], i, t);\n\t\t\t\t\t\t\t\tif(r !== u){ return r }\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t//if(a.test.is(c,l[i])){ return i } // should implement deep equality testing!\n\t\t\t\t\t\t\tif(c === l[i]){ return i } // use this for now\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn f? t.r : Type.list.index? 0 : -1;\n\t\t\t}\n\t\t}());\n\t\tType.time = {};\n\t\tType.time.is = function(t){ return t? t instanceof Date : (+new Date().getTime()) }\n\n\t\tvar fn_is = Type.fn.is;\n\t\tvar list_is = Type.list.is;\n\t\tvar obj = Type.obj, obj_is = obj.is, obj_has = obj.has, obj_map = obj.map;\n\t\tmodule.exports = Type;\n\t})(USE, './type');\n\n\t;USE(function(module){\n\t\t// On event emitter generic javascript utility.\n\t\tmodule.exports = function onto(tag, arg, as){\n\t\t\tif(!tag){ return {to: onto} }\n\t\t\tvar u, tag = (this.tag || (this.tag = {}))[tag] ||\n\t\t\t(this.tag[tag] = {tag: tag, to: onto._ = {\n\t\t\t\tnext: function(arg){ var tmp;\n\t\t\t\t\tif((tmp = this.to)){\n\t\t\t\t\t\ttmp.next(arg);\n\t\t\t\t}}\n\t\t\t}});\n\t\t\tif('function' == typeof arg){\n\t\t\t\tvar be = {\n\t\t\t\t\toff: onto.off ||\n\t\t\t\t\t(onto.off = function(){\n\t\t\t\t\t\tif(this.next === onto._.next){ return !0 }\n\t\t\t\t\t\tif(this === this.the.last){\n\t\t\t\t\t\t\tthis.the.last = this.back;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthis.to.back = this.back;\n\t\t\t\t\t\tthis.next = onto._.next;\n\t\t\t\t\t\tthis.back.to = this.to;\n\t\t\t\t\t\tif(this.the.last === this.the){\n\t\t\t\t\t\t\tdelete this.on.tag[this.the.tag];\n\t\t\t\t\t\t}\n\t\t\t\t\t}),\n\t\t\t\t\tto: onto._,\n\t\t\t\t\tnext: arg,\n\t\t\t\t\tthe: tag,\n\t\t\t\t\ton: this,\n\t\t\t\t\tas: as,\n\t\t\t\t};\n\t\t\t\t(be.back = tag.last || tag).to = be;\n\t\t\t\treturn tag.last = be;\n\t\t\t}\n\t\t\tif((tag = tag.to) && u !== arg){ tag.next(arg) }\n\t\t\treturn tag;\n\t\t};\n\t})(USE, './onto');\n\n\t;USE(function(module){\n\t\tvar to = (typeof setImmediate !== \"undefined\")? setImmediate : setTimeout, puff = function(cb){\n\t\t\tif(Q.length){ Q.push(cb); return } Q = [cb];\n\t\t\tto(function go(S){ S = S || +new Date;\n\t\t\t\tvar i = 0, cb; while(i < 9 && (cb = Q[i++])){ cb() }\n\t\t\t\tconsole.STAT && console.STAT(S, +new Date - S, 'puff');\n\t\t\t\tif(cb && !(+new Date - S)){ return go(S) }\n\t\t\t\tif(!(Q = Q.slice(i)).length){ return }\n\t\t\t\tto(go, 0);\n\t\t\t}, 0);\n\t\t}, Q = [];\n\t\tmodule.exports = setTimeout.puff = puff;\n\t})(USE, './puff');\n\n\t;USE(function(module){\n\t\t/* Based on the Hypothetical Amnesia Machine thought experiment */\n\t\tfunction HAM(machineState, incomingState, currentState, incomingValue, currentValue){\n\t\t\tif(machineState < incomingState){\n\t\t\t\treturn {defer: true}; // the incoming value is outside the boundary of the machine's state, it must be reprocessed in another state.\n\t\t\t}\n\t\t\tif(incomingState < currentState){\n\t\t\t\treturn {historical: true}; // the incoming value is within the boundary of the machine's state, but not within the range.\n\n\t\t\t}\n\t\t\tif(currentState < incomingState){\n\t\t\t\treturn {converge: true, incoming: true}; // the incoming value is within both the boundary and the range of the machine's state.\n\n\t\t\t}\n\t\t\tif(incomingState === currentState){\n\t\t\t\tincomingValue = Lexical(incomingValue) || \"\";\n\t\t\t\tcurrentValue = Lexical(currentValue) || \"\";\n\t\t\t\tif(incomingValue === currentValue){ // Note: while these are practically the same, the deltas could be technically different\n\t\t\t\t\treturn {state: true};\n\t\t\t\t}\n\t\t\t\t/*\n\t\t\t\t\tThe following is a naive implementation, but will always work.\n\t\t\t\t\tNever change it unless you have specific needs that absolutely require it.\n\t\t\t\t\tIf changed, your data will diverge unless you guarantee every peer's algorithm has also been changed to be the same.\n\t\t\t\t\tAs a result, it is highly discouraged to modify despite the fact that it is naive,\n\t\t\t\t\tbecause convergence (data integrity) is generally more important.\n\t\t\t\t\tAny difference in this algorithm must be given a new and different name.\n\t\t\t\t*/\n\t\t\t\tif(incomingValue < currentValue){ // Lexical only works on simple value types!\n\t\t\t\t\treturn {converge: true, current: true};\n\t\t\t\t}\n\t\t\t\tif(currentValue < incomingValue){ // Lexical only works on simple value types!\n\t\t\t\t\treturn {converge: true, incoming: true};\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn {err: \"Invalid CRDT Data: \"+ incomingValue +\" to \"+ currentValue +\" at \"+ incomingState +\" to \"+ currentState +\"!\"};\n\t\t}\n\t\tif(typeof JSON === 'undefined'){\n\t\t\tthrow new Error(\n\t\t\t\t'JSON is not included in this browser. Please load it first: ' +\n\t\t\t\t'ajax.cdnjs.com/ajax/libs/json2/20110223/json2.js'\n\t\t\t);\n\t\t}\n\t\tvar Lexical = JSON.stringify, undefined;\n\t\tmodule.exports = HAM;\n\t})(USE, './HAM');\n\n\t;USE(function(module){\n\t\tvar Type = USE('./type');\n\t\tvar Val = {};\n\t\tVal.is = function(v){ // Valid values are a subset of JSON: null, binary, number (!Infinity), text, or a soul relation. Arrays need special algorithms to handle concurrency, so they are not supported directly. Use an extension that supports them if needed but research their problems first.\n\t\t\tif(v === u){ return false }\n\t\t\tif(v === null){ return true } // \"deletes\", nulling out keys.\n\t\t\tif(v === Infinity){ return false } // we want this to be, but JSON does not support it, sad face.\n\t\t\tif(text_is(v) // by \"text\" we mean strings.\n\t\t\t|| bi_is(v) // by \"binary\" we mean boolean.\n\t\t\t|| num_is(v)){ // by \"number\" we mean integers or decimals.\n\t\t\t\treturn true; // simple values are valid.\n\t\t\t}\n\t\t\treturn Val.link.is(v) || false; // is the value a soul relation? Then it is valid and return it. If not, everything else remaining is an invalid data type. Custom extensions can be built on top of these primitives to support other types.\n\t\t}\n\t\tVal.link = Val.rel = {_: '#'};\n\t\t;(function(){\n\t\t\tVal.link.is = function(v){ // this defines whether an object is a soul relation or not, they look like this: {'#': 'UUID'}\n\t\t\t\tif(v && v[rel_] && !v._ && obj_is(v)){ // must be an object.\n\t\t\t\t\tvar o = {};\n\t\t\t\t\tobj_map(v, map, o);\n\t\t\t\t\tif(o.id){ // a valid id was found.\n\t\t\t\t\t\treturn o.id; // yay! Return it.\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn false; // the value was not a valid soul relation.\n\t\t\t}\n\t\t\tfunction map(s, k){ var o = this; // map over the object...\n\t\t\t\tif(o.id){ return o.id = false } // if ID is already defined AND we're still looping through the object, it is considered invalid.\n\t\t\t\tif(k == rel_ && text_is(s)){ // the key should be '#' and have a text value.\n\t\t\t\t\to.id = s; // we found the soul!\n\t\t\t\t} else {\n\t\t\t\t\treturn o.id = false; // if there exists anything else on the object that isn't the soul, then it is considered invalid.\n\t\t\t\t}\n\t\t\t}\n\t\t}());\n\t\tVal.link.ify = function(t){ return obj_put({}, rel_, t) } // convert a soul into a relation and return it.\n\t\tType.obj.has._ = '.';\n\t\tvar rel_ = Val.link._, u;\n\t\tvar bi_is = Type.bi.is;\n\t\tvar num_is = Type.num.is;\n\t\tvar text_is = Type.text.is;\n\t\tvar obj = Type.obj, obj_is = obj.is, obj_put = obj.put, obj_map = obj.map;\n\t\tmodule.exports = Val;\n\t})(USE, './val');\n\n\t;USE(function(module){\n\t\tvar Type = USE('./type');\n\t\tvar Val = USE('./val');\n\t\tvar Node = {_: '_'};\n\t\tNode.soul = function(n, o){ return (n && n._ && n._[o || soul_]) } // convenience function to check to see if there is a soul on a node and return it.\n\t\tNode.soul.ify = function(n, o){ // put a soul on an object.\n\t\t\to = (typeof o === 'string')? {soul: o} : o || {};\n\t\t\tn = n || {}; // make sure it exists.\n\t\t\tn._ = n._ || {}; // make sure meta exists.\n\t\t\tn._[soul_] = o.soul || n._[soul_] || text_random(); // put the soul on it.\n\t\t\treturn n;\n\t\t}\n\t\tNode.soul._ = Val.link._;\n\t\t;(function(){\n\t\t\tNode.is = function(n, cb, as){ var s; // checks to see if an object is a valid node.\n\t\t\t\tif(!obj_is(n)){ return false } // must be an object.\n\t\t\t\tif(s = Node.soul(n)){ // must have a soul on it.\n\t\t\t\t\treturn !obj_map(n, map, {as:as,cb:cb,s:s,n:n});\n\t\t\t\t}\n\t\t\t\treturn false; // nope! This was not a valid node.\n\t\t\t}\n\t\t\tfunction map(v, k){ // we invert this because the way we check for this is via a negation.\n\t\t\t\tif(k === Node._){ return } // skip over the metadata.\n\t\t\t\tif(!Val.is(v)){ return true } // it is true that this is an invalid node.\n\t\t\t\tif(this.cb){ this.cb.call(this.as, v, k, this.n, this.s) } // optionally callback each key/value.\n\t\t\t}\n\t\t}());\n\t\t;(function(){\n\t\t\tNode.ify = function(obj, o, as){ // returns a node from a shallow object.\n\t\t\t\tif(!o){ o = {} }\n\t\t\t\telse if(typeof o === 'string'){ o = {soul: o} }\n\t\t\t\telse if('function' == typeof o){ o = {map: o} }\n\t\t\t\tif(o.map){ o.node = o.map.call(as, obj, u, o.node || {}) }\n\t\t\t\tif(o.node = Node.soul.ify(o.node || {}, o)){\n\t\t\t\t\tobj_map(obj, map, {o:o,as:as});\n\t\t\t\t}\n\t\t\t\treturn o.node; // This will only be a valid node if the object wasn't already deep!\n\t\t\t}\n\t\t\tfunction map(v, k){ var o = this.o, tmp, u; // iterate over each key/value.\n\t\t\t\tif(o.map){\n\t\t\t\t\ttmp = o.map.call(this.as, v, ''+k, o.node);\n\t\t\t\t\tif(u === tmp){\n\t\t\t\t\t\tobj_del(o.node, k);\n\t\t\t\t\t} else\n\t\t\t\t\tif(o.node){ o.node[k] = tmp }\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif(Val.is(v)){\n\t\t\t\t\to.node[k] = v;\n\t\t\t\t}\n\t\t\t}\n\t\t}());\n\t\tvar obj = Type.obj, obj_is = obj.is, obj_del = obj.del, obj_map = obj.map;\n\t\tvar text = Type.text, text_random = text.random;\n\t\tvar soul_ = Node.soul._;\n\t\tvar u;\n\t\tmodule.exports = Node;\n\t})(USE, './node');\n\n\t;USE(function(module){\n\t\tvar Type = USE('./type');\n\t\tvar Node = USE('./node');\n\t\tfunction State(){\n\t\t\tvar t;\n\t\t\t/*if(perf){\n\t\t\t\tt = start + perf.now(); // Danger: Accuracy decays significantly over time, even if precise.\n\t\t\t} else {*/\n\t\t\t\tt = +new Date;\n\t\t\t//}\n\t\t\tif(last < t){\n\t\t\t\treturn N = 0, last = t + State.drift;\n\t\t\t}\n\t\t\treturn last = t + ((N += 1) / D) + State.drift;\n\t\t}\n\t\tvar time = Type.time.is, last = -Infinity, N = 0, D = 1000; // WARNING! In the future, on machines that are D times faster than 2016AD machines, you will want to increase D by another several orders of magnitude so the processing speed never out paces the decimal resolution (increasing an integer effects the state accuracy).\n\t\tvar perf = (typeof performance !== 'undefined')? (performance.timing && performance) : false, start = (perf && perf.timing && perf.timing.navigationStart) || (perf = false);\n\t\tvar S_ = State._ = '>';\n\t\tState.drift = 0;\n\t\tState.is = function(n, k, o){ // convenience function to get the state on a key on a node and return it.\n\t\t\tvar tmp = (k && n && n[N_] && n[N_][S_]) || o;\n\t\t\tif(!tmp){ return }\n\t\t\treturn num_is(tmp = tmp[k])? tmp : -Infinity;\n\t\t}\n\t\tState.lex = function(){ return State().toString(36).replace('.','') }\n\t\tState.ify = function(n, k, s, v, soul){ // put a key's state on a node.\n\t\t\tif(!n || !n[N_]){ // reject if it is not node-like.\n\t\t\t\tif(!soul){ // unless they passed a soul\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tn = Node.soul.ify(n, soul); // then make it so!\n\t\t\t}\n\t\t\tvar tmp = obj_as(n[N_], S_); // grab the states data.\n\t\t\tif(u !== k && k !== N_){\n\t\t\t\tif(num_is(s)){\n\t\t\t\t\ttmp[k] = s; // add the valid state.\n\t\t\t\t}\n\t\t\t\tif(u !== v){ // Note: Not its job to check for valid values!\n\t\t\t\t\tn[k] = v;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn n;\n\t\t}\n\t\tState.to = function(from, k, to){\n\t\t\tvar val = (from||{})[k];\n\t\t\tif(obj_is(val)){\n\t\t\t\tval = obj_copy(val);\n\t\t\t}\n\t\t\treturn State.ify(to, k, State.is(from, k), val, Node.soul(from));\n\t\t}\n\t\t;(function(){\n\t\t\tState.map = function(cb, s, as){ var u; // for use with Node.ify\n\t\t\t\tvar o = obj_is(o = cb || s)? o : null;\n\t\t\t\tcb = fn_is(cb = cb || s)? cb : null;\n\t\t\t\tif(o && !cb){\n\t\t\t\t\ts = num_is(s)? s : State();\n\t\t\t\t\to[N_] = o[N_] || {};\n\t\t\t\t\tobj_map(o, map, {o:o,s:s});\n\t\t\t\t\treturn o;\n\t\t\t\t}\n\t\t\t\tas = as || obj_is(s)? s : u;\n\t\t\t\ts = num_is(s)? s : State();\n\t\t\t\treturn function(v, k, o, opt){\n\t\t\t\t\tif(!cb){\n\t\t\t\t\t\tmap.call({o: o, s: s}, v,k);\n\t\t\t\t\t\treturn v;\n\t\t\t\t\t}\n\t\t\t\t\tcb.call(as || this || {}, v, k, o, opt);\n\t\t\t\t\tif(obj_has(o,k) && u === o[k]){ return }\n\t\t\t\t\tmap.call({o: o, s: s}, v,k);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfunction map(v,k){\n\t\t\t\tif(N_ === k){ return }\n\t\t\t\tState.ify(this.o, k, this.s) ;\n\t\t\t}\n\t\t}());\n\t\tvar obj = Type.obj, obj_as = obj.as, obj_has = obj.has, obj_is = obj.is, obj_map = obj.map, obj_copy = obj.copy;\n\t\tvar num = Type.num, num_is = num.is;\n\t\tvar fn = Type.fn, fn_is = fn.is;\n\t\tvar N_ = Node._, u;\n\t\tmodule.exports = State;\n\t})(USE, './state');\n\n\t;USE(function(module){\n\t\tvar Type = USE('./type');\n\t\tvar Val = USE('./val');\n\t\tvar Node = USE('./node');\n\t\tvar Graph = {};\n\t\t;(function(){\n\t\t\tGraph.is = function(g, cb, fn, as){ // checks to see if an object is a valid graph.\n\t\t\t\tif(!g || !obj_is(g) || obj_empty(g)){ return false } // must be an object.\n\t\t\t\treturn !obj_map(g, map, {cb:cb,fn:fn,as:as}); // makes sure it wasn't an empty object.\n\t\t\t}\n\t\t\tfunction map(n, s){ // we invert this because the way'? we check for this is via a negation.\n\t\t\t\tif(!n || s !== Node.soul(n) || !Node.is(n, this.fn, this.as)){ return true } // it is true that this is an invalid graph.\n\t\t\t\tif(!this.cb){ return }\n\t\t\t\tnf.n = n; nf.as = this.as; // sequential race conditions aren't races.\n\t\t\t\tthis.cb.call(nf.as, n, s, nf);\n\t\t\t}\n\t\t\tfunction nf(fn){ // optional callback for each node.\n\t\t\t\tif(fn){ Node.is(nf.n, fn, nf.as) } // where we then have an optional callback for each key/value.\n\t\t\t}\n\t\t}());\n\t\t;(function(){\n\t\t\tGraph.ify = function(obj, env, as){\n\t\t\t\tvar at = {path: [], obj: obj};\n\t\t\t\tif(!env){\n\t\t\t\t\tenv = {};\n\t\t\t\t} else\n\t\t\t\tif(typeof env === 'string'){\n\t\t\t\t\tenv = {soul: env};\n\t\t\t\t} else\n\t\t\t\tif('function' == typeof env){\n\t\t\t\t\tenv.map = env;\n\t\t\t\t}\n\t\t\t\tif(typeof as === 'string'){\n\t\t\t\t\tenv.soul = env.soul || as;\n\t\t\t\t\tas = u;\n\t\t\t\t}\n\t\t\t\tif(env.soul){\n\t\t\t\t\tat.link = Val.link.ify(env.soul);\n\t\t\t\t}\n\t\t\t\tenv.shell = (as||{}).shell;\n\t\t\t\tenv.graph = env.graph || {};\n\t\t\t\tenv.seen = env.seen || [];\n\t\t\t\tenv.as = env.as || as;\n\t\t\t\tnode(env, at);\n\t\t\t\tenv.root = at.node;\n\t\t\t\treturn env.graph;\n\t\t\t}\n\t\t\tfunction node(env, at){ var tmp;\n\t\t\t\tif(tmp = seen(env, at)){ return tmp }\n\t\t\t\tat.env = env;\n\t\t\t\tat.soul = soul;\n\t\t\t\tif(Node.ify(at.obj, map, at)){\n\t\t\t\t\tat.link = at.link || Val.link.ify(Node.soul(at.node));\n\t\t\t\t\tif(at.obj !== env.shell){\n\t\t\t\t\t\tenv.graph[Val.link.is(at.link)] = at.node;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn at;\n\t\t\t}\n\t\t\tfunction map(v,k,n){\n\t\t\t\tvar at = this, env = at.env, is, tmp;\n\t\t\t\tif(Node._ === k && obj_has(v,Val.link._)){\n\t\t\t\t\treturn n._; // TODO: Bug?\n\t\t\t\t}\n\t\t\t\tif(!(is = valid(v,k,n, at,env))){ return }\n\t\t\t\tif(!k){\n\t\t\t\t\tat.node = at.node || n || {};\n\t\t\t\t\tif(obj_has(v, Node._) && Node.soul(v)){ // ? for safety ?\n\t\t\t\t\t\tat.node._ = obj_copy(v._);\n\t\t\t\t\t}\n\t\t\t\t\tat.node = Node.soul.ify(at.node, Val.link.is(at.link));\n\t\t\t\t\tat.link = at.link || Val.link.ify(Node.soul(at.node));\n\t\t\t\t}\n\t\t\t\tif(tmp = env.map){\n\t\t\t\t\ttmp.call(env.as || {}, v,k,n, at);\n\t\t\t\t\tif(obj_has(n,k)){\n\t\t\t\t\t\tv = n[k];\n\t\t\t\t\t\tif(u === v){\n\t\t\t\t\t\t\tobj_del(n, k);\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif(!(is = valid(v,k,n, at,env))){ return }\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif(!k){ return at.node }\n\t\t\t\tif(true === is){\n\t\t\t\t\treturn v;\n\t\t\t\t}\n\t\t\t\ttmp = node(env, {obj: v, path: at.path.concat(k)});\n\t\t\t\tif(!tmp.node){ return }\n\t\t\t\treturn tmp.link; //{'#': Node.soul(tmp.node)};\n\t\t\t}\n\t\t\tfunction soul(id){ var at = this;\n\t\t\t\tvar prev = Val.link.is(at.link), graph = at.env.graph;\n\t\t\t\tat.link = at.link || Val.link.ify(id);\n\t\t\t\tat.link[Val.link._] = id;\n\t\t\t\tif(at.node && at.node[Node._]){\n\t\t\t\t\tat.node[Node._][Val.link._] = id;\n\t\t\t\t}\n\t\t\t\tif(obj_has(graph, prev)){\n\t\t\t\t\tgraph[id] = graph[prev];\n\t\t\t\t\tobj_del(graph, prev);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfunction valid(v,k,n, at,env){ var tmp;\n\t\t\t\tif(Val.is(v)){ return true }\n\t\t\t\tif(obj_is(v)){ return 1 }\n\t\t\t\tif(tmp = env.invalid){\n\t\t\t\t\tv = tmp.call(env.as || {}, v,k,n);\n\t\t\t\t\treturn valid(v,k,n, at,env);\n\t\t\t\t}\n\t\t\t\tenv.err = \"Invalid value at '\" + at.path.concat(k).join('.') + \"'!\";\n\t\t\t\tif(Type.list.is(v)){ env.err += \" Use `.set(item)` instead of an Array.\" }\n\t\t\t}\n\t\t\tfunction seen(env, at){\n\t\t\t\tvar arr = env.seen, i = arr.length, has;\n\t\t\t\twhile(i--){ has = arr[i];\n\t\t\t\t\tif(at.obj === has.obj){ return has }\n\t\t\t\t}\n\t\t\t\tarr.push(at);\n\t\t\t}\n\t\t}());\n\t\tGraph.node = function(node){\n\t\t\tvar soul = Node.soul(node);\n\t\t\tif(!soul){ return }\n\t\t\treturn obj_put({}, soul, node);\n\t\t}\n\t\t;(function(){\n\t\t\tGraph.to = function(graph, root, opt){\n\t\t\t\tif(!graph){ return }\n\t\t\t\tvar obj = {};\n\t\t\t\topt = opt || {seen: {}};\n\t\t\t\tobj_map(graph[root], map, {obj:obj, graph: graph, opt: opt});\n\t\t\t\treturn obj;\n\t\t\t}\n\t\t\tfunction map(v,k){ var tmp, obj;\n\t\t\t\tif(Node._ === k){\n\t\t\t\t\tif(obj_empty(v, Val.link._)){\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tthis.obj[k] = obj_copy(v);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif(!(tmp = Val.link.is(v))){\n\t\t\t\t\tthis.obj[k] = v;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif(obj = this.opt.seen[tmp]){\n\t\t\t\t\tthis.obj[k] = obj;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tthis.obj[k] = this.opt.seen[tmp] = Graph.to(this.graph, tmp, this.opt);\n\t\t\t}\n\t\t}());\n\t\tvar fn_is = Type.fn.is;\n\t\tvar obj = Type.obj, obj_is = obj.is, obj_del = obj.del, obj_has = obj.has, obj_empty = obj.empty, obj_put = obj.put, obj_map = obj.map, obj_copy = obj.copy;\n\t\tvar u;\n\t\tmodule.exports = Graph;\n\t})(USE, './graph');\n\n\t;USE(function(module){\n\t\t// request / response module, for asking and acking messages.\n\t\tUSE('./onto'); // depends upon onto!\n\t\tmodule.exports = function ask(cb, as){\n\t\t\tif(!this.on){ return }\n\t\t\tif(!('function' == typeof cb)){\n\t\t\t\tif(!cb || !as){ return }\n\t\t\t\tvar id = cb['#'] || cb, tmp = (this.tag||'')[id];\n\t\t\t\tif(!tmp){ return }\n\t\t\t\ttmp = this.on(id, as);\n\t\t\t\tclearTimeout(tmp.err);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tvar id = (as && as['#']) || Math.random().toString(36).slice(2);\n\t\t\tif(!cb){ return id }\n\t\t\tvar to = this.on(id, cb, as);\n\t\t\tto.err = to.err || setTimeout(function(){\n\t\t\t\tto.next({err: \"Error: No ACK yet.\", lack: true});\n\t\t\t\tto.off();\n\t\t\t}, (this.opt||{}).lack || 9000);\n\t\t\treturn id;\n\t\t}\n\t})(USE, './ask');\n\n\t;USE(function(module){\n\t\tvar Type = USE('./type');\n\t\tfunction Dup(opt){\n\t\t\tvar dup = {s:{}}, s = dup.s;\n\t\t\topt = opt || {max: 1000, age: /*1000 * 9};//*/ 1000 * 9 * 3};\n\t\t\tdup.check = function(id){\n\t\t\t\tif(!s[id]){ return false }\n\t\t\t\treturn dt(id);\n\t\t\t}\n\t\t\tvar dt = dup.track = function(id){\n\t\t\t\tvar it = s[id] || (s[id] = {});\n\t\t\t\tit.was = +new Date;\n\t\t\t\tif(!dup.to){ dup.to = setTimeout(dup.drop, opt.age + 9) }\n\t\t\t\treturn it;\n\t\t\t}\n\t\t\tdup.drop = function(age){\n\t\t\t\tvar now = +new Date;\n\t\t\t\tType.obj.map(s, function(it, id){\n\t\t\t\t\tif(it && (age || opt.age) > (now - it.was)){ return }\n\t\t\t\t\tdelete s[id];\n\t\t\t\t});\n\t\t\t\tdup.to = null;\n\t\t\t\tconsole.STAT && (age = +new Date - now) > 9 && console.STAT(now, age, 'dup drop');\n\t\t\t}\n\t\t\treturn dup;\n\t\t}\n\t\tmodule.exports = Dup;\n\t})(USE, './dup');\n\n\t;USE(function(module){\n\n\t\tfunction Gun(o){\n\t\t\tif(o instanceof Gun){ return (this._ = {$: this}).$ }\n\t\t\tif(!(this instanceof Gun)){ return new Gun(o) }\n\t\t\treturn Gun.create(this._ = {$: this, opt: o});\n\t\t}\n\n\t\tGun.is = function($){ return ($ instanceof Gun) || ($ && $._ && ($ === $._.$)) || false }\n\n\t\tGun.version = 0.2020;\n\n\t\tGun.chain = Gun.prototype;\n\t\tGun.chain.toJSON = function(){};\n\n\t\tvar Type = USE('./type');\n\t\tType.obj.to(Type, Gun);\n\t\tGun.HAM = USE('./HAM');\n\t\tGun.val = USE('./val');\n\t\tGun.node = USE('./node');\n\t\tGun.state = USE('./state');\n\t\tGun.graph = USE('./graph');\n\t\tGun.on = USE('./onto');\n\t\tGun.ask = USE('./ask');\n\t\tGun.dup = USE('./dup');\n\t\tGun.puff = USE('./puff');\n\n\t\t;(function(){\n\t\t\tGun.create = function(at){\n\t\t\t\tat.root = at.root || at;\n\t\t\t\tat.graph = at.graph || {};\n\t\t\t\tat.on = at.on || Gun.on;\n\t\t\t\tat.ask = at.ask || Gun.ask;\n\t\t\t\tat.dup = at.dup || Gun.dup();\n\t\t\t\tvar gun = at.$.opt(at.opt);\n\t\t\t\tif(!at.once){\n\t\t\t\t\tat.on('in', universe, at);\n\t\t\t\t\tat.on('out', universe, at);\n\t\t\t\t\tat.on('put', map, at);\n\t\t\t\t\tGun.on('create', at);\n\t\t\t\t\tat.on('create', at);\n\t\t\t\t}\n\t\t\t\tat.once = 1;\n\t\t\t\treturn gun;\n\t\t\t}\n\t\t\tfunction universe(msg){\n\t\t\t\tif(!msg){ return }\n\t\t\t\tif(msg.out === universe){ this.to.next(msg); return }\n\t\t\t\tvar eve = this, as = eve.as, at = as.at || as, gun = at.$, dup = at.dup, tmp, DBG = msg.DBG;\n\t\t\t\t(tmp = msg['#']) || (tmp = msg['#'] = text_rand(9));\n\t\t\t\tif(dup.check(tmp)){ return } dup.track(tmp);\n\t\t\t\ttmp = msg._; msg._ = ('function' == typeof tmp)? tmp : function(){};\n\t\t\t\t(msg.$ && (msg.$ === (msg.$._||'').$)) || (msg.$ = gun);\n\t\t\t\tif(!at.ask(msg['@'], msg)){ // is this machine listening for an ack?\n\t\t\t\t\tDBG && (DBG.u = +new Date);\n\t\t\t\t\tif(msg.get){ Gun.on._get(msg, gun) }\n\t\t\t\t\tif(msg.put){ put(msg); return }\n\t\t\t\t}\n\t\t\t\tDBG && (DBG.uc = +new Date);\n\t\t\t\teve.to.next(msg);\n\t\t\t\tDBG && (DBG.ua = +new Date);\n\t\t\t\tmsg.out = universe; at.on('out', msg);\n\t\t\t\tDBG && (DBG.ue = +new Date);\n\t\t\t}\n\t\t\tfunction put(msg){\n\t\t\t\tif(!msg){ return }\n\t\t\t\tvar ctx = msg._||'', root = ctx.root = ((ctx.$ = msg.$||'')._||'').root;\n\t\t\t\tvar put = msg.put, id = msg['#'], err, tmp;\n\t\t\t\tvar DBG = ctx.DBG = msg.DBG;\n\t\t\t\tif(put['#'] && put['.']){ root.on('put', msg); return } // TODO: BUG! This needs to call HAM instead.\n\t\t\t\t/*root.on(id, function(m){\n\t\t\t\t\tconsole.log('ack:', m);\n\t\t\t\t});*/\n\t\t\t\tctx.out = msg;\n\t\t\t\tctx.lot = {s: 0, more: 1};\n\t\t\t\tvar S = +new Date;\n\t\t\t\tDBG && (DBG.p = S);\n\t\t\t\tfor(var soul in put){ // Gun.obj.native() makes this safe.\n\t\t\t\t\tvar node = put[soul], states;\n\t\t\t\t\tif(!node){ err = ERR+cut(soul)+\"no node.\"; break }\n\t\t\t\t\tif(!(tmp = node._)){ err = ERR+cut(soul)+\"no meta.\"; break }\n\t\t\t\t\tif(soul !== tmp[_soul]){ err = ERR+cut(soul)+\"soul not same.\"; break }\n\t\t\t\t\tif(!(states = tmp[state_])){ err = ERR+cut(soul)+\"no state.\"; break }\n\t\t\t\t\tfor(var key in node){ // double loop uncool, but have to support old format.\n\t\t\t\t\t\tif(node_ === key){ continue }\n\t\t\t\t\t\tvar val = node[key], state = states[key];\n\t\t\t\t\t\tif(u === state){ err = ERR+cut(key)+\"on\"+cut(soul)+\"no state.\"; break }\n\t\t\t\t\t\tif(!val_is(val)){ err = ERR+cut(key)+\"on\"+cut(soul)+\"bad \"+(typeof val)+cut(val); break }\n\t\t\t\t\t\tham(val, key, soul, state, msg);\n\t\t\t\t\t}\n\t\t\t\t\tif(err){ break }\n\t\t\t\t}\n\t\t\t\tDBG && (DBG.pe = +new Date);\n\t\t\t\tif(console.STAT){ console.STAT(S, +new Date - S, 'mix');console.STAT(S, ctx.lot.s, 'mix #') }\n\t\t\t\tif(ctx.err = err){ root.on('in', {'@': id, err: Gun.log(err)}); return }\n\t\t\t\tif(!(--ctx.lot.more)){ fire(ctx) } // if synchronous.\n\t\t\t\tif(!ctx.stun && !msg['@']){ root.on('in', {'@': id, ok: -1}) } // in case no diff sent to storage, etc., still ack.\n\t\t\t} Gun.on.put = put;\n\t\t\tfunction ham(val, key, soul, state, msg){\n\t\t\t\tvar ctx = msg._||'', root = ctx.root, graph = root.graph, lot;\n\t\t\t\tvar vertex = graph[soul] || empty, was = state_is(vertex, key, 1), known = vertex[key];\n\t\t\t\tvar machine = State(), is = HAM(machine, state, was, val, known), u;\n\t\t\t\tif(!is.incoming){\n\t\t\t\t\tif(is.defer){\n\t\t\t\t\t\tvar to = state - machine;\n\t\t\t\t\t\tsetTimeout(function(){\n\t\t\t\t\t\t\tham(val, key, soul, state, msg);\n\t\t\t\t\t\t}, to > MD? MD : to); // setTimeout Max Defer 32bit :(\n\t\t\t\t\t\tif(!ctx.to){ root.on('in', {'@': msg['#'], err: to}) } ctx.to = 1; // TODO: This causes too many problems unless sending peers auto-retry.\n\t\t\t\t\t\treturn to;\n\t\t\t\t\t}\n\t\t\t\t\t//return; // it should be this\n\t\t\t\t\tif(!ctx.miss){ return } // but some chains have a cache miss that need to re-fire. // TODO: Improve in future.\n\t\t\t\t}\n\t\t\t\t(lot = ctx.lot||'').s++; lot.more++;\n\t\t\t\t(ctx.stun || (ctx.stun = {}))[soul+key] = 1;\n\t\t\t\tvar DBG = ctx.DBG; DBG && (DBG.ph = DBG.ph || +new Date);\n\t\t\t\troot.on('put', {'#': msg['#'], '@': msg['@'], put: {'#': soul, '.': key, ':': val, '>': state}, _: ctx});\n\t\t\t}\n\t\t\tfunction map(msg){\n\t\t\t\tvar DBG; if(DBG = (msg._||'').DBG){ DBG.pa = +new Date; DBG.pm = DBG.pm || +new Date}\n      \tvar eve = this, root = eve.as, graph = root.graph, ctx = msg._, put = msg.put, soul = put['#'], key = put['.'], val = put[':'], state = put['>'], id = msg['#'], tmp;\n\t\t\t\tgraph[soul] = state_ify(graph[soul], key, state, val, soul); // TODO: Only put in graph if subscribed? Relays vs Browsers?\n\t\t\t\tchain(ctx, soul, key, (u !== (tmp = put['=']))? tmp : val, state); // TODO: This should NOT be how the API works, this should be done at an extension layer, but hacky solution to migrate with old code for now.\n\t\t\t\tif((tmp = ctx.out) && (tmp = tmp.put)){\n\t\t\t\t\ttmp[soul] = state_ify(tmp[soul], key, state, val, soul); // TODO: Hacky, fix & come back later, for actual pushing messages.\n\t\t\t\t}\n\t\t\t\tif(!(--ctx.lot.more)){ fire(ctx) } // TODO: 'forget' feature in SEA tied to this, bad approach, but hacked in for now. Any changes here must update there.\n\t\t\t\teve.to.next(msg);\n\t\t\t}\n\t\t\tfunction chain(ctx, soul, key,val, state){\n\t\t\t\tvar root = ctx.root, put, tmp;\n\t\t\t\t(root.opt||'').super && root.$.get(soul); // I think we need super for now, but since we are rewriting, should consider getting rid of it.\n\t\t\t\tif(!root || !(tmp = root.next) || !(tmp = tmp[soul]) || !tmp.$){ return }\n\t\t\t\t(put = ctx.put || (ctx.put = {}))[soul] = state_ify(put[soul], key, state, val, soul);\n\t\t\t\ttmp.put = state_ify(tmp.put, key, state, val, soul);\n\t\t\t}\n\t\t\tfunction fire(ctx){\n\t\t\t\tif(ctx.err){ return }\n\t\t\t\tvar stop = {};\n\t\t\t\tvar root = ((ctx.$||'')._||'').root, next = (root||'').next||'', put = ctx.put, tmp;\n\t\t\t\tvar S = +new Date;\n\t\t\t\t//Gun.graph.is(put, function(node, soul){\n\t\t\t\tfor(var soul in put){ var node = put[soul]; // Gun.obj.native() makes this safe.\n\t\t\t\t\tif(!(tmp = next[soul]) || !tmp.$){ continue }\n\t\t\t\t\troot.stop = stop; // temporary fix till a better solution?\n\t\t\t\t\ttmp.on('in', {$: tmp.$, get: soul, put: node});\n\t\t\t\t\troot.stop = null; // temporary fix till a better solution?\n\t\t\t\t}\n\t\t\t\tconsole.STAT && console.STAT(S, +new Date - S, 'fire');\n\t\t\t\tctx.DBG && (ctx.DBG.f = +new Date);\n\t\t\t\tif(!(tmp = ctx.out)){ return }\n\t\t\t\ttmp.out = universe;\n\t\t\t\troot.on('out', tmp);\n\t\t\t}\n\t\t\tvar ERR = \"Error: Invalid graph!\";\n\t\t\tvar cut = function(s){ return \" '\"+(''+s).slice(0,9)+\"...' \" }\n\t\t\tvar HAM = Gun.HAM, MD = 2147483647, State = Gun.state;\n\t\t}());\n\n\t\t;(function(){\n\t\t\tGun.on._put = function(msg, gun){\n\t\t\t\tvar at = gun._, ctx = {$: gun, graph: at.graph, put: {}, map: {}, souls: {}, machine: Gun.state(), ack: msg['@'], cat: at, stop: {}};\n\t\t\t\tif(!Gun.obj.map(msg.put, perf, ctx)){ return } // HNPERF: performance test, not core code, do not port.\n\t\t\t\tif(!Gun.graph.is(msg.put, null, verify, ctx)){ ctx.err = \"Error: Invalid graph!\" }\n\t\t\t\tif(ctx.err){ return at.on('in', {'@': msg['#'], err: Gun.log(ctx.err) }) }\n\t\t\t\tobj_map(ctx.put, merge, ctx);\n\t\t\t\tif(!ctx.async){ obj_map(ctx.map, map, ctx) }\n\t\t\t\tif(u !== ctx.defer){\n\t\t\t\t\tvar to = ctx.defer - ctx.machine;\n\t\t\t\t\tsetTimeout(function(){\n\t\t\t\t\t\tGun.on._put(msg, gun);\n\t\t\t\t\t}, to > MD? MD : to ); // setTimeout Max Defer 32bit :(\n\t\t\t\t}\n\t\t\t\tif(!ctx.diff){ return }\n\t\t\t\tat.on('put', obj_to(msg, {put: ctx.diff}));\n\t\t\t};\n\t\t\tfunction verify(val, key, node, soul){ var ctx = this;\n\t\t\t\tvar state = Gun.state.is(node, key), tmp;\n\t\t\t\tif(!state){ return ctx.err = \"Error: No state on '\"+key+\"' in node '\"+soul+\"'!\" }\n\t\t\t\tvar vertex = ctx.graph[soul] || empty, was = Gun.state.is(vertex, key, true), known = vertex[key];\n\t\t\t\tvar HAM = Gun.HAM(ctx.machine, state, was, val, known);\n\t\t\t\tif(!HAM.incoming){\n\t\t\t\t\tif(HAM.defer){ // pick the lowest\n\t\t\t\t\t\tctx.defer = (state < (ctx.defer || Infinity))? state : ctx.defer;\n\t\t\t\t\t}\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tctx.put[soul] = Gun.state.to(node, key, ctx.put[soul]);\n\t\t\t\t(ctx.diff || (ctx.diff = {}))[soul] = Gun.state.to(node, key, ctx.diff[soul]);\n\t\t\t\tctx.souls[soul] = true;\n\t\t\t}\n\t\t\tfunction merge(node, soul){\n\t\t\t\tvar ctx = this, cat = ctx.$._, at = (cat.next || empty)[soul];\n\t\t\t\tif(!at){\n\t\t\t\t\tif(!(cat.opt||empty).super){\n\t\t\t\t\t\tctx.souls[soul] = false;\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tat = (ctx.$.get(soul)._);\n\t\t\t\t}\n\t\t\t\tvar msg = ctx.map[soul] = {\n\t\t\t\t\tput: node,\n\t\t\t\t\tget: soul,\n\t\t\t\t\t$: at.$\n\t\t\t\t}, as = {ctx: ctx, msg: msg};\n\t\t\t\tctx.async = !!cat.tag.node;\n\t\t\t\tif(ctx.ack){ msg['@'] = ctx.ack }\n\t\t\t\tobj_map(node, each, as);\n\t\t\t\tif(!ctx.async){ return }\n\t\t\t\tif(!ctx.and){\n\t\t\t\t\t// If it is async, we only need to setup one listener per context (ctx)\n\t\t\t\t\tcat.on('node', function(m){\n\t\t\t\t\t\tthis.to.next(m); // make sure to call other context's listeners.\n\t\t\t\t\t\tif(m !== ctx.map[m.get]){ return } // filter out events not from this context!\n\t\t\t\t\t\tctx.souls[m.get] = false; // set our many-async flag\n\t\t\t\t\t\tobj_map(m.put, patch, m); // merge into view\n\t\t\t\t\t\tif(obj_map(ctx.souls, function(v){ if(v){ return v } })){ return } // if flag still outstanding, keep waiting.\n\t\t\t\t\t\tif(ctx.c){ return } ctx.c = 1; // failsafe for only being called once per context.\n\t\t\t\t\t\tthis.off();\n\t\t\t\t\t\tobj_map(ctx.map, map, ctx); // all done, trigger chains.\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tctx.and = true;\n\t\t\t\tcat.on('node', msg); // each node on the current context's graph needs to be emitted though.\n\t\t\t}\n\t\t\tfunction each(val, key){\n\t\t\t\tvar ctx = this.ctx, graph = ctx.graph, msg = this.msg, soul = msg.get, node = msg.put, at = (msg.$._), tmp;\n\t\t\t\tgraph[soul] = Gun.state.to(node, key, graph[soul]);\n\t\t\t\tif(ctx.async){ return }\n\t\t\t\tat.put = Gun.state.to(node, key, at.put);\n\t\t\t}\n\t\t\tfunction patch(val, key){\n\t\t\t\tvar msg = this, node = msg.put, at = (msg.$._);\n\t\t\t\tat.put = Gun.state.to(node, key, at.put);\n\t\t\t}\n\t\t\tfunction map(msg, soul){\n\t\t\t\tif(!msg.$){ return }\n\t\t\t\tthis.cat.stop = this.stop; // temporary fix till a better solution?\n\t\t\t\t(msg.$._).on('in', msg);\n\t\t\t\tthis.cat.stop = null; // temporary fix till a better solution?\n\t\t\t}\n\t\t\tfunction perf(node, soul){ if(node !== this.graph[soul]){ return true } } // HNPERF: do not port!\n\n\t\t\tGun.on._get = function(msg, gun){\n\t\t\t\tvar root = gun._, get = msg.get, soul = get[_soul], node = root.graph[soul], has = get[_has], tmp;\n\t\t\t\tvar next = root.next || (root.next = {}), at = next[soul];\n\t\t\t\t// queue concurrent GETs?\n\t\t\t\tvar ctx = msg._||'', DBG = ctx.DBG = msg.DBG;\n\t\t\t\tDBG && (DBG.g = +new Date);\n\t\t\t\tif(!node){ return root.on('get', msg) }\n\t\t\t\tif(has){\n\t\t\t\t\tif('string' != typeof has || !obj_has(node, has)){ return root.on('get', msg) }\n\t\t\t\t\tnode = Gun.state.to(node, has);\n\t\t\t\t\t// If we have a key in-memory, do we really need to fetch?\n\t\t\t\t\t// Maybe... in case the in-memory key we have is a local write\n\t\t\t\t\t// we still need to trigger a pull/merge from peers.\n\t\t\t\t} else {\n\t\t\t\t\tnode = Gun.window? Gun.obj.copy(node) : node; // HNPERF: If !browser bump Performance? Is this too dangerous to reference root graph? Copy / shallow copy too expensive for big nodes. Gun.obj.to(node); // 1 layer deep copy // Gun.obj.copy(node); // too slow on big nodes\n\t\t\t\t}\n\t\t\t\tnode = Gun.graph.node(node);\n\t\t\t\ttmp = (at||empty).ack;\n\t\t\t\tvar faith = function(){}; faith.ram = faith.faith = true; // HNPERF: We're testing performance improvement by skipping going through security again, but this should be audited.\n\t\t\t\tfaith.$ = msg.$;\n\t\t\t\tDBG && (DBG.ga = +new Date);\n\t\t\t\troot.on('in', {\n\t\t\t\t\t'@': msg['#'],\n\t\t\t\t\tput: node,\n\t\t\t\t\tram: 1,\n\t\t\t\t\t$: gun,\n\t\t\t\t\t_: faith\n\t\t\t\t});\n\t\t\t\tDBG && (DBG.gm = +new Date);\n\t\t\t\t//if(0 < tmp){ return }\n\t\t\t\troot.on('get', msg);\n\t\t\t\tDBG && (DBG.gd = +new Date);\n\t\t\t}\n\t\t}());\n\n\t\t;(function(){\n\t\t\tGun.chain.opt = function(opt){\n\t\t\t\topt = opt || {};\n\t\t\t\tvar gun = this, at = gun._, tmp = opt.peers || opt;\n\t\t\t\tif(!obj_is(opt)){ opt = {} }\n\t\t\t\tif(!obj_is(at.opt)){ at.opt = opt }\n\t\t\t\tif(text_is(tmp)){ tmp = [tmp] }\n\t\t\t\tif(list_is(tmp)){\n\t\t\t\t\ttmp = obj_map(tmp, function(url, i, map){\n\t\t\t\t\t\ti = {}; i.id = i.url = url; map(url, i);\n\t\t\t\t\t});\n\t\t\t\t\tif(!obj_is(at.opt.peers)){ at.opt.peers = {}}\n\t\t\t\t\tat.opt.peers = obj_to(tmp, at.opt.peers);\n\t\t\t\t}\n\t\t\t\tat.opt.peers = at.opt.peers || {};\n\t\t\t\tobj_map(opt, function each(v,k){\n\t\t\t\t\tif(!obj_has(this, k) || text.is(v) || obj.empty(v)){ this[k] = v ; return }\n\t\t\t\t\tif(v && v.constructor !== Object && !list_is(v)){ return }\n\t\t\t\t\tobj_map(v, each, this[k]);\n\t\t\t\t}, at.opt);\n\t\t\t\tGun.on('opt', at);\n\t\t\t\t//at.opt.uuid = at.opt.uuid || function(){ return state_lex() + text_rand(12) }\n\t\t\t\tGun.obj.native();\n\t\t\t\treturn gun;\n\t\t\t}\n\t\t}());\n\t\tGun.obj.native = function(){ var p = Object.prototype; for(var i in p){ console.log(\"Native Object.prototype polluted, reverting\", i); delete p[i]; } };\n\n\t\tvar list_is = Gun.list.is;\n\t\tvar text = Gun.text, text_is = text.is, text_rand = text.random;\n\t\tvar obj = Gun.obj, obj_empty = obj.empty, obj_is = obj.is, obj_has = obj.has, obj_to = obj.to, obj_map = obj.map, obj_copy = obj.copy;\n\t\tvar state_lex = Gun.state.lex, state_ify = Gun.state.ify, state_is = Gun.state.is, _soul = Gun.val.link._, _has = '.', node_ = Gun.node._, val_is = Gun.val.is, rel_is = Gun.val.link.is, state_ = Gun.state._;\n\t\tvar empty = {}, u;\n\t\tvar C;\n\n\t\tGun.log = function(){ return (!Gun.log.off && C.log.apply(C, arguments)), [].slice.call(arguments).join(' ') };\n\t\tGun.log.once = function(w,s,o){ return (o = Gun.log.once)[w] = o[w] || 0, o[w]++ || Gun.log(s) };\n\n\t\tif(typeof window !== \"undefined\"){ (window.GUN = window.Gun = Gun).window = window }\n\t\ttry{ if(typeof MODULE !== \"undefined\"){ MODULE.exports = Gun } }catch(e){}\n\t\tmodule.exports = Gun;\n\n\t\t(Gun.window||'').console = (Gun.window||'').console || {log: function(){}};\n\t\t(C = console).only = function(i, s){ return (C.only.i && i === C.only.i && C.only.i++) && (C.log.apply(C, arguments) || s) };\n\n\t\t;\"Please do not remove welcome log unless you are paying for a monthly sponsorship, thanks!\";\n\t\tGun.log.once(\"welcome\", \"Hello wonderful person! :) Thanks for using GUN, please ask for help on http://chat.gun.eco if anything takes you longer than 5min to figure out!\");\n\t})(USE, './root');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('./root');\n\t\tGun.chain.back = function(n, opt){ var tmp;\n\t\t\tn = n || 1;\n\t\t\tif(-1 === n || Infinity === n){\n\t\t\t\treturn this._.root.$;\n\t\t\t} else\n\t\t\tif(1 === n){\n\t\t\t\treturn (this._.back || this._).$;\n\t\t\t}\n\t\t\tvar gun = this, at = gun._;\n\t\t\tif(typeof n === 'string'){\n\t\t\t\tn = n.split('.');\n\t\t\t}\n\t\t\tif(n instanceof Array){\n\t\t\t\tvar i = 0, l = n.length, tmp = at;\n\t\t\t\tfor(i; i < l; i++){\n\t\t\t\t\ttmp = (tmp||empty)[n[i]];\n\t\t\t\t}\n\t\t\t\tif(u !== tmp){\n\t\t\t\t\treturn opt? gun : tmp;\n\t\t\t\t} else\n\t\t\t\tif((tmp = at.back)){\n\t\t\t\t\treturn tmp.$.back(n, opt);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif('function' == typeof n){\n\t\t\t\tvar yes, tmp = {back: at};\n\t\t\t\twhile((tmp = tmp.back)\n\t\t\t\t&& u === (yes = n(tmp, opt))){}\n\t\t\t\treturn yes;\n\t\t\t}\n\t\t\tif(Gun.num.is(n)){\n\t\t\t\treturn (at.back || at).$.back(n - 1);\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tvar empty = {}, u;\n\t})(USE, './back');\n\n\t;USE(function(module){\n\t\t// WARNING: GUN is very simple, but the JavaScript chaining API around GUN\n\t\t// is complicated and was extremely hard to build. If you port GUN to another\n\t\t// language, consider implementing an easier API to build.\n\t\tvar Gun = USE('./root');\n\t\tGun.chain.chain = function(sub){\n\t\t\tvar gun = this, at = gun._, chain = new (sub || gun).constructor(gun), cat = chain._, root;\n\t\t\tcat.root = root = at.root;\n\t\t\tcat.id = ++root.once;\n\t\t\tcat.back = gun._;\n\t\t\tcat.on = Gun.on;\n\t\t\tcat.on('in', input, cat); // For 'in' if I add my own listeners to each then I MUST do it before in gets called. If I listen globally for all incoming data instead though, regardless of individual listeners, I can transform the data there and then as well.\n\t\t\tcat.on('out', output, cat); // However for output, there isn't really the global option. I must listen by adding my own listener individually BEFORE this one is ever called.\n\t\t\treturn chain;\n\t\t}\n\n\t\tfunction output(msg){\n\t\t\tvar put, get, at = this.as, back = at.back, root = at.root, tmp;\n\t\t\tif(!msg.$){ msg.$ = at.$ }\n\t\t\tthis.to.next(msg);\n\t\t\tif(get = msg.get){\n\t\t\t\t/*if(u !== at.put){\n\t\t\t\t\tat.on('in', at);\n\t\t\t\t\treturn;\n\t\t\t\t}*/\n\t\t\t\tif(at.lex){ msg.get = obj_to(at.lex, msg.get) }\n\t\t\t\tif(get['#'] || at.soul){\n\t\t\t\t\tget['#'] = get['#'] || at.soul;\n\t\t\t\t\tmsg['#'] || (msg['#'] = text_rand(9));\n\t\t\t\t\tback = (root.$.get(get['#'])._);\n\t\t\t\t\tif(!(get = get['.'])){\n\t\t\t\t\t\ttmp = back.ack;\n\t\t\t\t\t\tif(!tmp){ back.ack = -1 }\n\t\t\t\t\t\tif(obj_has(back, 'put')){\n\t\t\t\t\t\t\tback.on('in', back);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif(tmp && u !== back.put){ return } //if(tmp){ return }\n\t\t\t\t\t\tmsg.$ = back.$;\n\t\t\t\t\t} else\n\t\t\t\t\tif(obj_has(back.put, get)){ // TODO: support #LEX !\n\t\t\t\t\t\tput = (back.$.get(get)._);\n\t\t\t\t\t\tif(!(tmp = put.ack)){ put.ack = -1 }\n\t\t\t\t\t\tback.on('in', {\n\t\t\t\t\t\t\t$: back.$,\n\t\t\t\t\t\t\tput: Gun.state.to(back.put, get),\n\t\t\t\t\t\t\tget: back.get\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif(tmp){ return }\n\t\t\t\t\t} else\n\t\t\t\t\tif('string' != typeof get){\n\t\t\t\t\t\tvar put = {}, meta = (back.put||{})._;\n\t\t\t\t\t\tGun.obj.map(back.put, function(v,k){\n\t\t\t\t\t\t\tif(!Gun.text.match(k, get)){ return }\n\t\t\t\t\t\t\tput[k] = v;\n\t\t\t\t\t\t})\n\t\t\t\t\t\tif(!Gun.obj.empty(put)){\n\t\t\t\t\t\t\tput._ = meta;\n\t\t\t\t\t\t\tback.on('in', {$: back.$, put: put, get: back.get})\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif(tmp = at.lex){\n\t\t\t\t\t\t\ttmp = (tmp._) || (tmp._ = function(){});\n\t\t\t\t\t\t\tif(back.ack < tmp.ask){ tmp.ask = back.ack }\n\t\t\t\t\t\t\tif(tmp.ask){ return }\n\t\t\t\t\t\t\ttmp.ask = 1;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\troot.ask(ack, msg);\n\t\t\t\t\treturn root.on('in', msg);\n\t\t\t\t}\n\t\t\t\tif(root.now){ root.now[at.id] = root.now[at.id] || true; at.pass = {} }\n\t\t\t\tif(get['.']){\n\t\t\t\t\tif(at.get){\n\t\t\t\t\t\tmsg = {get: {'.': at.get}, $: at.$};\n\t\t\t\t\t\t//if(back.ask || (back.ask = {})[at.get]){ return }\n\t\t\t\t\t\t(back.ask || (back.ask = {}));\n\t\t\t\t\t\tback.ask[at.get] = msg.$._; // TODO: PERFORMANCE? More elegant way?\n\t\t\t\t\t\treturn back.on('out', msg);\n\t\t\t\t\t}\n\t\t\t\t\tmsg = {get: {}, $: at.$};\n\t\t\t\t\treturn back.on('out', msg);\n\t\t\t\t}\n\t\t\t\tat.ack = at.ack || -1;\n\t\t\t\tif(at.get){\n\t\t\t\t\tmsg.$ = at.$;\n\t\t\t\t\tget['.'] = at.get;\n\t\t\t\t\t(back.ask || (back.ask = {}))[at.get] = msg.$._; // TODO: PERFORMANCE? More elegant way?\n\t\t\t\t\treturn back.on('out', msg);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn back.on('out', msg);\n\t\t}\n\n\t\tfunction input(msg){\n\t\t\tvar eve = this, cat = eve.as, root = cat.root, gun = msg.$, at = (gun||empty)._ || empty, change = msg.put, rel, tmp;\n\t\t\tif(cat.get && msg.get !== cat.get){\n\t\t\t\tmsg = obj_to(msg, {get: cat.get});\n\t\t\t}\n\t\t\tif(cat.has && at !== cat){\n\t\t\t\tmsg = obj_to(msg, {$: cat.$});\n\t\t\t\tif(at.ack){\n\t\t\t\t\tcat.ack = at.ack;\n\t\t\t\t\t//cat.ack = cat.ack || at.ack;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif(u === change){\n\t\t\t\ttmp = at.put;\n\t\t\t\teve.to.next(msg);\n\t\t\t\tif(cat.soul){ return } // TODO: BUG, I believee the fresh input refactor caught an edge case that a `gun.get('soul').get('key')` that points to a soul that doesn't exist will not trigger val/get etc.\n\t\t\t\tif(u === tmp && u !== at.put){ return }\n\t\t\t\techo(cat, msg, eve);\n\t\t\t\tif(cat.has){\n\t\t\t\t\tnot(cat, msg);\n\t\t\t\t}\n\t\t\t\tobj_del(at.echo, cat.id);\n\t\t\t\tobj_del(cat.map, at.id);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(cat.soul){\n\t\t\t\teve.to.next(msg);\n\t\t\t\techo(cat, msg, eve);\n\t\t\t\tif(cat.next){ obj_map(change, map, {msg: msg, cat: cat}) }\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(!(rel = Gun.val.link.is(change))){\n\t\t\t\tif(Gun.val.is(change)){\n\t\t\t\t\tif(cat.has || cat.soul){\n\t\t\t\t\t\tnot(cat, msg);\n\t\t\t\t\t} else\n\t\t\t\t\tif(at.has || at.soul){\n\t\t\t\t\t\t(at.echo || (at.echo = {}))[cat.id] = at.echo[at.id] || cat;\n\t\t\t\t\t\t(cat.map || (cat.map = {}))[at.id] = cat.map[at.id] || {at: at};\n\t\t\t\t\t\t//if(u === at.put){ return } // Not necessary but improves performance. If we have it but at does not, that means we got things out of order and at will get it. Once at gets it, it will tell us again.\n\t\t\t\t\t}\n\t\t\t\t\teve.to.next(msg);\n\t\t\t\t\techo(cat, msg, eve);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif(cat.has && at !== cat && obj_has(at, 'put')){\n\t\t\t\t\tcat.put = at.put;\n\t\t\t\t};\n\t\t\t\tif((rel = Gun.node.soul(change)) && at.has){\n\t\t\t\t\tat.put = (cat.root.$.get(rel)._).put;\n\t\t\t\t}\n\t\t\t\ttmp = (root.stop || {})[at.id];\n\t\t\t\t//if(tmp && tmp[cat.id]){ } else {\n\t\t\t\t\teve.to.next(msg);\n\t\t\t\t//}\n\t\t\t\trelate(cat, msg, at, rel);\n\t\t\t\techo(cat, msg, eve);\n\t\t\t\tif(cat.next){ obj_map(change, map, {msg: msg, cat: cat}) }\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tvar was = root.stop;\n\t\t\ttmp = root.stop || {};\n\t\t\ttmp = tmp[at.id] || (tmp[at.id] = {});\n\t\t\t//if(tmp[cat.id]){ return }\n\t\t\ttmp.is = tmp.is || at.put;\n\t\t\ttmp[cat.id] = at.put || true;\n\t\t\t//if(root.stop){\n\t\t\t\teve.to.next(msg)\n\t\t\t//}\n\t\t\trelate(cat, msg, at, rel);\n\t\t\techo(cat, msg, eve);\n\t\t}\n\n\t\tfunction relate(at, msg, from, rel){\n\t\t\tif(!rel || node_ === at.get){ return }\n\t\t\tvar tmp = (at.root.$.get(rel)._);\n\t\t\tif(at.has){\n\t\t\t\tfrom = tmp;\n\t\t\t} else\n\t\t\tif(from.has){\n\t\t\t\trelate(from, msg, from, rel);\n\t\t\t}\n\t\t\tif(from === at){ return }\n\t\t\tif(!from.$){ from = {} }\n\t\t\t(from.echo || (from.echo = {}))[at.id] = from.echo[at.id] || at;\n\t\t\tif(at.has && !(at.map||empty)[from.id]){ // if we haven't seen this before.\n\t\t\t\tnot(at, msg);\n\t\t\t}\n\t\t\ttmp = from.id? ((at.map || (at.map = {}))[from.id] = at.map[from.id] || {at: from}) : {};\n\t\t\tif(rel === tmp.link){\n\t\t\t\tif(!(tmp.pass || at.pass)){\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif(at.pass){\n\t\t\t\tGun.obj.map(at.map, function(tmp){ tmp.pass = true })\n\t\t\t\tobj_del(at, 'pass');\n\t\t\t}\n\t\t\tif(tmp.pass){ obj_del(tmp, 'pass') }\n\t\t\tif(at.has){ at.link = rel }\n\t\t\task(at, tmp.link = rel);\n\t\t}\n\t\tfunction echo(at, msg, ev){\n\t\t\tif(!at.echo){ return } // || node_ === at.get ?\n\t\t\t//if(at.has){ msg = obj_to(msg, {event: ev}) }\n\t\t\tobj_map(at.echo, reverb, msg);\n\t\t}\n\t\tfunction reverb(to){\n\t\t\tif(!to || !to.on){ return }\n\t\t\tto.on('in', this);\n\t\t}\n\t\tfunction map(data, key){ // Map over only the changes on every update.\n\t\t\tvar cat = this.cat, next = cat.next || empty, via = this.msg, chain, at, tmp;\n\t\t\tif(node_ === key && !next[key]){ return }\n\t\t\tif(!(at = next[key])){\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t//if(data && data[_soul] && (tmp = Gun.val.link.is(data)) && (tmp = (cat.root.$.get(tmp)._)) && obj_has(tmp, 'put')){\n\t\t\t//\tdata = tmp.put;\n\t\t\t//}\n\t\t\tif(at.has){\n\t\t\t\t//if(!(data && data[_soul] && Gun.val.link.is(data) === Gun.node.soul(at.put))){\n\t\t\t\tif(u === at.put || !Gun.val.link.is(data)){\n\t\t\t\t\tat.put = data;\n\t\t\t\t}\n\t\t\t\tchain = at.$;\n\t\t\t} else\n\t\t\tif(tmp = via.$){\n\t\t\t\ttmp = (chain = via.$.get(key))._;\n\t\t\t\tif(u === tmp.put || !Gun.val.link.is(data)){\n\t\t\t\t\ttmp.put = data;\n\t\t\t\t}\n\t\t\t}\n\t\t\tat.on('in', {\n\t\t\t\tput: data,\n\t\t\t\tget: key,\n\t\t\t\t$: chain,\n\t\t\t\tvia: via\n\t\t\t});\n\t\t}\n\t\tfunction not(at, msg){\n\t\t\tif(!(at.has || at.soul)){ return }\n\t\t\tvar tmp = at.map, root = at.root;\n\t\t\tat.map = null;\n\t\t\tif(at.has){\n\t\t\t\tif(at.dub && at.root.stop){ at.dub = null }\n\t\t\t\tat.link = null;\n\t\t\t}\n\t\t\t//if(!root.now || !root.now[at.id]){\n\t\t\tif(!at.pass){\n\t\t\t\tif((!msg['@']) && null === tmp){ return }\n\t\t\t\t//obj_del(at, 'pass');\n\t\t\t}\n\t\t\tif(u === tmp && Gun.val.link.is(at.put)){ return } // This prevents the very first call of a thing from triggering a \"clean up\" call. // TODO: link.is(at.put) || !val.is(at.put) ?\n\t\t\tobj_map(tmp, function(proxy){\n\t\t\t\tif(!(proxy = proxy.at)){ return }\n\t\t\t\tobj_del(proxy.echo, at.id);\n\t\t\t});\n\t\t\ttmp = at.put;\n\t\t\tobj_map(at.next, function(neat, key){\n\t\t\t\tif(u === tmp && u !== at.put){ return true }\n\t\t\t\tneat.put = u;\n\t\t\t\tif(neat.ack){\n\t\t\t\t\tneat.ack = -1; // Shouldn't this be reset to 0? If we do that, SEA test `set user ref should be found` fails, odd.\n\t\t\t\t}\n\t\t\t\tneat.on('in', {\n\t\t\t\t\tget: key,\n\t\t\t\t\t$: neat.$,\n\t\t\t\t\tput: u\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t\tfunction ask(at, soul){\n\t\t\tvar tmp = (at.root.$.get(soul)._), lex = at.lex;\n\t\t\tif(at.ack || lex){\n\t\t\t\t(lex = lex||{})['#'] = soul;\n\t\t\t\ttmp.on('out', {get: lex});\n\t\t\t\tif(!at.ask){ return } // TODO: PERFORMANCE? More elegant way?\n\t\t\t}\n\t\t\ttmp = at.ask; Gun.obj.del(at, 'ask');\n\t\t\tobj_map(tmp || at.next, function(neat, key){\n\t\t\t\tvar lex = neat.lex || {}; lex['#'] = soul; lex['.'] = lex['.'] || key;\n\t\t\t\tneat.on('out', {get: lex});\n\t\t\t});\n\t\t\tGun.obj.del(at, 'ask'); // TODO: PERFORMANCE? More elegant way?\n\t\t}\n\t\tfunction ack(msg, ev){\n\t\t\tvar as = this.as, get = as.get||'', at = as.$._, tmp = (msg.put||'')[get['#']];\n\t\t\tif(at.ack){ at.ack = (at.ack + 1) || 1; }\n\t\t\tif(!msg.put || ('string' == typeof get['.'] && !obj_has(tmp, at.get))){\n\t\t\t\tif(at.put !== u){ return }\n\t\t\t\tat.on('in', {\n\t\t\t\t\tget: at.get,\n\t\t\t\t\tput: at.put = u,\n\t\t\t\t\t$: at.$,\n\t\t\t\t\t'@': msg['@']\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(node_ == get['.']){ // is this a security concern?\n\t\t\t\tat.on('in', {get: at.get, put: Gun.val.link.ify(get['#']), $: at.$, '@': msg['@']});\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(at.$ === (msg._||'').$){ // replying to self, for perf, skip ham/security tho needs audit.\n\t\t\t\t(msg._).miss = (at.put === u);\n\t\t\t}\n\t\t\tGun.on.put(msg);\n\t\t}\n\t\tvar empty = {}, u;\n\t\tvar obj = Gun.obj, obj_has = obj.has, obj_put = obj.put, obj_del = obj.del, obj_to = obj.to, obj_map = obj.map;\n\t\tvar text_rand = Gun.text.random;\n\t\tvar _soul = Gun.val.link._, node_ = Gun.node._;\n\t})(USE, './chain');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('./root');\n\t\tGun.chain.get = function(key, cb, as){\n\t\t\tvar gun, tmp;\n\t\t\tif(typeof key === 'string'){\n\t\t\t        if(key.length == 0) {\n\t\t\t              (as = this.chain())._.err = {err: Gun.log('Invalid zero length string key!', key)};\n\t\t\t              return null\n\t\t\t        }\n\t\t\t\tvar back = this, cat = back._;\n\t\t\t\tvar next = cat.next || empty;\n\t\t\t\tif(!(gun = next[key])){\n\t\t\t\t\tgun = cache(key, back);\n\t\t\t\t}\n\t\t\t\tgun = gun.$;\n\t\t\t} else\n\t\t\tif('function' == typeof key){\n\t\t\t\tif(true === cb){ return soul(this, key, cb, as), this }\n\t\t\t\tgun = this;\n\t\t\t\tvar at = gun._, root = at.root, tmp = root.now, ev;\n\t\t\t\tas = cb || {};\n\t\t\t\tas.at = at;\n\t\t\t\tas.use = key;\n\t\t\t\tas.out = as.out || {};\n\t\t\t\tas.out.get = as.out.get || {};\n\t\t\t\t(ev = at.on('in', use, as)).rid = rid;\n\t\t\t\t(root.now = {$:1})[as.now = at.id] = ev;\n\t\t\t\tvar mum = root.mum; root.mum = {};\n\t\t\t\tat.on('out', as.out);\n\t\t\t\troot.mum = mum;\n\t\t\t\troot.now = tmp;\n\t\t\t\treturn gun;\n\t\t\t} else\n\t\t\tif(num_is(key)){\n\t\t\t\treturn this.get(''+key, cb, as);\n\t\t\t} else\n\t\t\tif(tmp = rel.is(key)){\n\t\t\t\treturn this.get(tmp, cb, as);\n\t\t\t} else\n\t\t\tif(obj.is(key)){\n\t\t\t\tgun = this;\n\t\t\t\tif(tmp = ((tmp = key['#'])||empty)['='] || tmp){ gun = gun.get(tmp) }\n\t\t\t\tgun._.lex = key;\n\t\t\t\treturn gun;\n\t\t\t} else {\n\t\t\t\t(as = this.chain())._.err = {err: Gun.log('Invalid get request!', key)}; // CLEAN UP\n\t\t\t\tif(cb){ cb.call(as, as._.err) }\n\t\t\t\treturn as;\n\t\t\t}\n\t\t\tif(tmp = this._.stun){ // TODO: Refactor?\n\t\t\t\tgun._.stun = gun._.stun || tmp;\n\t\t\t}\n\t\t\tif(cb && 'function' == typeof cb){\n\t\t\t\tgun.get(cb, as);\n\t\t\t}\n\t\t\treturn gun;\n\t\t}\n\t\tfunction cache(key, back){\n\t\t\tvar cat = back._, next = cat.next, gun = back.chain(), at = gun._;\n\t\t\tif(!next){ next = cat.next = {} }\n\t\t\tnext[at.get = key] = at;\n\t\t\tif(back === cat.root.$){\n\t\t\t\tat.soul = key;\n\t\t\t} else\n\t\t\tif(cat.soul || cat.has){\n\t\t\t\tat.has = key;\n\t\t\t\t//if(obj_has(cat.put, key)){\n\t\t\t\t\t//at.put = cat.put[key];\n\t\t\t\t//}\n\t\t\t}\n\t\t\treturn at;\n\t\t}\n\t\tfunction soul(gun, cb, opt, as){\n\t\t\tvar cat = gun._, acks = 0, tmp;\n\t\t\tif(tmp = cat.soul || cat.link || cat.dub){ return cb(tmp, as, cat) }\n\t\t\tif(cat.jam){ return cat.jam.push([cb, as]) }\n\t\t\tcat.jam = [[cb,as]];\n\t\t\tgun.get(function go(msg, eve){\n\t\t\t\tif(u === msg.put && !cat.root.opt.super && (tmp = Object.keys(cat.root.opt.peers).length) && ++acks <= tmp){ // TODO: super should not be in core code, bring AXE up into core instead to fix?\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\teve.rid(msg);\n\t\t\t\tvar at = ((at = msg.$) && at._) || {}, i = 0, as;\n\t\t\t\ttmp = cat.jam; delete cat.jam; // tmp = cat.jam.splice(0, 100);\n\t\t\t\t//if(tmp.length){ process.nextTick(function(){ go(msg, eve) }) }\n\t\t\t\twhile(as = tmp[i++]){ //Gun.obj.map(tmp, function(as, cb){\n\t\t\t\t\tvar cb = as[0], id; as = as[1];\n\t\t\t\t\tcb && cb(id = at.link || at.soul || rel.is(msg.put) || node_soul(msg.put) || at.dub, as, msg, eve);\n\t\t\t\t} //);\n\t\t\t}, {out: {get: {'.':true}}});\n\t\t\treturn gun;\n\t\t}\n\t\tfunction use(msg){\n\t\t\tvar eve = this, as = eve.as, cat = as.at, root = cat.root, gun = msg.$, at = (gun||{})._ || {}, data = msg.put || at.put, tmp;\n\t\t\tif((tmp = root.now) && eve !== tmp[as.now]){ return eve.to.next(msg) }\n\t\t\t//if(at.async && msg.root){ return }\n\t\t\t//if(at.async === 1 && cat.async !== true){ return }\n\t\t\t//if(root.stop && root.stop[at.id]){ return } root.stop && (root.stop[at.id] = true);\n\t\t\t//if(!at.async && !cat.async && at.put && msg.put === at.put){ return }\n\t\t\t//else if(!cat.async && msg.put !== at.put && root.stop && root.stop[at.id]){ return } root.stop && (root.stop[at.id] = true);\n\n\n\t\t\t//root.stop && (root.stop.id = root.stop.id || Gun.text.random(2));\n\t\t\t//if((tmp = root.stop) && (tmp = tmp[at.id] || (tmp[at.id] = {})) && tmp[cat.id]){ return } tmp && (tmp[cat.id] = true);\n\t\t\tif(eve.seen && at.id && eve.seen[at.id]){ return eve.to.next(msg) }\n\t\t\t//if((tmp = root.stop)){ if(tmp[at.id]){ return } tmp[at.id] = msg.root; } // temporary fix till a better solution?\n\t\t\tif((tmp = data) && tmp[rel._] && (tmp = rel.is(tmp))){\n\t\t\t\ttmp = ((msg.$$ = at.root.$.get(tmp))._);\n\t\t\t\tif(u !== tmp.put){\n\t\t\t\t\tmsg = obj_to(msg, {put: data = tmp.put});\n\t\t\t\t}\n\t\t\t}\n\t\t\tif((tmp = root.mum) && at.id){ // TODO: can we delete mum entirely now?\n\t\t\t\tvar id = at.id + (eve.id || (eve.id = Gun.text.random(9)));\n\t\t\t\tif(tmp[id]){ return }\n\t\t\t\tif(u !== data && !rel.is(data)){ tmp[id] = true; }\n\t\t\t}\n\t\t\tas.use(msg, eve);\n\t\t\tif(eve.stun){\n\t\t\t\teve.stun = null;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\teve.to.next(msg);\n\t\t}\n\t\tfunction rid(at){\n\t\t\tvar cat = this.on;\n\t\t\tif(!at || cat.soul || cat.has){ return this.off() }\n\t\t\tif(!(at = (at = (at = at.$ || at)._ || at).id)){ return }\n\t\t\tvar map = cat.map, tmp, seen;\n\t\t\t//if(!map || !(tmp = map[at]) || !(tmp = tmp.at)){ return }\n\t\t\tif(tmp = (seen = this.seen || (this.seen = {}))[at]){ return true }\n\t\t\tseen[at] = true;\n\t\t\treturn;\n\t\t\t//tmp.echo[cat.id] = {}; // TODO: Warning: This unsubscribes ALL of this chain's listeners from this link, not just the one callback event.\n\t\t\t//obj.del(map, at); // TODO: Warning: This unsubscribes ALL of this chain's listeners from this link, not just the one callback event.\n\t\t\treturn;\n\t\t}\n\t\tvar obj = Gun.obj, obj_map = obj.map, obj_has = obj.has, obj_to = Gun.obj.to;\n\t\tvar num_is = Gun.num.is;\n\t\tvar rel = Gun.val.link, node_soul = Gun.node.soul, node_ = Gun.node._;\n\t\tvar empty = {}, u;\n\t})(USE, './get');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('./root');\n\t\tGun.chain.put = function(data, cb, as){\n\t\t\tvar gun = this, at = (gun._), root = at.root.$, ctx = root._, M = 100, tmp;\n\t\t\tas = as || {};\n\t\t\tas.data = data;\n\t\t\tas.via = as.$ = as.via || as.$ || gun;\n\t\t\tif(typeof cb === 'string'){\n\t\t\t\tas.soul = cb;\n\t\t\t} else {\n\t\t\t\tas.ack = as.ack || cb;\n\t\t\t}\n\t\t\tif(at.soul){\n\t\t\t\tas.soul = at.soul;\n\t\t\t}\n\t\t\tif(as.soul || root === gun){\n\t\t\t\tif(!obj_is(as.data)){\n\t\t\t\t\t(as.ack||noop).call(as, as.out = {err: Gun.log(\"Data saved to the root level of the graph must be a node (an object), not a\", (typeof as.data), 'of \"' + as.data + '\"!')});\n\t\t\t\t\tif(as.res){ as.res() }\n\t\t\t\t\treturn gun;\n\t\t\t\t}\n\t\t\t\tas.soul = as.soul || (as.not = Gun.node.soul(as.data) || (as.via.back('opt.uuid') || Gun.text.random)());\n\t\t\t\tas.via._.stun = {};\n\t\t\t\tif(!as.soul){ // polyfill async uuid for SEA\n\t\t\t\t\tas.via.back('opt.uuid')(function(err, soul){ // TODO: improve perf without anonymous callback\n\t\t\t\t\t\tif(err){ return Gun.log(err) } // TODO: Handle error!\n\t\t\t\t\t\t(as.ref||as.$).put(as.data, as.soul = soul, as);\n\t\t\t\t\t});\n\t\t\t\t\treturn gun;\n\t\t\t\t}\n\t\t\t\tas.$ = root.get(as.soul);\n\t\t\t\tas.ref = as.$;\n\t\t\t\tify(as);\n\t\t\t\treturn gun;\n\t\t\t}\n\t\t\tas.via._.stun = {};\n\t\t\tif(Gun.is(data)){\n\t\t\t\tdata.get(function(soul, o, msg){\n\t\t\t\t\tif(!soul){\n\t\t\t\t\t\tdelete as.via._.stun;\n\t\t\t\t\t\treturn Gun.log(\"The reference you are saving is a\", typeof msg.put, '\"'+ msg.put +'\", not a node (object)!');\n\t\t\t\t\t}\n\t\t\t\t\tgun.put(Gun.val.link.ify(soul), cb, as);\n\t\t\t\t}, true);\n\t\t\t\treturn gun;\n\t\t\t}\n\t\t\tif(at.has && (tmp = Gun.val.link.is(data))){ at.dub = tmp }\n\t\t\tas.ref = as.ref || (root._ === (tmp = at.back))? gun : tmp.$;\n\t\t\tif(as.ref._.soul && Gun.val.is(as.data) && at.get){\n\t\t\t\tas.data = obj_put({}, at.get, as.data);\n\t\t\t\tas.ref.put(as.data, as.soul, as);\n\t\t\t\treturn gun;\n\t\t\t}\n\t\t\tas.ref.get(any, true, {as: as});\n\t\t\tif(!as.out){\n\t\t\t\t// TODO: Perf idea! Make a global lock, that blocks everything while it is on, but if it is on the lock it does the expensive lookup to see if it is a dependent write or not and if not then it proceeds full speed. Meh? For write heavy async apps that would be terrible.\n\t\t\t\tas.res = as.res || stun; // Gun.on.stun(as.ref); // TODO: BUG! Deal with locking?\n\t\t\t\tas.$._.stun = as.ref._.stun;\n\t\t\t}\n\t\t\treturn gun;\n\t\t};\n\t\t/*Gun.chain.put = function(data, cb, as){ // don't rewrite! :(\n\t\t\tvar gun = this, at = gun._;\n\t\t\tas = as || {};\n\t\t\tas.soul || (as.soul = at.soul || ('string' == typeof cb && cb));\n\t\t\tif(!as.soul){ return get(data, cb, as) }\n\n\t\t\treturn gun;\n\t\t}*/\n\n\t\tfunction ify(as){\n\t\t\tas.batch = batch;\n\t\t\tvar opt = as.opt||{}, env = as.env = Gun.state.map(map, opt.state);\n\t\t\tenv.soul = as.soul;\n\t\t\tas.graph = Gun.graph.ify(as.data, env, as);\n\t\t\tif(env.err){\n\t\t\t\t(as.ack||noop).call(as, as.out = {err: Gun.log(env.err)});\n\t\t\t\tif(as.res){ as.res() }\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tas.batch();\n\t\t}\n\n\t\tfunction stun(cb){\n\t\t\tif(cb){ cb() }\n\t\t\treturn;\n\t\t\tvar as = this;\n\t\t\tif(!as.ref){ return }\n\t\t\tif(cb){\n\t\t\t\tas.after = as.ref._.tag;\n\t\t\t\tas.now = as.ref._.tag = {};\n\t\t\t\tcb();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(as.after){\n\t\t\t\tas.ref._.tag = as.after;\n\t\t\t}\n\t\t}\n\n\t\tfunction batch(){ var as = this;\n\t\t\tif(!as.graph || !obj_empty(as.stun)){ return }\n\t\t\tas.res = as.res || function(cb){ if(cb){ cb() } };\n\t\t\tas.res(function(){\n\t\t\t\tdelete as.via._.stun;\n\t\t\t\tvar cat = (as.$.back(-1)._), ask = cat.ask(function(ack){\n\t\t\t\t\tcat.root.on('ack', ack);\n\t\t\t\t\tif(ack.err){ Gun.log(ack) }\n\t\t\t\t\tif(++acks > (as.acks || 0)){ this.off() } // Adjustable ACKs! Only 1 by default.\n\t\t\t\t\tif(!as.ack){ return }\n\t\t\t\t\tas.ack(ack, this);\n\t\t\t\t\t//--C;\n\t\t\t\t}, as.opt), acks = 0;\n\t\t\t\t//C++;\n\t\t\t\t// NOW is a hack to get synchronous replies to correctly call.\n\t\t\t\t// and STOP is a hack to get async behavior to correctly call.\n\t\t\t\t// neither of these are ideal, need to be fixed without hacks,\n\t\t\t\t// but for now, this works for current tests. :/\n\t\t\t\tvar tmp = cat.root.now; obj.del(cat.root, 'now');\n\t\t\t\tvar mum = cat.root.mum; cat.root.mum = {};\n\t\t\t\t(as.ref._).on('out', {\n\t\t\t\t\t$: as.ref, put: as.out = as.env.graph, opt: as.opt, '#': ask\n\t\t\t\t});\n\t\t\t\tcat.root.mum = mum? obj.to(mum, cat.root.mum) : mum;\n\t\t\t\tcat.root.now = tmp;\n\t\t\t\tas.via._.on('res', {}); delete as.via._.tag.res; // emitting causes mem leak?\n\t\t\t}, as);\n\t\t\tif(as.res){ as.res() }\n\t\t} function no(v,k){ if(v){ return true } }\n\n\t\tfunction map(v,k,n, at){ var as = this;\n\t\t\tvar is = Gun.is(v);\n\t\t\tif(k || !at.path.length){ return }\n\t\t\t(as.res||iife)(function(){\n\t\t\t\tvar path = at.path, ref = as.ref, opt = as.opt;\n\t\t\t\tvar i = 0, l = path.length;\n\t\t\t\tfor(i; i < l; i++){\n\t\t\t\t\tref = ref.get(path[i]);\n\t\t\t\t}\n\t\t\t\tif(is){ ref = v }\n\t\t\t\t//if(as.not){ (ref._).dub = Gun.text.random() } // This might optimize stuff? Maybe not needed anymore. Make sure it doesn't introduce bugs.\n\t\t\t\tvar id = (ref._).dub;\n\t\t\t\tif(id || (id = Gun.node.soul(at.obj))){\n\t\t\t\t\tref.back(-1).get(id);\n\t\t\t\t\tat.soul(id);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\t(as.stun = as.stun || {})[path] = 1;\n\t\t\t\tref.get(soul, true, {as: {at: at, as: as, p:path, ref: ref}});\n\t\t\t}, {as: as, at: at});\n\t\t\t//if(is){ return {} }\n\t\t}\n\t\tvar G = String.fromCharCode(31);\n\t\tfunction soul(id, as, msg, eve){\n\t\t\tvar as = as.as, path = as.p, ref = as.ref, cat = as.at, pat = [], sat; as = as.as;\n\t\t\tref.back(function(at){\n\t\t\t\tif(sat = at.soul || at.link || at.dub){ return sat }\n\t\t\t\tpat.push(at.has || at.get);\n\t\t\t});\n\t\t\tpat = [sat || as.soul].concat(pat.reverse());\n\t\t\tvar at = ((msg || {}).$ || {})._ || {};\n\t\t\tid = at.dub = at.dub || id || Gun.node.soul(cat.obj) || Gun.node.soul(msg.put || at.put) || Gun.val.link.is(msg.put || at.put) || pat.join('/') /* || (function(){\n\t\t\t\treturn (as.soul+'.')+Gun.text.hash(path.join(G)).toString(32);\n\t\t\t})(); // TODO: BUG!? Do we really want the soul of the object given to us? Could that be dangerous? What about copy operations? */\n\t\t\tif(eve){ eve.stun = true }\n\t\t\tif(!id){ // polyfill async uuid for SEA\n\t\t\t\tas.via.back('opt.uuid')(function(err, id){ // TODO: improve perf without anonymous callback\n\t\t\t\t\tif(err){ return Gun.log(err) } // TODO: Handle error.\n\t\t\t\t\tsolve(at, at.dub = at.dub || id, cat, as);\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tsolve(at, at.dub = id, cat, as);\n\t\t}\n\n\t\tfunction solve(at, id, cat, as){\n\t\t\tat.$.back(-1).get(id);\n\t\t\tcat.soul(id);\n\t\t\tdelete as.stun[cat.path];\n\t\t\tas.batch();\n\t\t}\n\n\t\tfunction any(soul, as, msg, eve){\n\t\t\tas = as.as;\n\t\t\tif(!msg.$ || !msg.$._){ return } // TODO: Handle\n\t\t\tif(msg.err){ // TODO: Handle\n\t\t\t\tGun.log(\"Please report this as an issue! Put.any.err\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tvar at = (msg.$._), data = at.put, opt = as.opt||{}, root, tmp;\n\t\t\tif((tmp = as.ref) && tmp._.now){ return }\n\t\t\tif(eve){ eve.stun = true }\n\t\t\tif(as.ref !== as.$){\n\t\t\t\ttmp = (as.$._).get || at.get;\n\t\t\t\tif(!tmp){ // TODO: Handle\n\t\t\t\t\tdelete as.via._.stun;\n\t\t\t\t\tGun.log(\"Please report this as an issue! Put.no.get\"); // TODO: BUG!??\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tas.data = obj_put({}, tmp, as.data);\n\t\t\t\ttmp = null;\n\t\t\t}\n\t\t\tif(u === data){\n\t\t\t\tif(!at.get){ delete as.via._.stun; return } // TODO: Handle\n\t\t\t\tif(!soul){\n\t\t\t\t\ttmp = at.$.back(function(at){\n\t\t\t\t\t\tif(at.link || at.soul){ return at.link || at.soul }\n\t\t\t\t\t\tas.data = obj_put({}, at.get, as.data);\n\t\t\t\t\t});\n\t\t\t\t\tas.not = true; // maybe consider this?\n\t\t\t\t}\n\t\t\t\ttmp = tmp || at.soul || at.link || at.dub;// || at.get;\n\t\t\t\tat = tmp? (at.root.$.get(tmp)._) : at;\n\t\t\t\tas.soul = tmp;\n\t\t\t\tdata = as.data;\n\t\t\t}\n\t\t\tif(!as.not && !(as.soul = as.soul || soul)){\n\t\t\t\tif(as.path && obj_is(as.data)){\n\t\t\t\t\tas.soul = (opt.uuid || as.via.back('opt.uuid') || Gun.text.random)();\n\t\t\t\t} else {\n\t\t\t\t\t//as.data = obj_put({}, as.$._.get, as.data);\n\t\t\t\t\tif(node_ == at.get){\n\t\t\t\t\t\tas.soul = (at.put||empty)['#'] || at.dub;\n\t\t\t\t\t}\n\t\t\t\t\tas.soul = as.soul || at.soul || at.link || (opt.uuid || as.via.back('opt.uuid') || Gun.text.random)();\n\t\t\t\t}\n\t\t\t\tif(!as.soul){ // polyfill async uuid for SEA\n\t\t\t\t\tas.via.back('opt.uuid')(function(err, soul){ // TODO: improve perf without anonymous callback\n\t\t\t\t\t\tif(err){ delete as.via._.stun; return Gun.log(err) } // Handle error.\n\t\t\t\t\t\tas.ref.put(as.data, as.soul = soul, as);\n\t\t\t\t\t});\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tas.ref.put(as.data, as.soul, as);\n\t\t}\n\t\tvar obj = Gun.obj, obj_is = obj.is, obj_put = obj.put, obj_map = obj.map, obj_empty = obj.empty;\n\t\tvar u, empty = {}, noop = function(){}, iife = function(fn,as){fn.call(as||empty)};\n\t\tvar node_ = Gun.node._;\n\t})(USE, './put');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('./root');\n\t\tUSE('./chain');\n\t\tUSE('./back');\n\t\tUSE('./put');\n\t\tUSE('./get');\n\t\tmodule.exports = Gun;\n\t})(USE, './index');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('./index');\n\t\tGun.chain.on = function(tag, arg, eas, as){\n\t\t\tvar gun = this, at = gun._, tmp, act, off;\n\t\t\tif(typeof tag === 'string'){\n\t\t\t\tif(!arg){ return at.on(tag) }\n\t\t\t\tact = at.on(tag, arg, eas || at, as);\n\t\t\t\tif(eas && eas.$){\n\t\t\t\t\t(eas.subs || (eas.subs = [])).push(act);\n\t\t\t\t}\n\t\t\t\treturn gun;\n\t\t\t}\n\t\t\tvar opt = arg;\n\t\t\topt = (true === opt)? {change: true} : opt || {};\n\t\t\topt.at = at;\n\t\t\topt.ok = tag;\n\t\t\t//opt.last = {};\n\t\t\tgun.get(ok, opt); // TODO: PERF! Event listener leak!!!?\n\t\t\treturn gun;\n\t\t}\n\n\t\tfunction ok(msg, ev){ var opt = this;\n\t\t\tvar gun = msg.$, at = (gun||{})._ || {}, data = at.put || msg.put, cat = opt.at, tmp;\n\t\t\tif(u === data){\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(tmp = msg.$$){\n\t\t\t\ttmp = (msg.$$._);\n\t\t\t\tif(u === tmp.put){\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tdata = tmp.put;\n\t\t\t}\n\t\t\tif(opt.change){ // TODO: BUG? Move above the undef checks?\n\t\t\t\tdata = msg.put;\n\t\t\t}\n\t\t\t// DEDUPLICATE // TODO: NEEDS WORK! BAD PROTOTYPE\n\t\t\t//if(tmp.put === data && tmp.get === id && !Gun.node.soul(data)){ return }\n\t\t\t//tmp.put = data;\n\t\t\t//tmp.get = id;\n\t\t\t// DEDUPLICATE // TODO: NEEDS WORK! BAD PROTOTYPE\n\t\t\t//at.last = data;\n\t\t\tif(opt.as){\n\t\t\t\topt.ok.call(opt.as, msg, ev);\n\t\t\t} else {\n\t\t\t\topt.ok.call(gun, data, msg.get, msg, ev);\n\t\t\t}\n\t\t}\n\n\t\tGun.chain.val = function(cb, opt){\n\t\t\tGun.log.once(\"onceval\", \"Future Breaking API Change: .val -> .once, apologies unexpected.\");\n\t\t\treturn this.once(cb, opt);\n\t\t}\n\t\tGun.chain.once = function(cb, opt){\n\t\t\tvar gun = this, at = gun._, data = at.put;\n\t\t\tif(0 < at.ack && u !== data){\n\t\t\t\t(cb || noop).call(gun, data, at.get);\n\t\t\t\treturn gun;\n\t\t\t}\n\t\t\tif(cb){\n\t\t\t\t(opt = opt || {}).ok = cb;\n\t\t\t\topt.at = at;\n\t\t\t\topt.out = {'#': Gun.text.random(9)};\n\t\t\t\tgun.get(val, {as: opt});\n\t\t\t\topt.async = true; //opt.async = at.stun? 1 : true;\n\t\t\t} else {\n\t\t\t\tGun.log.once(\"valonce\", \"Chainable val is experimental, its behavior and API may change moving forward. Please play with it and report bugs and ideas on how to improve it.\");\n\t\t\t\tvar chain = gun.chain();\n\t\t\t\tchain._.nix = gun.once(function(){\n\t\t\t\t\tchain._.on('in', gun._);\n\t\t\t\t});\n\t\t\t\treturn chain;\n\t\t\t}\n\t\t\treturn gun;\n\t\t}\n\n\t\tfunction val(msg, eve, to){\n\t\t\tif(!msg.$){ eve.off(); return }\n\t\t\tvar opt = this.as, cat = opt.at, gun = msg.$, at = gun._, data = at.put || msg.put, link, tmp;\n\t\t\tif(tmp = msg.$$){\n\t\t\t\tlink = tmp = (msg.$$._);\n\t\t\t\tif(u !== link.put){\n\t\t\t\t\tdata = link.put;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif((tmp = eve.wait) && (tmp = tmp[at.id])){ clearTimeout(tmp) }\n\t\t\teve.ack = (eve.ack||0)+1;\n\t\t\t// TODO: super should not be in core code, bring AXE up into core instead to fix?\n\t\t\tif(!to && u === data && !at.root.opt.super && eve.ack <= (opt.acks || Object.keys(at.root.opt.peers).length)){ return }\n\t\t\tif((!to && (u === data || at.soul || at.link || (link && !(0 < link.ack))))\n\t\t\t|| (u === data && !at.root.opt.super && (tmp = Object.keys(at.root.opt.peers).length) && (!to && (link||at).ack < tmp))){\n\t\t\t\ttmp = (eve.wait = {})[at.id] = setTimeout(function(){\n\t\t\t\t\tval.call({as:opt}, msg, eve, tmp || 1);\n\t\t\t\t}, opt.wait || 99);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(link && u === link.put && (tmp = rel.is(data))){ data = Gun.node.ify({}, tmp) }\n\t\t\teve.rid? eve.rid(msg) : eve.off();\n\t\t\topt.ok.call(gun || opt.$, data, msg.get);\n\t\t}\n\n\t\tGun.chain.off = function(){\n\t\t\t// make off more aggressive. Warning, it might backfire!\n\t\t\tvar gun = this, at = gun._, tmp;\n\t\t\tvar cat = at.back;\n\t\t\tif(!cat){ return }\n\t\t\tat.ack = 0; // so can resubscribe.\n\t\t\tif(tmp = cat.next){\n\t\t\t\tif(tmp[at.get]){\n\t\t\t\t\tobj_del(tmp, at.get);\n\t\t\t\t} else {\n\n\t\t\t\t}\n\t\t\t}\n\t\t\tif(tmp = cat.ask){\n\t\t\t\tobj_del(tmp, at.get);\n\t\t\t}\n\t\t\tif(tmp = cat.put){\n\t\t\t\tobj_del(tmp, at.get);\n\t\t\t}\n\t\t\tif(tmp = at.soul){\n\t\t\t\tobj_del(cat.root.graph, tmp);\n\t\t\t}\n\t\t\tif(tmp = at.map){\n\t\t\t\tobj_map(tmp, function(at){\n\t\t\t\t\tif(at.link){\n\t\t\t\t\t\tcat.root.$.get(at.link).off();\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif(tmp = at.next){\n\t\t\t\tobj_map(tmp, function(neat){\n\t\t\t\t\tneat.$.off();\n\t\t\t\t});\n\t\t\t}\n\t\t\tat.on('off', {});\n\t\t\treturn gun;\n\t\t}\n\t\tvar obj = Gun.obj, obj_map = obj.map, obj_has = obj.has, obj_del = obj.del, obj_to = obj.to;\n\t\tvar rel = Gun.val.link;\n\t\tvar empty = {}, noop = function(){}, u;\n\t})(USE, './on');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('./index');\n\t\tGun.chain.map = function(cb, opt, t){\n\t\t\tvar gun = this, cat = gun._, chain;\n\t\t\tif(!cb){\n\t\t\t\tif(chain = cat.each){ return chain }\n\t\t\t\tcat.each = chain = gun.chain();\n\t\t\t\tchain._.nix = gun.back('nix');\n\t\t\t\tgun.on('in', map, chain._);\n\t\t\t\treturn chain;\n\t\t\t}\n\t\t\tGun.log.once(\"mapfn\", \"Map functions are experimental, their behavior and API may change moving forward. Please play with it and report bugs and ideas on how to improve it.\");\n\t\t\tchain = gun.chain();\n\t\t\tgun.map().on(function(data, key, at, ev){\n\t\t\t\tvar next = (cb||noop).call(this, data, key, at, ev);\n\t\t\t\tif(u === next){ return }\n\t\t\t\tif(data === next){ return chain._.on('in', at) }\n\t\t\t\tif(Gun.is(next)){ return chain._.on('in', next._) }\n\t\t\t\tchain._.on('in', {get: key, put: next});\n\t\t\t});\n\t\t\treturn chain;\n\t\t}\n\t\tfunction map(msg){\n\t\t\tif(!msg.put || Gun.val.is(msg.put)){ return this.to.next(msg) }\n\t\t\tif(this.as.nix){ this.off() } // TODO: Ugly hack!\n\t\t\tobj_map(msg.put, each, {at: this.as, msg: msg});\n\t\t\tthis.to.next(msg);\n\t\t}\n\t\tfunction each(v,k){\n\t\t\tif(n_ === k){ return }\n\t\t\tvar msg = this.msg, gun = msg.$, at = gun._, cat = this.at, tmp = at.lex;\n\t\t\tif(tmp && !Gun.text.match(k, tmp['.'] || tmp['#'] || tmp)){ return } // review?\n\t\t\t((tmp = gun.get(k)._).echo || (tmp.echo = {}))[cat.id] = tmp.echo[cat.id] || cat;\n\t\t}\n\t\tvar obj_map = Gun.obj.map, noop = function(){}, event = {stun: noop, off: noop}, n_ = Gun.node._, u;\n\t})(USE, './map');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('./index');\n\t\tGun.chain.set = function(item, cb, opt){\n\t\t\tvar gun = this, soul;\n\t\t\tcb = cb || function(){};\n\t\t\topt = opt || {}; opt.item = opt.item || item;\n\t\t\tif(soul = Gun.node.soul(item)){ item = Gun.obj.put({}, soul, Gun.val.link.ify(soul)) }\n\t\t\tif(!Gun.is(item)){\n\t\t\t\tif(Gun.obj.is(item)){\n\t\t\t\t\t//item = gun.back(-1).get(soul = soul || Gun.node.soul(item) || (gun.back('opt.uuid') || uuid)()).put(item);\n\t\t\t\t\tsoul = soul || Gun.node.soul(item) || uuid(); // this just key now, not a soul.\n\t\t\t\t}\n\t\t\t\treturn gun.get(soul || uuid()).put(item, cb, opt);\n\t\t\t}\n\t\t\titem.get(function(soul, o, msg){\n\t\t\t\tif(!soul && item._.stun){ item._.on('res', function(){ this.off(); gun.set(item, cb, opt) }); return }\n\t\t\t\tif(!soul){ return cb.call(gun, {err: Gun.log('Only a node can be linked! Not \"' + msg.put + '\"!')}) }\n\t\t\t\tgun.put(Gun.obj.put({}, soul, Gun.val.link.ify(soul)), cb, opt);\n\t\t\t},true);\n\t\t\treturn item;\n\t\t}\n\t\tfunction uuid(){ return Gun.state.lex() + Gun.text.random(7) }\n\t})(USE, './set');\n\n\t;USE(function(module){\n\t\tif(typeof Gun === 'undefined'){ return } // TODO: localStorage is Browser only. But it would be nice if it could somehow plugin into NodeJS compatible localStorage APIs?\n\n\t\tvar root, noop = function(){}, store, u;\n\t\ttry{store = (Gun.window||noop).localStorage}catch(e){}\n\t\tif(!store){\n\t\t\tGun.log(\"Warning: No localStorage exists to persist data to!\");\n\t\t\tstore = {setItem: function(k,v){this[k]=v}, removeItem: function(k){delete this[k]}, getItem: function(k){return this[k]}};\n\t\t}\n\t\t/*\n\t\t\tNOTE: Both `lib/file.js` and `lib/memdisk.js` are based on this design!\n\t\t\tIf you update anything here, consider updating the other adapters as well.\n\t\t*/\n\n\t\tGun.on('create', function(root){\n\t\t\t// This code is used to queue offline writes for resync.\n\t\t\t// See the next 'opt' code below for actual saving of data.\n\t\t\tvar ev = this.to, opt = root.opt;\n\t\t\tif(root.once){ return ev.next(root) }\n\t\t\tif(false === opt.localStorage){ return ev.next(root) } // we want offline resynce queue regardless! // actually, this doesn't help, per @go1dfish 's observation. Disabling for now, will need better solution later.\n\t\t\topt.prefix = opt.file || 'gun/';\n\t\t\tvar gap = Gun.obj.ify(store.getItem('gap/'+opt.prefix)) || {};\n\t\t\tvar empty = Gun.obj.empty, id, to, go;\n\t\t\t// add re-sync command.\n\t\t\tif(!empty(gap)){\n\t\t\t\tvar disk = Gun.obj.ify(store.getItem(opt.prefix)) || {}, send = {};\n\t\t\t\tGun.obj.map(gap, function(node, soul){\n\t\t\t\t\tGun.obj.map(node, function(val, key){\n\t\t\t\t\t\tsend[soul] = Gun.state.to(disk[soul], key, send[soul]);\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t\tsetTimeout(function(){\n\t\t\t\t\t// TODO: Holy Grail dangling by this thread! If gap / offline resync doesn't trigger, it doesn't work. Ouch, and this is a localStorage specific adapter. :(\n\t\t\t\t\troot.on('out', {put: send, '#': root.ask(ack)});\n\t\t\t\t},1);\n\t\t\t}\n\n\t\t\troot.on('out', function(msg){\n\t\t\t\tif(msg.lS){ return } // TODO: for IndexedDB and others, shouldn't send to peers ACKs to our own GETs. // THIS IS BLOCKING BROWSERS REPLYING TO REQUESTS, NO??? CHANGE THIS SOON!! UNDER CONTROLLED CIRCUMSTANCES!! Or maybe in-memory already doe sit?\n\t\t\t\tif(Gun.is(msg.$) && msg.put && !msg['@']){\n\t\t\t\t\tid = msg['#'];\n\t\t\t\t\tGun.graph.is(msg.put, null, map);\n\t\t\t\t\tif(!to){ to = setTimeout(flush, opt.wait || 1) }\n\t\t\t\t}\n\t\t\t\tthis.to.next(msg);\n\t\t\t});\n\t\t\troot.on('ack', ack);\n\n\t\t\tfunction ack(ack){ // TODO: This is experimental, not sure if we should keep this type of event hook.\n\t\t\t\tif(ack.err || !ack.ok){ return }\n\t\t\t\tvar id = ack['@'];\n\t\t\t\tsetTimeout(function(){\n\t\t\t\t\tGun.obj.map(gap, function(node, soul){\n\t\t\t\t\t\tGun.obj.map(node, function(val, key){\n\t\t\t\t\t\t\tif(id !== val){ return }\n\t\t\t\t\t\t\tdelete node[key];\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif(empty(node)){\n\t\t\t\t\t\t\tdelete gap[soul];\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t\tflush();\n\t\t\t\t}, opt.wait || 1);\n\t\t\t};\n\t\t\tev.next(root);\n\n\t\t\tvar map = function(val, key, node, soul){\n\t\t\t\t(gap[soul] || (gap[soul] = {}))[key] = id;\n\t\t\t}\n\t\t\tvar flush = function(){\n\t\t\t\tclearTimeout(to);\n\t\t\t\tto = false;\n\t\t\t\ttry{store.setItem('gap/'+opt.prefix, JSON.stringify(gap));\n\t\t\t\t}catch(e){ Gun.log(err = e || \"localStorage failure\") }\n\t\t\t}\n\t\t});\n\n\t\tGun.on('create', function(root){\n\t\t\tthis.to.next(root);\n\t\t\tvar opt = root.opt;\n\t\t\tif(root.once){ return }\n\t\t\tif(false === opt.localStorage){ return }\n\t\t\topt.prefix = opt.file || 'gun/';\n\t\t\tvar graph = root.graph, acks = {}, count = 0, to;\n\t\t\tvar disk = Gun.obj.ify(store.getItem(opt.prefix)) || {};\n\t\t\tvar lS = function(){}, u;\n\t\t\troot.on('localStorage', disk); // NON-STANDARD EVENT!\n\n\t\t\troot.on('put', function(msg){\n\t\t\t\tthis.to.next(msg);\n\t\t\t\tvar put = msg.put, soul = put['#'], key = put['.'], val = put[':'], state = put['>'], tmp;\n\t\t\t\tdisk[soul] = Gun.state.ify(disk[soul], key, state, val, soul);\n\t\t\t\tif(!msg['@']){ (acks[msg['#']] = (tmp = (msg._||'').lot || {})).lS = (tmp.lS||0)+1; } // only ack non-acks.\n\t\t\t\tcount += 1;\n\t\t\t\tif(count >= (opt.batch || 1000)){\n\t\t\t\t\treturn flush();\n\t\t\t\t}\n\t\t\t\tif(to){ return }\n\t\t\t\tto = setTimeout(flush, opt.wait || 1);\n\t\t\t});\n\n\t\t\troot.on('get', function(msg){\n\t\t\t\tthis.to.next(msg);\n\t\t\t\tvar lex = msg.get, soul, data, u;\n\t\t\t\tfunction to(){\n\t\t\t\tif(!lex || !(soul = lex['#'])){ return }\n\t\t\t\t//if(0 >= msg.cap){ return }\n\t\t\t\tvar has = lex['.'];\n\t\t\t\tdata = disk[soul] || u;\n\t\t\t\tif(data && has){\n\t\t\t\t\tdata = Gun.state.to(data, has);\n\t\t\t\t}\n\t\t\t\t//if(!data && !Gun.obj.empty(opt.peers)){ return } // if data not found, don't ack if there are peers. // Hmm, what if we have peers but we are disconnected?\n\t\t\t\troot.on('in', {'@': msg['#'], put: Gun.graph.node(data), lS:1});// || root.$});\n\t\t\t\t};\n\t\t\t\tGun.debug? setTimeout(to,1) : to();\n\t\t\t});\n\n\t\t\tvar map = function(val, key, node, soul){\n\t\t\t\tdisk[soul] = Gun.state.to(node, key, disk[soul]);\n\t\t\t}\n\n\t\t\tvar flush = function(data){\n\t\t\t\tvar err;\n\t\t\t\tcount = 0;\n\t\t\t\tclearTimeout(to);\n\t\t\t\tto = false;\n\t\t\t\tvar ack = acks;\n\t\t\t\tacks = {};\n\t\t\t\tif(data){ disk = data }\n\t\t\t\ttry{store.setItem(opt.prefix, JSON.stringify(disk));\n\t\t\t\t}catch(e){\n\t\t\t\t\tGun.log(err = (e || \"localStorage failure\") + \" Consider using GUN's IndexedDB plugin for RAD for more storage space, https://gun.eco/docs/RAD#install\");\n\t\t\t\t\troot.on('localStorage:error', {err: err, file: opt.prefix, flush: disk, retry: flush});\n\t\t\t\t}\n\t\t\t\tif(!err && !Gun.obj.empty(opt.peers)){ return } // only ack if there are no peers.\n\t\t\t\tGun.obj.map(ack, function(yes, id){\n\t\t\t\t\tif(yes){\n\t\t\t\t\t\tif(yes.more){ acks[id] = yes; return }\n\t\t\t\t\t\tif(yes.s !== yes.lS){ err = \"localStorage batch not same.\" }\n\t\t\t\t\t}\n\t\t\t\t\troot.on('in', {\n\t\t\t\t\t\t'@': id,\n\t\t\t\t\t\terr: err,\n\t\t\t\t\t\tok: 0 // localStorage isn't reliable, so make its `ok` code be a low number.\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t})(USE, './adapters/localStorage');\n\n\t;USE(function(module){\n\t\tvar Type = USE('../type');\n\n\t\tfunction Mesh(root){\n\t\t\tvar mesh = function(){};\n\t\t\tvar opt = root.opt || {};\n\t\t\topt.log = opt.log || console.log;\n\t\t\topt.gap = opt.gap || opt.wait || 0;\n\t\t\topt.pack = opt.pack || (opt.memory? (opt.memory * 1000 * 1000) : 1399000000) * 0.3; // max_old_space_size defaults to 1400 MB.\n\t\t\topt.puff = opt.puff || 9; // IDEA: do a start/end benchmark, divide ops/result.\n\t\t\tvar puff = setTimeout.puff || setTimeout;\n\n\t\t\tvar dup = root.dup, dup_check = dup.check, dup_track = dup.track;\n\n\t\t\tvar hear = mesh.hear = function(raw, peer){\n\t\t\t\tif(!raw){ return }\n\t\t\t\tif(opt.pack <= raw.length){ return mesh.say({dam: '!', err: \"Message too big!\"}, peer) }\n\t\t\t\tvar msg, id, hash, tmp = raw[0], DBG;\n\t\t\t\tif(mesh === this){ hear.d += raw.length||0 ; ++hear.c } // STATS!\n\t\t\t\tif('[' === tmp){\n\t\t\t\t\ttry{msg = JSON.parse(raw)}catch(e){opt.log('DAM JSON parse error', e)}\n\t\t\t\t\traw = '';\n\t\t\t\t\tif(!msg){ return }\n\t\t\t\t\tconsole.STAT && console.STAT(+new Date, msg.length, '# on hear batch');\n\t\t\t\t\tvar P = opt.puff;\n\t\t\t\t\t(function go(){\n\t\t\t\t\t\tvar S = +new Date;\n\t\t\t\t\t\t//var P = peer.puff || opt.puff, s = +new Date; // TODO: For future, but in mix?\n\t\t\t\t\t\tvar i = 0, m; while(i < P && (m = msg[i++])){ hear(m, peer) }\n\t\t\t\t\t\t//peer.puff = Math.ceil((+new Date - s)? P * 1.1 : P * 0.9);\n\t\t\t\t\t\tmsg = msg.slice(i); // slicing after is faster than shifting during.\n\t\t\t\t\t\tconsole.STAT && console.STAT(S, +new Date - S, 'hear loop');\n\t\t\t\t\t\tflush(peer); // force send all synchronously batched acks.\n\t\t\t\t\t\tif(!msg.length){ return }\n\t\t\t\t\t\tpuff(go, 0);\n\t\t\t\t\t}());\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif('{' === tmp || ((raw['#'] || obj_is(raw)) && (msg = raw))){\n\t\t\t\t\ttry{msg = msg || JSON.parse(raw);\n\t\t\t\t\t}catch(e){return opt.log('DAM JSON parse error', e)}\n\t\t\t\t\tif(!msg){ return }\n\t\t\t\t\tif(msg.DBG){ msg.DBG = DBG = {DBG: msg.DBG} }\n\t\t\t\t\tDBG && (DBG.hp = +new Date);\n\t\t\t\t\tif(!(id = msg['#'])){ id = msg['#'] = Type.text.random(9) }\n\t\t\t\t\tif(tmp = dup_check(id)){ return }\n\t\t\t\t\t/*if(!(hash = msg['##']) && u !== msg.put){ hash = msg['##'] = Type.obj.hash(msg.put) }\n\t\t\t\t\tif(hash && (tmp = msg['@'] || (msg.get && id))){ // Reduces backward daisy in case varying hashes at different daisy depths are the same.\n\t\t\t\t\t\tif(dup.check(tmp+hash)){ return }\n\t\t\t\t\t\tdup.track(tmp+hash, true).it = it(msg); // GUN core also dedups, so `true` is needed. // Does GUN core need to dedup anymore?\n\t\t\t\t\t}\n\t\t\t\t\tif(tmp = msg['><']){ (msg._).to = Type.obj.map(tmp.split(','), tomap) }\n\t\t\t\t\t*/ // TOOD: COME BACK TO THIS LATER!!! IMPORTANT MESH STUFF!!\n\t\t\t\t\t(msg._ = function(){}).via = mesh.leap = peer;\n\t\t\t\t\tif(tmp = msg.dam){\n\t\t\t\t\t\tif(tmp = mesh.hear[tmp]){\n\t\t\t\t\t\t\ttmp(msg, peer, root);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdup_track(id);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tvar S = +new Date, ST;\n\t\t\t\t\tDBG && (DBG.is = S);\n\t\t\t\t\troot.on('in', msg);\n\t\t\t\t\t//ECHO = msg.put || ECHO; !(msg.ok !== -3740) && mesh.say({ok: -3740, put: ECHO, '@': msg['#']}, peer);\n\t\t\t\t\tDBG && (DBG.hd = +new Date);\n\t\t\t\t\tconsole.STAT && (ST = +new Date - S) > 9 && console.STAT(S, ST, 'msg'); // TODO: PERF: caught one > 1.5s on tgif\n\t\t\t\t\tdup_track(id).via = peer;\n\t\t\t\t\tmesh.leap = null; // warning! mesh.leap could be buggy.\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar tomap = function(k,i,m){m(k,true)};\n\t\t\tvar noop = function(){};\n\t\t\thear.c = hear.d = 0;\n\n\t\t\t;(function(){\n\t\t\t\tvar SMIA = 0;\n\t\t\t\tvar message, loop;\n\t\t\t\tfunction each(peer){ mesh.say(message, peer) }\n\t\t\t\tvar say = mesh.say = function(msg, peer){ var tmp;\n\t\t\t\t\tif((tmp = this) && (tmp = tmp.to) && tmp.next){ tmp.next(msg) } // compatible with middleware adapters.\n\t\t\t\t\tif(!msg){ return false }\n\t\t\t\t\tvar id, hash, raw;\n\t\t\t\t\tvar DBG = msg.DBG, S; if(!peer){ S = +new Date ; DBG && (DBG.y = S) }\n\t\t\t\t\tvar meta = msg._||(msg._=function(){});\n\t\t\t\t\tif(!(id = msg['#'])){ id = msg['#'] = Type.text.random(9) }\n\t\t\t\t\t//if(!(hash = msg['##']) && u !== msg.put){ hash = msg['##'] = Type.obj.hash(msg.put) }\n\t\t\t\t\tif(!(raw = meta.raw)){\n\t\t\t\t\t\traw = mesh.raw(msg);\n\t\t\t\t\t\t/*if(hash && (tmp = msg['@'])){\n\t\t\t\t\t\t\tdup.track(tmp+hash).it = it(msg);\n\t\t\t\t\t\t\tif(tmp = (dup.s[tmp]||ok).it){\n\t\t\t\t\t\t\t\tif(hash === tmp['##']){ return false }\n\t\t\t\t\t\t\t\ttmp['##'] = hash;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}*/\n\t\t\t\t\t}\n\t\t\t\t\tS && console.STAT && console.STAT(S, +new Date - S, 'say prep');\n\t\t\t\t\t!loop && dup_track(id);//.it = it(msg); // track for 9 seconds, default. Earth<->Mars would need more! // always track, maybe move this to the 'after' logic if we split function.\n\t\t\t\t\t//console.log(\"SEND!\", JSON.parse(JSON.stringify(msg)));\n\t\t\t\t\tif(!peer && (tmp = msg['@'])){ peer = ((tmp = dup.s[tmp]) && (tmp.via || ((tmp = tmp.it) && (tmp = tmp._) && tmp.via))) || mesh.leap } // warning! mesh.leap could be buggy!\n\t\t\t\t\tif(!peer && msg['@']){\n\t\t\t\t\t\tconsole.STAT && console.STAT(+new Date, ++SMIA, 'total no peer to ack to');\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t} // TODO: Temporary? If ack via trace has been lost, acks will go to all peers, which trashes browser bandwidth. Not relaying the ack will force sender to ask for ack again. Note, this is technically wrong for mesh behavior.\n\t\t\t\t\tif(!peer && mesh.way){ return mesh.way(msg) }\n\t\t\t\t\tif(!peer || !peer.id){ message = msg;\n\t\t\t\t\t\tif(!Type.obj.is(peer || opt.peers)){ return false }\n\t\t\t\t\t\tvar P = opt.puff, ps = opt.peers, pl = Object.keys(peer || opt.peers || {}); // TODO: BETTER PERF? No object.keys? It is polyfilled by Type.js tho.\n\t\t\t\t\t\t;(function go(){\n\t\t\t\t\t\t\tvar S = +new Date;\n\t\t\t\t\t\t\t//Type.obj.map(peer || opt.peers, each); // in case peer is a peer list.\n\t\t\t\t\t\t\tloop = 1; var wr = meta.raw; meta.raw = raw; // quick perf hack\n\t\t\t\t\t\t\tvar i = 0, p; while(i < 9 && (p = (pl||'')[i++])){\n\t\t\t\t\t\t\t\tif(!(p = ps[p])){ continue }\n\t\t\t\t\t\t\t\tsay(msg, p);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tmeta.raw = wr; loop = 0;\n\t\t\t\t\t\t\tpl = pl.slice(i); // slicing after is faster than shifting during.\n\t\t\t\t\t\t\tconsole.STAT && console.STAT(S, +new Date - S, 'say loop');\n\t\t\t\t\t\t\tif(!pl.length){ return }\n\t\t\t\t\t\t\tpuff(go, 0);\n\t\t\t\t\t\t\tdup_track(msg['@']); // keep for later\n\t\t\t\t\t\t}());\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\t// TODO: PERF: consider splitting function here, so say loops do less work.\n\t\t\t\t\tif(!peer.wire && mesh.wire){ mesh.wire(peer) }\n\t\t\t\t\tif(id === peer.last){ return } peer.last = id;  // was it just sent?\n\t\t\t\t\tif(peer === meta.via){ return false } // don't send back to self.\n\t\t\t\t\tif((tmp = meta.to) && (tmp[peer.url] || tmp[peer.pid] || tmp[peer.id]) /*&& !o*/){ return false }\n\t\t\t\t\tif(peer.batch){\n\t\t\t\t\t\tpeer.tail = (tmp = peer.tail || 0) + raw.length;\n\t\t\t\t\t\tif(peer.tail <= opt.pack){\n\t\t\t\t\t\t\t//peer.batch.push(raw);\n\t\t\t\t\t\t\tpeer.batch += (tmp?',':'')+raw; // TODO: Prevent double JSON! // FOR v1.0 !?\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tflush(peer);\n\t\t\t\t\t}\n\t\t\t\t\t//peer.batch = [];\n\t\t\t\t\tpeer.batch = '['; // TODO: Prevent double JSON!\n\t\t\t\t\tvar S = +new Date, ST;\n\t\t\t\t\tsetTimeout(function(){\n\t\t\t\t\t\tconsole.STAT && (ST = +new Date - S) > 9 && console.STAT(S, ST, '0ms TO', id, peer.id);\n\t\t\t\t\t\tflush(peer);\n\t\t\t\t\t}, opt.gap);\n\t\t\t\t\tsend(raw, peer);\n\t\t\t\t}\n\t\t\t\tmesh.say.c = mesh.say.d = 0;\n\t\t\t}());\n\n\t\t\tfunction flush(peer){\n\t\t\t\tvar tmp = peer.batch, t = 'string' == typeof tmp, l;\n\t\t\t\tif(t){ tmp += ']' }// TODO: Prevent double JSON!\n\t\t\t\tpeer.batch = peer.tail = null;\n\t\t\t\tif(!tmp){ return }\n\t\t\t\tif(t? 3 > tmp.length : !tmp.length){ return } // TODO: ^\n\t\t\t\tif(!t){try{tmp = (1 === tmp.length? tmp[0] : JSON.stringify(tmp));\n\t\t\t\t}catch(e){return opt.log('DAM JSON stringify error', e)}}\n\t\t\t\tif(!tmp){ return }\n\t\t\t\tsend(tmp, peer);\n\t\t\t}\n\t\t\t// for now - find better place later.\n\t\t\tfunction send(raw, peer){ try{\n\t\t\t\tvar wire = peer.wire;\n\t\t\t\tif(peer.say){\n\t\t\t\t\tpeer.say(raw);\n\t\t\t\t} else\n\t\t\t\tif(wire.send){\n\t\t\t\t\twire.send(raw);\n\t\t\t\t}\n\t\t\t\tmesh.say.d += raw.length||0; ++mesh.say.c; // STATS!\n\t\t\t}catch(e){\n\t\t\t\t(peer.queue = peer.queue || []).push(raw);\n\t\t\t}}\n\n\t\t\t;(function(){\n\t\t\t\t// TODO: this caused a out-of-memory crash!\n\t\t\t\tmesh.raw = function(msg){ // TODO: Clean this up / delete it / move logic out!\n\t\t\t\t\tif(!msg){ return '' }\n\t\t\t\t\tvar meta = (msg._) || {}, put, hash, tmp;\n\t\t\t\t\tif(tmp = meta.raw){ return tmp }\n\t\t\t\t\tif('string' == typeof msg){ return msg }\n\t\t\t\t\t/*if(!msg.dam){ // TOOD: COME BACK TO THIS LATER!!! IMPORTANT MESH STUFF!!\n\t\t\t\t\t\tvar i = 0, to = []; Type.obj.map(opt.peers, function(p){\n\t\t\t\t\t\t\tto.push(p.url || p.pid || p.id); if(++i > 3){ return true } // limit server, fast fix, improve later! // For \"tower\" peer, MUST include 6 surrounding ids. // REDUCED THIS TO 3 for temporary relay peer performance, towers still should list neighbors.\n\t\t\t\t\t\t}); if(i > 1){ msg['><'] = to.join() }\n\t\t\t\t\t}*/  // TOOD: COME BACK TO THIS LATER!!! IMPORTANT MESH STUFF!!\n\t\t\t\t\tvar raw = $(msg); // optimize by reusing put = the JSON.stringify from .hash?\n\t\t\t\t\t/*if(u !== put){\n\t\t\t\t\t\ttmp = raw.indexOf(_, raw.indexOf('put'));\n\t\t\t\t\t\traw = raw.slice(0, tmp-1) + put + raw.slice(tmp + _.length + 1);\n\t\t\t\t\t\t//raw = raw.replace('\"'+ _ +'\"', put); // NEVER USE THIS! ALSO NEVER DELETE IT TO NOT MAKE SAME MISTAKE! https://github.com/amark/gun/wiki/@$$ Heisenbug\n\t\t\t\t\t}*/\n\t\t\t\t\t// TODO: PERF: tgif, CPU way too much on re-JSONifying ^ it.\n\t\t\t\t\t/*\n\t\t\t\t\t\t// NOTE TO SELF: Switch NTS to DAM now.\n\t\t\t\t\t*/\n\t\t\t\t\tif(meta && (raw||'').length < (1000 * 100)){ meta.raw = raw } // HNPERF: If string too big, don't keep in memory.\n\t\t\t\t\treturn raw;\n\t\t\t\t}\n\t\t\t\tvar $ = JSON.stringify, _ = ':])([:';\n\n\t\t\t}());\n\n\t\t\tmesh.hi = function(peer){\n\t\t\t\tvar tmp = peer.wire || {};\n\t\t\t\tif(peer.id){\n\t\t\t\t\topt.peers[peer.url || peer.id] = peer;\n\t\t\t\t} else {\n\t\t\t\t\ttmp = peer.id = peer.id || Type.text.random(9);\n\t\t\t\t\tmesh.say({dam: '?', pid: root.opt.pid}, opt.peers[tmp] = peer);\n\t\t\t\t\tdelete dup.s[peer.last]; // IMPORTANT: see https://gun.eco/docs/DAM#self\n\t\t\t\t}\n\t\t\t\tpeer.met = peer.met || +(new Date);\n\t\t\t\tif(!tmp.hied){ root.on(tmp.hied = 'hi', peer) }\n\t\t\t\t// @rogowski I need this here by default for now to fix go1dfish's bug\n\t\t\t\ttmp = peer.queue; peer.queue = [];\n\t\t\t\tType.obj.map(tmp, function(msg){\n\t\t\t\t\tsend(msg, peer);\n\t\t\t\t});\n\t\t\t\tType.obj.native && Type.obj.native(); // dirty place to check if other JS polluted.\n\t\t\t}\n\t\t\tmesh.bye = function(peer){\n\t\t\t\troot.on('bye', peer);\n\t\t\t\tvar tmp = +(new Date); tmp = (tmp - (peer.met||tmp));\n\t\t\t\tmesh.bye.time = ((mesh.bye.time || tmp) + tmp) / 2;\n\t\t\t}\n\t\t\tmesh.hear['!'] = function(msg, peer){ opt.log('Error:', msg.err) }\n\t\t\tmesh.hear['?'] = function(msg, peer){\n\t\t\t\tif(msg.pid){\n\t\t\t\t\tif(!peer.pid){ peer.pid = msg.pid }\n\t\t\t\t\tif(msg['@']){ return }\n\t\t\t\t}\n\t\t\t\tmesh.say({dam: '?', pid: opt.pid, '@': msg['#']}, peer);\n\t\t\t\tdelete dup.s[peer.last]; // IMPORTANT: see https://gun.eco/docs/DAM#self\n\t\t\t}\n\n\t\t\troot.on('create', function(root){\n\t\t\t\troot.opt.pid = root.opt.pid || Type.text.random(9);\n\t\t\t\tthis.to.next(root);\n\t\t\t\troot.on('out', mesh.say);\n\t\t\t});\n\n\t\t\troot.on('bye', function(peer, tmp){\n\t\t\t\tpeer = opt.peers[peer.id || peer] || peer;\n\t\t\t\tthis.to.next(peer);\n\t\t\t\tpeer.bye? peer.bye() : (tmp = peer.wire) && tmp.close && tmp.close();\n\t\t\t\tType.obj.del(opt.peers, peer.id);\n\t\t\t\tpeer.wire = null;\n\t\t\t});\n\n\t\t\tvar gets = {};\n\t\t\troot.on('bye', function(peer, tmp){ this.to.next(peer);\n\t\t\t\tif(!(tmp = peer.url)){ return } gets[tmp] = true;\n\t\t\t\tsetTimeout(function(){ delete gets[tmp] },opt.lack || 9000);\n\t\t\t});\n\t\t\troot.on('hi', function(peer, tmp){ this.to.next(peer);\n\t\t\t\tif(!(tmp = peer.url) || !gets[tmp]){ return } delete gets[tmp];\n\t\t\t\tif(opt.super){ return } // temporary (?) until we have better fix/solution?\n\t\t\t\tType.obj.map(root.next, function(node, soul){\n\t\t\t\t\ttmp = {}; tmp[soul] = root.graph[soul];\n\t\t\t\t\tmesh.say({'##': Type.obj.hash(tmp), get: {'#': soul}}, peer);\n\t\t\t\t})\n\t\t\t});\n\n\t\t\treturn mesh;\n\t\t}\n\n\t\t;(function(){\n\t\t\tvar $ = JSON.stringify, u;\n\n\t\t\tType.obj.hash = function(obj, hash){\n\t\t\t\tif(!hash && u === (obj = $(obj, sort))){ return }\n\t\t\t\treturn Type.text.hash(hash || obj || '');\n\t\t\t}\n\n\t\t\tfunction sort(k, v){ var tmp;\n\t\t\t\tif(!(v instanceof Object)){ return v }\n\t\t\t\tvar S = +new Date;\n\t\t\t\tType.obj.map(Object.keys(v).sort(), map, {to: tmp = {}, on: v});\n\t\t\t\tconsole.STAT && console.STAT(S, +new Date - S, 'sort');\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\tType.obj.hash.sort = sort;\n\n\t\t\tfunction map(k){\n\t\t\t\tthis.to[k] = this.on[k];\n\t\t\t}\n\t\t}());\n\n\t\tfunction it(msg){ return msg || {_: msg._, '##': msg['##']} } // HNPERF: Only need some meta data, not full reference (took up too much memory). // HNPERF: Garrrgh! We add meta data to msg over time, copying the object happens to early.\n\n\t  var empty = {}, ok = true, u;\n\t\tvar obj_is = Type.obj.is, obj_map = Type.obj.map;\n\n\t  try{ module.exports = Mesh }catch(e){}\n\n\t})(USE, './adapters/mesh');\n\n\t;USE(function(module){\n\t\tvar Gun = USE('../index');\n\t\tGun.Mesh = USE('./mesh');\n\n\t\tGun.on('opt', function(root){\n\t\t\tthis.to.next(root);\n\t\t\tvar opt = root.opt;\n\t\t\tif(root.once){ return }\n\t\t\tif(false === opt.WebSocket){ return }\n\n\t\t\tvar env;\n\t\t\tif(typeof window !== \"undefined\"){ env = window }\n\t\t\tif(typeof global !== \"undefined\"){ env = global }\n\t\t\tenv = env || {};\n\n\t\t\tvar websocket = opt.WebSocket || env.WebSocket || env.webkitWebSocket || env.mozWebSocket;\n\t\t\tif(!websocket){ return }\n\t\t\topt.WebSocket = websocket;\n\n\t\t\tvar mesh = opt.mesh = opt.mesh || Gun.Mesh(root);\n\n\t\t\tvar wire = mesh.wire || opt.wire;\n\t\t\tmesh.wire = opt.wire = open;\n\t\t\tfunction open(peer){ try{\n\t\t\t\tif(!peer || !peer.url){ return wire && wire(peer) }\n\t\t\t\tvar url = peer.url.replace(/^http/, 'ws');\n\t\t\t\tvar wire = peer.wire = new opt.WebSocket(url);\n\t\t\t\twire.onclose = function(){\n\t\t\t\t\topt.mesh.bye(peer);\n\t\t\t\t\treconnect(peer);\n\t\t\t\t};\n\t\t\t\twire.onerror = function(error){\n\t\t\t\t\treconnect(peer);\n\t\t\t\t};\n\t\t\t\twire.onopen = function(){\n\t\t\t\t\topt.mesh.hi(peer);\n\t\t\t\t}\n\t\t\t\twire.onmessage = function(msg){\n\t\t\t\t\tif(!msg){ return }\n\t\t\t\t\topt.mesh.hear(msg.data || msg, peer);\n\t\t\t\t};\n\t\t\t\treturn wire;\n\t\t\t}catch(e){}}\n\n\t\t\tsetTimeout(function(){ root.on('out', {dam:'hi'}) },1); // it can take a while to open a socket, so maybe no longer lazy load for perf reasons?\n\n\t\t\tvar wait = 2 * 1000;\n\t\t\tfunction reconnect(peer){\n\t\t\t\tclearTimeout(peer.defer);\n\t\t\t\tif(doc && peer.retry <= 0){ return } peer.retry = (peer.retry || opt.retry || 60) - 1;\n\t\t\t\tpeer.defer = setTimeout(function to(){\n\t\t\t\t\tif(doc && doc.hidden){ return setTimeout(to,wait) }\n\t\t\t\t\topen(peer);\n\t\t\t\t}, wait);\n\t\t\t}\n\t\t\tvar doc = 'undefined' !== typeof document && document;\n\t\t});\n\t\tvar noop = function(){};\n\t})(USE, './adapters/websocket');\n\n}());\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/*!\n    localForage -- Offline Storage, Improved\n    Version 1.7.4\n    https://localforage.github.io/localForage\n    (c) 2013-2017 Mozilla, Apache License 2.0\n*/\n!function(a){if(\"object\"==typeof exports&&\"undefined\"!=typeof module)module.exports=a();else if(\"function\"==typeof define&&define.amd)define([],a);else{var b;b=\"undefined\"!=typeof window?window:\"undefined\"!=typeof global?global:\"undefined\"!=typeof self?self:this,b.localforage=a()}}(function(){return function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i=\"function\"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);var j=new Error(\"Cannot find module '\"+g+\"'\");throw j.code=\"MODULE_NOT_FOUND\",j}var k=c[g]={exports:{}};b[g][0].call(k.exports,function(a){var c=b[g][1][a];return e(c||a)},k,k.exports,a,b,c,d)}return c[g].exports}for(var f=\"function\"==typeof require&&require,g=0;g<d.length;g++)e(d[g]);return e}({1:[function(a,b,c){(function(a){\"use strict\";function c(){k=!0;for(var a,b,c=l.length;c;){for(b=l,l=[],a=-1;++a<c;)b[a]();c=l.length}k=!1}function d(a){1!==l.push(a)||k||e()}var e,f=a.MutationObserver||a.WebKitMutationObserver;if(f){var g=0,h=new f(c),i=a.document.createTextNode(\"\");h.observe(i,{characterData:!0}),e=function(){i.data=g=++g%2}}else if(a.setImmediate||void 0===a.MessageChannel)e=\"document\"in a&&\"onreadystatechange\"in a.document.createElement(\"script\")?function(){var b=a.document.createElement(\"script\");b.onreadystatechange=function(){c(),b.onreadystatechange=null,b.parentNode.removeChild(b),b=null},a.document.documentElement.appendChild(b)}:function(){setTimeout(c,0)};else{var j=new a.MessageChannel;j.port1.onmessage=c,e=function(){j.port2.postMessage(0)}}var k,l=[];b.exports=d}).call(this,\"undefined\"!=typeof global?global:\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{})},{}],2:[function(a,b,c){\"use strict\";function d(){}function e(a){if(\"function\"!=typeof a)throw new TypeError(\"resolver must be a function\");this.state=s,this.queue=[],this.outcome=void 0,a!==d&&i(this,a)}function f(a,b,c){this.promise=a,\"function\"==typeof b&&(this.onFulfilled=b,this.callFulfilled=this.otherCallFulfilled),\"function\"==typeof c&&(this.onRejected=c,this.callRejected=this.otherCallRejected)}function g(a,b,c){o(function(){var d;try{d=b(c)}catch(b){return p.reject(a,b)}d===a?p.reject(a,new TypeError(\"Cannot resolve promise with itself\")):p.resolve(a,d)})}function h(a){var b=a&&a.then;if(a&&(\"object\"==typeof a||\"function\"==typeof a)&&\"function\"==typeof b)return function(){b.apply(a,arguments)}}function i(a,b){function c(b){f||(f=!0,p.reject(a,b))}function d(b){f||(f=!0,p.resolve(a,b))}function e(){b(d,c)}var f=!1,g=j(e);\"error\"===g.status&&c(g.value)}function j(a,b){var c={};try{c.value=a(b),c.status=\"success\"}catch(a){c.status=\"error\",c.value=a}return c}function k(a){return a instanceof this?a:p.resolve(new this(d),a)}function l(a){var b=new this(d);return p.reject(b,a)}function m(a){function b(a,b){function d(a){g[b]=a,++h!==e||f||(f=!0,p.resolve(j,g))}c.resolve(a).then(d,function(a){f||(f=!0,p.reject(j,a))})}var c=this;if(\"[object Array]\"!==Object.prototype.toString.call(a))return this.reject(new TypeError(\"must be an array\"));var e=a.length,f=!1;if(!e)return this.resolve([]);for(var g=new Array(e),h=0,i=-1,j=new this(d);++i<e;)b(a[i],i);return j}function n(a){function b(a){c.resolve(a).then(function(a){f||(f=!0,p.resolve(h,a))},function(a){f||(f=!0,p.reject(h,a))})}var c=this;if(\"[object Array]\"!==Object.prototype.toString.call(a))return this.reject(new TypeError(\"must be an array\"));var e=a.length,f=!1;if(!e)return this.resolve([]);for(var g=-1,h=new this(d);++g<e;)b(a[g]);return h}var o=a(1),p={},q=[\"REJECTED\"],r=[\"FULFILLED\"],s=[\"PENDING\"];b.exports=e,e.prototype.catch=function(a){return this.then(null,a)},e.prototype.then=function(a,b){if(\"function\"!=typeof a&&this.state===r||\"function\"!=typeof b&&this.state===q)return this;var c=new this.constructor(d);if(this.state!==s){g(c,this.state===r?a:b,this.outcome)}else this.queue.push(new f(c,a,b));return c},f.prototype.callFulfilled=function(a){p.resolve(this.promise,a)},f.prototype.otherCallFulfilled=function(a){g(this.promise,this.onFulfilled,a)},f.prototype.callRejected=function(a){p.reject(this.promise,a)},f.prototype.otherCallRejected=function(a){g(this.promise,this.onRejected,a)},p.resolve=function(a,b){var c=j(h,b);if(\"error\"===c.status)return p.reject(a,c.value);var d=c.value;if(d)i(a,d);else{a.state=r,a.outcome=b;for(var e=-1,f=a.queue.length;++e<f;)a.queue[e].callFulfilled(b)}return a},p.reject=function(a,b){a.state=q,a.outcome=b;for(var c=-1,d=a.queue.length;++c<d;)a.queue[c].callRejected(b);return a},e.resolve=k,e.reject=l,e.all=m,e.race=n},{1:1}],3:[function(a,b,c){(function(b){\"use strict\";\"function\"!=typeof b.Promise&&(b.Promise=a(2))}).call(this,\"undefined\"!=typeof global?global:\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{})},{2:2}],4:[function(a,b,c){\"use strict\";function d(a,b){if(!(a instanceof b))throw new TypeError(\"Cannot call a class as a function\")}function e(){try{if(\"undefined\"!=typeof indexedDB)return indexedDB;if(\"undefined\"!=typeof webkitIndexedDB)return webkitIndexedDB;if(\"undefined\"!=typeof mozIndexedDB)return mozIndexedDB;if(\"undefined\"!=typeof OIndexedDB)return OIndexedDB;if(\"undefined\"!=typeof msIndexedDB)return msIndexedDB}catch(a){return}}function f(){try{if(!ua||!ua.open)return!1;var a=\"undefined\"!=typeof openDatabase&&/(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent)&&!/Chrome/.test(navigator.userAgent)&&!/BlackBerry/.test(navigator.platform),b=\"function\"==typeof fetch&&-1!==fetch.toString().indexOf(\"[native code\");return(!a||b)&&\"undefined\"!=typeof indexedDB&&\"undefined\"!=typeof IDBKeyRange}catch(a){return!1}}function g(a,b){a=a||[],b=b||{};try{return new Blob(a,b)}catch(f){if(\"TypeError\"!==f.name)throw f;for(var c=\"undefined\"!=typeof BlobBuilder?BlobBuilder:\"undefined\"!=typeof MSBlobBuilder?MSBlobBuilder:\"undefined\"!=typeof MozBlobBuilder?MozBlobBuilder:WebKitBlobBuilder,d=new c,e=0;e<a.length;e+=1)d.append(a[e]);return d.getBlob(b.type)}}function h(a,b){b&&a.then(function(a){b(null,a)},function(a){b(a)})}function i(a,b,c){\"function\"==typeof b&&a.then(b),\"function\"==typeof c&&a.catch(c)}function j(a){return\"string\"!=typeof a&&(console.warn(a+\" used as a key, but it is not a string.\"),a=String(a)),a}function k(){if(arguments.length&&\"function\"==typeof arguments[arguments.length-1])return arguments[arguments.length-1]}function l(a){for(var b=a.length,c=new ArrayBuffer(b),d=new Uint8Array(c),e=0;e<b;e++)d[e]=a.charCodeAt(e);return c}function m(a){return new va(function(b){var c=a.transaction(wa,Ba),d=g([\"\"]);c.objectStore(wa).put(d,\"key\"),c.onabort=function(a){a.preventDefault(),a.stopPropagation(),b(!1)},c.oncomplete=function(){var a=navigator.userAgent.match(/Chrome\\/(\\d+)/),c=navigator.userAgent.match(/Edge\\//);b(c||!a||parseInt(a[1],10)>=43)}}).catch(function(){return!1})}function n(a){return\"boolean\"==typeof xa?va.resolve(xa):m(a).then(function(a){return xa=a})}function o(a){var b=ya[a.name],c={};c.promise=new va(function(a,b){c.resolve=a,c.reject=b}),b.deferredOperations.push(c),b.dbReady?b.dbReady=b.dbReady.then(function(){return c.promise}):b.dbReady=c.promise}function p(a){var b=ya[a.name],c=b.deferredOperations.pop();if(c)return c.resolve(),c.promise}function q(a,b){var c=ya[a.name],d=c.deferredOperations.pop();if(d)return d.reject(b),d.promise}function r(a,b){return new va(function(c,d){if(ya[a.name]=ya[a.name]||B(),a.db){if(!b)return c(a.db);o(a),a.db.close()}var e=[a.name];b&&e.push(a.version);var f=ua.open.apply(ua,e);b&&(f.onupgradeneeded=function(b){var c=f.result;try{c.createObjectStore(a.storeName),b.oldVersion<=1&&c.createObjectStore(wa)}catch(c){if(\"ConstraintError\"!==c.name)throw c;console.warn('The database \"'+a.name+'\" has been upgraded from version '+b.oldVersion+\" to version \"+b.newVersion+', but the storage \"'+a.storeName+'\" already exists.')}}),f.onerror=function(a){a.preventDefault(),d(f.error)},f.onsuccess=function(){c(f.result),p(a)}})}function s(a){return r(a,!1)}function t(a){return r(a,!0)}function u(a,b){if(!a.db)return!0;var c=!a.db.objectStoreNames.contains(a.storeName),d=a.version<a.db.version,e=a.version>a.db.version;if(d&&(a.version!==b&&console.warn('The database \"'+a.name+\"\\\" can't be downgraded from version \"+a.db.version+\" to version \"+a.version+\".\"),a.version=a.db.version),e||c){if(c){var f=a.db.version+1;f>a.version&&(a.version=f)}return!0}return!1}function v(a){return new va(function(b,c){var d=new FileReader;d.onerror=c,d.onloadend=function(c){var d=btoa(c.target.result||\"\");b({__local_forage_encoded_blob:!0,data:d,type:a.type})},d.readAsBinaryString(a)})}function w(a){return g([l(atob(a.data))],{type:a.type})}function x(a){return a&&a.__local_forage_encoded_blob}function y(a){var b=this,c=b._initReady().then(function(){var a=ya[b._dbInfo.name];if(a&&a.dbReady)return a.dbReady});return i(c,a,a),c}function z(a){o(a);for(var b=ya[a.name],c=b.forages,d=0;d<c.length;d++){var e=c[d];e._dbInfo.db&&(e._dbInfo.db.close(),e._dbInfo.db=null)}return a.db=null,s(a).then(function(b){return a.db=b,u(a)?t(a):b}).then(function(d){a.db=b.db=d;for(var e=0;e<c.length;e++)c[e]._dbInfo.db=d}).catch(function(b){throw q(a,b),b})}function A(a,b,c,d){void 0===d&&(d=1);try{var e=a.db.transaction(a.storeName,b);c(null,e)}catch(e){if(d>0&&(!a.db||\"InvalidStateError\"===e.name||\"NotFoundError\"===e.name))return va.resolve().then(function(){if(!a.db||\"NotFoundError\"===e.name&&!a.db.objectStoreNames.contains(a.storeName)&&a.version<=a.db.version)return a.db&&(a.version=a.db.version+1),t(a)}).then(function(){return z(a).then(function(){A(a,b,c,d-1)})}).catch(c);c(e)}}function B(){return{forages:[],db:null,dbReady:null,deferredOperations:[]}}function C(a){function b(){return va.resolve()}var c=this,d={db:null};if(a)for(var e in a)d[e]=a[e];var f=ya[d.name];f||(f=B(),ya[d.name]=f),f.forages.push(c),c._initReady||(c._initReady=c.ready,c.ready=y);for(var g=[],h=0;h<f.forages.length;h++){var i=f.forages[h];i!==c&&g.push(i._initReady().catch(b))}var j=f.forages.slice(0);return va.all(g).then(function(){return d.db=f.db,s(d)}).then(function(a){return d.db=a,u(d,c._defaultConfig.version)?t(d):a}).then(function(a){d.db=f.db=a,c._dbInfo=d;for(var b=0;b<j.length;b++){var e=j[b];e!==c&&(e._dbInfo.db=d.db,e._dbInfo.version=d.version)}})}function D(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.get(a);h.onsuccess=function(){var a=h.result;void 0===a&&(a=null),x(a)&&(a=w(a)),b(a)},h.onerror=function(){d(h.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function E(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.openCursor(),i=1;h.onsuccess=function(){var c=h.result;if(c){var d=c.value;x(d)&&(d=w(d));var e=a(d,c.key,i++);void 0!==e?b(e):c.continue()}else b()},h.onerror=function(){d(h.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function F(a,b,c){var d=this;a=j(a);var e=new va(function(c,e){var f;d.ready().then(function(){return f=d._dbInfo,\"[object Blob]\"===za.call(b)?n(f.db).then(function(a){return a?b:v(b)}):b}).then(function(b){A(d._dbInfo,Ba,function(f,g){if(f)return e(f);try{var h=g.objectStore(d._dbInfo.storeName);null===b&&(b=void 0);var i=h.put(b,a);g.oncomplete=function(){void 0===b&&(b=null),c(b)},g.onabort=g.onerror=function(){var a=i.error?i.error:i.transaction.error;e(a)}}catch(a){e(a)}})}).catch(e)});return h(e,c),e}function G(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Ba,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.delete(a);f.oncomplete=function(){b()},f.onerror=function(){d(h.error)},f.onabort=function(){var a=h.error?h.error:h.transaction.error;d(a)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function H(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Ba,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.clear();e.oncomplete=function(){a()},e.onabort=e.onerror=function(){var a=g.error?g.error:g.transaction.error;c(a)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function I(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Aa,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.count();g.onsuccess=function(){a(g.result)},g.onerror=function(){c(g.error)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function J(a,b){var c=this,d=new va(function(b,d){if(a<0)return void b(null);c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=!1,i=g.openKeyCursor();i.onsuccess=function(){var c=i.result;if(!c)return void b(null);0===a?b(c.key):h?b(c.key):(h=!0,c.advance(a))},i.onerror=function(){d(i.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function K(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Aa,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.openKeyCursor(),h=[];g.onsuccess=function(){var b=g.result;if(!b)return void a(h);h.push(b.key),b.continue()},g.onerror=function(){c(g.error)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function L(a,b){b=k.apply(this,arguments);var c=this.config();a=\"function\"!=typeof a&&a||{},a.name||(a.name=a.name||c.name,a.storeName=a.storeName||c.storeName);var d,e=this;if(a.name){var f=a.name===c.name&&e._dbInfo.db,g=f?va.resolve(e._dbInfo.db):s(a).then(function(b){var c=ya[a.name],d=c.forages;c.db=b;for(var e=0;e<d.length;e++)d[e]._dbInfo.db=b;return b});d=a.storeName?g.then(function(b){if(b.objectStoreNames.contains(a.storeName)){var c=b.version+1;o(a);var d=ya[a.name],e=d.forages;b.close();for(var f=0;f<e.length;f++){var g=e[f];g._dbInfo.db=null,g._dbInfo.version=c}return new va(function(b,d){var e=ua.open(a.name,c);e.onerror=function(a){e.result.close(),d(a)},e.onupgradeneeded=function(){e.result.deleteObjectStore(a.storeName)},e.onsuccess=function(){var a=e.result;a.close(),b(a)}}).then(function(a){d.db=a;for(var b=0;b<e.length;b++){var c=e[b];c._dbInfo.db=a,p(c._dbInfo)}}).catch(function(b){throw(q(a,b)||va.resolve()).catch(function(){}),b})}}):g.then(function(b){o(a);var c=ya[a.name],d=c.forages;b.close();for(var e=0;e<d.length;e++){d[e]._dbInfo.db=null}return new va(function(b,c){var d=ua.deleteDatabase(a.name);d.onerror=d.onblocked=function(a){var b=d.result;b&&b.close(),c(a)},d.onsuccess=function(){var a=d.result;a&&a.close(),b(a)}}).then(function(a){c.db=a;for(var b=0;b<d.length;b++)p(d[b]._dbInfo)}).catch(function(b){throw(q(a,b)||va.resolve()).catch(function(){}),b})})}else d=va.reject(\"Invalid arguments\");return h(d,b),d}function M(){return\"function\"==typeof openDatabase}function N(a){var b,c,d,e,f,g=.75*a.length,h=a.length,i=0;\"=\"===a[a.length-1]&&(g--,\"=\"===a[a.length-2]&&g--);var j=new ArrayBuffer(g),k=new Uint8Array(j);for(b=0;b<h;b+=4)c=Da.indexOf(a[b]),d=Da.indexOf(a[b+1]),e=Da.indexOf(a[b+2]),f=Da.indexOf(a[b+3]),k[i++]=c<<2|d>>4,k[i++]=(15&d)<<4|e>>2,k[i++]=(3&e)<<6|63&f;return j}function O(a){var b,c=new Uint8Array(a),d=\"\";for(b=0;b<c.length;b+=3)d+=Da[c[b]>>2],d+=Da[(3&c[b])<<4|c[b+1]>>4],d+=Da[(15&c[b+1])<<2|c[b+2]>>6],d+=Da[63&c[b+2]];return c.length%3==2?d=d.substring(0,d.length-1)+\"=\":c.length%3==1&&(d=d.substring(0,d.length-2)+\"==\"),d}function P(a,b){var c=\"\";if(a&&(c=Ua.call(a)),a&&(\"[object ArrayBuffer]\"===c||a.buffer&&\"[object ArrayBuffer]\"===Ua.call(a.buffer))){var d,e=Ga;a instanceof ArrayBuffer?(d=a,e+=Ia):(d=a.buffer,\"[object Int8Array]\"===c?e+=Ka:\"[object Uint8Array]\"===c?e+=La:\"[object Uint8ClampedArray]\"===c?e+=Ma:\"[object Int16Array]\"===c?e+=Na:\"[object Uint16Array]\"===c?e+=Pa:\"[object Int32Array]\"===c?e+=Oa:\"[object Uint32Array]\"===c?e+=Qa:\"[object Float32Array]\"===c?e+=Ra:\"[object Float64Array]\"===c?e+=Sa:b(new Error(\"Failed to get type for BinaryArray\"))),b(e+O(d))}else if(\"[object Blob]\"===c){var f=new FileReader;f.onload=function(){var c=Ea+a.type+\"~\"+O(this.result);b(Ga+Ja+c)},f.readAsArrayBuffer(a)}else try{b(JSON.stringify(a))}catch(c){console.error(\"Couldn't convert value into a JSON string: \",a),b(null,c)}}function Q(a){if(a.substring(0,Ha)!==Ga)return JSON.parse(a);var b,c=a.substring(Ta),d=a.substring(Ha,Ta);if(d===Ja&&Fa.test(c)){var e=c.match(Fa);b=e[1],c=c.substring(e[0].length)}var f=N(c);switch(d){case Ia:return f;case Ja:return g([f],{type:b});case Ka:return new Int8Array(f);case La:return new Uint8Array(f);case Ma:return new Uint8ClampedArray(f);case Na:return new Int16Array(f);case Pa:return new Uint16Array(f);case Oa:return new Int32Array(f);case Qa:return new Uint32Array(f);case Ra:return new Float32Array(f);case Sa:return new Float64Array(f);default:throw new Error(\"Unkown type: \"+d)}}function R(a,b,c,d){a.executeSql(\"CREATE TABLE IF NOT EXISTS \"+b.storeName+\" (id INTEGER PRIMARY KEY, key unique, value)\",[],c,d)}function S(a){var b=this,c={db:null};if(a)for(var d in a)c[d]=\"string\"!=typeof a[d]?a[d].toString():a[d];var e=new va(function(a,d){try{c.db=openDatabase(c.name,String(c.version),c.description,c.size)}catch(a){return d(a)}c.db.transaction(function(e){R(e,c,function(){b._dbInfo=c,a()},function(a,b){d(b)})},d)});return c.serializer=Va,e}function T(a,b,c,d,e,f){a.executeSql(c,d,e,function(a,g){g.code===g.SYNTAX_ERR?a.executeSql(\"SELECT name FROM sqlite_master WHERE type='table' AND name = ?\",[b.storeName],function(a,h){h.rows.length?f(a,g):R(a,b,function(){a.executeSql(c,d,e,f)},f)},f):f(a,g)},f)}function U(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,\"SELECT * FROM \"+e.storeName+\" WHERE key = ? LIMIT 1\",[a],function(a,c){var d=c.rows.length?c.rows.item(0).value:null;d&&(d=e.serializer.deserialize(d)),b(d)},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function V(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,\"SELECT * FROM \"+e.storeName,[],function(c,d){for(var f=d.rows,g=f.length,h=0;h<g;h++){var i=f.item(h),j=i.value;if(j&&(j=e.serializer.deserialize(j)),void 0!==(j=a(j,i.key,h+1)))return void b(j)}b()},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function W(a,b,c,d){var e=this;a=j(a);var f=new va(function(f,g){e.ready().then(function(){void 0===b&&(b=null);var h=b,i=e._dbInfo;i.serializer.serialize(b,function(b,j){j?g(j):i.db.transaction(function(c){T(c,i,\"INSERT OR REPLACE INTO \"+i.storeName+\" (key, value) VALUES (?, ?)\",[a,b],function(){f(h)},function(a,b){g(b)})},function(b){if(b.code===b.QUOTA_ERR){if(d>0)return void f(W.apply(e,[a,h,c,d-1]));g(b)}})})}).catch(g)});return h(f,c),f}function X(a,b,c){return W.apply(this,[a,b,c,1])}function Y(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,\"DELETE FROM \"+e.storeName+\" WHERE key = ?\",[a],function(){b()},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function Z(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,\"DELETE FROM \"+d.storeName,[],function(){a()},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function $(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,\"SELECT COUNT(key) as c FROM \"+d.storeName,[],function(b,c){var d=c.rows.item(0).c;a(d)},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function _(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,\"SELECT key FROM \"+e.storeName+\" WHERE id = ? LIMIT 1\",[a+1],function(a,c){var d=c.rows.length?c.rows.item(0).key:null;b(d)},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function aa(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,\"SELECT key FROM \"+d.storeName,[],function(b,c){for(var d=[],e=0;e<c.rows.length;e++)d.push(c.rows.item(e).key);a(d)},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function ba(a){return new va(function(b,c){a.transaction(function(d){d.executeSql(\"SELECT name FROM sqlite_master WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'\",[],function(c,d){for(var e=[],f=0;f<d.rows.length;f++)e.push(d.rows.item(f).name);b({db:a,storeNames:e})},function(a,b){c(b)})},function(a){c(a)})})}function ca(a,b){b=k.apply(this,arguments);var c=this.config();a=\"function\"!=typeof a&&a||{},a.name||(a.name=a.name||c.name,a.storeName=a.storeName||c.storeName);var d,e=this;return d=a.name?new va(function(b){var d;d=a.name===c.name?e._dbInfo.db:openDatabase(a.name,\"\",\"\",0),b(a.storeName?{db:d,storeNames:[a.storeName]}:ba(d))}).then(function(a){return new va(function(b,c){a.db.transaction(function(d){function e(a){return new va(function(b,c){d.executeSql(\"DROP TABLE IF EXISTS \"+a,[],function(){b()},function(a,b){c(b)})})}for(var f=[],g=0,h=a.storeNames.length;g<h;g++)f.push(e(a.storeNames[g]));va.all(f).then(function(){b()}).catch(function(a){c(a)})},function(a){c(a)})})}):va.reject(\"Invalid arguments\"),h(d,b),d}function da(){try{return\"undefined\"!=typeof localStorage&&\"setItem\"in localStorage&&!!localStorage.setItem}catch(a){return!1}}function ea(a,b){var c=a.name+\"/\";return a.storeName!==b.storeName&&(c+=a.storeName+\"/\"),c}function fa(){var a=\"_localforage_support_test\";try{return localStorage.setItem(a,!0),localStorage.removeItem(a),!1}catch(a){return!0}}function ga(){return!fa()||localStorage.length>0}function ha(a){var b=this,c={};if(a)for(var d in a)c[d]=a[d];return c.keyPrefix=ea(a,b._defaultConfig),ga()?(b._dbInfo=c,c.serializer=Va,va.resolve()):va.reject()}function ia(a){var b=this,c=b.ready().then(function(){for(var a=b._dbInfo.keyPrefix,c=localStorage.length-1;c>=0;c--){var d=localStorage.key(c);0===d.indexOf(a)&&localStorage.removeItem(d)}});return h(c,a),c}function ja(a,b){var c=this;a=j(a);var d=c.ready().then(function(){var b=c._dbInfo,d=localStorage.getItem(b.keyPrefix+a);return d&&(d=b.serializer.deserialize(d)),d});return h(d,b),d}function ka(a,b){var c=this,d=c.ready().then(function(){for(var b=c._dbInfo,d=b.keyPrefix,e=d.length,f=localStorage.length,g=1,h=0;h<f;h++){var i=localStorage.key(h);if(0===i.indexOf(d)){var j=localStorage.getItem(i);if(j&&(j=b.serializer.deserialize(j)),void 0!==(j=a(j,i.substring(e),g++)))return j}}});return h(d,b),d}function la(a,b){var c=this,d=c.ready().then(function(){var b,d=c._dbInfo;try{b=localStorage.key(a)}catch(a){b=null}return b&&(b=b.substring(d.keyPrefix.length)),b});return h(d,b),d}function ma(a){var b=this,c=b.ready().then(function(){for(var a=b._dbInfo,c=localStorage.length,d=[],e=0;e<c;e++){var f=localStorage.key(e);0===f.indexOf(a.keyPrefix)&&d.push(f.substring(a.keyPrefix.length))}return d});return h(c,a),c}function na(a){var b=this,c=b.keys().then(function(a){return a.length});return h(c,a),c}function oa(a,b){var c=this;a=j(a);var d=c.ready().then(function(){var b=c._dbInfo;localStorage.removeItem(b.keyPrefix+a)});return h(d,b),d}function pa(a,b,c){var d=this;a=j(a);var e=d.ready().then(function(){void 0===b&&(b=null);var c=b;return new va(function(e,f){var g=d._dbInfo;g.serializer.serialize(b,function(b,d){if(d)f(d);else try{localStorage.setItem(g.keyPrefix+a,b),e(c)}catch(a){\"QuotaExceededError\"!==a.name&&\"NS_ERROR_DOM_QUOTA_REACHED\"!==a.name||f(a),f(a)}})})});return h(e,c),e}function qa(a,b){if(b=k.apply(this,arguments),a=\"function\"!=typeof a&&a||{},!a.name){var c=this.config();a.name=a.name||c.name,a.storeName=a.storeName||c.storeName}var d,e=this;return d=a.name?new va(function(b){b(a.storeName?ea(a,e._defaultConfig):a.name+\"/\")}).then(function(a){for(var b=localStorage.length-1;b>=0;b--){var c=localStorage.key(b);0===c.indexOf(a)&&localStorage.removeItem(c)}}):va.reject(\"Invalid arguments\"),h(d,b),d}function ra(a,b){a[b]=function(){var c=arguments;return a.ready().then(function(){return a[b].apply(a,c)})}}function sa(){for(var a=1;a<arguments.length;a++){var b=arguments[a];if(b)for(var c in b)b.hasOwnProperty(c)&&($a(b[c])?arguments[0][c]=b[c].slice():arguments[0][c]=b[c])}return arguments[0]}var ta=\"function\"==typeof Symbol&&\"symbol\"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&\"function\"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?\"symbol\":typeof a},ua=e();\"undefined\"==typeof Promise&&a(3);var va=Promise,wa=\"local-forage-detect-blob-support\",xa=void 0,ya={},za=Object.prototype.toString,Aa=\"readonly\",Ba=\"readwrite\",Ca={_driver:\"asyncStorage\",_initStorage:C,_support:f(),iterate:E,getItem:D,setItem:F,removeItem:G,clear:H,length:I,key:J,keys:K,dropInstance:L},Da=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\",Ea=\"~~local_forage_type~\",Fa=/^~~local_forage_type~([^~]+)~/,Ga=\"__lfsc__:\",Ha=Ga.length,Ia=\"arbf\",Ja=\"blob\",Ka=\"si08\",La=\"ui08\",Ma=\"uic8\",Na=\"si16\",Oa=\"si32\",Pa=\"ur16\",Qa=\"ui32\",Ra=\"fl32\",Sa=\"fl64\",Ta=Ha+Ia.length,Ua=Object.prototype.toString,Va={serialize:P,deserialize:Q,stringToBuffer:N,bufferToString:O},Wa={_driver:\"webSQLStorage\",_initStorage:S,_support:M(),iterate:V,getItem:U,setItem:X,removeItem:Y,clear:Z,length:$,key:_,keys:aa,dropInstance:ca},Xa={_driver:\"localStorageWrapper\",_initStorage:ha,_support:da(),iterate:ka,getItem:ja,setItem:pa,removeItem:oa,clear:ia,length:na,key:la,keys:ma,dropInstance:qa},Ya=function(a,b){return a===b||\"number\"==typeof a&&\"number\"==typeof b&&isNaN(a)&&isNaN(b)},Za=function(a,b){for(var c=a.length,d=0;d<c;){if(Ya(a[d],b))return!0;d++}return!1},$a=Array.isArray||function(a){return\"[object Array]\"===Object.prototype.toString.call(a)},_a={},ab={},bb={INDEXEDDB:Ca,WEBSQL:Wa,LOCALSTORAGE:Xa},cb=[bb.INDEXEDDB._driver,bb.WEBSQL._driver,bb.LOCALSTORAGE._driver],db=[\"dropInstance\"],eb=[\"clear\",\"getItem\",\"iterate\",\"key\",\"keys\",\"length\",\"removeItem\",\"setItem\"].concat(db),fb={description:\"\",driver:cb.slice(),name:\"localforage\",size:4980736,storeName:\"keyvaluepairs\",version:1},gb=function(){function a(b){d(this,a);for(var c in bb)if(bb.hasOwnProperty(c)){var e=bb[c],f=e._driver;this[c]=f,_a[f]||this.defineDriver(e)}this._defaultConfig=sa({},fb),this._config=sa({},this._defaultConfig,b),this._driverSet=null,this._initDriver=null,this._ready=!1,this._dbInfo=null,this._wrapLibraryMethodsWithReady(),this.setDriver(this._config.driver).catch(function(){})}return a.prototype.config=function(a){if(\"object\"===(void 0===a?\"undefined\":ta(a))){if(this._ready)return new Error(\"Can't call config() after localforage has been used.\");for(var b in a){if(\"storeName\"===b&&(a[b]=a[b].replace(/\\W/g,\"_\")),\"version\"===b&&\"number\"!=typeof a[b])return new Error(\"Database version must be a number.\");this._config[b]=a[b]}return!(\"driver\"in a&&a.driver)||this.setDriver(this._config.driver)}return\"string\"==typeof a?this._config[a]:this._config},a.prototype.defineDriver=function(a,b,c){var d=new va(function(b,c){try{var d=a._driver,e=new Error(\"Custom driver not compliant; see https://mozilla.github.io/localForage/#definedriver\");if(!a._driver)return void c(e);for(var f=eb.concat(\"_initStorage\"),g=0,i=f.length;g<i;g++){var j=f[g];if((!Za(db,j)||a[j])&&\"function\"!=typeof a[j])return void c(e)}(function(){for(var b=function(a){return function(){var b=new Error(\"Method \"+a+\" is not implemented by the current driver\"),c=va.reject(b);return h(c,arguments[arguments.length-1]),c}},c=0,d=db.length;c<d;c++){var e=db[c];a[e]||(a[e]=b(e))}})();var k=function(c){_a[d]&&console.info(\"Redefining LocalForage driver: \"+d),_a[d]=a,ab[d]=c,b()};\"_support\"in a?a._support&&\"function\"==typeof a._support?a._support().then(k,c):k(!!a._support):k(!0)}catch(a){c(a)}});return i(d,b,c),d},a.prototype.driver=function(){return this._driver||null},a.prototype.getDriver=function(a,b,c){var d=_a[a]?va.resolve(_a[a]):va.reject(new Error(\"Driver not found.\"));return i(d,b,c),d},a.prototype.getSerializer=function(a){var b=va.resolve(Va);return i(b,a),b},a.prototype.ready=function(a){var b=this,c=b._driverSet.then(function(){return null===b._ready&&(b._ready=b._initDriver()),b._ready});return i(c,a,a),c},a.prototype.setDriver=function(a,b,c){function d(){g._config.driver=g.driver()}function e(a){return g._extend(a),d(),g._ready=g._initStorage(g._config),g._ready}function f(a){return function(){function b(){for(;c<a.length;){var f=a[c];return c++,g._dbInfo=null,g._ready=null,g.getDriver(f).then(e).catch(b)}d();var h=new Error(\"No available storage method found.\");return g._driverSet=va.reject(h),g._driverSet}var c=0;return b()}}var g=this;$a(a)||(a=[a]);var h=this._getSupportedDrivers(a),j=null!==this._driverSet?this._driverSet.catch(function(){return va.resolve()}):va.resolve();return this._driverSet=j.then(function(){var a=h[0];return g._dbInfo=null,g._ready=null,g.getDriver(a).then(function(a){g._driver=a._driver,d(),g._wrapLibraryMethodsWithReady(),g._initDriver=f(h)})}).catch(function(){d();var a=new Error(\"No available storage method found.\");return g._driverSet=va.reject(a),g._driverSet}),i(this._driverSet,b,c),this._driverSet},a.prototype.supports=function(a){return!!ab[a]},a.prototype._extend=function(a){sa(this,a)},a.prototype._getSupportedDrivers=function(a){for(var b=[],c=0,d=a.length;c<d;c++){var e=a[c];this.supports(e)&&b.push(e)}return b},a.prototype._wrapLibraryMethodsWithReady=function(){for(var a=0,b=eb.length;a<b;a++)ra(this,eb[a])},a.prototype.createInstance=function(b){return new a(b)},a}(),hb=new gb;b.exports=hb},{3:3}]},{},[4])(4)});","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:strategies:6.1.5'] && _();\n}\ncatch (e) { }\n","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:background-sync:6.1.5'] && _();\n}\ncatch (e) { }\n","\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:core:6.1.5'] && _();\n}\ncatch (e) { }\n"]}