initial

author: Richard <q@1bpm.net> 2025-04-13 18:48:02 +0100
committer: Richard <q@1bpm.net> 2025-04-13 18:48:02 +0100
commit: 9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22 (patch)
tree: 291bd79ce340e67affa755a8a6b4f6a83cce93ea /site/code/csound.js
download: apps.csound.1bpm.net-9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22.tar.gz
apps.csound.1bpm.net-9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22.tar.bz2
apps.csound.1bpm.net-9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22.zip
1 files changed, 903 insertions, 0 deletions
diff --git a/site/code/csound.js b/site/code/csound.js
new file mode 100644
index 0000000..fc1706e
--- /dev/null
+++ b/site/code/csound.js
@@ -0,0 +1,903 @@
+/*
+
+ Copyright The Closure Library Authors.
+ SPDX-License-Identifier: Apache-2.0
+*/
+var $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this||self;goog.exportPath_=function(a,b,c,d){a=a.split(".");d=d||goog.global;a[0]in d||"undefined"==typeof d.execScript||d.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)if(a.length||void 0===b)d=d[e]&&d[e]!==Object.prototype[e]?d[e]:d[e]={};else if(!c&&goog.isObject(b)&&goog.isObject(d[e]))for(var f in b)b.hasOwnProperty(f)&&(d[e][f]=b[f]);else d[e]=b};
+goog.define=function(a,b){if(!COMPILED){var c=goog.global.CLOSURE_UNCOMPILED_DEFINES,d=goog.global.CLOSURE_DEFINES;c&&void 0===c.nodeType&&Object.prototype.hasOwnProperty.call(c,a)?b=c[a]:d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)&&(b=d[a])}return b};goog.FEATURESET_YEAR=2020;goog.DEBUG=!0;goog.LOCALE="en";goog.getLocale=function(){return goog.LOCALE};goog.TRUSTED_SITE=!0;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;
+goog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b,c){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var d=a;(d=d.substring(0,d.lastIndexOf(".")))&&!goog.getObjectByName(d);)goog.implicitNamespaces_[d]=!0}goog.exportPath_(a,b,c)};goog.NONCE_PATTERN_=/^[\w+/_-]+[=]{0,2}$/;
+goog.getScriptNonce_=function(a){a=(a||goog.global).document;return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
+goog.module=function(a){if("string"!==typeof a||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");
+goog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;
+goog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG};goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1};
+goog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0};
+goog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error('Module with namespace "'+a+'" already exists.');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error('Module with namespace "'+
+a+'" has been loaded incorrectly.');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){};COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&null!=goog.getObjectByName(a)},goog.implicitNamespaces_={"goog.module":!0});
+goog.getObjectByName=function(a,b){a=a.split(".");b=b||goog.global;for(var c=0;c<a.length;c++)if(b=b[a[c]],null==b)return null;return b};goog.addDependency=function(a,b,c,d){!COMPILED&&goog.DEPENDENCIES_ENABLED&&goog.debugLoader_.addDependency(a,b,c,d)};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};
+goog.require=function(a){if(!COMPILED){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_.requested(a);if(goog.isProvided_(a)){if(goog.isInModuleLoader_())return goog.module.getInternal_(a)}else if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{goog.debugLoader_.load_(a)}finally{goog.moduleLoaderState_=b}}return null}};goog.requireType=function(a){return{}};goog.basePath="";goog.abstractMethod=function(){throw Error("unimplemented abstract method");};
+goog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";goog.ASSUME_ES_MODULES_TRANSPILED=!1;goog.TRUSTED_TYPES_POLICY_NAME="goog";
+goog.hasBadLetScoping=null;
+goog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:"",declareLegacyNamespace:!1,type:goog.ModuleType.GOOG};var c={},d=c;if("function"===typeof a)d=a.call(void 0,d);else if("string"===typeof a)d=goog.loadModuleFromSource_.call(void 0,d,a);else throw Error("Invalid module definition");var e=goog.moduleLoaderState_.moduleName;if("string"===typeof e&&e)goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(e,d,c!==d):goog.SEAL_MODULE_EXPORTS&&
+Object.seal&&"object"==typeof d&&null!=d&&Object.seal(d),goog.loadedModules_[e]={exports:d,type:goog.ModuleType.GOOG,moduleId:goog.moduleLoaderState_.moduleName};else throw Error('Invalid module name "'+e+'"');}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a,b){eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(b));return a};goog.normalizePath_=function(a){a=a.split("/");for(var b=0;b<a.length;)"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++;return a.join("/")};
+goog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC)return goog.global.CLOSURE_LOAD_FILE_SYNC(a);try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};goog.typeOf=function(a){var b=typeof a;return"object"!=b?b:a?Array.isArray(a)?"array":b:"null"};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};
+goog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear};goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return Object.prototype.hasOwnProperty.call(a,goog.UID_PROPERTY_)&&a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return!!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute"in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};
+goog.UID_PROPERTY_="closure_uid_"+(1E9*Math.random()>>>0);goog.uidCounter_=0;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};
+goog.bindJs_=function(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var e=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(e,d);return a.apply(b,e)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};
+goog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var d=c.slice();d.push.apply(d,arguments);return a.apply(this,d)}};goog.now=function(){return Date.now()};goog.globalEval=function(a){(0,eval)(a)};
+goog.getCssName=function(a,b){if("."==String(a).charAt(0))throw Error('className passed in goog.getCssName must not start with ".". You passed: '+a);var c=function(e){return goog.cssNameMapping_[e]||e},d=function(e){e=e.split("-");for(var f=[],g=0;g<e.length;g++)f.push(c(e[g]));return f.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(e){return e};a=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(a):a};
+goog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.GetMsgOptions=function(){};
+goog.getMsg=function(a,b,c){c&&c.html&&(a=a.replace(/</g,"&lt;"));c&&c.unescapeHtmlEntities&&(a=a.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&apos;/g,"'").replace(/&quot;/g,'"').replace(/&amp;/g,"&"));b&&(a=a.replace(/\{\$([^}]+)}/g,function(d,e){return null!=b&&e in b?b[e]:d}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,!0,c)};goog.exportProperty=function(a,b,c){a[b]=c};
+goog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(d,e,f){for(var g=Array(arguments.length-2),h=2;h<arguments.length;h++)g[h-2]=arguments[h];return b.prototype[e].apply(d,g)}};goog.scope=function(a){if(goog.isInModuleLoader_())throw Error("goog.scope is not supported within a module.");a.call(goog.global)};COMPILED||(goog.global.COMPILED=COMPILED);
+goog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).");});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;
+goog.defineClass.createSealingConstructor_=function(a,b){return goog.defineClass.SEAL_CLASS_INSTANCES?function(){var c=a.apply(this,arguments)||this;c[goog.UID_PROPERTY_]=c[goog.UID_PROPERTY_];return c}:a};goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
+goog.defineClass.applyProperties_=function(a,b){for(var c in b)Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c]);for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++)c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])};goog.identity_=function(a){return a};
+goog.createTrustedTypesPolicy=function(a){var b=null,c=goog.global.trustedTypes;if(!c||!c.createPolicy)return b;try{b=c.createPolicy(a,{createHTML:goog.identity_,createScript:goog.identity_,createScriptURL:goog.identity_})}catch(d){goog.logToConsole_(d.message)}return b};
+!COMPILED&&goog.DEPENDENCIES_ENABLED&&(goog.isEdge_=function(){return!!(goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"").match(/Edge\/(\d+)(\.\d)*/i)},goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write"in a},goog.isDocumentLoading_=function(){var a=goog.global.document;return a.attachEvent?"complete"!=a.readyState:"loading"==a.readyState},goog.findBasePath_=function(){if(void 0!=goog.global.CLOSURE_BASE_PATH&&"string"===typeof goog.global.CLOSURE_BASE_PATH)goog.basePath=
+goog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.slice(d-7,d)){goog.basePath=c.slice(0,d-7);break}}}},goog.findBasePath_(),goog.protectScriptTag_=function(a){return a.replace(/<\/(SCRIPT)/ig,"\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_={};this.idToPath_={};this.written_={};this.loadingDeps_=
+[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory;this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){b=[];for(var e=0;e<a.length;e++){var f=this.getPathFromDeps_(a[e]);if(!f)throw Error("Unregonized namespace: "+a[e]);b.push(this.dependencies_[f])}f=goog.require;var g=0;for(e=0;e<a.length;e++)f(a[e]),b[e].onLoad(function(){++g==a.length&&c()})}else c()},
+goog.DebugLoader_.prototype.loadClosureDeps=function(){this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath+"deps.js"),"deps.js",[],[],{}));this.loadDeps_()},goog.DebugLoader_.prototype.requested=function(a,b){(a=this.getPathFromDeps_(a))&&(b||this.areDepsLoaded_(this.dependencies_[a].requires))&&(b=this.deferredCallbacks_[a])&&(delete this.deferredCallbacks_[a],b())},goog.DebugLoader_.prototype.setDependencyFactory=function(a){this.factory_=a},goog.DebugLoader_.prototype.load_=
+function(a){if(this.getPathFromDeps_(a)){var b=this,c=[],d=function(e){var f=b.getPathFromDeps_(e);if(!f)throw Error("Bad dependency path or symbol: "+e);if(!b.written_[f]){b.written_[f]=!0;e=b.dependencies_[f];for(f=0;f<e.requires.length;f++)goog.isProvided_(e.requires[f])||d(e.requires[f]);c.push(e)}};d(a);a=!!this.depsToLoad_.length;this.depsToLoad_=this.depsToLoad_.concat(c);this.paused_||a||this.loadDeps_()}else goog.logToConsole_("goog.require could not find: "+a)},goog.DebugLoader_.prototype.loadDeps_=
+function(){for(var a=this,b=this.paused_;this.depsToLoad_.length&&!b;)(function(){var c=!1,d=a.depsToLoad_.shift(),e=!1;a.loading_(d);var f={pause:function(){if(c)throw Error("Cannot call pause after the call to load.");b=!0},resume:function(){c?a.resume_():b=!1},loaded:function(){if(e)throw Error("Double call to loaded.");e=!0;a.loaded_(d)},pending:function(){for(var g=[],h=0;h<a.loadingDeps_.length;h++)g.push(a.loadingDeps_[h]);return g},setModuleState:function(g){goog.moduleLoaderState_={type:g,
+moduleName:"",declareLegacyNamespace:!1}},registerEs6ModuleExports:function(g,h,k){k&&(goog.loadedModules_[k]={exports:h,type:goog.ModuleType.ES6,moduleId:k||""})},registerGoogModuleExports:function(g,h){goog.loadedModules_[g]={exports:h,type:goog.ModuleType.GOOG,moduleId:g}},clearModuleState:function(){goog.moduleLoaderState_=null},defer:function(g){if(c)throw Error("Cannot register with defer after the call to load.");a.defer_(d,g)},areDepsLoaded:function(){return a.areDepsLoaded_(d.requires)}};
+try{d.load(f)}finally{c=!0}})();b&&this.pause_()},goog.DebugLoader_.prototype.pause_=function(){this.paused_=!0},goog.DebugLoader_.prototype.resume_=function(){this.paused_&&(this.paused_=!1,this.loadDeps_())},goog.DebugLoader_.prototype.loading_=function(a){this.loadingDeps_.push(a)},goog.DebugLoader_.prototype.loaded_=function(a){for(var b=0;b<this.loadingDeps_.length;b++)if(this.loadingDeps_[b]==a){this.loadingDeps_.splice(b,1);break}for(b=0;b<this.deferredQueue_.length;b++)if(this.deferredQueue_[b]==
+a.path){this.deferredQueue_.splice(b,1);break}if(this.loadingDeps_.length==this.deferredQueue_.length&&!this.depsToLoad_.length)for(;this.deferredQueue_.length;)this.requested(this.deferredQueue_.shift(),!0);a.loaded()},goog.DebugLoader_.prototype.areDepsLoaded_=function(a){for(var b=0;b<a.length;b++){var c=this.getPathFromDeps_(a[b]);if(!c||!(c in this.deferredCallbacks_||goog.isProvided_(a[b])))return!1}return!0},goog.DebugLoader_.prototype.getPathFromDeps_=function(a){return a in this.idToPath_?
+this.idToPath_[a]:a in this.dependencies_?a:null},goog.DebugLoader_.prototype.defer_=function(a,b){this.deferredCallbacks_[a.path]=b;this.deferredQueue_.push(a.path)},goog.LoadController=function(){},goog.LoadController.prototype.pause=function(){},goog.LoadController.prototype.resume=function(){},goog.LoadController.prototype.loaded=function(){},goog.LoadController.prototype.pending=function(){},goog.LoadController.prototype.registerEs6ModuleExports=function(a,b,c){},goog.LoadController.prototype.setModuleState=
+function(a){},goog.LoadController.prototype.clearModuleState=function(){},goog.LoadController.prototype.defer=function(a){},goog.LoadController.prototype.areDepsLoaded=function(){},goog.Dependency=function(a,b,c,d,e){this.path=a;this.relativePath=b;this.provides=c;this.requires=d;this.loadFlags=e;this.loaded_=!1;this.loadCallbacks_=[]},goog.Dependency.prototype.getPathName=function(){var a=this.path,b=a.indexOf("://");0<=b&&(a=a.substring(b+3),b=a.indexOf("/"),0<=b&&(a=a.substring(b+1)));return a},
+goog.Dependency.prototype.onLoad=function(a){this.loaded_?a():this.loadCallbacks_.push(a)},goog.Dependency.prototype.loaded=function(){this.loaded_=!0;var a=this.loadCallbacks_;this.loadCallbacks_=[];for(var b=0;b<a.length;b++)a[b]()},goog.Dependency.defer_=!1,goog.Dependency.callbackMap_={},goog.Dependency.registerCallback_=function(a){var b=Math.random().toString(32);goog.Dependency.callbackMap_[b]=a;return b},goog.Dependency.unregisterCallback_=function(a){delete goog.Dependency.callbackMap_[a]},
+goog.Dependency.callback_=function(a,b){if(a in goog.Dependency.callbackMap_){for(var c=goog.Dependency.callbackMap_[a],d=[],e=1;e<arguments.length;e++)d.push(arguments[e]);c.apply(void 0,d)}else throw Error("Callback key "+a+" does not exist (was base.js loaded more than once?).");},goog.Dependency.prototype.load=function(a){if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var b=goog.global.document;if("complete"==
+b.readyState&&!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING){if(/\bdeps.js$/.test(this.path)){a.loaded();return}throw Error('Cannot write "'+this.path+'" after document load');}var c=goog.getScriptNonce_();if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&goog.isDocumentLoading_()){var d=function(h){h.readyState&&"complete"!=h.readyState?h.onload=d:(goog.Dependency.unregisterCallback_(e),a.loaded())};var e=goog.Dependency.registerCallback_(d);c=c?' nonce="'+c+'"':"";var f='<script src="'+this.path+'"'+
+c+(goog.Dependency.defer_?" defer":"")+' id="script-'+e+'">\x3c/script>';f+="<script"+c+">";f=goog.Dependency.defer_?f+("document.getElementById('script-"+e+"').onload = function() {\n  goog.Dependency.callback_('"+e+"', this);\n};\n"):f+("goog.Dependency.callback_('"+e+"', document.getElementById('script-"+e+"'));");f+="\x3c/script>";b.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(f):f)}else{var g=b.createElement("script");g.defer=goog.Dependency.defer_;g.async=!1;c&&(g.nonce=
+c);g.onload=function(){g.onload=null;a.loaded()};g.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path):this.path;b.head.appendChild(g)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."),a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,
+b,c,d,e)},goog.inherits(goog.Es6ModuleDependency,goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(n,m){var l="",p=goog.getScriptNonce_();p&&(l=' nonce="'+p+'"');n=m?'<script type="module" crossorigin'+l+">"+m+"\x3c/script>":'<script type="module" crossorigin src="'+n+'"'+l+">\x3c/script>";d.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(n):n)}function c(n,m){var l=d.createElement("script");l.defer=!0;l.async=!1;l.type="module";l.setAttribute("crossorigin",
+!0);var p=goog.getScriptNonce_();p&&(l.nonce=p);m?l.text=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScript(m):m:l.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(n):n;d.head.appendChild(l)}if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var d=goog.global.document,e=this;if(goog.isDocumentLoading_()){var f=b;goog.Dependency.defer_=!0}else f=c;var g=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(g);
+a.setModuleState(goog.ModuleType.ES6)});f(void 0,'goog.Dependency.callback_("'+g+'")');f(this.path,void 0);var h=goog.Dependency.registerCallback_(function(n){goog.Dependency.unregisterCallback_(h);a.registerEs6ModuleExports(e.path,n,goog.moduleLoaderState_.moduleName)});f(void 0,'import * as m from "'+this.path+'"; goog.Dependency.callback_("'+h+'", m)');var k=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(k);a.clearModuleState();a.loaded()});f(void 0,'goog.Dependency.callback_("'+
+k+'")')}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),a.pause()},goog.TransformedDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e);this.contents_=null;this.lazyFetch_=!goog.inHtmlDocument_()||!("noModule"in goog.global.document.createElement("script"))},goog.inherits(goog.TransformedDependency,goog.Dependency),goog.TransformedDependency.prototype.load=function(a){function b(){e.contents_=goog.loadFileSync_(e.path);e.contents_&&(e.contents_=
+e.transform(e.contents_),e.contents_&&(e.contents_+="\n//# sourceURL="+e.path))}function c(){e.lazyFetch_&&b();if(e.contents_){f&&a.setModuleState(goog.ModuleType.ES6);try{var n=e.contents_;e.contents_=null;goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(n));if(f)var m=goog.moduleLoaderState_.moduleName}finally{f&&a.clearModuleState()}f&&goog.global.$jscomp.require.ensure([e.getPathName()],function(){a.registerEs6ModuleExports(e.path,goog.global.$jscomp.require(e.getPathName()),m)});a.loaded()}}
+function d(){var n=goog.global.document,m=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(m);c()}),l=goog.getScriptNonce_();l="<script"+(l?' nonce="'+l+'"':"")+">"+goog.protectScriptTag_('goog.Dependency.callback_("'+m+'");')+"\x3c/script>";n.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(l):l)}var e=this;if(goog.global.CLOSURE_IMPORT_SCRIPT)b(),this.contents_&&goog.global.CLOSURE_IMPORT_SCRIPT("",this.contents_)?(this.contents_=null,a.loaded()):
+a.pause();else{var f=this.loadFlags.module==goog.ModuleType.ES6;this.lazyFetch_||b();var g=1<a.pending().length;if(goog.Dependency.defer_&&(g||goog.isDocumentLoading_()))a.defer(function(){c()});else{var h=goog.global.document;g=goog.inHtmlDocument_()&&("ActiveXObject"in goog.global||goog.isEdge_());if(f&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()&&!g){goog.Dependency.defer_=!0;a.pause();var k=h.onreadystatechange;h.onreadystatechange=function(){"interactive"==h.readyState&&(h.onreadystatechange=
+k,c(),a.resume());"function"===typeof k&&k.apply(void 0,arguments)}}else goog.inHtmlDocument_()&&goog.isDocumentLoading_()?d():c()}}},goog.TransformedDependency.prototype.transform=function(a){},goog.PreTranspiledEs6ModuleDependency=function(a,b,c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.PreTranspiledEs6ModuleDependency,goog.TransformedDependency),goog.PreTranspiledEs6ModuleDependency.prototype.transform=function(a){return a},goog.GoogModuleDependency=function(a,b,
+c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.GoogModuleDependency,goog.TransformedDependency),goog.GoogModuleDependency.prototype.transform=function(a){return goog.LOAD_MODULE_USING_EVAL&&void 0!==goog.global.JSON?"goog.loadModule("+goog.global.JSON.stringify(a+"\n//# sourceURL="+this.path+"\n")+");":'goog.loadModule(function(exports) {"use strict";'+a+"\n;return exports});\n//# sourceURL="+this.path+"\n"},goog.DebugLoader_.prototype.addDependency=function(a,b,c,d){b=
+b||[];a=a.replace(/\\/g,"/");var e=goog.normalizePath_(goog.basePath+a);d&&"boolean"!==typeof d||(d=d?{module:goog.ModuleType.GOOG}:{});c=this.factory_.createDependency(e,a,b,c,d);this.dependencies_[e]=c;for(c=0;c<b.length;c++)this.idToPath_[b[c]]=e;this.idToPath_[a]=e},goog.DependencyFactory=function(){},goog.DependencyFactory.prototype.createDependency=function(a,b,c,d,e){return e.module==goog.ModuleType.GOOG?new goog.GoogModuleDependency(a,b,c,d,e):e.module==goog.ModuleType.ES6?goog.ASSUME_ES_MODULES_TRANSPILED?
+new goog.PreTranspiledEs6ModuleDependency(a,b,c,d,e):new goog.Es6ModuleDependency(a,b,c,d,e):new goog.Dependency(a,b,c,d,e)},goog.debugLoader_=new goog.DebugLoader_,goog.loadClosureDeps=function(){goog.debugLoader_.loadClosureDeps()},goog.setDependencyFactory=function(a){goog.debugLoader_.setDependencyFactory(a)},goog.TRUSTED_TYPES_POLICY_=goog.TRUSTED_TYPES_POLICY_NAME?goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME+"#base"):null,goog.global.CLOSURE_NO_DEPS||goog.debugLoader_.loadClosureDeps(),
+goog.bootstrap=function(a,b){goog.debugLoader_.bootstrap(a,b)});if(!COMPILED){var isChrome87=!1;try{isChrome87=eval(goog.global.trustedTypes.emptyScript)!==goog.global.trustedTypes.emptyScript}catch(a){}goog.CLOSURE_EVAL_PREFILTER_=goog.global.trustedTypes&&isChrome87&&goog.createTrustedTypesPolicy("goog#base#devonly#eval")||{createScript:goog.identity_}};function atobPolyfill$$module$dist$__csound_wasm_inline(a){a=String(a).replace(/[=]+$/,"");1===a.length%4&&console.error("'atob' failed: The string to be decoded is not correctly encoded.");for(var b=0,c,d,e=0,f="";d=a.charAt(e++);~d&&(c=b%4?64*c+d:d,b++%4)&&(f+=String.fromCharCode(255&c>>(-2*b&6))))d="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(d);return f}
+function bufferFromBrowser$$module$dist$__csound_wasm_inline(a){return"undefined"!=typeof AudioWorkletGlobalScope?atobPolyfill$$module$dist$__csound_wasm_inline(a):window.atob(a)}function __toArrayBuffer$$module$dist$__csound_wasm_inline(a){a=bufferFromBrowser$$module$dist$__csound_wasm_inline(a);for(var b=new Uint8Array(a.length),c=0;c<a.length;++c)b[c]=a.charCodeAt(c);return b.buffer}
+var $jscompDefaultExport$$module$dist$__csound_wasm_inline=()=>__toArrayBuffer$$module$dist$__csound_wasm_inline("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"),module$dist$__csound_wasm_inline=
+{};module$dist$__csound_wasm_inline.default=$jscompDefaultExport$$module$dist$__csound_wasm_inline;const proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.proxy"),createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.endpoint"),releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.releaseProxy"),throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.thrown"),isObject$$module$node_modules$comlink$dist$esm$comlink_mjs=a=>"object"===typeof a&&null!==a||"function"===typeof a,proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs=
+{canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs],serialize(a){const {port1:b,port2:c}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b);return[c,[c]]},deserialize(a){a.start();return wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a)}},throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs={canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&
+throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs in a,serialize({value:a}){return[a instanceof Error?{isError:!0,value:{message:a.message,name:a.name,stack:a.stack}}:{isError:!1,value:a},[]]},deserialize(a){if(a.isError)throw Object.assign(Error(a.value.message),a.value);throw a.value;}},transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs=new Map([["proxy",proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs],["throw",throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs]]);
+function expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self){b.addEventListener("message",function e(d){if(d&&d.data){var {id:f,type:g,path:h}=Object.assign({path:[]},d.data),k=(d.data.argumentList||[]).map(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);try{const m=h.slice(0,-1).reduce((p,q)=>p[q],a),l=h.reduce((p,q)=>p[q],a);switch(g){case "GET":var n=l;break;case "SET":m[h.slice(-1)[0]]=fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(d.data.value);
+n=!0;break;case "APPLY":n=l.apply(m,k);break;case "CONSTRUCT":const p=new l(...k);n=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(p);break;case "ENDPOINT":const {port1:q,port2:u}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,u);n=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(q,[q]);break;case "RELEASE":n=void 0;break;default:return}}catch(m){n={value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0}}Promise.resolve(n).catch(m=>
+({value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0})).then(m=>{const [l,p]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(m);b.postMessage(Object.assign(Object.assign({},l),{id:f}),p);"RELEASE"===g&&(b.removeEventListener("message",e),closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(b))})}});b.start&&b.start()}function isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return"MessagePort"===a.constructor.name}
+function closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a){isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a.close()}function wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[],b)}function throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(a){if(a)throw Error("Proxy has been released and is not useable");}
+function createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=[],c=function(){}){let d=!1;const e=new Proxy(c,{get(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);if(g===releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs)return()=>requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"RELEASE",path:b.map(h=>h.toString())}).then(()=>{closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a);d=!0});if("then"===
+g){if(0===b.length)return{then:()=>e};f=requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"GET",path:b.map(h=>h.toString())}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return f.then.bind(f)}return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[...b,g])},set(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [k,n]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
+{type:"SET",path:[...b,g].map(m=>m.toString()),value:k},n).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},apply(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);f=b[b.length-1];if(f===createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs)return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"ENDPOINT"}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);if("bind"===f)return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
+b.slice(0,-1));const [k,n]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"APPLY",path:b.map(m=>m.toString()),argumentList:k},n).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},construct(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [h,k]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(g);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
+{type:"CONSTRUCT",path:b.map(n=>n.toString()),argumentList:h},k).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)}});return e}function myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Array.prototype.concat.apply([],a)}
+function processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(a){a=a.map(toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return[a.map(b=>b[0]),myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a.map(b=>b[1]))]}const transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs=new WeakMap;function transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.set(a,b);return a}
+function proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Object.assign(a,{[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:!0})}function windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self,c="*"){return{postMessage:(d,e)=>a.postMessage(d,c,e),addEventListener:b.addEventListener.bind(b),removeEventListener:b.removeEventListener.bind(b)}}
+function toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){for(const [b,c]of transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs)if(c.canHandle(a)){const [d,e]=c.serialize(a);return[{type:"HANDLER",name:b,value:d},e]}return[{type:"RAW",value:a},transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a)||[]]}
+function fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){switch(a.type){case "HANDLER":return transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a.name).deserialize(a.value);case "RAW":return a.value}}
+function requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b,c){return new Promise(d=>{const e=generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs();a.addEventListener("message",function h(g){g.data&&g.data.id&&g.data.id===e&&(a.removeEventListener("message",h),d(g.data))});a.start&&a.start();a.postMessage(Object.assign({id:e},b),c)})}
+function generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs(){return Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}var module$node_modules$comlink$dist$esm$comlink_mjs={};module$node_modules$comlink$dist$esm$comlink_mjs.createEndpoint=createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.expose=expose$$module$node_modules$comlink$dist$esm$comlink_mjs;
+module$node_modules$comlink$dist$esm$comlink_mjs.proxy=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.proxyMarker=proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.releaseProxy=releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.transfer=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs;
+module$node_modules$comlink$dist$esm$comlink_mjs.transferHandlers=transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.windowEndpoint=windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.wrap=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs;var module$node_modules$lines_logger$lib$index={default:{}};module$node_modules$lines_logger$lib$index.default.__esModule=!0;module$node_modules$lines_logger$lib$index.default.LoggerFactory=module$node_modules$lines_logger$lib$index.default.logLevels=void 0;module$node_modules$lines_logger$lib$index.default.logLevels={log_raise_error:1,log_with_warnings:2,trace:3,debug:4,info:5,warn:6,error:7,disable:8};
+var LoggerFactory$$module$node_modules$lines_logger$lib$index=function(){function a(b,c){if(void 0===b&&(b="log_with_warnings"),void 0===c&&(c=null),this.logLevel=b,!module$node_modules$lines_logger$lib$index.default.logLevels[b])throw Error("Invalid log level "+b+" allowed: "+JSON.stringify(module$node_modules$lines_logger$lib$index.default.logLevels));this.mockConsole=c||console}return a.prototype.dummy=function(){},a.prototype.setLogWarnings=function(b){this.logLevel=b},a.prototype.getLogWarnings=
+function(){return this.logLevel},a.prototype.getSingleLoggerColor=function(b,c,d){return this.getSingleLoggerStyle(b,this.getColorStyle(c),d)},a.prototype.getSingleLogger=function(b,c){var d=this.getRandomColor(b);return this.getSingleLoggerStyle(b,this.getColorStyle(d),c)},a.prototype.getSingleLoggerStyle=function(b,c,d,e){var f=this;return void 0===e&&(e="log_with_warnings"),function(){for(var g=[],h=0;h<arguments.length;h++)g[h]=arguments[h];if(module$node_modules$lines_logger$lib$index.default.logLevels[f.logLevel]>
+module$node_modules$lines_logger$lib$index.default.logLevels[e])return f.dummy;g=Array.prototype.slice.call(g);h=g.shift().split("{}");for(var k=[f.mockConsole,"%c"+b,c],n=0;n<h.length;n++)k.push(h[n]),void 0!==g[n]&&k.push(g[n]);if(h.length-1!==g.length)if("log_with_warnings"===f.logLevel)f.mockConsole.error("MissMatch amount of arguments");else if("log_raise_error"===f.logLevel)throw Error("MissMatch amount of arguments");return Function.prototype.bind.apply(d,k)}},a.prototype.getLoggerColor=function(b,
+c){return this.getLoggerStyle(b,this.getColorStyle(c))},a.prototype.getColorStyle=function(b){return"color: white; background-color: "+b+"; padding: 2px 6px; border-radius: 2px; font-size: 10px"},a.getHash=function(b,c){void 0===c&&(c=0);var d=3735928559^c;c^=1103547991;for(var e=0,f;e<b.length;e++)f=b.charCodeAt(e),d=Math.imul(d^f,2654435761),c=Math.imul(c^f,1597334677);return d=Math.imul(d^d>>>16,2246822507)^Math.imul(c^c>>>13,3266489909),4294967296*(2097151&(Math.imul(c^c>>>16,2246822507)^Math.imul(d^
+d>>>13,3266489909)))+(d>>>0)},a.prototype.getRandomColor=function(b){void 0===b&&(b="");b=a.getHash(b);for(var c="#",d=0;3>d;d++)c+=("00"+(8+(b>>7*d&127)).toString(16)).substr(-2);return c},a.prototype.getLogger=function(b){return this.getLoggerColor(b,this.getRandomColor(b))},a.prototype.getLoggerStyle=function(b,c){return{trace:this.getSingleLoggerStyle(b,c,this.mockConsole.trace,"trace"),debug:this.getSingleLoggerStyle(b,c,this.mockConsole.debug,"debug"),log:this.getSingleLoggerStyle(b,c,this.mockConsole.log,
+"info"),warn:this.getSingleLoggerStyle(b,c,this.mockConsole.warn,"warn"),error:this.getSingleLoggerStyle(b,c,this.mockConsole.error,"error")}},a}();module$node_modules$lines_logger$lib$index.default.LoggerFactory=LoggerFactory$$module$node_modules$lines_logger$lib$index;let logWorkletMain$$module$src$logger,logWorkletWorker$$module$src$logger,logSABMain$$module$src$logger,logSABWorker$$module$src$logger,logVANMain$$module$src$logger,logVANWorker$$module$src$logger,logOldSpnMain$$module$src$logger,logOldSpnWorker$$module$src$logger,logIndex$$module$src$logger,logSPNMainSingle$$module$src$logger,logSinglethreadWorkletMain$$module$src$logger,logSinglethreadWorkletWorker$$module$src$logger,logCommonUtils$$module$src$logger,logWasmModule$$module$src$logger,logMidiRequest$$module$src$logger;
+const isProd$$module$src$logger=1;logWorkletMain$$module$src$logger=a=>b=>{};logWorkletWorker$$module$src$logger=a=>b=>{};logSABMain$$module$src$logger=a=>b=>{};logSABWorker$$module$src$logger=a=>b=>{};logVANMain$$module$src$logger=a=>b=>{};logVANWorker$$module$src$logger=a=>b=>{};logOldSpnMain$$module$src$logger=a=>b=>{};logOldSpnWorker$$module$src$logger=a=>b=>{};logIndex$$module$src$logger=a=>b=>{};logSPNMainSingle$$module$src$logger=a=>b=>{};
+logSinglethreadWorkletMain$$module$src$logger=a=>b=>{};logSinglethreadWorkletWorker$$module$src$logger=a=>b=>{};logCommonUtils$$module$src$logger=a=>b=>{};logWasmModule$$module$src$logger=a=>b=>{};logMidiRequest$$module$src$logger=a=>b=>{};var $jscompDefaultExport$$module$src$logger=a=>b=>{},module$src$logger={};module$src$logger.default=$jscompDefaultExport$$module$src$logger;module$src$logger.logCommonUtils=logCommonUtils$$module$src$logger;module$src$logger.logIndex=logIndex$$module$src$logger;
+module$src$logger.logMidiRequest=logMidiRequest$$module$src$logger;module$src$logger.logOldSpnMain=logOldSpnMain$$module$src$logger;module$src$logger.logOldSpnWorker=logOldSpnWorker$$module$src$logger;module$src$logger.logSABMain=logSABMain$$module$src$logger;module$src$logger.logSABWorker=logSABWorker$$module$src$logger;module$src$logger.logSPNMainSingle=logSPNMainSingle$$module$src$logger;module$src$logger.logSinglethreadWorkletMain=logSinglethreadWorkletMain$$module$src$logger;
+module$src$logger.logSinglethreadWorkletWorker=logSinglethreadWorkletWorker$$module$src$logger;module$src$logger.logVANMain=logVANMain$$module$src$logger;module$src$logger.logVANWorker=logVANWorker$$module$src$logger;module$src$logger.logWasmModule=logWasmModule$$module$src$logger;module$src$logger.logWorkletMain=logWorkletMain$$module$src$logger;module$src$logger.logWorkletWorker=logWorkletWorker$$module$src$logger;const csoundCreate$$module$src$modules$instantiation=a=>()=>a.exports.csoundCreateWasi();csoundCreate$$module$src$modules$instantiation.toString=()=>"create = async () => undefined;";const csoundDestroy$$module$src$modules$instantiation=a=>b=>a.exports.csoundDestroy(b);csoundDestroy$$module$src$modules$instantiation.toString=()=>"destroy = async () => undefined;";const csoundGetAPIVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetAPIVersion();
+csoundGetAPIVersion$$module$src$modules$instantiation.toString=()=>"getAPIVersion = async () => Number;";const csoundGetVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetVersion();csoundGetVersion$$module$src$modules$instantiation.toString=()=>"getVersion = async () => Number;";const csoundInitialize$$module$src$modules$instantiation=a=>(b,c)=>a.exports.csoundInitialize(c);csoundInitialize$$module$src$modules$instantiation.toString=()=>"initialize = async () => Number;";
+var module$src$modules$instantiation={};module$src$modules$instantiation.csoundCreate=csoundCreate$$module$src$modules$instantiation;module$src$modules$instantiation.csoundDestroy=csoundDestroy$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetAPIVersion=csoundGetAPIVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetVersion=csoundGetVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundInitialize=csoundInitialize$$module$src$modules$instantiation;const WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders=!1;function TextEncoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";return this}TextEncoderPoly$$module$src$utils$text_encoders.prototype.encode=function(a){if("string"!==typeof a)throw new TypeError("passed argument must be of type string "+a+" "+typeof a);a=unescape(encodeURIComponent(a));const b=new Uint8Array(a.length);[...a].forEach(function(c,d){b[d]=c.codePointAt(0)});return b};
+function TextDecoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";this.ignoreBOM=!1;this.trimNull=a=>{const b=a.indexOf("\x00");return-1<b?a.slice(0,Math.max(0,b)):a};this.decode=function(a,b){if(void 0===a)return"";if("boolean"!==typeof(void 0!==b&&"stream"in b?b.stream:!1))throw new TypeError("stream option must be boolean");if(ArrayBuffer.isView(a)){a=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);const c=Array.from({length:a.length});a.forEach(function(d,e){c[e]=String.fromCodePoint(d)});
+return this.trimNull(c.join(""))}throw new TypeError("passed argument must be an array buffer view");}}
+const decoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextDecoderPoly$$module$src$utils$text_encoders:new TextDecoder("utf8"),encoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextEncoderPoly$$module$src$utils$text_encoders:new TextEncoder("utf8"),uint2String$$module$src$utils$text_encoders=a=>decoder$$module$src$utils$text_encoders.decode(a);var module$src$utils$text_encoders={};
+module$src$utils$text_encoders.decoder=decoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.encoder=encoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.uint2String=uint2String$$module$src$utils$text_encoders;const trimNull$$module$src$utils$trim_null=a=>{const b=a.indexOf("\x00");return-1<b?a.substr(0,b):a};var module$src$utils$trim_null={};module$src$utils$trim_null.trimNull=trimNull$$module$src$utils$trim_null;const freeStringPtr$$module$src$utils$string_pointers=(a,b)=>{a.exports.freeStringMem(b)},ptr2string$$module$src$utils$string_pointers=(a,b)=>{({buffer:a}=a.wasi.memory);b=new Uint8Array(a,b);b=uint2String$$module$src$utils$text_encoders(b);return trimNull$$module$src$utils$trim_null(b)},string2ptr$$module$src$utils$string_pointers=(a,b)=>{if("string"!==typeof b)console.error("Expected string but got",typeof b);else{b=encoder$$module$src$utils$text_encoders.encode(b);var c=a.exports.allocStringMem(b.length);
+({buffer:a}=a.wasi.memory);(new Uint8Array(a,c,b.length+1)).set(b);return c}};var module$src$utils$string_pointers={};module$src$utils$string_pointers.freeStringPtr=freeStringPtr$$module$src$utils$string_pointers;module$src$utils$string_pointers.ptr2string=ptr2string$$module$src$utils$string_pointers;module$src$utils$string_pointers.string2ptr=string2ptr$$module$src$utils$string_pointers;const csoundParseOrc$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundParseOrc(b,c);csoundParseOrc$$module$src$modules$performance.toString=()=>"parseOrc = async (orchestra) => Object;";const csoundCompileTree$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundCompileTree(b,c);csoundCompileTree$$module$src$modules$performance.toString=()=>"compileTree = async (tree) => Number;";
+const csoundCompileOrc$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileOrc(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileOrc$$module$src$modules$performance.toString=()=>"compileOrc = async (orchestra) => Number;";
+const csoundEvalCode$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundEvalCode(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundEvalCode$$module$src$modules$performance.toString=()=>"csoundEvalCode = async (orchestra) => Number;";const csoundStart$$module$src$modules$performance=a=>b=>a.exports.csoundStartWasi(b);csoundStart$$module$src$modules$performance.toString=()=>"start = async () => Number;";
+const csoundCompileCsd$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);let d;try{d=a.exports.csoundCompileCsd(b,c)}catch(e){console.error(e)}freeStringPtr$$module$src$utils$string_pointers(a,c);return d};csoundCompileCsd$$module$src$modules$performance.toString=()=>"compileCsd = async (path) => Number;";
+const csoundCompileCsdText$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileCsdText(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileCsdText$$module$src$modules$performance.toString=()=>"compileCsdText = async (csoundDocument) => Number;";const csoundPerform$$module$src$modules$performance=a=>b=>a.exports.csoundPerform(b);csoundPerform$$module$src$modules$performance.toString=()=>"perform = async () => Number;";
+const csoundPerformKsmps$$module$src$modules$performance=a=>b=>a.exports.csoundPerformKsmpsWasi(b);csoundPerformKsmps$$module$src$modules$performance.toString=()=>"performKsmps = async (csound) => Number;";const csoundPerformBuffer$$module$src$modules$performance=a=>b=>a.exports.csoundPerformBuffer(b);csoundPerformBuffer$$module$src$modules$performance.toString=()=>"performBuffer = async (csound) => Number;";const csoundStop$$module$src$modules$performance=a=>b=>a.exports.csoundStop(b);
+csoundStop$$module$src$modules$performance.toString=()=>"stop = async () => undefined;";const csoundCleanup$$module$src$modules$performance=a=>b=>a.exports.csoundCleanup(b);csoundCleanup$$module$src$modules$performance.toString=()=>"cleanup = async () => Number;";const csoundReset$$module$src$modules$performance=a=>b=>a.exports.csoundResetWasi(b);csoundReset$$module$src$modules$performance.toString=()=>"reset = async () => Number;";var module$src$modules$performance={};
+module$src$modules$performance.csoundCleanup=csoundCleanup$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsd=csoundCompileCsd$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsdText=csoundCompileCsdText$$module$src$modules$performance;module$src$modules$performance.csoundCompileOrc=csoundCompileOrc$$module$src$modules$performance;module$src$modules$performance.csoundCompileTree=csoundCompileTree$$module$src$modules$performance;
+module$src$modules$performance.csoundEvalCode=csoundEvalCode$$module$src$modules$performance;module$src$modules$performance.csoundParseOrc=csoundParseOrc$$module$src$modules$performance;module$src$modules$performance.csoundPerform=csoundPerform$$module$src$modules$performance;module$src$modules$performance.csoundPerformBuffer=csoundPerformBuffer$$module$src$modules$performance;module$src$modules$performance.csoundPerformKsmps=csoundPerformKsmps$$module$src$modules$performance;
+module$src$modules$performance.csoundReset=csoundReset$$module$src$modules$performance;module$src$modules$performance.csoundStart=csoundStart$$module$src$modules$performance;module$src$modules$performance.csoundStop=csoundStop$$module$src$modules$performance;const sizeOfPrimitive$$module$src$utils$native_sizes={int:4,MYFLT:4,char:1},sizeofStruct$$module$src$utils$native_sizes=a=>a.reduce((b,[,c,...d])=>b+("char"===c?sizeOfPrimitive$$module$src$utils$native_sizes[c]*d[0]:sizeOfPrimitive$$module$src$utils$native_sizes[c]),0);var module$src$utils$native_sizes={};module$src$utils$native_sizes.sizeOfPrimitive=sizeOfPrimitive$$module$src$utils$native_sizes;module$src$utils$native_sizes.sizeofStruct=sizeofStruct$$module$src$utils$native_sizes;const structBufferToObject$$module$src$utils$structure_buffer_to_object=(a,b)=>{[a]=a.reduce(([c,d],[e,f,...g])=>{g="char"===f?sizeOfPrimitive$$module$src$utils$native_sizes[f]*g[0]:sizeOfPrimitive$$module$src$utils$native_sizes[f];f="char"===f?trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(b.subarray(d,g)))||"":b[d];c[e]=f;return[c,d+g]},[{},0]);return a};var module$src$utils$structure_buffer_to_object={};
+module$src$utils$structure_buffer_to_object.structBufferToObject=structBufferToObject$$module$src$utils$structure_buffer_to_object;const CSOUND_PARAMS$$module$src$structures=[["debug_mode","int"],["buffer_frames","int"],["hardware_buffer_frames","int"],["displays","int"],["ascii_graphs","int"],["postscript_graphs","int"],["message_level","int"],["tempo","int"],["ring_bell","int"],["use_cscore","int"],["terminate_on_midi","int"],["heartbeat","int"],["defer_gen01_load","int"],["midi_key","int"],["midi_key_cps","int"],["midi_key_oct","int"],["midi_key_pch","int"],["midi_velocity","int"],["midi_velocity_amp","int"],["no_default_paths",
+"int"],["number_of_threads","int"],["syntax_check_only","int"],["csd_line_counts","int"],["compute_weights","int"],["realtime_mode","int"],["sample_accurate","int"],["sample_rate_override","MYFLT"],["control_rate_override","MYFLT"],["nchnls_override","int"],["nchnls_i_override","int"],["e0dbfs_override","MYFLT"],["daemon","int"],["ksmps_override","int"],["FFT_library","int"]],CS_MIDIDEVICE$$module$src$structures=[["device_name","char",64],["interface_name","char",64],["device_id","char",64],["midi_module",
+"char",64],["isOutput","int"]];var module$src$structures={};const csoundGetSr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSr(b);csoundGetSr$$module$src$modules$attributes.toString=()=>"getSr = async () => Number;";const csoundGetKr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKr(b);csoundGetKr$$module$src$modules$attributes.toString=()=>"getKr = async () => Number;";const csoundGetKsmps$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKsmps(b);csoundGetKsmps$$module$src$modules$attributes.toString=()=>"getKsmps = async () => Number;";
+const csoundGetNchnls$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnls(b);csoundGetNchnls$$module$src$modules$attributes.toString=()=>"getNchnls = async () => Number;";const csoundGetNchnlsInput$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnlsInput(b);csoundGetNchnlsInput$$module$src$modules$attributes.toString=()=>"getNchnlsInput = async () => Number;";const csoundGet0dBFS$$module$src$modules$attributes=a=>b=>a.exports.csoundGet0dBFS(b);
+csoundGet0dBFS$$module$src$modules$attributes.toString=()=>"get0dBFS = async () => Number;";const csoundGetA4$$module$src$modules$attributes=a=>b=>a.exports.csoundGetA4(b);csoundGetA4$$module$src$modules$attributes.toString=()=>"getA4 = async () => Number;";const csoundGetCurrentTimeSamples$$module$src$modules$attributes=a=>b=>a.exports.csoundGetCurrentTimeSamples(b);csoundGetCurrentTimeSamples$$module$src$modules$attributes.toString=()=>"getCurrentTimeSamples = async () => Number;";
+const csoundGetSizeOfMYFLT$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSizeOfMYFLT(b);csoundGetSizeOfMYFLT$$module$src$modules$attributes.toString=()=>"getSizeOfMYFLT = async () => Number;";const csoundSetOption$$module$src$modules$attributes=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundSetOption(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundSetOption$$module$src$modules$attributes.toString=()=>"setOption = async (option) => Number;";
+const csoundSetParams$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetParams(b,c)};csoundSetParams$$module$src$modules$attributes.toString=()=>"setParams = async (csoundParams) => undefined;";
+const csoundGetParams$$module$src$modules$attributes=a=>b=>{var {buffer:c}=a.wasi.memory;const d=sizeofStruct$$module$src$utils$native_sizes(CSOUND_PARAMS$$module$src$structures),e=a.exports.allocCsoundParamsStruct();c=new Uint8Array(c,e,d);a.exports.csoundGetParams(b,e);b=structBufferToObject$$module$src$utils$structure_buffer_to_object(CSOUND_PARAMS$$module$src$structures,c);a.exports.freeCsoundParams(e);return b};csoundGetParams$$module$src$modules$attributes.toString=()=>"getParams = async () => CSOUND_PARAMS;";
+const csoundGetDebug$$module$src$modules$attributes=a=>b=>a.exports.csoundGetDebug(b);csoundGetDebug$$module$src$modules$attributes.toString=()=>"getDebug = async () => Number;";const csoundSetDebug$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetDebug(b,c)};csoundSetDebug$$module$src$modules$attributes.toString=()=>"setDebug = async (number) => undefined;";var module$src$modules$attributes={};module$src$modules$attributes.csoundGet0dBFS=csoundGet0dBFS$$module$src$modules$attributes;
+module$src$modules$attributes.csoundGetA4=csoundGetA4$$module$src$modules$attributes;module$src$modules$attributes.csoundGetCurrentTimeSamples=csoundGetCurrentTimeSamples$$module$src$modules$attributes;module$src$modules$attributes.csoundGetDebug=csoundGetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKr=csoundGetKr$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKsmps=csoundGetKsmps$$module$src$modules$attributes;
+module$src$modules$attributes.csoundGetNchnls=csoundGetNchnls$$module$src$modules$attributes;module$src$modules$attributes.csoundGetNchnlsInput=csoundGetNchnlsInput$$module$src$modules$attributes;module$src$modules$attributes.csoundGetParams=csoundGetParams$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSizeOfMYFLT=csoundGetSizeOfMYFLT$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSr=csoundGetSr$$module$src$modules$attributes;
+module$src$modules$attributes.csoundSetDebug=csoundSetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundSetOption=csoundSetOption$$module$src$modules$attributes;module$src$modules$attributes.csoundSetParams=csoundSetParams$$module$src$modules$attributes;const csoundGetInputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBufferSize(b);csoundGetInputBufferSize$$module$src$modules$rtaudio.toString=()=>"getInputBufferSize = async () => Number;";const csoundGetOutputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBufferSize(b);csoundGetOutputBufferSize$$module$src$modules$rtaudio.toString=()=>"getOutputBufferSize = async () => Number;";const csoundGetInputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBuffer(b);
+csoundGetInputBuffer$$module$src$modules$rtaudio.toString=()=>"getInputBuffer = async () => Number;";const csoundGetOutputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBuffer(b);csoundGetOutputBuffer$$module$src$modules$rtaudio.toString=()=>"getOutputBuffer = async () => Number;";const csoundGetSpin$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpin(b);csoundGetSpin$$module$src$modules$rtaudio.toString=()=>"getSpin = async (csound) => Number;";
+const csoundGetSpout$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpout(b);csoundGetSpout$$module$src$modules$rtaudio.toString=()=>"getSpout = async () => Number;";var module$src$modules$rtaudio={};module$src$modules$rtaudio.csoundGetInputBuffer=csoundGetInputBuffer$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetInputBufferSize=csoundGetInputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetOutputBuffer=csoundGetOutputBuffer$$module$src$modules$rtaudio;
+module$src$modules$rtaudio.csoundGetOutputBufferSize=csoundGetOutputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpin=csoundGetSpin$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpout=csoundGetSpout$$module$src$modules$rtaudio;function add$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>add$$module$node_modules$rambda$dist$rambda_mjs(a,c):Number(a)+Number(b)}const cloneList$$module$node_modules$rambda$dist$rambda_mjs=a=>Array.prototype.slice.call(a);function curry$$module$node_modules$rambda$dist$rambda_mjs(a,b=[]){return(...c)=>{c=[...b,...c];return c.length>=a.length?a(...c):curry$$module$node_modules$rambda$dist$rambda_mjs(a,c)}}
+function adjustFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d=0>a?c.length+a:a;if(a>=c.length||0>d)return c;a=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);a[d]=b(a[d]);return a}const adjust$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(adjustFn$$module$node_modules$rambda$dist$rambda_mjs);
+function all$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>all$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(!a(b[c]))return!1;return!0}function allPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(!a[c](...b))return!1;c++}return!0}}function always$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>a}
+function and$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>and$$module$node_modules$rambda$dist$rambda_mjs(a,c):a&&b}function any$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>any$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=0;for(;c<b.length;){if(a(b[c],c))return!0;c++}return!1}
+function anyPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(a[c](...b))return!0;c++}return!1}}function append$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>append$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.split("").concat(a);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);c.push(a);return c}
+function apply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>apply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.apply(this,b)}const {isArray:isArray$$module$node_modules$rambda$dist$rambda_mjs}=Array;
+function __findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a,b=0){for(const c in a)!1!==a.hasOwnProperty(c)&&"constructor"!==c&&("object"===typeof a[c]&&(b=Math.max(b,__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a[c]))),"function"===typeof a[c]&&(b=Math.max(b,a[c].length)));return b}
+function __filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(){const a=[];let b=0;const c=arguments.length;for(;b<c&&"undefined"!==typeof arguments[b];)a[b]=arguments[b],b++;return a}
+function __applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){var d=b-c.length;if(1===d)return f=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f));if(2===d)return(f,g)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g));if(3===d)return(f,g,h)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,
+b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h));if(4===d)return(f,g,h,k)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h,k));if(4<d)return(...f)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,...f));if(isArray$$module$node_modules$rambda$dist$rambda_mjs(a)){var e=[];d=0;const f=a.length;
+for(;d<f;d++){if("object"===typeof a[d]||isArray$$module$node_modules$rambda$dist$rambda_mjs(a[d]))e[d]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[d],b,c);"function"===typeof a[d]&&(e[d]=a[d](...c))}return e}d={};for(e in a)!1!==a.hasOwnProperty(e)&&"constructor"!==e&&("object"===typeof a[e]?d[e]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[e],b,c):"function"===typeof a[e]&&(d[e]=a[e](...c)));return d}
+function applySpec$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a);return 0===c?()=>({}):__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,c,b)}function assocFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return Object.assign({},c,{[a]:b})}const assoc$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocFn$$module$node_modules$rambda$dist$rambda_mjs);
+function _isInteger$$module$node_modules$rambda$dist$rambda_mjs(a){return a<<0===a}const isInteger$$module$node_modules$rambda$dist$rambda_mjs=Number.isInteger||_isInteger$$module$node_modules$rambda$dist$rambda_mjs;
+function assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d="string"===typeof a?a.split(".").map(e=>isInteger$$module$node_modules$rambda$dist$rambda_mjs(Number(e))?Number(e):e):a;if(0===d.length)return b;a=d[0];if(1<d.length){const e="object"===typeof c&&null!==c&&c.hasOwnProperty(a)?c[a]:isInteger$$module$node_modules$rambda$dist$rambda_mjs(d[1])?[]:{};b=assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(d,1),b,e)}return isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)&&
+isArray$$module$node_modules$rambda$dist$rambda_mjs(c)?(c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c),c[a]=b,c):assoc$$module$node_modules$rambda$dist$rambda_mjs(a,b,c)}const assocPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocPathFn$$module$node_modules$rambda$dist$rambda_mjs);
+function _curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return function(){var d=0;let e=0;const f=b.length,g=arguments.length,h=Array(f+g);for(;d<f;)h[d]=b[d],d++;for(;e<g;)h[f+e]=arguments[e],e++;d=a-h.length;return h.length>=a?c.apply(this,h):_arity$1$$module$node_modules$rambda$dist$rambda_mjs(d,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,h,c))}}
+function _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};
+case 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,n){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,n,m){return b.apply(this,arguments)};default:return function(c,d,e,f,g,h,k,n,m,l){return b.apply(this,arguments)}}}
+function curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>curryN$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(10<a)throw Error("First argument to _arity must be a non-negative integer no greater than ten");return _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,[],b))}
+function bind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>bind$$module$node_modules$rambda$dist$rambda_mjs(a,c):curryN$$module$node_modules$rambda$dist$rambda_mjs(a.length,(...c)=>a.apply(b,c))}function both$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>both$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>a(...c)&&b(...c)}
+function chain$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>chain$$module$node_modules$rambda$dist$rambda_mjs(a,c):[].concat(...b.map(a))}function clampFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(a>b)throw Error("min must not be greater than max in clamp(min, max, value)");if(c>=a&&c<=b)return c;if(c>b)return b;if(c<a)return a}const clamp$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(clampFn$$module$node_modules$rambda$dist$rambda_mjs);
+function clone$$module$node_modules$rambda$dist$rambda_mjs(a){const b=isArray$$module$node_modules$rambda$dist$rambda_mjs(a)?Array(a.length):{};if(a&&a.getTime)return new Date(a.getTime());for(const c in a){const d=a[c];b[c]="object"===typeof d&&null!==d?d.getTime?new Date(d.getTime()):clone$$module$node_modules$rambda$dist$rambda_mjs(d):d}return b}function complement$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>!a(...b)}
+class ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs{constructor(a){this.value=a}}function reduceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(c))throw new TypeError("reduce: list must be array or iterable");let d=0;const e=c.length;for(;d<e;){b=a(b,c[d],d,c);if(b instanceof ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs)return b.value;d++}return b}
+const reduce$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(reduceFn$$module$node_modules$rambda$dist$rambda_mjs),reduceStopper$$module$node_modules$rambda$dist$rambda_mjs=a=>new ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs(a);
+function _arity$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};
+case 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,n){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,n,m){return b.apply(this,arguments)};case 10:return function(c,d,e,f,g,h,k,n,m,l){return b.apply(this,arguments)};default:throw Error("First argument to _arity must be a non-negative integer no greater than ten");}}
+function _pipe$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(){return b.call(this,a.apply(this,arguments))}}
+function pipe$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("pipe requires at least one argument");return _arity$$module$node_modules$rambda$dist$rambda_mjs(arguments[0].length,reduceFn$$module$node_modules$rambda$dist$rambda_mjs(_pipe$$module$node_modules$rambda$dist$rambda_mjs,arguments[0],Array.prototype.slice.call(arguments,1,Infinity)))}
+function compose$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("compose requires at least one argument");return pipe$$module$node_modules$rambda$dist$rambda_mjs.apply(this,Array.prototype.slice.call(arguments,0).reverse())}function concat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>concat$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof a?`${a}${b}`:[...a,...b]}
+function cond$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>{let c=!1,d;a.forEach(([e,f])=>{!c&&e(b)&&(c=!0,d=f(b))});return d}}const {keys:keys$1$$module$node_modules$rambda$dist$rambda_mjs}=Object;function mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=Array(b.length);for(;d<b.length;)e[d]=c?a(b[d],d):a(b[d]),d++;return e}
+function mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,g);let c=0;const d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b),e=d.length,f={};for(;c<e;){const g=d[c];f[g]=a(b[g],g,b);c++}return f}const mapObjIndexed$$module$node_modules$rambda$dist$rambda_mjs=mapObject$$module$node_modules$rambda$dist$rambda_mjs;
+function map$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>map$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error(INCORRECT_ITERABLE_INPUT);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}
+function max$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>max$$module$node_modules$rambda$dist$rambda_mjs(a,c):b>a?b:a}
+function converge$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>converge$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=reduce$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>max$$module$node_modules$rambda$dist$rambda_mjs(d,e.length),0,b);return curryN$$module$node_modules$rambda$dist$rambda_mjs(c,function(){return a.apply(this,map$$module$node_modules$rambda$dist$rambda_mjs(d=>d.apply(this,arguments),b))})}
+function count$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>count$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?b.filter(c=>a(c)).length:0}function countBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>countBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};b.forEach(d=>{d=a(d);c[d]?c[d]++:c[d]=1});return c}
+const dec$$module$node_modules$rambda$dist$rambda_mjs=a=>a-1;function isFalsy$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a||!0===Number.isNaN(a)}function defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c):isFalsy$$module$node_modules$rambda$dist$rambda_mjs(b)?a:b}
+function type$$module$node_modules$rambda$dist$rambda_mjs(a){if(null===a)return"Null";if(void 0===a)return"Undefined";if(Number.isNaN(a))return"NaN";a=Object.prototype.toString.call(a).slice(8,-1);return"AsyncFunction"===a?"Promise":a}
+function _lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property 'indexOf' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.lastIndexOf(a);({length:c}=b);let d=-1;for(;-1<--c&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}
+function _indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property 'indexOf' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.indexOf(a);let d=c=-1;const {length:e}=b;for(;++c<e&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}
+function _arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a){const b=[];let c;for(;!(c=a.next()).done;)b.push(c.value);return b}function _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(a.size!==b.size)return!1;a=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a.values());const c=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(b.values());return 0===a.filter(d=>-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,c)).length}
+function parseError$$module$node_modules$rambda$dist$rambda_mjs(a){const b=a.__proto__.toString();return["Error","TypeError"].includes(b)?[b,a.message]:[]}function parseDate$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toDateString?[!0,a.getTime()]:[!1]}function parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a){return a.constructor!==RegExp?[!1]:[!0,a.toString()]}
+function equals$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>equals$$module$node_modules$rambda$dist$rambda_mjs(a,f);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(c!==type$$module$node_modules$rambda$dist$rambda_mjs(b))return!1;if("Function"===c)return void 0===a.name?!1:a.name===b.name;if(["NaN","Undefined","Null"].includes(c))return!0;if("Number"===c)return Object.is(-0,a)!==Object.is(-0,b)?!1:a.toString()===b.toString();if(["String","Boolean"].includes(c))return a.toString()===
+b.toString();if("Array"===c){c=Array.from(a);const f=Array.from(b);if(c.toString()!==f.toString())return!1;let g=!0;c.forEach((h,k)=>{g&&(h===f[k]||equals$$module$node_modules$rambda$dist$rambda_mjs(h,f[k])||(g=!1))});return g}var d=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a),e=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseDate$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseDate$$module$node_modules$rambda$dist$rambda_mjs(b);
+if(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseError$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseError$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[0]===e[0]&&d[1]===e[1]:!1;if("Set"===c)return _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b);if("Object"===c){c=Object.keys(a);if(c.length!==Object.keys(b).length)return!1;let f=!0;c.forEach(g=>{if(f){const h=a[g];g=b[g];h===g||equals$$module$node_modules$rambda$dist$rambda_mjs(h,g)||(f=!1)}});
+return f}return!1}function includes$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>includes$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof b)return b.includes(a);if(!b)throw new TypeError(`Cannot read property \'indexOf\' of ${b}`);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b):!1}
+class _Set$$module$node_modules$rambda$dist$rambda_mjs{constructor(){this.set=new Set;this.items={}}checkUniqueness(a){var b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Null","Undefined","NaN"].includes(b)?b in this.items?!1:this.items[b]=!0:["Object","Array"].includes(b)?b in this.items?-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,this.items[b])?(this.items[b].push(a),!0):!1:(this.items[b]=[a],!0):(b=this.set.size,this.set.add(a),this.set.size!==b)}}
+function uniq$$module$node_modules$rambda$dist$rambda_mjs(a){const b=new _Set$$module$node_modules$rambda$dist$rambda_mjs,c=[];a.forEach(d=>{b.checkUniqueness(d)&&c.push(d)});return c}function difference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>difference$$module$node_modules$rambda$dist$rambda_mjs(a,c):uniq$$module$node_modules$rambda$dist$rambda_mjs(a).filter(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b))}
+function dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(null===b||void 0===b)return{};const c={};for(const d in b)c[d]=b[d];delete c[a];return c}function divide$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>divide$$module$node_modules$rambda$dist$rambda_mjs(a,c):a/b}
+function drop$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>drop$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.slice(0<a?a:0)}function dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,c):0<a?b.slice(0,-a):b.slice()}
+function dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(0===b.length)return b;const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if("function"!==typeof a)throw Error(`'predicate' is from wrong type ${typeof a}`);if(!c&&"string"!==typeof b)throw Error(`'iterable' is from wrong type ${typeof b}`);let d=!1;const e=[];let f=b.length;for(;0<f;)f--,d||!1!==a(b[f])?d&&e.push(b[f]):
+(d=!0,e.push(b[f]));return c?e.reverse():e.reverse().join("")}function dropRepeats$$module$node_modules$rambda$dist$rambda_mjs(a){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`${a} is not a list`);const b=[];a.reduce((c,d)=>{equals$$module$node_modules$rambda$dist$rambda_mjs(c,d)||b.push(d);return d},void 0);return b}
+function dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`${b} is not a list`);const c=[];b.reduce((d,e)=>{if(void 0===d)return c.push(e),e;a(d,e)||c.push(e);return e},void 0);return c}
+function dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!1;const e=[];let f=-1;for(;f++<b.length-1;)d?e.push(b[f]):a(b[f])||(d||(d=!0),e.push(b[f]));return c?e:e.join("")}
+function either$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>either$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>!(!a(...c)&&!b(...c))}
+function endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);if("string"===typeof b)return b.endsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;const c=b.length-a.length;let d=!0;return a.filter((e,f)=>{if(!d)return!1;(e=equals$$module$node_modules$rambda$dist$rambda_mjs(e,b[f+c]))||(d=!1);return e}).length===a.length}
+function prop$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>prop$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(b)return b[a]}function eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a,b),prop$$module$node_modules$rambda$dist$rambda_mjs(a,c))}const eqProps$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs);
+function evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapArray$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c,b,!0)}
+function evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapObject$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>{if("Object"===type$$module$node_modules$rambda$dist$rambda_mjs(c)){const e=type$$module$node_modules$rambda$dist$rambda_mjs(a[d]);return"Function"===e?a[d](c):"Object"===e?evolve$$module$node_modules$rambda$dist$rambda_mjs(a[d],c):c}return"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c},b)}
+function evolve$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>evolve$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=type$$module$node_modules$rambda$dist$rambda_mjs(a),d=type$$module$node_modules$rambda$dist$rambda_mjs(b);if(d!==c)throw Error("iterableType !== rulesType");if(!["Object","Array"].includes(c))throw Error(`'iterable' and 'rules' are from wrong type ${c}`);return"Object"===d?evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b):evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,
+b)}function F$$module$node_modules$rambda$dist$rambda_mjs(){return!1}function filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(const d in b)a(b[d],d,b)&&(c[d]=b[d]);return c}function filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=b.length,f=[];for(;d<e;)(c?a(b[d],d):a(b[d]))&&f.push(b[d]),d++;return f}
+function filter$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>filter$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error("Incorrect iterable input");return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,!1):filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}
+function find$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>find$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=0;const d=b.length;for(;c<d;){const e=b[c];if(a(e))return e;c++}}function findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;let d=-1;for(;++d<c;)if(a(b[d]))return d;return-1}
+function findLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLast$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return b[c]}function findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return c;return-1}
+function flatten$$module$node_modules$rambda$dist$rambda_mjs(a,b){b=void 0===b?[]:b;for(let c=0;c<a.length;c++)isArray$$module$node_modules$rambda$dist$rambda_mjs(a[c])?flatten$$module$node_modules$rambda$dist$rambda_mjs(a[c],b):b.push(a[c]);return b}
+function flipFn$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{if(1===b.length)return c=>a(c,b[0]);if(2===b.length)return a(b[1],b[0]);if(3===b.length)return a(b[1],b[0],b[2]);if(4===b.length)return a(b[1],b[0],b[2],b[3]);throw Error("R.flip doesn't work with arity > 4");}}function flip$$module$node_modules$rambda$dist$rambda_mjs(a){return flipFn$$module$node_modules$rambda$dist$rambda_mjs(a)}
+function forEach$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>forEach$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(void 0!==b){if(isArray$$module$node_modules$rambda$dist$rambda_mjs(b))for(var c=0,d=b.length;c<d;)a(b[c]),c++;else{c=0;d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b);const e=d.length;for(;c<e;){const f=d[c];a(b[f],f,b);c++}}return b}}
+function fromPairs$$module$node_modules$rambda$dist$rambda_mjs(a){const b={};a.forEach(([c,d])=>b[c]=d);return b}function groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};for(let d=0;d<b.length;d++){const e=b[d],f=a(e);c[f]||(c[f]=[]);c[f].push(e)}return c}
+function groupWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw new TypeError("list.reduce is not a function");const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);if(1===b.length)return[c];const d=[];let e=[];c.reduce((f,g,h)=>{if(0===h)return g;const k=a(f,g),n=0===e.length;h=h===b.length-1;if(k)return n&&e.push(f),e.push(g),h&&d.push(e),g;if(n)return d.push([f]),h&&d.push([g]),g;d.push(e);h&&d.push([g]);e=[];return g},
+void 0);return d}function has$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>has$$module$node_modules$rambda$dist$rambda_mjs(a,c):b?b.hasOwnProperty(a):!1}function createPath$$module$node_modules$rambda$dist$rambda_mjs(a,b="."){return"string"===typeof a?a.split(b):a}
+function path$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>path$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=b,d=0,e=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);d<e.length;){if(null===c||void 0===c||null===c[e[d]])return;c=c[e[d]];d++}return c}}
+function hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,c):void 0!==path$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function head$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[0]||"":a[0]}function _objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b}const objectIs$$module$node_modules$rambda$dist$rambda_mjs=Object.is||_objectIs$$module$node_modules$rambda$dist$rambda_mjs;
+function identical$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>identical$$module$node_modules$rambda$dist$rambda_mjs(a,c):objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function identity$$module$node_modules$rambda$dist$rambda_mjs(a){return a}function ifElseFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return(...d)=>!0===("boolean"===typeof a?a:a(...d))?b(...d):c(...d)}
+const ifElse$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(ifElseFn$$module$node_modules$rambda$dist$rambda_mjs),inc$$module$node_modules$rambda$dist$rambda_mjs=a=>a+1;function indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(let d=0;d<b.length;d++){const e=b[d];c[path$$module$node_modules$rambda$dist$rambda_mjs(a,e)]=e}return c}
+function indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof a)return indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b);const c={};for(let d=0;d<b.length;d++){const e=b[d];c[a(e)]=e}return c}
+function indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=-1,{length:e}=a;c=c>e?e:c;0>c&&(c+=e);e=b>c?0:c-b>>>0;b>>>=0;for(c=Array(e);++d<e;)c[d]=a[d+b];return c}
+function init$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.slice(0,-1):a.length?baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,0,-1):[]}function intersection$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>intersection$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b)}
+function intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,f);let c=-1;const d=b.length,e=[];for(;++c<d;)c===d-1?e.push(b[c]):e.push(b[c],a);return e}function is$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>is$$module$node_modules$rambda$dist$rambda_mjs(a,c):null!=b&&b.constructor===a||b instanceof a}
+function isEmpty$$module$node_modules$rambda$dist$rambda_mjs(a){const b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Undefined","NaN","Number","Null"].includes(b)?!1:a?"Object"===b?0===Object.keys(a).length:"Array"===b?0===a.length:!1:!0}function isNil$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a}
+function join$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>join$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.join(a)}function juxt$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>a.map(c=>c(...b))}function keys$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.keys(a)}function last$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[a.length-1]||"":a[a.length-1]}
+function lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function length$$module$node_modules$rambda$dist$rambda_mjs(a){return isArray$$module$node_modules$rambda$dist$rambda_mjs(a)||"string"===typeof a?a.length:NaN}
+function lens$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(c){return function(d){return c(a(d)).map(e=>b(e,d))}}}function nth$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>nth$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=0>a?b.length+a:a;return"[object String]"===Object.prototype.toString.call(b)?b.charAt(c):b[c]}
+function updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);return-1===a?c.fill(b,a):c.fill(b,a,a+1)}const update$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(updateFn$$module$node_modules$rambda$dist$rambda_mjs);
+function lensIndex$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(nth$$module$node_modules$rambda$dist$rambda_mjs(a),update$$module$node_modules$rambda$dist$rambda_mjs(a))}function lensPath$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a),assocPath$$module$node_modules$rambda$dist$rambda_mjs(a))}
+function lensProp$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a),assoc$$module$node_modules$rambda$dist$rambda_mjs(a))}function match$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>match$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=b.match(a);return null===c?[]:c}
+function mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,c):!isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)||!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||1>b?NaN:(a%b+b)%b}function maxByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)>a(b)?c:b}const maxBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(maxByFn$$module$node_modules$rambda$dist$rambda_mjs);
+function sum$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>b+c,0)}function mean$$module$node_modules$rambda$dist$rambda_mjs(a){return sum$$module$node_modules$rambda$dist$rambda_mjs(a)/a.length}function median$$module$node_modules$rambda$dist$rambda_mjs(a){var b=a.length;if(0===b)return NaN;const c=2-b%2;b=(b-c)/2;return mean$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,0).sort((d,e)=>d===e?0:d<e?-1:1).slice(b,b+c))}
+function mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,c):Object.assign({},a||{},b||{})}function mergeAll$$module$node_modules$rambda$dist$rambda_mjs(a){let b={};map$$module$node_modules$rambda$dist$rambda_mjs(c=>{b=mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,c)},a);return b}
+function mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=clone$$module$node_modules$rambda$dist$rambda_mjs(a);Object.keys(b).forEach(d=>{"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(b[d])?"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?c[d]=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a[d],b[d]):c[d]=b[d]:c[d]=b[d]});return c}
+function mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,c):mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,a)}function mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d={};Object.keys(b).forEach(e=>{d[e]=void 0===c[e]?b[e]:a(b[e],c[e])});Object.keys(c).forEach(e=>{void 0===d[e]&&(d[e]=void 0===b[e]?c[e]:a(b[e],c[e]))});return d}
+const mergeWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs);function min$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>min$$module$node_modules$rambda$dist$rambda_mjs(a,c):b<a?b:a}function minByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)<a(b)?c:b}const minBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(minByFn$$module$node_modules$rambda$dist$rambda_mjs);
+function ownKeys$$module$node_modules$rambda$dist$rambda_mjs(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(e){return Object.getOwnPropertyDescriptor(a,e).enumerable}));c.push.apply(c,d)}return c}
+function _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(a){for(var b=1;b<arguments.length;b++){var c=null!=arguments[b]?arguments[b]:{};b%2?ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c),!0).forEach(function(d){_defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,d,c[d])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(c)):ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c)).forEach(function(d){Object.defineProperty(a,
+d,Object.getOwnPropertyDescriptor(c,d))})}return a}function _defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c;return a}function isIterable$$module$node_modules$rambda$dist$rambda_mjs(a){return Array.isArray(a)||"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a)}
+function modifyFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return isIterable$$module$node_modules$rambda$dist$rambda_mjs(c)&&void 0!==c[a]?isArray$$module$node_modules$rambda$dist$rambda_mjs(c)?updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b(c[a]),c):_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a]:b(c[a])}):c}const modify$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyFn$$module$node_modules$rambda$dist$rambda_mjs);
+function modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){a=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);if(1===a.length)return _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a[0]]:b(c[a[0]])});if(void 0===path$$module$node_modules$rambda$dist$rambda_mjs(a,c))return c;b=modifyPath$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,1),b,c[a[0]]);return b===c[a[0]]?c:assoc$$module$node_modules$rambda$dist$rambda_mjs(a[0],
+b,c)}const modifyPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs);function modulo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>modulo$$module$node_modules$rambda$dist$rambda_mjs(a,c):a%b}
+function moveFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(0>a||0>b)throw Error("Rambda.move does not support negative indexes");if(a>c.length-1||b>c.length-1)return c;const d=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);d[a]=c[b];d[b]=c[a];return d}const move$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(moveFn$$module$node_modules$rambda$dist$rambda_mjs);
+function multiply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>multiply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a*b}function negate$$module$node_modules$rambda$dist$rambda_mjs(a){return-a}function none$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>none$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(a(b[c]))return!1;return!0}
+function not$$module$node_modules$rambda$dist$rambda_mjs(a){return!a}function objOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>objOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):{[a]:b}}function of$$module$node_modules$rambda$dist$rambda_mjs(a){return[a]}
+function omit$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>omit$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(null!==b&&void 0!==b){var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={};for(const e in b)c.includes(e)||(d[e]=b[e]);return d}}
+function on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,d){return 3===arguments.length?e=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,e):2===arguments.length?(e,f)=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,e,f):a(b(c),b(d))}function onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b){let c;return function(){a&&(c=a.apply(b||this,arguments),a=null);return c}}
+function once$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length){const c=onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b);return curry$$module$node_modules$rambda$dist$rambda_mjs(c)}return onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function or$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>or$$module$node_modules$rambda$dist$rambda_mjs(a,c):a||b}const Identity$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(a))});
+function overFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(d=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(d)))(c).x}const over$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(overFn$$module$node_modules$rambda$dist$rambda_mjs);
+function partial$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=a.length;return(...d)=>b.length+d.length>=c?a(...b,...d):partial$$module$node_modules$rambda$dist$rambda_mjs(a,...[...b,...d])}function partialObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return c=>a(mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(c,b))}
+function partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={},d={};Object.entries(b).forEach(([e,f])=>{a(f,e)?c[e]=f:d[e]=f});return[c,d]}function partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){const d=[],e=[];let f=-1;for(;f++<b.length-1;)(c?a(b[f],f):a(b[f]))?d.push(b[f]):e.push(b[f]);return[d,e]}
+function partition$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>partition$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}
+function pathEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a,c),b)}const pathEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathEqFn$$module$node_modules$rambda$dist$rambda_mjs);
+function pathOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,path$$module$node_modules$rambda$dist$rambda_mjs(b,c))}const pathOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathOrFn$$module$node_modules$rambda$dist$rambda_mjs);
+function paths$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>paths$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.map(c=>path$$module$node_modules$rambda$dist$rambda_mjs(c,b))}
+function pick$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pick$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)c[e]in b&&(d[c[e]]=b[c[e]]),e++;return d}}
+function pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)d[c[e]]=c[e]in b?b[c[e]]:void 0,e++;return d}}
+function pluck$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>pluck$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=[];map$$module$node_modules$rambda$dist$rambda_mjs(d=>{void 0!==d[a]&&c.push(d[a])},b);return c}function prepend$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>prepend$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof b?[a].concat(b.split("")):[a].concat(b)}
+const product$$module$node_modules$rambda$dist$rambda_mjs=reduce$$module$node_modules$rambda$dist$rambda_mjs(multiply$$module$node_modules$rambda$dist$rambda_mjs,1);function propEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?equals$$module$node_modules$rambda$dist$rambda_mjs(b,prop$$module$node_modules$rambda$dist$rambda_mjs(a,c)):!1}const propEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propEqFn$$module$node_modules$rambda$dist$rambda_mjs);
+function propIsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return is$$module$node_modules$rambda$dist$rambda_mjs(a,c[b])}const propIs$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propIsFn$$module$node_modules$rambda$dist$rambda_mjs);function propOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c[b]):a}const propOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propOrFn$$module$node_modules$rambda$dist$rambda_mjs);
+function props$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>props$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error("propsToPick is not a list");return mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>b[c],a)}function propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(prop$$module$node_modules$rambda$dist$rambda_mjs(b,c))}
+const propSatisfies$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs);
+function range$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>range$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(Number.isNaN(Number(a))||Number.isNaN(Number(b)))throw new TypeError("Both arguments to range must be numbers");if(b<a)return[];const c=b-a,d=Array(c);for(let e=0;e<c;e++)d[e]=a+e;return d}
+function reject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>reject$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!a(c),b)}function repeat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>repeat$$module$node_modules$rambda$dist$rambda_mjs(a,c):Array(b).fill(a)}function replaceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.replace(a,b)}
+const replace$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(replaceFn$$module$node_modules$rambda$dist$rambda_mjs);function reverse$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.split("").reverse().join(""):a.slice().reverse()}function setFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return over$$module$node_modules$rambda$dist$rambda_mjs(a,always$$module$node_modules$rambda$dist$rambda_mjs(b),c)}
+const set$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(setFn$$module$node_modules$rambda$dist$rambda_mjs);function sliceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.slice(a,b)}const slice$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(sliceFn$$module$node_modules$rambda$dist$rambda_mjs);
+function sort$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sort$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort(a)}function sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort((c,d)=>{c=a(c);d=a(d);return c===d?0:c<d?-1:1})}
+function split$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>split$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.split(a)}function maybe$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b=a&&"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(b)?b():b;c=a||"Function"!==type$$module$node_modules$rambda$dist$rambda_mjs(c)?c:c();return a?b:c}
+function take$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>take$$module$node_modules$rambda$dist$rambda_mjs(a,c):0>a?b.slice():"string"===typeof b?b.slice(0,a):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,0,a)}
+function splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!b)throw new TypeError(`Cannot read property 'slice' of ${b}`);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b)&&"string"!==typeof b)return[[],[]];const c=maybe$$module$node_modules$rambda$dist$rambda_mjs(0>a,0>b.length+a?0:b.length+a,a);return[take$$module$node_modules$rambda$dist$rambda_mjs(c,b),drop$$module$node_modules$rambda$dist$rambda_mjs(c,
+b)]}function splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(1>a)throw Error("First argument to splitEvery must be a positive integer");const c=[];let d=0;for(;d<b.length;)c.push(b.slice(d,d+=a));return c}
+function splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(!b)throw new TypeError(`Cannot read property 'length' of ${b}`);const c=[],d=[];let e=!1,f=-1;for(;f++<b.length-1;)e?d.push(b[f]):a(b[f])?(d.push(b[f]),e=!0):c.push(b[f]);return[c,d]}
+function startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.startsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;let c=!0;return a.filter((d,e)=>{if(!c)return!1;(d=equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]))||(c=!1);return d}).length===a.length}
+function subtract$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>subtract$$module$node_modules$rambda$dist$rambda_mjs(a,c):a-b}
+function symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,c):concat$$module$node_modules$rambda$dist$rambda_mjs(filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b),a),filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b))}
+function T$$module$node_modules$rambda$dist$rambda_mjs(){return!0}function tail$$module$node_modules$rambda$dist$rambda_mjs(a){return drop$$module$node_modules$rambda$dist$rambda_mjs(1,a)}
+function takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;if(0>a)return b.slice();let d=a>c?c:a;return"string"===typeof b?b.slice(c-d):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,c-d,c)}
+function takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(0===b.length)return b;let c=!1;const d=[];let e=b.length;for(;!c||0===e;)e--,!1===a(b[e])?c=!0:c||d.push(b[e]);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?d.reverse():d.reverse().join("")}
+function takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!0;const e=[];let f=-1;for(;f++<b.length-1;)a(b[f])?d&&e.push(b[f]):d&&(d=!1);return c?e:e.join("")}
+function tap$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>tap$$module$node_modules$rambda$dist$rambda_mjs(a,c);a(b);return b}function test$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>test$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof a)throw new TypeError(`\u2018test\u2019 requires a value of type RegExp as its first argument; received "${a}"`);return-1!==b.search(a)}
+function times$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>times$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||0>b)throw new RangeError("n must be an integer");return map$$module$node_modules$rambda$dist$rambda_mjs(a,range$$module$node_modules$rambda$dist$rambda_mjs(0,b))}function toLower$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toLowerCase()}
+function toPairs$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.entries(a)}function toString$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toString()}function toUpper$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toUpperCase()}function transpose$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>{c.forEach((d,e)=>isArray$$module$node_modules$rambda$dist$rambda_mjs(b[e])?b[e].push(d):b.push([d]));return b},[])}
+function trim$$module$node_modules$rambda$dist$rambda_mjs(a){return a.trim()}const isFunction$$module$node_modules$rambda$dist$rambda_mjs=a=>["Promise","Function"].includes(type$$module$node_modules$rambda$dist$rambda_mjs(a));
+function tryCatch$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isFunction$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`R.tryCatch | fn '${a}'`);const c=isFunction$$module$node_modules$rambda$dist$rambda_mjs(b);return(...d)=>{try{return a(...d)}catch(e){return c?b(e,...d):b}}}function unapply$$module$node_modules$rambda$dist$rambda_mjs(a){return function(...b){return a.call(this,b)}}
+function union$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>union$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(a);b.forEach(d=>{includes$$module$node_modules$rambda$dist$rambda_mjs(d,a)||c.push(d)});return c}
+function uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=new Set;return b.filter(d=>{if(c.has(a(d)))return!1;c.add(a(d));return!0})}function includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=!1,e=-1;for(;++e<c.length&&!d;)a(b,c[e])&&(d=!0);return d}
+function uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=-1;const d=[];for(;++c<b.length;){const e=b[c];includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,e,d)||d.push(e)}return d}function unless$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unless$$module$node_modules$rambda$dist$rambda_mjs(a,c):c=>a(c)?c:b(c)}
+function unwind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unwind$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b[a])?mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},b),{},{[a]:c}),b[a]):[b]}
+function values$$module$node_modules$rambda$dist$rambda_mjs(a){return"Object"!==type$$module$node_modules$rambda$dist$rambda_mjs(a)?[]:Object.values(a)}const Const$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Const$$module$node_modules$rambda$dist$rambda_mjs(a)});function view$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>view$$module$node_modules$rambda$dist$rambda_mjs(a,c):a(Const$$module$node_modules$rambda$dist$rambda_mjs)(b).x}
+function whenFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)?b(c):c}const when$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(whenFn$$module$node_modules$rambda$dist$rambda_mjs);function where$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return d=>where$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=!0;for(const d in a){if(!c)continue;const e=a[d](b[d]);c&&!1===e&&(c=!1)}return c}
+function whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return c=>whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(const c in a)if(a[c](b[c]))return!0;return!1}
+function whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=filter$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]),a);return Object.keys(c).length===Object.keys(a).length}
+function without$$module$node_modules$rambda$dist$rambda_mjs(a,b){return void 0===b?c=>without$$module$node_modules$rambda$dist$rambda_mjs(a,c):reduce$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,a)?c:c.concat(d),[],b)}function xor$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>xor$$module$node_modules$rambda$dist$rambda_mjs(a,c):!!a&&!b||!!b&&!a}
+function zip$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>zip$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=[],d=Math.min(a.length,b.length);for(let e=0;e<d;e++)c[e]=[a[e],b[e]];return c}function zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,c):take$$module$node_modules$rambda$dist$rambda_mjs(b.length,a).reduce((c,d,e)=>{c[d]=b[e];return c},{})}
+function zipWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return take$$module$node_modules$rambda$dist$rambda_mjs(b.length>c.length?c.length:b.length,b).map((d,e)=>a(d,c[e]))}const zipWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(zipWithFn$$module$node_modules$rambda$dist$rambda_mjs);var module$node_modules$rambda$dist$rambda_mjs={};module$node_modules$rambda$dist$rambda_mjs.F=F$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.T=T$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.__findHighestArity=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._arity=_arity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._indexOf=_indexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._lastIndexOf=_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs._pipe=_pipe$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.add=add$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.adjust=adjust$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.all=all$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.allPass=allPass$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.always=always$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.and=and$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.any=any$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.anyPass=anyPass$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.append=append$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.apply=apply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.applySpec=applySpec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assoc=assoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assocPath=assocPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.bind=bind$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.both=both$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.chain=chain$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clamp=clamp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clone=clone$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.complement=complement$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.compose=compose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.concat=concat$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.cond=cond$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.converge=converge$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.count=count$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.countBy=countBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curry=curry$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curryN=curryN$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dec=dec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.defaultTo=defaultTo$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.difference=difference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dissoc=dissoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.divide=divide$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.drop=drop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropLast=dropLast$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.dropLastWhile=dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeats=dropRepeats$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeatsWith=dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropWhile=dropWhile$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.either=either$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.endsWith=endsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.eqProps=eqProps$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.equals=equals$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolve=evolve$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.evolveArray=evolveArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolveObject=evolveObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filter=filter$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterArray=filterArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterObject=filterObject$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.find=find$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findIndex=findIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLast=findLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLastIndex=findLastIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.flatten=flatten$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.flip=flip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.forEach=forEach$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.fromPairs=fromPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupBy=groupBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupWith=groupWith$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.has=has$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.hasPath=hasPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.head=head$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identical=identical$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identity=identity$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.ifElse=ifElse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.inc=inc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.includes=includes$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexBy=indexBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexOf=indexOf$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.init=init$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersection=intersection$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersperse=intersperse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.is=is$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.isEmpty=isEmpty$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.isNil=isNil$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.join=join$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.juxt=juxt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.keys=keys$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.last=last$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.lastIndexOf=lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.length=length$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lens=lens$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensIndex=lensIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensPath=lensPath$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.lensProp=lensProp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.map=map$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapArray=mapArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObjIndexed=mapObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObject=mapObject$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.match=match$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mathMod=mathMod$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.max=max$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxBy=maxBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxByFn=maxByFn$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.mean=mean$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.median=median$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.merge=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeAll=mergeAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeDeepRight=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.mergeLeft=mergeLeft$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeRight=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeWith=mergeWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.min=min$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.minBy=minBy$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.minByFn=minByFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modify=modify$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPath=modifyPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPathFn=modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modulo=modulo$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.move=move$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.multiply=multiply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.negate=negate$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.none=none$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.not=not$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.nth=nth$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.objOf=objOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.of=of$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.omit=omit$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.on=on$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.once=once$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.or=or$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.over=over$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partial=partial$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partialObject=partialObject$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.partition=partition$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionArray=partitionArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionObject=partitionObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.path=path$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pathEq=pathEq$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.pathOr=pathOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.paths=paths$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pick=pick$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pickAll=pickAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pipe=pipe$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.pluck=pluck$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prepend=prepend$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.product=product$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prop=prop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propEq=propEq$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.propIs=propIs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propOr=propOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propSatisfies=propSatisfies$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.props=props$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.range=range$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.reduce=reduce$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceFn=reduceFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceStopper=reduceStopper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reject=reject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.repeat=repeat$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.replace=replace$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reverse=reverse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.set=set$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.slice=slice$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sort=sort$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.sortBy=sortBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.split=split$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitAt=splitAt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitEvery=splitEvery$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitWhen=splitWhen$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.startsWith=startsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.subtract=subtract$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sum=sum$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.symmetricDifference=symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tail=tail$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.take=take$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLast=takeLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLastWhile=takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeWhile=takeWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tap=tap$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.test=test$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.times=times$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toLower=toLower$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toPairs=toPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toString=toString$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.toUpper=toUpper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.transpose=transpose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.trim=trim$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tryCatch=tryCatch$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.type=type$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.unapply=unapply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.union=union$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniq=uniq$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqBy=uniqBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqWith=uniqWith$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.unless=unless$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.unwind=unwind$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.update=update$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.updateFn=updateFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.values=values$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.view=view$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.when=when$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.where=where$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereAny=whereAny$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereEq=whereEq$$module$node_modules$rambda$dist$rambda_mjs;
+module$node_modules$rambda$dist$rambda_mjs.without=without$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.xor=xor$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zip=zip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipObj=zipObj$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipWith=zipWith$$module$node_modules$rambda$dist$rambda_mjs;const csoundSetMidiCallbacks$$module$src$modules$rtmidi=a=>b=>{a.exports.csoundSetMidiCallbacks(b)},csoundGetMIDIDevList$$module$src$modules$rtmidi=a=>(b,c)=>{const {buffer:d}=a.wasi.memory,e=a.exports.csoundGetMIDIDevList(b,void 0,c?1:0);if(0===e)return[];const f=sizeofStruct$$module$src$utils$native_sizes(CS_MIDIDEVICE$$module$src$structures),g=a.exports.allocCsMidiDeviceStruct(e);a.exports.csoundGetMIDIDevList(b,g,c?1:0);const h=new Uint8Array(d,g,f*e);b=range$$module$node_modules$rambda$dist$rambda_mjs(0,
+e).map(k=>structBufferToObject$$module$src$utils$structure_buffer_to_object(CS_MIDIDEVICE$$module$src$structures,h.subarray(k*f,f)));a.exports.freeCsMidiDeviceStruct(g);return b};csoundGetMIDIDevList$$module$src$modules$rtmidi.toString=()=>"getMIDIDevList = async (isOutput) => Object;";
+const csoundGetRtMidiName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getRtMidiName(b);c=new Uint8Array(c,b,128);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetRtMidiName$$module$src$modules$rtmidi.toString=()=>"getRtMidiName = async () => String;";
+const csoundGetMidiOutFileName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getMidiOutFileName(b);c=new Uint8Array(c,b,128);b&&0<b.length&&freeStringPtr$$module$src$utils$string_pointers(a,b);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""},_isRequestingRtMidiInput$$module$src$modules$rtmidi=a=>b=>a.exports.isRequestingRtMidiInput(b),csoundPushMidiMessage$$module$src$modules$rtmidi=a=>(b,c,d,e)=>{a.exports.pushMidiMessage(b,
+c,d,e)};csoundPushMidiMessage$$module$src$modules$rtmidi.toString=()=>"midiMessage = async (status, data1, data2) => undefined;";var module$src$modules$rtmidi={};module$src$modules$rtmidi._isRequestingRtMidiInput=_isRequestingRtMidiInput$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMIDIDevList=csoundGetMIDIDevList$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMidiOutFileName=csoundGetMidiOutFileName$$module$src$modules$rtmidi;
+module$src$modules$rtmidi.csoundGetRtMidiName=csoundGetRtMidiName$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundPushMidiMessage=csoundPushMidiMessage$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundSetMidiCallbacks=csoundSetMidiCallbacks$$module$src$modules$rtmidi;const csoundInputMessage$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessage(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessage$$module$src$modules$control_events.toString=()=>"inputMessage = async (scoreEvent) => Number;";
+const csoundInputMessageAsync$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessageAsync(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessageAsync$$module$src$modules$control_events.toString=()=>"inputMessageAsync = async (scoreEvent) => Number;";
+const csoundGetControlChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetControlChannelWasi(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundGetControlChannel$$module$src$modules$control_events.toString=()=>"getControlChannel = async (channelName) => Number;";
+const csoundSetControlChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);a.exports.csoundSetControlChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c)};csoundSetControlChannel$$module$src$modules$control_events.toString=()=>"setControlChannel = async (channelName, value) => void;";
+const csoundGetStringChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetStringChannelWasi(b,c);const d=ptr2string$$module$src$utils$string_pointers(a,b);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,b);return d};csoundGetStringChannel$$module$src$modules$control_events.toString=()=>"getStringChannel = async (channelName) => String;";
+const csoundSetStringChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);a.exports.csoundSetStringChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d)};csoundSetStringChannel$$module$src$modules$control_events.toString=()=>"setStringChannel = async (channelName, value) => void;";var module$src$modules$control_events={};
+module$src$modules$control_events.csoundGetControlChannel=csoundGetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundGetStringChannel=csoundGetStringChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessage=csoundInputMessage$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessageAsync=csoundInputMessageAsync$$module$src$modules$control_events;
+module$src$modules$control_events.csoundSetControlChannel=csoundSetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundSetStringChannel=csoundSetStringChannel$$module$src$modules$control_events;const csoundGetOutputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetOutputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetOutputName$$module$src$modules$general_io.toString=()=>"getOutputName = async () => String;";
+const csoundGetInputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetInputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetInputName$$module$src$modules$general_io.toString=()=>"getInputName = async (csound) => String;";var module$src$modules$general_io={};module$src$modules$general_io.csoundGetInputName=csoundGetInputName$$module$src$modules$general_io;
+module$src$modules$general_io.csoundGetOutputName=csoundGetOutputName$$module$src$modules$general_io;const csoundAppendEnv$$module$src$modules$extra=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);b=a.exports.csoundAppendEnv(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d);return b};csoundAppendEnv$$module$src$modules$extra.toString=()=>"appendEnv = async (csound, variable, value) => Number;";const csoundShouldDaemonize$$module$src$modules$extra=a=>b=>a.exports.csoundShouldDaemonize(b);
+var module$src$modules$extra={};module$src$modules$extra.csoundAppendEnv=csoundAppendEnv$$module$src$modules$extra;module$src$modules$extra.csoundShouldDaemonize=csoundShouldDaemonize$$module$src$modules$extra;const csoundIsScorePending$$module$src$modules$score_handling=a=>b=>a.exports.csoundIsScorePending(b);csoundIsScorePending$$module$src$modules$score_handling.toString=()=>"isScorePending = async () => Number;";const csoundSetScorePending$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScorePending(b,c);csoundSetScorePending$$module$src$modules$score_handling.toString=()=>"setScorePending = async (pending) => Number;";
+const csoundReadScore$$module$src$modules$score_handling=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundReadScore(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundReadScore$$module$src$modules$score_handling.toString=()=>"readScore = async (score) => Number;";const csoundGetScoreTime$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreTime(b);csoundGetScoreTime$$module$src$modules$score_handling.toString=()=>"getScoreTime = async () => Number;";
+const csoundGetScoreOffsetSeconds$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreOffsetSeconds(b);csoundGetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"getScoreOffsetSeconds = async () => Number;";const csoundSetScoreOffsetSeconds$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScoreOffsetSeconds(b,c);csoundSetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"setScoreOffsetSeconds = async () => Number;";
+const csoundRewindScore$$module$src$modules$score_handling=a=>b=>a.exports.csoundRewindScore(b);csoundRewindScore$$module$src$modules$score_handling.toString=()=>"rewindScore = async () => undefined;";var module$src$modules$score_handling={};module$src$modules$score_handling.csoundGetScoreOffsetSeconds=csoundGetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundGetScoreTime=csoundGetScoreTime$$module$src$modules$score_handling;
+module$src$modules$score_handling.csoundIsScorePending=csoundIsScorePending$$module$src$modules$score_handling;module$src$modules$score_handling.csoundReadScore=csoundReadScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundRewindScore=csoundRewindScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScoreOffsetSeconds=csoundSetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScorePending=csoundSetScorePending$$module$src$modules$score_handling;const csoundTableLength$$module$src$modules$table=a=>(b,c)=>a.exports.csoundTableLength(b,c);csoundTableLength$$module$src$modules$table.toString=()=>"tableLength = async (tableNum) => Number;";const csoundTableGet$$module$src$modules$table=a=>(b,c,d)=>a.exports.csoundTableGet(b,c,d);csoundTableGet$$module$src$modules$table.toString=()=>"tableGet = async (tableNum, tableIndex) => Number;";const csoundTableSet$$module$src$modules$table=a=>(b,c,d,e)=>a.exports.csoundTableSet(b,c,d,e);
+csoundTableSet$$module$src$modules$table.toString=()=>"tableSet = async (tableNum, tableIndex, value) => undefined;";const csoundTableCopyIn$$module$src$modules$table=a=>(b,c,d)=>{const e=a.exports.allocFloatArray(d.length);(new Float64Array(a.wasi.memory.buffer,e,d.length)).set(d);a.exports.csoundTableCopyIn(b,c,e);a.exports.freeFloatArrayMem(e)};csoundTableCopyIn$$module$src$modules$table.toString=()=>"tableCopyIn = async (tableNum, float64Array) => undefined;";
+const csoundTableCopyOut$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundTableLength(b,c);if(0<d){const e=a.exports.allocFloatArray(d);a.exports.csoundTableCopyOut(b,c,e);({buffer:b}=a.wasi.memory);d=new Float64Array(b,e,d);a.exports.freeFloatArrayMem(e);return Float64Array.from(d)}};csoundTableCopyOut$$module$src$modules$table.toString=()=>"tableCopyOut = async (tableNum) => ?Float64Array;";const csoundGetTable$$module$src$modules$table=csoundTableCopyOut$$module$src$modules$table;
+csoundTableCopyOut$$module$src$modules$table.toString=csoundTableCopyOut$$module$src$modules$table.toString;const csoundGetTableArgs$$module$src$modules$table=a=>(b,c)=>{const d=a.exports.allocFloatArray(1024);a.exports.csoundGetTableArgs(b,d,c);({buffer:b}=a.wasi.memory);b=new Float64Array(b,d,1024);a.exports.freeFloatArrayMem(d);return b};csoundGetTableArgs$$module$src$modules$table.toString=()=>"getTableArgs = async (tableNum) => ?Float64Array;";
+const csoundIsNamedGEN$$module$src$modules$table=a=>(b,c)=>a.exports.csoundIsNamedGEN(b,c);csoundIsNamedGEN$$module$src$modules$table.toString=()=>"isNamedGEN = async (tableNum) => number;";const csoundGetNamedGEN$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundIsNamedGEN(b,c);if(0<d){const e=a.exports.allocStringMem(d);a.exports.csoundGetNamedGEN(b,e,c,d);({buffer:b}=a.wasi.memory);d=new Uint8Array(b,e,d);return uint2String$$module$src$utils$text_encoders(d)}};
+csoundGetNamedGEN$$module$src$modules$table.toString=()=>"getNamedGEN = async (tableNum) => ?string;";var module$src$modules$table={};module$src$modules$table.csoundGetNamedGEN=csoundGetNamedGEN$$module$src$modules$table;module$src$modules$table.csoundGetTable=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundGetTableArgs=csoundGetTableArgs$$module$src$modules$table;module$src$modules$table.csoundIsNamedGEN=csoundIsNamedGEN$$module$src$modules$table;
+module$src$modules$table.csoundTableCopyIn=csoundTableCopyIn$$module$src$modules$table;module$src$modules$table.csoundTableCopyOut=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundTableGet=csoundTableGet$$module$src$modules$table;module$src$modules$table.csoundTableLength=csoundTableLength$$module$src$modules$table;module$src$modules$table.csoundTableSet=csoundTableSet$$module$src$modules$table;function writeFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.writeFile(c,b)}}writeFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";function appendFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.appendFile(c,b)}}appendFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";
+function readFile$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readFile(c)}readFile$$module$src$filesystem$worker_fs.toString=()=>"async (path) => ?Uint8Array";function unlink$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.unlink(c)}unlink$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";function readdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readdir(c)}readdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => string[]";
+function mkdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.mkdir(c)}mkdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";var module$src$filesystem$worker_fs={};module$src$filesystem$worker_fs.appendFile=appendFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.mkdir=mkdir$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readFile=readFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readdir=readdir$$module$src$filesystem$worker_fs;
+module$src$filesystem$worker_fs.unlink=unlink$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.writeFile=writeFile$$module$src$filesystem$worker_fs;const api$$module$src$libcsound={csoundCreate:csoundCreate$$module$src$modules$instantiation,csoundDestroy:csoundDestroy$$module$src$modules$instantiation,csoundGetAPIVersion:csoundGetAPIVersion$$module$src$modules$instantiation,csoundGetVersion:csoundGetVersion$$module$src$modules$instantiation,csoundInitialize:csoundInitialize$$module$src$modules$instantiation,csoundParseOrc:csoundParseOrc$$module$src$modules$performance,csoundCompileTree:csoundCompileTree$$module$src$modules$performance,csoundCompileOrc:csoundCompileOrc$$module$src$modules$performance,
+csoundEvalCode:csoundEvalCode$$module$src$modules$performance,csoundStart:csoundStart$$module$src$modules$performance,csoundCompileCsd:csoundCompileCsd$$module$src$modules$performance,csoundCompileCsdText:csoundCompileCsdText$$module$src$modules$performance,csoundPerform:csoundPerform$$module$src$modules$performance,csoundPerformKsmps:csoundPerformKsmps$$module$src$modules$performance,csoundPerformBuffer:csoundPerformBuffer$$module$src$modules$performance,csoundStop:csoundStop$$module$src$modules$performance,
+csoundCleanup:csoundCleanup$$module$src$modules$performance,csoundReset:csoundReset$$module$src$modules$performance,csoundGetSr:csoundGetSr$$module$src$modules$attributes,csoundGetKr:csoundGetKr$$module$src$modules$attributes,csoundGetKsmps:csoundGetKsmps$$module$src$modules$attributes,csoundGetNchnls:csoundGetNchnls$$module$src$modules$attributes,csoundGetNchnlsInput:csoundGetNchnlsInput$$module$src$modules$attributes,csoundGet0dBFS:csoundGet0dBFS$$module$src$modules$attributes,csoundGetA4:csoundGetA4$$module$src$modules$attributes,
+csoundGetCurrentTimeSamples:csoundGetCurrentTimeSamples$$module$src$modules$attributes,csoundGetSizeOfMYFLT:csoundGetSizeOfMYFLT$$module$src$modules$attributes,csoundSetOption:csoundSetOption$$module$src$modules$attributes,csoundSetParams:csoundSetParams$$module$src$modules$attributes,csoundGetParams:csoundGetParams$$module$src$modules$attributes,csoundGetDebug:csoundGetDebug$$module$src$modules$attributes,csoundSetDebug:csoundSetDebug$$module$src$modules$attributes,csoundGetInputBufferSize:csoundGetInputBufferSize$$module$src$modules$rtaudio,
+csoundGetOutputBufferSize:csoundGetOutputBufferSize$$module$src$modules$rtaudio,csoundGetInputBuffer:csoundGetInputBuffer$$module$src$modules$rtaudio,csoundGetOutputBuffer:csoundGetOutputBuffer$$module$src$modules$rtaudio,csoundGetSpin:csoundGetSpin$$module$src$modules$rtaudio,csoundGetSpout:csoundGetSpout$$module$src$modules$rtaudio,csoundGetMIDIDevList:csoundGetMIDIDevList$$module$src$modules$rtmidi,csoundSetMidiCallbacks:csoundSetMidiCallbacks$$module$src$modules$rtmidi,csoundGetRtMidiName:csoundGetRtMidiName$$module$src$modules$rtmidi,
+csoundGetMidiOutFileName:csoundGetMidiOutFileName$$module$src$modules$rtmidi,csoundPushMidiMessage:csoundPushMidiMessage$$module$src$modules$rtmidi,_isRequestingRtMidiInput:_isRequestingRtMidiInput$$module$src$modules$rtmidi,csoundInputMessage:csoundInputMessage$$module$src$modules$control_events,csoundInputMessageAsync:csoundInputMessageAsync$$module$src$modules$control_events,csoundGetControlChannel:csoundGetControlChannel$$module$src$modules$control_events,csoundSetControlChannel:csoundSetControlChannel$$module$src$modules$control_events,
+csoundGetStringChannel:csoundGetStringChannel$$module$src$modules$control_events,csoundSetStringChannel:csoundSetStringChannel$$module$src$modules$control_events,csoundGetInputName:csoundGetInputName$$module$src$modules$general_io,csoundGetOutputName:csoundGetOutputName$$module$src$modules$general_io,csoundAppendEnv:csoundAppendEnv$$module$src$modules$extra,csoundShouldDaemonize:csoundShouldDaemonize$$module$src$modules$extra,csoundIsScorePending:csoundIsScorePending$$module$src$modules$score_handling,
+csoundSetScorePending:csoundSetScorePending$$module$src$modules$score_handling,csoundReadScore:csoundReadScore$$module$src$modules$score_handling,csoundGetScoreTime:csoundGetScoreTime$$module$src$modules$score_handling,csoundGetScoreOffsetSeconds:csoundGetScoreOffsetSeconds$$module$src$modules$score_handling,csoundSetScoreOffsetSeconds:csoundSetScoreOffsetSeconds$$module$src$modules$score_handling,csoundRewindScore:csoundRewindScore$$module$src$modules$score_handling,csoundTableLength:csoundTableLength$$module$src$modules$table,
+csoundTableGet:csoundTableGet$$module$src$modules$table,csoundTableSet:csoundTableSet$$module$src$modules$table,csoundTableCopyIn:csoundTableCopyIn$$module$src$modules$table,csoundTableCopyOut:csoundTableCopyOut$$module$src$modules$table,csoundGetTable:csoundTableCopyOut$$module$src$modules$table,csoundGetTableArgs:csoundGetTableArgs$$module$src$modules$table,csoundIsNamedGEN:csoundIsNamedGEN$$module$src$modules$table,csoundGetNamedGEN:csoundGetNamedGEN$$module$src$modules$table,fs:module$src$filesystem$worker_fs};
+var $jscompDefaultExport$$module$src$libcsound=function(a){return mergeAll$$module$node_modules$rambda$dist$rambda_mjs([reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,api$$module$src$libcsound[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(dissoc$$module$node_modules$rambda$dist$rambda_mjs("fs")(api$$module$src$libcsound))),reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,
+api$$module$src$libcsound.fs[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(module$src$filesystem$worker_fs))])},module$src$libcsound={};module$src$libcsound.api=api$$module$src$libcsound;module$src$libcsound.default=$jscompDefaultExport$$module$src$libcsound;const appendBuffers$$module$src$utils=(a,b)=>{const c=new Uint8Array(a.byteLength+b.byteLength);c.set(new Uint8Array(a),0);c.set(new Uint8Array(b),a.byteLength);return c.buffer},nearestPowerOf2$$module$src$utils=a=>1<<31-Math.clz32(a),isIos$$module$src$utils=()=>/iPhone|iPad|iPod/.test(navigator.userAgent),isFirefox$$module$src$utils=()=>navigator.userAgent.toLowerCase().includes("firefox"),isSafari$$module$src$utils=()=>"string"===typeof navigator.vendor&&navigator.vendor.includes("Apple"),isSabSupported$$module$src$utils=
+()=>!isFirefox$$module$src$utils()&&window&&void 0!==window.Atomics&&void 0!==window.SharedArrayBuffer,areWorkletsSupported$$module$src$utils=()=>void 0!==AudioNode&&void 0!==AudioWorkletNode,WebkitAudioContext$$module$src$utils=()=>{if(void 0!==window.webkitAudioContext)return window.webkitAudioContext;if(void 0!==window.AudioContext)return window.AudioContext},isScriptProcessorNodeSupported$$module$src$utils=()=>{const a=WebkitAudioContext$$module$src$utils();return void 0!==a&&void 0!==a.prototype.createScriptProcessor},
+csoundApiRename$$module$src$utils=a=>{let b=a.replace(/^csound/i,"");"csoundPushMidiMessage"===a&&(b="midiMessage");return b.charAt(0).toLowerCase()+b.slice(1)},stopableStates$$module$src$utils=new Set(["realtimePerformanceStarted","realtimePerformancePaused","realtimePerformanceResumed","renderStarted"]),makeProxyCallback$$module$src$utils=(a,b,c,d)=>async(...e)=>{if(!d||!stopableStates$$module$src$utils.has(d)){const f={};0<Object.values(f).length&&await a.callUncloned("syncWorkerFs",[b,f])}return await a.callUncloned(c,
+[b,...e])},makeSingleThreadCallback$$module$src$utils=(a,b)=>async(...c)=>await b.apply({},[a,...c]),fetchPlugins$$module$src$utils=async a=>await Promise.all(a.map(async b=>(await fetch(b)).arrayBuffer()));var module$src$utils={};module$src$utils.WebkitAudioContext=WebkitAudioContext$$module$src$utils;module$src$utils.appendBuffers=appendBuffers$$module$src$utils;module$src$utils.areWorkletsSupported=areWorkletsSupported$$module$src$utils;module$src$utils.csoundApiRename=csoundApiRename$$module$src$utils;
+module$src$utils.fetchPlugins=fetchPlugins$$module$src$utils;module$src$utils.isIos=isIos$$module$src$utils;module$src$utils.isSabSupported=isSabSupported$$module$src$utils;module$src$utils.isSafari=isSafari$$module$src$utils;module$src$utils.isScriptProcessorNodeSupported=isScriptProcessorNodeSupported$$module$src$utils;module$src$utils.makeProxyCallback=makeProxyCallback$$module$src$utils;module$src$utils.makeSingleThreadCallback=makeSingleThreadCallback$$module$src$utils;
+module$src$utils.nearestPowerOf2=nearestPowerOf2$$module$src$utils;module$src$utils.stopableStates=stopableStates$$module$src$utils;const messageEventHandler$$module$src$mains$messages_main=a=>b=>{if(b.data.log)a&&a.publicEvents&&a.publicEvents.triggerMessage?a.publicEvents.triggerMessage(b.data.log):console.log("object"===typeof b.data.log&&"string"===typeof b.data.log.log?b.data.log.log:b.data.log);else if(b.data.playStateChange&&a&&a.onPlayStateChange)a.onPlayStateChange(b.data.playStateChange)},iterableMessageChannel$$module$src$mains$messages_main=()=>{const {port1:a,port2:b}=new MessageChannel;return[a,b]},safelyClosePorts$$module$src$mains$messages_main=
+([a,b])=>{if(void 0!==a.close)try{a.close()}catch(c){}if(void 0!==b.close)try{b.close()}catch(c){}};
+class IPCMessagePorts$$module$src$mains$messages_main{constructor(){const {port1:a,port2:b}=new MessageChannel;this.mainMessagePort=a;this.workerMessagePort=b;const {port1:c,port2:d}=new MessageChannel;this.mainMessagePortAudio=c;this.workerMessagePortAudio=d;const {port1:e,port2:f}=new MessageChannel;this.csoundWorkerFrameRequestPort=e;this.audioWorkerFrameRequestPort=f;const {port1:g,port2:h}=new MessageChannel;this.csoundWorkerAudioInputPort=g;this.audioWorkerAudioInputPort=h;const {port1:k,port2:n}=
+new MessageChannel;this.csoundWorkerRtMidiPort=k;this.csoundMainRtMidiPort=n;const {port1:m,port2:l}=new MessageChannel;this.sabWorkerCallbackReply=m;this.sabMainCallbackReply=l;const {port1:p,port2:q}=new MessageChannel;this.mainMessagePort2=p;this.workerMessagePort2=q;this.restartAudioWorkerPorts=this.restartAudioWorkerPorts.bind(this)}restartAudioWorkerPorts(){safelyClosePorts$$module$src$mains$messages_main([this.csoundWorkerAudioInputPort,this.audioWorkerAudioInputPort]);[this.csoundWorkerAudioInputPort,
+this.audioWorkerAudioInputPort]=iterableMessageChannel$$module$src$mains$messages_main();safelyClosePorts$$module$src$mains$messages_main([this.mainMessagePortAudio,this.workerMessagePortAudio]);[this.mainMessagePortAudio,this.workerMessagePortAudio]=iterableMessageChannel$$module$src$mains$messages_main();safelyClosePorts$$module$src$mains$messages_main([this.csoundWorkerFrameRequestPort,this.audioWorkerFrameRequestPort]);[this.csoundWorkerFrameRequestPort,this.audioWorkerFrameRequestPort]=iterableMessageChannel$$module$src$mains$messages_main();
+safelyClosePorts$$module$src$mains$messages_main([this.mainMessagePort2,this.workerMessagePort2]);[this.mainMessagePort2,this.workerMessagePort2]=iterableMessageChannel$$module$src$mains$messages_main()}}var module$src$mains$messages_main={};module$src$mains$messages_main.IPCMessagePorts=IPCMessagePorts$$module$src$mains$messages_main;module$src$mains$messages_main.messageEventHandler=messageEventHandler$$module$src$mains$messages_main;function clearArray$$module$src$utils$clear_array(a){for(;0<a.length;)a.pop()}var module$src$utils$clear_array={};module$src$utils$clear_array.clearArray=clearArray$$module$src$utils$clear_array;class EventPromises$$module$src$utils$event_promises{constructor(){this.timeoutTimers=[];this.resumeResolver=this.resumePromise=this.pauseResolver=this.pausePromise=this.stopResolver=this.stopPromise=this.startResolver=this.startPromise=void 0;this.createStartPromise=this.createStartPromise.bind(this);this.releaseStartPromise=this.releaseStartPromise.bind(this);this.createStopPromise=this.createStopPromise.bind(this);this.releaseStopPromise=this.releaseStopPromise.bind(this);this.createPausePromise=
+this.createPausePromise.bind(this);this.releasePausePromise=this.releasePausePromise.bind(this);this.createResumePromise=this.createResumePromise.bind(this);this.releaseResumePromise=this.releaseResumePromise.bind(this);this.waitForStart=this.waitForStart.bind(this);this.waitForStop=this.waitForStop.bind(this);this.isWaitingToStart=this.isWaitingToStart.bind(this);this.isWaitingToStop=this.isWaitingToStop.bind(this)}isWaitingToStart(){return void 0!==this.startPromise}isWaitingToStop(){return void 0!==
+this.stopPromise}isWaiting(a){return void 0!==this.startPromise?(console.error(`cannot ${a} while starting, did you forget to 'await'?`),!0):void 0!==this.stopPromise?(console.error(`cannot ${a} while stopping, did you forget to 'await'?`),!0):void 0!==this.pausePromise?(console.error(`cannot ${a} while pausing, did you forget to 'await'?`),!0):void 0!==this.resumePromise?(console.error(`cannot ${a} while resuming, did you forget to 'await'?`),!0):!1}async waitForStart(){return this.startPromise?
+await this.startPromise:-1}async waitForStop(){let a;return null!=(a=this.stopPromise)?a:-1}async waitForPause(){let a;return null!=(a=this.pausePromise)?a:-1}async waitForResume(){let a;return null!=(a=this.resumePromise)?a:-1}createStartPromise(){this.startPromise||(this.startPromise=new Promise(a=>{this.startResolver=a;const b=setTimeout(()=>{this.timeoutTimers=reject$$module$node_modules$rambda$dist$rambda_mjs(equals$$module$node_modules$rambda$dist$rambda_mjs(b),this.timeoutTimers);this.startPromise&&
+(console.warn("start promise timed out"),this.startResolver(),delete this.startResolver,this.startPromise&&delete this.startPromise)},2E3);this.timeoutTimers.push(b)}))}releaseStartPromise(){try{this.timeoutTimers.forEach(clearTimeout),clearArray$$module$src$utils$clear_array(this.timeoutTimers)}catch(a){console.error(a)}this.startResolver&&(this.startResolver(),delete this.startResolver);this.startPromise&&delete this.startPromise}createStopPromise(){this.stopPromise||(this.stopPromise=new Promise(a=>
+{this.stopResolver=a;const b=setTimeout(()=>{this.timeoutTimers=reject$$module$node_modules$rambda$dist$rambda_mjs(equals$$module$node_modules$rambda$dist$rambda_mjs(b),this.timeoutTimers);this.stopPromise&&(console.warn("stop promise timed out"),this.stopResolver(),delete this.stopResolver,this.stopPromise&&delete this.stopPromise)},2E3);this.timeoutTimers.push(b)}))}releaseStopPromise(){try{this.timeoutTimers.forEach(clearTimeout),clearArray$$module$src$utils$clear_array(this.timeoutTimers)}catch(a){console.error(a)}this.stopResolver&&
+(this.stopResolver(),delete this.stopResolver);this.stopPromise&&delete this.stopPromise}createPausePromise(){this.pausePromise||(this.pausePromise=new Promise(a=>{this.pauseResolver=a;const b=setTimeout(()=>{this.timeoutTimers=reject$$module$node_modules$rambda$dist$rambda_mjs(equals$$module$node_modules$rambda$dist$rambda_mjs(b),this.timeoutTimers);this.pausePromise&&(console.warn("pause promise timed out"),this.pauseResolver(),delete this.pauseResolver,this.pausePromise&&delete this.pausePromise)},
+2E3);this.timeoutTimers.push(b)}))}releasePausePromise(){try{this.timeoutTimers.forEach(clearTimeout),clearArray$$module$src$utils$clear_array(this.timeoutTimers)}catch(a){console.error(a)}this.pauseResolver&&(this.pauseResolver(),delete this.pauseResolver);this.pausePromise&&delete this.pausePromise}createResumePromise(){this.resumePromise||(this.resumePromise=new Promise(a=>{this.resumeResolver=a;const b=setTimeout(()=>{this.timeoutTimers=reject$$module$node_modules$rambda$dist$rambda_mjs(equals$$module$node_modules$rambda$dist$rambda_mjs(b),
+this.timeoutTimers);this.resumePromise&&(console.warn("resume promise timed out"),this.resumeResolver(),delete this.resumeResolver,this.resumePromise&&delete this.resumePromise)},2E3);this.timeoutTimers.push(b)}))}releaseResumePromise(){try{this.timeoutTimers.forEach(clearTimeout),clearArray$$module$src$utils$clear_array(this.timeoutTimers)}catch(a){console.error(a)}this.resumeResolver&&(this.resumeResolver(),delete this.resumeResolver);this.resumePromise&&delete this.resumePromise}}
+var module$src$utils$event_promises={};module$src$utils$event_promises.EventPromises=EventPromises$$module$src$utils$event_promises;var module$node_modules$eventemitter3$umd$eventemitter3_min={};
+module$node_modules$eventemitter3$umd$eventemitter3_min.default=function(){return function e(b,c,d){function f(k,n){if(!c[k]){if(!b[k]){var m="function"==typeof require&&require;if(!n&&m)return m(k,!0);if(g)return g(k,!0);n=Error("Cannot find module '"+k+"'");throw n.code="MODULE_NOT_FOUND",n;}n=c[k]={exports:{}};b[k][0].call(n.exports,function(l){return f(b[k][1][l]||l)},n,n.exports,e,b,c,d)}return c[k].exports}for(var g="function"==typeof require&&require,h=0;h<d.length;h++)f(d[h]);return f}({1:[function(b,
+c,d){function e(){}function f(l,p,q){this.fn=l;this.context=p;this.once=q||!1}function g(l,p,q,u,t){if("function"!=typeof q)throw new TypeError("The listener must be a function");q=new f(q,u||l,t);p=m?m+p:p;return l._events[p]?l._events[p].fn?l._events[p]=[l._events[p],q]:l._events[p].push(q):(l._events[p]=q,l._eventsCount++),l}function h(l,p){0==--l._eventsCount?l._events=new e:delete l._events[p]}function k(){this._events=new e;this._eventsCount=0}var n=Object.prototype.hasOwnProperty,m="~";Object.create&&
+(e.prototype=Object.create(null),(new e).__proto__||(m=!1));k.prototype.eventNames=function(){var l,p,q=[];if(0===this._eventsCount)return q;for(p in l=this._events)n.call(l,p)&&q.push(m?p.slice(1):p);return Object.getOwnPropertySymbols?q.concat(Object.getOwnPropertySymbols(l)):q};k.prototype.listeners=function(l){l=this._events[m?m+l:l];if(!l)return[];if(l.fn)return[l.fn];for(var p=0,q=l.length,u=Array(q);p<q;p++)u[p]=l[p].fn;return u};k.prototype.listenerCount=function(l){return(l=this._events[m?
+m+l:l])?l.fn?1:l.length:0};k.prototype.emit=function(l,p,q,u,t,x){var r=m?m+l:l;if(!this._events[r])return!1;var y;r=this._events[r];var v=arguments.length;if(r.fn){switch(r.once&&this.removeListener(l,r.fn,void 0,!0),v){case 1:return r.fn.call(r.context),!0;case 2:return r.fn.call(r.context,p),!0;case 3:return r.fn.call(r.context,p,q),!0;case 4:return r.fn.call(r.context,p,q,u),!0;case 5:return r.fn.call(r.context,p,q,u,t),!0;case 6:return r.fn.call(r.context,p,q,u,t,x),!0}w=1;for(y=Array(v-1);w<
+v;w++)y[w-1]=arguments[w];r.fn.apply(r.context,y)}else for(var z,B=r.length,w=0;w<B;w++)switch(r[w].once&&this.removeListener(l,r[w].fn,void 0,!0),v){case 1:r[w].fn.call(r[w].context);break;case 2:r[w].fn.call(r[w].context,p);break;case 3:r[w].fn.call(r[w].context,p,q);break;case 4:r[w].fn.call(r[w].context,p,q,u);break;default:if(!y)for(z=1,y=Array(v-1);z<v;z++)y[z-1]=arguments[z];r[w].fn.apply(r[w].context,y)}return!0};k.prototype.on=function(l,p,q){return g(this,l,p,q,!1)};k.prototype.once=function(l,
+p,q){return g(this,l,p,q,!0)};k.prototype.removeListener=function(l,p,q,u){l=m?m+l:l;if(!this._events[l])return this;if(!p)return h(this,l),this;var t=this._events[l];if(t.fn)t.fn!==p||u&&!t.once||q&&t.context!==q||h(this,l);else{for(var x=0,r=[],y=t.length;x<y;x++)(t[x].fn!==p||u&&!t[x].once||q&&t[x].context!==q)&&r.push(t[x]);r.length?this._events[l]=1===r.length?r[0]:r:h(this,l)}return this};k.prototype.removeAllListeners=function(l){var p;return l?(p=m?m+l:l,this._events[p]&&h(this,p)):(this._events=
+new e,this._eventsCount=0),this};k.prototype.off=k.prototype.removeListener;k.prototype.addListener=k.prototype.on;k.prefixed=m;k.EventEmitter=k;void 0!==c&&(c.exports=k)},{}]},{},[1])(1)}();class PublicEventAPI$$module$src$events{constructor(a){this.parent=a;this.eventEmitter=new module$node_modules$eventemitter3$umd$eventemitter3_min.default;this.currentDerivedPlayState=void 0;this.decorateAPI=this.decorateAPI.bind(this);this.triggerRealtimePerformanceStarted=this.triggerRealtimePerformanceStarted.bind(this);this.triggerRealtimePerformancePaused=this.triggerRealtimePerformancePaused.bind(this);this.triggerRealtimePerformanceResumed=this.triggerRealtimePerformanceResumed.bind(this);
+this.triggerRealtimePerformanceEnded=this.triggerRealtimePerformanceEnded.bind(this);this.triggerRenderStarted=this.triggerRenderStarted.bind(this);this.triggerRenderEnded=this.triggerRenderEnded.bind(this);this.triggerOnAudioNodeCreated=this.triggerOnAudioNodeCreated.bind(this);this.terminateInstance=this.terminateInstance.bind(this)}terminateInstance(){this.eventEmitter.removeAllListeners("play pause stop realtimePerformanceStarted realtimePerformancePaused realtimePerformanceResumed realtimePerformanceEnded renderStarted renderEnded onAudioNodeCreated message".split(" "));
+Object.keys(this).forEach(a=>delete this[a])}triggerRealtimePerformanceStarted(){this.eventEmitter.emit("realtimePerformanceStarted");"play"!==this.currentDerivedPlayState&&(this.eventEmitter.emit("play"),this.currentDerivedPlayState="play")}triggerRealtimePerformancePaused(){this.eventEmitter.emit("realtimePerformancePaused");"pause"!==this.currentDerivedPlayState&&(this.eventEmitter.emit("pause"),this.currentDerivedPlayState="pause")}triggerRealtimePerformanceResumed(){this.eventEmitter.emit("realtimePerformanceResumed");
+"play"!==this.currentDerivedPlayState&&(this.eventEmitter.emit("play"),this.currentDerivedPlayState="play")}triggerRealtimePerformanceEnded(){this.eventEmitter.emit("realtimePerformanceEnded");"stop"!==this.currentDerivedPlayState&&(this.eventEmitter.emit("stop"),this.currentDerivedPlayState="stop")}triggerRenderStarted(){this.eventEmitter.emit("renderStarted");"stop"!==this.currentDerivedPlayState&&(this.eventEmitter.emit("stop"),this.currentDerivedPlayState="stop")}triggerRenderEnded(){this.eventEmitter.emit("renderEnded");
+"stop"!==this.currentDerivedPlayState&&(this.eventEmitter.emit("stop"),this.currentDerivedPlayState="stop")}triggerOnAudioNodeCreated(a){this.eventEmitter.emit("onAudioNodeCreated",a)}triggerMessage({log:a}){this.eventEmitter.emit("message",a)}decorateAPI(a){a.eventNames=this.eventEmitter.eventNames.bind(this.eventEmitter);a.listenerCount=this.eventEmitter.listenerCount.bind(this.eventEmitter);a.listeners=this.eventEmitter.listeners.bind(this.eventEmitter);a.off=this.eventEmitter.off.bind(this.eventEmitter);
+a.on=this.eventEmitter.on.bind(this.eventEmitter);a.addListener=this.eventEmitter.on.bind(this.eventEmitter);a.once=this.eventEmitter.once.bind(this.eventEmitter);a.removeAllListeners=this.eventEmitter.removeAllListeners.bind(this.eventEmitter);a.removeListener=this.eventEmitter.removeListener.bind(this.eventEmitter);return a}}var module$src$events={};module$src$events.PublicEventAPI=PublicEventAPI$$module$src$events;var $jscompDefaultExport$$module$dist$__compiled_vanilla_worker_inline=()=>(window.URL||window.webkitURL).createObjectURL(new Blob(['(function(){/*\n\n Copyright The Closure Library Authors.\n SPDX-License-Identifier: Apache-2.0\n*/\nvar $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this||self;goog.exportPath_=function(a,b,c,d){a=a.split(".");d=d||goog.global;a[0]in d||"undefined"==typeof d.execScript||d.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)if(a.length||void 0===b)d=d[e]&&d[e]!==Object.prototype[e]?d[e]:d[e]={};else if(!c&&goog.isObject(b)&&goog.isObject(d[e]))for(var f in b)b.hasOwnProperty(f)&&(d[e][f]=b[f]);else d[e]=b};\ngoog.define=function(a,b){if(!COMPILED){var c=goog.global.CLOSURE_UNCOMPILED_DEFINES,d=goog.global.CLOSURE_DEFINES;c&&void 0===c.nodeType&&Object.prototype.hasOwnProperty.call(c,a)?b=c[a]:d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)&&(b=d[a])}return b};goog.FEATURESET_YEAR=2020;goog.DEBUG=!0;goog.LOCALE="en";goog.getLocale=function(){return goog.LOCALE};goog.TRUSTED_SITE=!0;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;\ngoog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error(\'Namespace "\'+a+\'" already declared.\');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b,c){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var d=a;(d=d.substring(0,d.lastIndexOf(".")))&&!goog.getObjectByName(d);)goog.implicitNamespaces_[d]=!0}goog.exportPath_(a,b,c)};goog.NONCE_PATTERN_=/^[\\w+/_-]+[=]{0,2}$/;\ngoog.getScriptNonce_=function(a){a=(a||goog.global).document;return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;\ngoog.module=function(a){if("string"!==typeof a||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You\'re likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");\ngoog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error(\'Namespace "\'+a+\'" already declared.\');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;\ngoog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG};goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1};\ngoog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0};\ngoog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error(\'Module with namespace "\'+a+\'" already exists.\');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error(\'Module with namespace "\'+\na+\'" has been loaded incorrectly.\');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){};COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&null!=goog.getObjectByName(a)},goog.implicitNamespaces_={"goog.module":!0});\ngoog.getObjectByName=function(a,b){a=a.split(".");b=b||goog.global;for(var c=0;c<a.length;c++)if(b=b[a[c]],null==b)return null;return b};goog.addDependency=function(a,b,c,d){!COMPILED&&goog.DEPENDENCIES_ENABLED&&goog.debugLoader_.addDependency(a,b,c,d)};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};\ngoog.require=function(a){if(!COMPILED){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_.requested(a);if(goog.isProvided_(a)){if(goog.isInModuleLoader_())return goog.module.getInternal_(a)}else if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{goog.debugLoader_.load_(a)}finally{goog.moduleLoaderState_=b}}return null}};goog.requireType=function(a){return{}};goog.basePath="";goog.abstractMethod=function(){throw Error("unimplemented abstract method");};\ngoog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";goog.ASSUME_ES_MODULES_TRANSPILED=!1;goog.TRUSTED_TYPES_POLICY_NAME="goog";\ngoog.hasBadLetScoping=null;\ngoog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:"",declareLegacyNamespace:!1,type:goog.ModuleType.GOOG};var c={},d=c;if("function"===typeof a)d=a.call(void 0,d);else if("string"===typeof a)d=goog.loadModuleFromSource_.call(void 0,d,a);else throw Error("Invalid module definition");var e=goog.moduleLoaderState_.moduleName;if("string"===typeof e&&e)goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(e,d,c!==d):goog.SEAL_MODULE_EXPORTS&&\nObject.seal&&"object"==typeof d&&null!=d&&Object.seal(d),goog.loadedModules_[e]={exports:d,type:goog.ModuleType.GOOG,moduleId:goog.moduleLoaderState_.moduleName};else throw Error(\'Invalid module name "\'+e+\'"\');}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a,b){eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(b));return a};goog.normalizePath_=function(a){a=a.split("/");for(var b=0;b<a.length;)"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++;return a.join("/")};\ngoog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC)return goog.global.CLOSURE_LOAD_FILE_SYNC(a);try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};goog.typeOf=function(a){var b=typeof a;return"object"!=b?b:a?Array.isArray(a)?"array":b:"null"};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};\ngoog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear};goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return Object.prototype.hasOwnProperty.call(a,goog.UID_PROPERTY_)&&a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return!!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute"in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};\ngoog.UID_PROPERTY_="closure_uid_"+(1E9*Math.random()>>>0);goog.uidCounter_=0;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};\ngoog.bindJs_=function(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var e=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(e,d);return a.apply(b,e)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};\ngoog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var d=c.slice();d.push.apply(d,arguments);return a.apply(this,d)}};goog.now=function(){return Date.now()};goog.globalEval=function(a){(0,eval)(a)};\ngoog.getCssName=function(a,b){if("."==String(a).charAt(0))throw Error(\'className passed in goog.getCssName must not start with ".". You passed: \'+a);var c=function(e){return goog.cssNameMapping_[e]||e},d=function(e){e=e.split("-");for(var f=[],g=0;g<e.length;g++)f.push(c(e[g]));return f.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(e){return e};a=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(a):a};\ngoog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.GetMsgOptions=function(){};\ngoog.getMsg=function(a,b,c){c&&c.html&&(a=a.replace(/</g,"&lt;"));c&&c.unescapeHtmlEntities&&(a=a.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&apos;/g,"\'").replace(/&quot;/g,\'"\').replace(/&amp;/g,"&"));b&&(a=a.replace(/\\{\\$([^}]+)}/g,function(d,e){return null!=b&&e in b?b[e]:d}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,!0,c)};goog.exportProperty=function(a,b,c){a[b]=c};\ngoog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(d,e,f){for(var g=Array(arguments.length-2),h=2;h<arguments.length;h++)g[h-2]=arguments[h];return b.prototype[e].apply(d,g)}};goog.scope=function(a){if(goog.isInModuleLoader_())throw Error("goog.scope is not supported within a module.");a.call(goog.global)};COMPILED||(goog.global.COMPILED=COMPILED);\ngoog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).");});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;\ngoog.defineClass.createSealingConstructor_=function(a,b){return goog.defineClass.SEAL_CLASS_INSTANCES?function(){var c=a.apply(this,arguments)||this;c[goog.UID_PROPERTY_]=c[goog.UID_PROPERTY_];return c}:a};goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");\ngoog.defineClass.applyProperties_=function(a,b){for(var c in b)Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c]);for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++)c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])};goog.identity_=function(a){return a};\ngoog.createTrustedTypesPolicy=function(a){var b=null,c=goog.global.trustedTypes;if(!c||!c.createPolicy)return b;try{b=c.createPolicy(a,{createHTML:goog.identity_,createScript:goog.identity_,createScriptURL:goog.identity_})}catch(d){goog.logToConsole_(d.message)}return b};\n!COMPILED&&goog.DEPENDENCIES_ENABLED&&(goog.isEdge_=function(){return!!(goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"").match(/Edge\\/(\\d+)(\\.\\d)*/i)},goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write"in a},goog.isDocumentLoading_=function(){var a=goog.global.document;return a.attachEvent?"complete"!=a.readyState:"loading"==a.readyState},goog.findBasePath_=function(){if(void 0!=goog.global.CLOSURE_BASE_PATH&&"string"===typeof goog.global.CLOSURE_BASE_PATH)goog.basePath=\ngoog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.slice(d-7,d)){goog.basePath=c.slice(0,d-7);break}}}},goog.findBasePath_(),goog.protectScriptTag_=function(a){return a.replace(/<\\/(SCRIPT)/ig,"\\\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_={};this.idToPath_={};this.written_={};this.loadingDeps_=\n[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory;this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){b=[];for(var e=0;e<a.length;e++){var f=this.getPathFromDeps_(a[e]);if(!f)throw Error("Unregonized namespace: "+a[e]);b.push(this.dependencies_[f])}f=goog.require;var g=0;for(e=0;e<a.length;e++)f(a[e]),b[e].onLoad(function(){++g==a.length&&c()})}else c()},\ngoog.DebugLoader_.prototype.loadClosureDeps=function(){this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath+"deps.js"),"deps.js",[],[],{}));this.loadDeps_()},goog.DebugLoader_.prototype.requested=function(a,b){(a=this.getPathFromDeps_(a))&&(b||this.areDepsLoaded_(this.dependencies_[a].requires))&&(b=this.deferredCallbacks_[a])&&(delete this.deferredCallbacks_[a],b())},goog.DebugLoader_.prototype.setDependencyFactory=function(a){this.factory_=a},goog.DebugLoader_.prototype.load_=\nfunction(a){if(this.getPathFromDeps_(a)){var b=this,c=[],d=function(e){var f=b.getPathFromDeps_(e);if(!f)throw Error("Bad dependency path or symbol: "+e);if(!b.written_[f]){b.written_[f]=!0;e=b.dependencies_[f];for(f=0;f<e.requires.length;f++)goog.isProvided_(e.requires[f])||d(e.requires[f]);c.push(e)}};d(a);a=!!this.depsToLoad_.length;this.depsToLoad_=this.depsToLoad_.concat(c);this.paused_||a||this.loadDeps_()}else goog.logToConsole_("goog.require could not find: "+a)},goog.DebugLoader_.prototype.loadDeps_=\nfunction(){for(var a=this,b=this.paused_;this.depsToLoad_.length&&!b;)(function(){var c=!1,d=a.depsToLoad_.shift(),e=!1;a.loading_(d);var f={pause:function(){if(c)throw Error("Cannot call pause after the call to load.");b=!0},resume:function(){c?a.resume_():b=!1},loaded:function(){if(e)throw Error("Double call to loaded.");e=!0;a.loaded_(d)},pending:function(){for(var g=[],h=0;h<a.loadingDeps_.length;h++)g.push(a.loadingDeps_[h]);return g},setModuleState:function(g){goog.moduleLoaderState_={type:g,\nmoduleName:"",declareLegacyNamespace:!1}},registerEs6ModuleExports:function(g,h,k){k&&(goog.loadedModules_[k]={exports:h,type:goog.ModuleType.ES6,moduleId:k||""})},registerGoogModuleExports:function(g,h){goog.loadedModules_[g]={exports:h,type:goog.ModuleType.GOOG,moduleId:g}},clearModuleState:function(){goog.moduleLoaderState_=null},defer:function(g){if(c)throw Error("Cannot register with defer after the call to load.");a.defer_(d,g)},areDepsLoaded:function(){return a.areDepsLoaded_(d.requires)}};\ntry{d.load(f)}finally{c=!0}})();b&&this.pause_()},goog.DebugLoader_.prototype.pause_=function(){this.paused_=!0},goog.DebugLoader_.prototype.resume_=function(){this.paused_&&(this.paused_=!1,this.loadDeps_())},goog.DebugLoader_.prototype.loading_=function(a){this.loadingDeps_.push(a)},goog.DebugLoader_.prototype.loaded_=function(a){for(var b=0;b<this.loadingDeps_.length;b++)if(this.loadingDeps_[b]==a){this.loadingDeps_.splice(b,1);break}for(b=0;b<this.deferredQueue_.length;b++)if(this.deferredQueue_[b]==\na.path){this.deferredQueue_.splice(b,1);break}if(this.loadingDeps_.length==this.deferredQueue_.length&&!this.depsToLoad_.length)for(;this.deferredQueue_.length;)this.requested(this.deferredQueue_.shift(),!0);a.loaded()},goog.DebugLoader_.prototype.areDepsLoaded_=function(a){for(var b=0;b<a.length;b++){var c=this.getPathFromDeps_(a[b]);if(!c||!(c in this.deferredCallbacks_||goog.isProvided_(a[b])))return!1}return!0},goog.DebugLoader_.prototype.getPathFromDeps_=function(a){return a in this.idToPath_?\nthis.idToPath_[a]:a in this.dependencies_?a:null},goog.DebugLoader_.prototype.defer_=function(a,b){this.deferredCallbacks_[a.path]=b;this.deferredQueue_.push(a.path)},goog.LoadController=function(){},goog.LoadController.prototype.pause=function(){},goog.LoadController.prototype.resume=function(){},goog.LoadController.prototype.loaded=function(){},goog.LoadController.prototype.pending=function(){},goog.LoadController.prototype.registerEs6ModuleExports=function(a,b,c){},goog.LoadController.prototype.setModuleState=\nfunction(a){},goog.LoadController.prototype.clearModuleState=function(){},goog.LoadController.prototype.defer=function(a){},goog.LoadController.prototype.areDepsLoaded=function(){},goog.Dependency=function(a,b,c,d,e){this.path=a;this.relativePath=b;this.provides=c;this.requires=d;this.loadFlags=e;this.loaded_=!1;this.loadCallbacks_=[]},goog.Dependency.prototype.getPathName=function(){var a=this.path,b=a.indexOf("://");0<=b&&(a=a.substring(b+3),b=a.indexOf("/"),0<=b&&(a=a.substring(b+1)));return a},\ngoog.Dependency.prototype.onLoad=function(a){this.loaded_?a():this.loadCallbacks_.push(a)},goog.Dependency.prototype.loaded=function(){this.loaded_=!0;var a=this.loadCallbacks_;this.loadCallbacks_=[];for(var b=0;b<a.length;b++)a[b]()},goog.Dependency.defer_=!1,goog.Dependency.callbackMap_={},goog.Dependency.registerCallback_=function(a){var b=Math.random().toString(32);goog.Dependency.callbackMap_[b]=a;return b},goog.Dependency.unregisterCallback_=function(a){delete goog.Dependency.callbackMap_[a]},\ngoog.Dependency.callback_=function(a,b){if(a in goog.Dependency.callbackMap_){for(var c=goog.Dependency.callbackMap_[a],d=[],e=1;e<arguments.length;e++)d.push(arguments[e]);c.apply(void 0,d)}else throw Error("Callback key "+a+" does not exist (was base.js loaded more than once?).");},goog.Dependency.prototype.load=function(a){if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var b=goog.global.document;if("complete"==\nb.readyState&&!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING){if(/\\bdeps.js$/.test(this.path)){a.loaded();return}throw Error(\'Cannot write "\'+this.path+\'" after document load\');}var c=goog.getScriptNonce_();if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&goog.isDocumentLoading_()){var d=function(h){h.readyState&&"complete"!=h.readyState?h.onload=d:(goog.Dependency.unregisterCallback_(e),a.loaded())};var e=goog.Dependency.registerCallback_(d);c=c?\' nonce="\'+c+\'"\':"";var f=\'<script src="\'+this.path+\'"\'+\nc+(goog.Dependency.defer_?" defer":"")+\' id="script-\'+e+\'">\\x3c/script>\';f+="<script"+c+">";f=goog.Dependency.defer_?f+("document.getElementById(\'script-"+e+"\').onload = function() {\\n  goog.Dependency.callback_(\'"+e+"\', this);\\n};\\n"):f+("goog.Dependency.callback_(\'"+e+"\', document.getElementById(\'script-"+e+"\'));");f+="\\x3c/script>";b.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(f):f)}else{var g=b.createElement("script");g.defer=goog.Dependency.defer_;g.async=!1;c&&(g.nonce=\nc);g.onload=function(){g.onload=null;a.loaded()};g.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path):this.path;b.head.appendChild(g)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."),a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,\nb,c,d,e)},goog.inherits(goog.Es6ModuleDependency,goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(l,m){var n="",p=goog.getScriptNonce_();p&&(n=\' nonce="\'+p+\'"\');l=m?\'<script type="module" crossorigin\'+n+">"+m+"\\x3c/script>":\'<script type="module" crossorigin src="\'+l+\'"\'+n+">\\x3c/script>";d.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(l):l)}function c(l,m){var n=d.createElement("script");n.defer=!0;n.async=!1;n.type="module";n.setAttribute("crossorigin",\n!0);var p=goog.getScriptNonce_();p&&(n.nonce=p);m?n.text=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScript(m):m:n.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(l):l;d.head.appendChild(n)}if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var d=goog.global.document,e=this;if(goog.isDocumentLoading_()){var f=b;goog.Dependency.defer_=!0}else f=c;var g=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(g);\na.setModuleState(goog.ModuleType.ES6)});f(void 0,\'goog.Dependency.callback_("\'+g+\'")\');f(this.path,void 0);var h=goog.Dependency.registerCallback_(function(l){goog.Dependency.unregisterCallback_(h);a.registerEs6ModuleExports(e.path,l,goog.moduleLoaderState_.moduleName)});f(void 0,\'import * as m from "\'+this.path+\'"; goog.Dependency.callback_("\'+h+\'", m)\');var k=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(k);a.clearModuleState();a.loaded()});f(void 0,\'goog.Dependency.callback_("\'+\nk+\'")\')}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),a.pause()},goog.TransformedDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e);this.contents_=null;this.lazyFetch_=!goog.inHtmlDocument_()||!("noModule"in goog.global.document.createElement("script"))},goog.inherits(goog.TransformedDependency,goog.Dependency),goog.TransformedDependency.prototype.load=function(a){function b(){e.contents_=goog.loadFileSync_(e.path);e.contents_&&(e.contents_=\ne.transform(e.contents_),e.contents_&&(e.contents_+="\\n//# sourceURL="+e.path))}function c(){e.lazyFetch_&&b();if(e.contents_){f&&a.setModuleState(goog.ModuleType.ES6);try{var l=e.contents_;e.contents_=null;goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(l));if(f)var m=goog.moduleLoaderState_.moduleName}finally{f&&a.clearModuleState()}f&&goog.global.$jscomp.require.ensure([e.getPathName()],function(){a.registerEs6ModuleExports(e.path,goog.global.$jscomp.require(e.getPathName()),m)});a.loaded()}}\nfunction d(){var l=goog.global.document,m=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(m);c()}),n=goog.getScriptNonce_();n="<script"+(n?\' nonce="\'+n+\'"\':"")+">"+goog.protectScriptTag_(\'goog.Dependency.callback_("\'+m+\'");\')+"\\x3c/script>";l.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(n):n)}var e=this;if(goog.global.CLOSURE_IMPORT_SCRIPT)b(),this.contents_&&goog.global.CLOSURE_IMPORT_SCRIPT("",this.contents_)?(this.contents_=null,a.loaded()):\na.pause();else{var f=this.loadFlags.module==goog.ModuleType.ES6;this.lazyFetch_||b();var g=1<a.pending().length;if(goog.Dependency.defer_&&(g||goog.isDocumentLoading_()))a.defer(function(){c()});else{var h=goog.global.document;g=goog.inHtmlDocument_()&&("ActiveXObject"in goog.global||goog.isEdge_());if(f&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()&&!g){goog.Dependency.defer_=!0;a.pause();var k=h.onreadystatechange;h.onreadystatechange=function(){"interactive"==h.readyState&&(h.onreadystatechange=\nk,c(),a.resume());"function"===typeof k&&k.apply(void 0,arguments)}}else goog.inHtmlDocument_()&&goog.isDocumentLoading_()?d():c()}}},goog.TransformedDependency.prototype.transform=function(a){},goog.PreTranspiledEs6ModuleDependency=function(a,b,c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.PreTranspiledEs6ModuleDependency,goog.TransformedDependency),goog.PreTranspiledEs6ModuleDependency.prototype.transform=function(a){return a},goog.GoogModuleDependency=function(a,b,\nc,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.GoogModuleDependency,goog.TransformedDependency),goog.GoogModuleDependency.prototype.transform=function(a){return goog.LOAD_MODULE_USING_EVAL&&void 0!==goog.global.JSON?"goog.loadModule("+goog.global.JSON.stringify(a+"\\n//# sourceURL="+this.path+"\\n")+");":\'goog.loadModule(function(exports) {"use strict";\'+a+"\\n;return exports});\\n//# sourceURL="+this.path+"\\n"},goog.DebugLoader_.prototype.addDependency=function(a,b,c,d){b=\nb||[];a=a.replace(/\\\\/g,"/");var e=goog.normalizePath_(goog.basePath+a);d&&"boolean"!==typeof d||(d=d?{module:goog.ModuleType.GOOG}:{});c=this.factory_.createDependency(e,a,b,c,d);this.dependencies_[e]=c;for(c=0;c<b.length;c++)this.idToPath_[b[c]]=e;this.idToPath_[a]=e},goog.DependencyFactory=function(){},goog.DependencyFactory.prototype.createDependency=function(a,b,c,d,e){return e.module==goog.ModuleType.GOOG?new goog.GoogModuleDependency(a,b,c,d,e):e.module==goog.ModuleType.ES6?goog.ASSUME_ES_MODULES_TRANSPILED?\nnew goog.PreTranspiledEs6ModuleDependency(a,b,c,d,e):new goog.Es6ModuleDependency(a,b,c,d,e):new goog.Dependency(a,b,c,d,e)},goog.debugLoader_=new goog.DebugLoader_,goog.loadClosureDeps=function(){goog.debugLoader_.loadClosureDeps()},goog.setDependencyFactory=function(a){goog.debugLoader_.setDependencyFactory(a)},goog.TRUSTED_TYPES_POLICY_=goog.TRUSTED_TYPES_POLICY_NAME?goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME+"#base"):null,goog.global.CLOSURE_NO_DEPS||goog.debugLoader_.loadClosureDeps(),\ngoog.bootstrap=function(a,b){goog.debugLoader_.bootstrap(a,b)});if(!COMPILED){var isChrome87=!1;try{isChrome87=eval(goog.global.trustedTypes.emptyScript)!==goog.global.trustedTypes.emptyScript}catch(a){}goog.CLOSURE_EVAL_PREFILTER_=goog.global.trustedTypes&&isChrome87&&goog.createTrustedTypesPolicy("goog#base#devonly#eval")||{createScript:goog.identity_}};const proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.proxy"),createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.endpoint"),releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.releaseProxy"),throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.thrown"),isObject$$module$node_modules$comlink$dist$esm$comlink_mjs=a=>"object"===typeof a&&null!==a||"function"===typeof a,proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs=\n{canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs],serialize(a){const {port1:b,port2:c}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b);return[c,[c]]},deserialize(a){a.start();return wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a)}},throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs={canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&\nthrowMarker$$module$node_modules$comlink$dist$esm$comlink_mjs in a,serialize({value:a}){return[a instanceof Error?{isError:!0,value:{message:a.message,name:a.name,stack:a.stack}}:{isError:!1,value:a},[]]},deserialize(a){if(a.isError)throw Object.assign(Error(a.value.message),a.value);throw a.value;}},transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs=new Map([["proxy",proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs],["throw",throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs]]);\nfunction expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self){b.addEventListener("message",function e(d){if(d&&d.data){var {id:f,type:g,path:h}=Object.assign({path:[]},d.data),k=(d.data.argumentList||[]).map(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);try{const m=h.slice(0,-1).reduce((p,q)=>p[q],a),n=h.reduce((p,q)=>p[q],a);switch(g){case "GET":var l=n;break;case "SET":m[h.slice(-1)[0]]=fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(d.data.value);\nl=!0;break;case "APPLY":l=n.apply(m,k);break;case "CONSTRUCT":const p=new n(...k);l=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(p);break;case "ENDPOINT":const {port1:q,port2:w}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,w);l=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(q,[q]);break;case "RELEASE":l=void 0;break;default:return}}catch(m){l={value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0}}Promise.resolve(l).catch(m=>\n({value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0})).then(m=>{const [n,p]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(m);b.postMessage(Object.assign(Object.assign({},n),{id:f}),p);"RELEASE"===g&&(b.removeEventListener("message",e),closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(b))})}});b.start&&b.start()}function isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return"MessagePort"===a.constructor.name}\nfunction closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a){isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a.close()}function wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[],b)}function throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(a){if(a)throw Error("Proxy has been released and is not useable");}\nfunction createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=[],c=function(){}){let d=!1;const e=new Proxy(c,{get(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);if(g===releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs)return()=>requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"RELEASE",path:b.map(h=>h.toString())}).then(()=>{closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a);d=!0});if("then"===\ng){if(0===b.length)return{then:()=>e};f=requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"GET",path:b.map(h=>h.toString())}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return f.then.bind(f)}return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[...b,g])},set(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [k,l]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\n{type:"SET",path:[...b,g].map(m=>m.toString()),value:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},apply(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);f=b[b.length-1];if(f===createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs)return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"ENDPOINT"}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);if("bind"===f)return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\nb.slice(0,-1));const [k,l]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"APPLY",path:b.map(m=>m.toString()),argumentList:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},construct(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [h,k]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(g);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\n{type:"CONSTRUCT",path:b.map(l=>l.toString()),argumentList:h},k).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)}});return e}function myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Array.prototype.concat.apply([],a)}\nfunction processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(a){a=a.map(toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return[a.map(b=>b[0]),myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a.map(b=>b[1]))]}const transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs=new WeakMap;function transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.set(a,b);return a}\nfunction proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Object.assign(a,{[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:!0})}function windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self,c="*"){return{postMessage:(d,e)=>a.postMessage(d,c,e),addEventListener:b.addEventListener.bind(b),removeEventListener:b.removeEventListener.bind(b)}}\nfunction toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){for(const [b,c]of transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs)if(c.canHandle(a)){const [d,e]=c.serialize(a);return[{type:"HANDLER",name:b,value:d},e]}return[{type:"RAW",value:a},transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a)||[]]}\nfunction fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){switch(a.type){case "HANDLER":return transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a.name).deserialize(a.value);case "RAW":return a.value}}\nfunction requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b,c){return new Promise(d=>{const e=generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs();a.addEventListener("message",function h(g){g.data&&g.data.id&&g.data.id===e&&(a.removeEventListener("message",h),d(g.data))});a.start&&a.start();a.postMessage(Object.assign({id:e},b),c)})}\nfunction generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs(){return Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}var module$node_modules$comlink$dist$esm$comlink_mjs={};module$node_modules$comlink$dist$esm$comlink_mjs.createEndpoint=createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.expose=expose$$module$node_modules$comlink$dist$esm$comlink_mjs;\nmodule$node_modules$comlink$dist$esm$comlink_mjs.proxy=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.proxyMarker=proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.releaseProxy=releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.transfer=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs;\nmodule$node_modules$comlink$dist$esm$comlink_mjs.transferHandlers=transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.windowEndpoint=windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.wrap=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs;function MessagePortState$$module$src$utils$message_port_state(){}MessagePortState$$module$src$utils$message_port_state.prototype.ready=!1;MessagePortState$$module$src$utils$message_port_state.prototype.port=void 0;MessagePortState$$module$src$utils$message_port_state.prototype.post=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.broadcastPlayState=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.workerState=void 0;\nMessagePortState$$module$src$utils$message_port_state.prototype.vanillaWorkerState=void 0;var $jscompDefaultExport$$module$src$utils$message_port_state=MessagePortState$$module$src$utils$message_port_state,module$src$utils$message_port_state={};module$src$utils$message_port_state.MessagePortState=MessagePortState$$module$src$utils$message_port_state;module$src$utils$message_port_state.default=$jscompDefaultExport$$module$src$utils$message_port_state;var module$node_modules$lines_logger$lib$index={default:{}};module$node_modules$lines_logger$lib$index.default.__esModule=!0;module$node_modules$lines_logger$lib$index.default.LoggerFactory=module$node_modules$lines_logger$lib$index.default.logLevels=void 0;module$node_modules$lines_logger$lib$index.default.logLevels={log_raise_error:1,log_with_warnings:2,trace:3,debug:4,info:5,warn:6,error:7,disable:8};\nvar LoggerFactory$$module$node_modules$lines_logger$lib$index=function(){function a(b,c){if(void 0===b&&(b="log_with_warnings"),void 0===c&&(c=null),this.logLevel=b,!module$node_modules$lines_logger$lib$index.default.logLevels[b])throw Error("Invalid log level "+b+" allowed: "+JSON.stringify(module$node_modules$lines_logger$lib$index.default.logLevels));this.mockConsole=c||console}return a.prototype.dummy=function(){},a.prototype.setLogWarnings=function(b){this.logLevel=b},a.prototype.getLogWarnings=\nfunction(){return this.logLevel},a.prototype.getSingleLoggerColor=function(b,c,d){return this.getSingleLoggerStyle(b,this.getColorStyle(c),d)},a.prototype.getSingleLogger=function(b,c){var d=this.getRandomColor(b);return this.getSingleLoggerStyle(b,this.getColorStyle(d),c)},a.prototype.getSingleLoggerStyle=function(b,c,d,e){var f=this;return void 0===e&&(e="log_with_warnings"),function(){for(var g=[],h=0;h<arguments.length;h++)g[h]=arguments[h];if(module$node_modules$lines_logger$lib$index.default.logLevels[f.logLevel]>\nmodule$node_modules$lines_logger$lib$index.default.logLevels[e])return f.dummy;g=Array.prototype.slice.call(g);h=g.shift().split("{}");for(var k=[f.mockConsole,"%c"+b,c],l=0;l<h.length;l++)k.push(h[l]),void 0!==g[l]&&k.push(g[l]);if(h.length-1!==g.length)if("log_with_warnings"===f.logLevel)f.mockConsole.error("MissMatch amount of arguments");else if("log_raise_error"===f.logLevel)throw Error("MissMatch amount of arguments");return Function.prototype.bind.apply(d,k)}},a.prototype.getLoggerColor=function(b,\nc){return this.getLoggerStyle(b,this.getColorStyle(c))},a.prototype.getColorStyle=function(b){return"color: white; background-color: "+b+"; padding: 2px 6px; border-radius: 2px; font-size: 10px"},a.getHash=function(b,c){void 0===c&&(c=0);var d=3735928559^c;c^=1103547991;for(var e=0,f;e<b.length;e++)f=b.charCodeAt(e),d=Math.imul(d^f,2654435761),c=Math.imul(c^f,1597334677);return d=Math.imul(d^d>>>16,2246822507)^Math.imul(c^c>>>13,3266489909),4294967296*(2097151&(Math.imul(c^c>>>16,2246822507)^Math.imul(d^\nd>>>13,3266489909)))+(d>>>0)},a.prototype.getRandomColor=function(b){void 0===b&&(b="");b=a.getHash(b);for(var c="#",d=0;3>d;d++)c+=("00"+(8+(b>>7*d&127)).toString(16)).substr(-2);return c},a.prototype.getLogger=function(b){return this.getLoggerColor(b,this.getRandomColor(b))},a.prototype.getLoggerStyle=function(b,c){return{trace:this.getSingleLoggerStyle(b,c,this.mockConsole.trace,"trace"),debug:this.getSingleLoggerStyle(b,c,this.mockConsole.debug,"debug"),log:this.getSingleLoggerStyle(b,c,this.mockConsole.log,\n"info"),warn:this.getSingleLoggerStyle(b,c,this.mockConsole.warn,"warn"),error:this.getSingleLoggerStyle(b,c,this.mockConsole.error,"error")}},a}();module$node_modules$lines_logger$lib$index.default.LoggerFactory=LoggerFactory$$module$node_modules$lines_logger$lib$index;let logWorkletMain$$module$src$logger,logWorkletWorker$$module$src$logger,logSABMain$$module$src$logger,logSABWorker$$module$src$logger,logVANMain$$module$src$logger,logVANWorker$$module$src$logger,logOldSpnMain$$module$src$logger,logOldSpnWorker$$module$src$logger,logIndex$$module$src$logger,logSPNMainSingle$$module$src$logger,logSinglethreadWorkletMain$$module$src$logger,logSinglethreadWorkletWorker$$module$src$logger,logCommonUtils$$module$src$logger,logWasmModule$$module$src$logger,logMidiRequest$$module$src$logger;\nconst isProd$$module$src$logger=1;logWorkletMain$$module$src$logger=a=>b=>{};logWorkletWorker$$module$src$logger=a=>b=>{};logSABMain$$module$src$logger=a=>b=>{};logSABWorker$$module$src$logger=a=>b=>{};logVANMain$$module$src$logger=a=>b=>{};logVANWorker$$module$src$logger=a=>b=>{};logOldSpnMain$$module$src$logger=a=>b=>{};logOldSpnWorker$$module$src$logger=a=>b=>{};logIndex$$module$src$logger=a=>b=>{};logSPNMainSingle$$module$src$logger=a=>b=>{};\nlogSinglethreadWorkletMain$$module$src$logger=a=>b=>{};logSinglethreadWorkletWorker$$module$src$logger=a=>b=>{};logCommonUtils$$module$src$logger=a=>b=>{};logWasmModule$$module$src$logger=a=>b=>{};logMidiRequest$$module$src$logger=a=>b=>{};var $jscompDefaultExport$$module$src$logger=a=>b=>{},module$src$logger={};module$src$logger.default=$jscompDefaultExport$$module$src$logger;module$src$logger.logCommonUtils=logCommonUtils$$module$src$logger;module$src$logger.logIndex=logIndex$$module$src$logger;\nmodule$src$logger.logMidiRequest=logMidiRequest$$module$src$logger;module$src$logger.logOldSpnMain=logOldSpnMain$$module$src$logger;module$src$logger.logOldSpnWorker=logOldSpnWorker$$module$src$logger;module$src$logger.logSABMain=logSABMain$$module$src$logger;module$src$logger.logSABWorker=logSABWorker$$module$src$logger;module$src$logger.logSPNMainSingle=logSPNMainSingle$$module$src$logger;module$src$logger.logSinglethreadWorkletMain=logSinglethreadWorkletMain$$module$src$logger;\nmodule$src$logger.logSinglethreadWorkletWorker=logSinglethreadWorkletWorker$$module$src$logger;module$src$logger.logVANMain=logVANMain$$module$src$logger;module$src$logger.logVANWorker=logVANWorker$$module$src$logger;module$src$logger.logWasmModule=logWasmModule$$module$src$logger;module$src$logger.logWorkletMain=logWorkletMain$$module$src$logger;module$src$logger.logWorkletWorker=logWorkletWorker$$module$src$logger;const DEFAULT_BUFFER_LEN$$module$src$constants=128,MAX_CHANNELS$$module$src$constants=32,RING_BUFFER_SIZE$$module$src$constants=16384,MIDI_BUFFER_SIZE$$module$src$constants=1024,MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants=3,CALLBACK_DATA_BUFFER_SIZE$$module$src$constants=16384,initialSharedState$$module$src$constants=[0,4096,0,0,0,0,-1,-1,-1,-1,0,DEFAULT_BUFFER_LEN$$module$src$constants,0,0,0,0,0,0,0,0],AUDIO_STATE$$module$src$constants={CSOUND_LOCK:0,FRAMES_REQUESTED:1,IS_PERFORMING:2,IS_RENDERING:3,\nIS_PAUSED:4,STOP:5,SAMPLE_RATE:6,KSMPS:7,NCHNLS:8,NCHNLS_I:9,IS_REQUESTING_MIC:10,BUFFER_LEN:11,OUTPUT_READ_INDEX:12,OUTPUT_WRITE_INDEX:13,AVAIL_IN_BUFS:14,AVAIL_OUT_BUFS:15,IS_REQUESTING_RTMIDI:16,RTMIDI_INDEX:17,AVAIL_RTMIDI_EVENTS:18,HAS_PENDING_CALLBACKS:19},DATA_TYPE$$module$src$constants={NUMBER:0,STRING:1,FLOAT_32:2,FLOAT_64:3};var module$src$constants={};module$src$constants.AUDIO_STATE=AUDIO_STATE$$module$src$constants;module$src$constants.CALLBACK_DATA_BUFFER_SIZE=CALLBACK_DATA_BUFFER_SIZE$$module$src$constants;\nmodule$src$constants.DATA_TYPE=DATA_TYPE$$module$src$constants;module$src$constants.DEFAULT_BUFFER_LEN=DEFAULT_BUFFER_LEN$$module$src$constants;module$src$constants.MAX_CHANNELS=MAX_CHANNELS$$module$src$constants;module$src$constants.MIDI_BUFFER_PAYLOAD_SIZE=MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants;module$src$constants.MIDI_BUFFER_SIZE=MIDI_BUFFER_SIZE$$module$src$constants;module$src$constants.RING_BUFFER_SIZE=RING_BUFFER_SIZE$$module$src$constants;module$src$constants.initialSharedState=initialSharedState$$module$src$constants;const handleCsoundStart$$module$src$workers$common_utils=(a,b,c,d,e)=>f=>{const {csound:g}=f,h=1===b.csoundShouldDaemonize(g);h&&(b.csoundSetOption(g,"--daemon"),b.csoundSetOption(g,"-odac"));const k=b.csoundStart(g),l=b.csoundGetOutputName(g)||"test.wav";logCommonUtils$$module$src$logger(`handleCsoundStart: actual csoundStart result ${k}, outputName: ${l}`)();0!==k&&a.post(`error: csoundStart failed while trying to render ${l},`+" look out for errors in options and syntax");setTimeout(()=>{const m=\nb._isRequestingRtMidiInput(g);if(h||m||l.includes("dac"))d(f);else if(a.broadcastPlayState("renderStarted"),e)e(f);else for(;0===b.csoundPerformKsmps(g););},0);return k},instantiateAudioPacket$$module$src$workers$common_utils=(a,b)=>{const c=[];for(let d=0;d<a;d++)c.push(new Float64Array(b));return c},renderFunction$$module$src$workers$common_utils=({libraryCsound:a,workerMessagePort:b})=>async({csound:c})=>{const d=a.csoundGetKr(c);let e=0,f=0;for(;("renderStarted"===b.vanillaWorkerState||"renderStarted"===\nb.workerState)&&0===e;)e=a.csoundPerformKsmps(c),f+=1,"function"===typeof setTimeout&&0===e&&0===f%(2*d)&&await new Promise(g=>setTimeout(g,0));b.broadcastPlayState("renderEnded")};var module$src$workers$common_utils={};module$src$workers$common_utils.handleCsoundStart=handleCsoundStart$$module$src$workers$common_utils;module$src$workers$common_utils.instantiateAudioPacket=instantiateAudioPacket$$module$src$workers$common_utils;module$src$workers$common_utils.renderFunction=renderFunction$$module$src$workers$common_utils;const csoundCreate$$module$src$modules$instantiation=a=>()=>a.exports.csoundCreateWasi();csoundCreate$$module$src$modules$instantiation.toString=()=>"create = async () => undefined;";const csoundDestroy$$module$src$modules$instantiation=a=>b=>a.exports.csoundDestroy(b);csoundDestroy$$module$src$modules$instantiation.toString=()=>"destroy = async () => undefined;";const csoundGetAPIVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetAPIVersion();\ncsoundGetAPIVersion$$module$src$modules$instantiation.toString=()=>"getAPIVersion = async () => Number;";const csoundGetVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetVersion();csoundGetVersion$$module$src$modules$instantiation.toString=()=>"getVersion = async () => Number;";const csoundInitialize$$module$src$modules$instantiation=a=>(b,c)=>a.exports.csoundInitialize(c);csoundInitialize$$module$src$modules$instantiation.toString=()=>"initialize = async () => Number;";\nvar module$src$modules$instantiation={};module$src$modules$instantiation.csoundCreate=csoundCreate$$module$src$modules$instantiation;module$src$modules$instantiation.csoundDestroy=csoundDestroy$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetAPIVersion=csoundGetAPIVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetVersion=csoundGetVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundInitialize=csoundInitialize$$module$src$modules$instantiation;const WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders=!1;function TextEncoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";return this}TextEncoderPoly$$module$src$utils$text_encoders.prototype.encode=function(a){if("string"!==typeof a)throw new TypeError("passed argument must be of type string "+a+" "+typeof a);a=unescape(encodeURIComponent(a));const b=new Uint8Array(a.length);[...a].forEach(function(c,d){b[d]=c.codePointAt(0)});return b};\nfunction TextDecoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";this.ignoreBOM=!1;this.trimNull=a=>{const b=a.indexOf("\\x00");return-1<b?a.slice(0,Math.max(0,b)):a};this.decode=function(a,b){if(void 0===a)return"";if("boolean"!==typeof(void 0!==b&&"stream"in b?b.stream:!1))throw new TypeError("stream option must be boolean");if(ArrayBuffer.isView(a)){a=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);const c=Array.from({length:a.length});a.forEach(function(d,e){c[e]=String.fromCodePoint(d)});\nreturn this.trimNull(c.join(""))}throw new TypeError("passed argument must be an array buffer view");}}\nconst decoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextDecoderPoly$$module$src$utils$text_encoders:new TextDecoder("utf8"),encoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextEncoderPoly$$module$src$utils$text_encoders:new TextEncoder("utf8"),uint2String$$module$src$utils$text_encoders=a=>decoder$$module$src$utils$text_encoders.decode(a);var module$src$utils$text_encoders={};\nmodule$src$utils$text_encoders.decoder=decoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.encoder=encoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.uint2String=uint2String$$module$src$utils$text_encoders;const trimNull$$module$src$utils$trim_null=a=>{const b=a.indexOf("\\x00");return-1<b?a.substr(0,b):a};var module$src$utils$trim_null={};module$src$utils$trim_null.trimNull=trimNull$$module$src$utils$trim_null;const freeStringPtr$$module$src$utils$string_pointers=(a,b)=>{a.exports.freeStringMem(b)},ptr2string$$module$src$utils$string_pointers=(a,b)=>{({buffer:a}=a.wasi.memory);b=new Uint8Array(a,b);b=uint2String$$module$src$utils$text_encoders(b);return trimNull$$module$src$utils$trim_null(b)},string2ptr$$module$src$utils$string_pointers=(a,b)=>{if("string"!==typeof b)console.error("Expected string but got",typeof b);else{b=encoder$$module$src$utils$text_encoders.encode(b);var c=a.exports.allocStringMem(b.length);\n({buffer:a}=a.wasi.memory);(new Uint8Array(a,c,b.length+1)).set(b);return c}};var module$src$utils$string_pointers={};module$src$utils$string_pointers.freeStringPtr=freeStringPtr$$module$src$utils$string_pointers;module$src$utils$string_pointers.ptr2string=ptr2string$$module$src$utils$string_pointers;module$src$utils$string_pointers.string2ptr=string2ptr$$module$src$utils$string_pointers;const csoundParseOrc$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundParseOrc(b,c);csoundParseOrc$$module$src$modules$performance.toString=()=>"parseOrc = async (orchestra) => Object;";const csoundCompileTree$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundCompileTree(b,c);csoundCompileTree$$module$src$modules$performance.toString=()=>"compileTree = async (tree) => Number;";\nconst csoundCompileOrc$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileOrc(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileOrc$$module$src$modules$performance.toString=()=>"compileOrc = async (orchestra) => Number;";\nconst csoundEvalCode$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundEvalCode(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundEvalCode$$module$src$modules$performance.toString=()=>"csoundEvalCode = async (orchestra) => Number;";const csoundStart$$module$src$modules$performance=a=>b=>a.exports.csoundStartWasi(b);csoundStart$$module$src$modules$performance.toString=()=>"start = async () => Number;";\nconst csoundCompileCsd$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);let d;try{d=a.exports.csoundCompileCsd(b,c)}catch(e){console.error(e)}freeStringPtr$$module$src$utils$string_pointers(a,c);return d};csoundCompileCsd$$module$src$modules$performance.toString=()=>"compileCsd = async (path) => Number;";\nconst csoundCompileCsdText$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileCsdText(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileCsdText$$module$src$modules$performance.toString=()=>"compileCsdText = async (csoundDocument) => Number;";const csoundPerform$$module$src$modules$performance=a=>b=>a.exports.csoundPerform(b);csoundPerform$$module$src$modules$performance.toString=()=>"perform = async () => Number;";\nconst csoundPerformKsmps$$module$src$modules$performance=a=>b=>a.exports.csoundPerformKsmpsWasi(b);csoundPerformKsmps$$module$src$modules$performance.toString=()=>"performKsmps = async (csound) => Number;";const csoundPerformBuffer$$module$src$modules$performance=a=>b=>a.exports.csoundPerformBuffer(b);csoundPerformBuffer$$module$src$modules$performance.toString=()=>"performBuffer = async (csound) => Number;";const csoundStop$$module$src$modules$performance=a=>b=>a.exports.csoundStop(b);\ncsoundStop$$module$src$modules$performance.toString=()=>"stop = async () => undefined;";const csoundCleanup$$module$src$modules$performance=a=>b=>a.exports.csoundCleanup(b);csoundCleanup$$module$src$modules$performance.toString=()=>"cleanup = async () => Number;";const csoundReset$$module$src$modules$performance=a=>b=>a.exports.csoundResetWasi(b);csoundReset$$module$src$modules$performance.toString=()=>"reset = async () => Number;";var module$src$modules$performance={};\nmodule$src$modules$performance.csoundCleanup=csoundCleanup$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsd=csoundCompileCsd$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsdText=csoundCompileCsdText$$module$src$modules$performance;module$src$modules$performance.csoundCompileOrc=csoundCompileOrc$$module$src$modules$performance;module$src$modules$performance.csoundCompileTree=csoundCompileTree$$module$src$modules$performance;\nmodule$src$modules$performance.csoundEvalCode=csoundEvalCode$$module$src$modules$performance;module$src$modules$performance.csoundParseOrc=csoundParseOrc$$module$src$modules$performance;module$src$modules$performance.csoundPerform=csoundPerform$$module$src$modules$performance;module$src$modules$performance.csoundPerformBuffer=csoundPerformBuffer$$module$src$modules$performance;module$src$modules$performance.csoundPerformKsmps=csoundPerformKsmps$$module$src$modules$performance;\nmodule$src$modules$performance.csoundReset=csoundReset$$module$src$modules$performance;module$src$modules$performance.csoundStart=csoundStart$$module$src$modules$performance;module$src$modules$performance.csoundStop=csoundStop$$module$src$modules$performance;const sizeOfPrimitive$$module$src$utils$native_sizes={int:4,MYFLT:4,char:1},sizeofStruct$$module$src$utils$native_sizes=a=>a.reduce((b,[,c,...d])=>b+("char"===c?sizeOfPrimitive$$module$src$utils$native_sizes[c]*d[0]:sizeOfPrimitive$$module$src$utils$native_sizes[c]),0);var module$src$utils$native_sizes={};module$src$utils$native_sizes.sizeOfPrimitive=sizeOfPrimitive$$module$src$utils$native_sizes;module$src$utils$native_sizes.sizeofStruct=sizeofStruct$$module$src$utils$native_sizes;const structBufferToObject$$module$src$utils$structure_buffer_to_object=(a,b)=>{[a]=a.reduce(([c,d],[e,f,...g])=>{g="char"===f?sizeOfPrimitive$$module$src$utils$native_sizes[f]*g[0]:sizeOfPrimitive$$module$src$utils$native_sizes[f];f="char"===f?trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(b.subarray(d,g)))||"":b[d];c[e]=f;return[c,d+g]},[{},0]);return a};var module$src$utils$structure_buffer_to_object={};\nmodule$src$utils$structure_buffer_to_object.structBufferToObject=structBufferToObject$$module$src$utils$structure_buffer_to_object;const CSOUND_PARAMS$$module$src$structures=[["debug_mode","int"],["buffer_frames","int"],["hardware_buffer_frames","int"],["displays","int"],["ascii_graphs","int"],["postscript_graphs","int"],["message_level","int"],["tempo","int"],["ring_bell","int"],["use_cscore","int"],["terminate_on_midi","int"],["heartbeat","int"],["defer_gen01_load","int"],["midi_key","int"],["midi_key_cps","int"],["midi_key_oct","int"],["midi_key_pch","int"],["midi_velocity","int"],["midi_velocity_amp","int"],["no_default_paths",\n"int"],["number_of_threads","int"],["syntax_check_only","int"],["csd_line_counts","int"],["compute_weights","int"],["realtime_mode","int"],["sample_accurate","int"],["sample_rate_override","MYFLT"],["control_rate_override","MYFLT"],["nchnls_override","int"],["nchnls_i_override","int"],["e0dbfs_override","MYFLT"],["daemon","int"],["ksmps_override","int"],["FFT_library","int"]],CS_MIDIDEVICE$$module$src$structures=[["device_name","char",64],["interface_name","char",64],["device_id","char",64],["midi_module",\n"char",64],["isOutput","int"]];var module$src$structures={};const csoundGetSr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSr(b);csoundGetSr$$module$src$modules$attributes.toString=()=>"getSr = async () => Number;";const csoundGetKr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKr(b);csoundGetKr$$module$src$modules$attributes.toString=()=>"getKr = async () => Number;";const csoundGetKsmps$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKsmps(b);csoundGetKsmps$$module$src$modules$attributes.toString=()=>"getKsmps = async () => Number;";\nconst csoundGetNchnls$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnls(b);csoundGetNchnls$$module$src$modules$attributes.toString=()=>"getNchnls = async () => Number;";const csoundGetNchnlsInput$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnlsInput(b);csoundGetNchnlsInput$$module$src$modules$attributes.toString=()=>"getNchnlsInput = async () => Number;";const csoundGet0dBFS$$module$src$modules$attributes=a=>b=>a.exports.csoundGet0dBFS(b);\ncsoundGet0dBFS$$module$src$modules$attributes.toString=()=>"get0dBFS = async () => Number;";const csoundGetA4$$module$src$modules$attributes=a=>b=>a.exports.csoundGetA4(b);csoundGetA4$$module$src$modules$attributes.toString=()=>"getA4 = async () => Number;";const csoundGetCurrentTimeSamples$$module$src$modules$attributes=a=>b=>a.exports.csoundGetCurrentTimeSamples(b);csoundGetCurrentTimeSamples$$module$src$modules$attributes.toString=()=>"getCurrentTimeSamples = async () => Number;";\nconst csoundGetSizeOfMYFLT$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSizeOfMYFLT(b);csoundGetSizeOfMYFLT$$module$src$modules$attributes.toString=()=>"getSizeOfMYFLT = async () => Number;";const csoundSetOption$$module$src$modules$attributes=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundSetOption(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundSetOption$$module$src$modules$attributes.toString=()=>"setOption = async (option) => Number;";\nconst csoundSetParams$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetParams(b,c)};csoundSetParams$$module$src$modules$attributes.toString=()=>"setParams = async (csoundParams) => undefined;";\nconst csoundGetParams$$module$src$modules$attributes=a=>b=>{var {buffer:c}=a.wasi.memory;const d=sizeofStruct$$module$src$utils$native_sizes(CSOUND_PARAMS$$module$src$structures),e=a.exports.allocCsoundParamsStruct();c=new Uint8Array(c,e,d);a.exports.csoundGetParams(b,e);b=structBufferToObject$$module$src$utils$structure_buffer_to_object(CSOUND_PARAMS$$module$src$structures,c);a.exports.freeCsoundParams(e);return b};csoundGetParams$$module$src$modules$attributes.toString=()=>"getParams = async () => CSOUND_PARAMS;";\nconst csoundGetDebug$$module$src$modules$attributes=a=>b=>a.exports.csoundGetDebug(b);csoundGetDebug$$module$src$modules$attributes.toString=()=>"getDebug = async () => Number;";const csoundSetDebug$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetDebug(b,c)};csoundSetDebug$$module$src$modules$attributes.toString=()=>"setDebug = async (number) => undefined;";var module$src$modules$attributes={};module$src$modules$attributes.csoundGet0dBFS=csoundGet0dBFS$$module$src$modules$attributes;\nmodule$src$modules$attributes.csoundGetA4=csoundGetA4$$module$src$modules$attributes;module$src$modules$attributes.csoundGetCurrentTimeSamples=csoundGetCurrentTimeSamples$$module$src$modules$attributes;module$src$modules$attributes.csoundGetDebug=csoundGetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKr=csoundGetKr$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKsmps=csoundGetKsmps$$module$src$modules$attributes;\nmodule$src$modules$attributes.csoundGetNchnls=csoundGetNchnls$$module$src$modules$attributes;module$src$modules$attributes.csoundGetNchnlsInput=csoundGetNchnlsInput$$module$src$modules$attributes;module$src$modules$attributes.csoundGetParams=csoundGetParams$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSizeOfMYFLT=csoundGetSizeOfMYFLT$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSr=csoundGetSr$$module$src$modules$attributes;\nmodule$src$modules$attributes.csoundSetDebug=csoundSetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundSetOption=csoundSetOption$$module$src$modules$attributes;module$src$modules$attributes.csoundSetParams=csoundSetParams$$module$src$modules$attributes;const csoundGetInputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBufferSize(b);csoundGetInputBufferSize$$module$src$modules$rtaudio.toString=()=>"getInputBufferSize = async () => Number;";const csoundGetOutputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBufferSize(b);csoundGetOutputBufferSize$$module$src$modules$rtaudio.toString=()=>"getOutputBufferSize = async () => Number;";const csoundGetInputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBuffer(b);\ncsoundGetInputBuffer$$module$src$modules$rtaudio.toString=()=>"getInputBuffer = async () => Number;";const csoundGetOutputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBuffer(b);csoundGetOutputBuffer$$module$src$modules$rtaudio.toString=()=>"getOutputBuffer = async () => Number;";const csoundGetSpin$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpin(b);csoundGetSpin$$module$src$modules$rtaudio.toString=()=>"getSpin = async (csound) => Number;";\nconst csoundGetSpout$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpout(b);csoundGetSpout$$module$src$modules$rtaudio.toString=()=>"getSpout = async () => Number;";var module$src$modules$rtaudio={};module$src$modules$rtaudio.csoundGetInputBuffer=csoundGetInputBuffer$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetInputBufferSize=csoundGetInputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetOutputBuffer=csoundGetOutputBuffer$$module$src$modules$rtaudio;\nmodule$src$modules$rtaudio.csoundGetOutputBufferSize=csoundGetOutputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpin=csoundGetSpin$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpout=csoundGetSpout$$module$src$modules$rtaudio;function add$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>add$$module$node_modules$rambda$dist$rambda_mjs(a,c):Number(a)+Number(b)}const cloneList$$module$node_modules$rambda$dist$rambda_mjs=a=>Array.prototype.slice.call(a);function curry$$module$node_modules$rambda$dist$rambda_mjs(a,b=[]){return(...c)=>{c=[...b,...c];return c.length>=a.length?a(...c):curry$$module$node_modules$rambda$dist$rambda_mjs(a,c)}}\nfunction adjustFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d=0>a?c.length+a:a;if(a>=c.length||0>d)return c;a=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);a[d]=b(a[d]);return a}const adjust$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(adjustFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction all$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>all$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(!a(b[c]))return!1;return!0}function allPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(!a[c](...b))return!1;c++}return!0}}function always$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>a}\nfunction and$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>and$$module$node_modules$rambda$dist$rambda_mjs(a,c):a&&b}function any$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>any$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=0;for(;c<b.length;){if(a(b[c],c))return!0;c++}return!1}\nfunction anyPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(a[c](...b))return!0;c++}return!1}}function append$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>append$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.split("").concat(a);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);c.push(a);return c}\nfunction apply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>apply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.apply(this,b)}const {isArray:isArray$$module$node_modules$rambda$dist$rambda_mjs}=Array;\nfunction __findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a,b=0){for(const c in a)!1!==a.hasOwnProperty(c)&&"constructor"!==c&&("object"===typeof a[c]&&(b=Math.max(b,__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a[c]))),"function"===typeof a[c]&&(b=Math.max(b,a[c].length)));return b}\nfunction __filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(){const a=[];let b=0;const c=arguments.length;for(;b<c&&"undefined"!==typeof arguments[b];)a[b]=arguments[b],b++;return a}\nfunction __applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){var d=b-c.length;if(1===d)return f=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f));if(2===d)return(f,g)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g));if(3===d)return(f,g,h)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,\nb,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h));if(4===d)return(f,g,h,k)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h,k));if(4<d)return(...f)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,...f));if(isArray$$module$node_modules$rambda$dist$rambda_mjs(a)){var e=[];d=0;const f=a.length;\nfor(;d<f;d++){if("object"===typeof a[d]||isArray$$module$node_modules$rambda$dist$rambda_mjs(a[d]))e[d]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[d],b,c);"function"===typeof a[d]&&(e[d]=a[d](...c))}return e}d={};for(e in a)!1!==a.hasOwnProperty(e)&&"constructor"!==e&&("object"===typeof a[e]?d[e]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[e],b,c):"function"===typeof a[e]&&(d[e]=a[e](...c)));return d}\nfunction applySpec$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a);return 0===c?()=>({}):__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,c,b)}function assocFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return Object.assign({},c,{[a]:b})}const assoc$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction _isInteger$$module$node_modules$rambda$dist$rambda_mjs(a){return a<<0===a}const isInteger$$module$node_modules$rambda$dist$rambda_mjs=Number.isInteger||_isInteger$$module$node_modules$rambda$dist$rambda_mjs;\nfunction assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d="string"===typeof a?a.split(".").map(e=>isInteger$$module$node_modules$rambda$dist$rambda_mjs(Number(e))?Number(e):e):a;if(0===d.length)return b;a=d[0];if(1<d.length){const e="object"===typeof c&&null!==c&&c.hasOwnProperty(a)?c[a]:isInteger$$module$node_modules$rambda$dist$rambda_mjs(d[1])?[]:{};b=assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(d,1),b,e)}return isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)&&\nisArray$$module$node_modules$rambda$dist$rambda_mjs(c)?(c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c),c[a]=b,c):assoc$$module$node_modules$rambda$dist$rambda_mjs(a,b,c)}const assocPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocPathFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction _curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return function(){var d=0;let e=0;const f=b.length,g=arguments.length,h=Array(f+g);for(;d<f;)h[d]=b[d],d++;for(;e<g;)h[f+e]=arguments[e],e++;d=a-h.length;return h.length>=a?c.apply(this,h):_arity$1$$module$node_modules$rambda$dist$rambda_mjs(d,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,h,c))}}\nfunction _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};\ncase 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,m){return b.apply(this,arguments)};default:return function(c,d,e,f,g,h,k,l,m,n){return b.apply(this,arguments)}}}\nfunction curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>curryN$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(10<a)throw Error("First argument to _arity must be a non-negative integer no greater than ten");return _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,[],b))}\nfunction bind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>bind$$module$node_modules$rambda$dist$rambda_mjs(a,c):curryN$$module$node_modules$rambda$dist$rambda_mjs(a.length,(...c)=>a.apply(b,c))}function both$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>both$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>a(...c)&&b(...c)}\nfunction chain$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>chain$$module$node_modules$rambda$dist$rambda_mjs(a,c):[].concat(...b.map(a))}function clampFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(a>b)throw Error("min must not be greater than max in clamp(min, max, value)");if(c>=a&&c<=b)return c;if(c>b)return b;if(c<a)return a}const clamp$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(clampFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction clone$$module$node_modules$rambda$dist$rambda_mjs(a){const b=isArray$$module$node_modules$rambda$dist$rambda_mjs(a)?Array(a.length):{};if(a&&a.getTime)return new Date(a.getTime());for(const c in a){const d=a[c];b[c]="object"===typeof d&&null!==d?d.getTime?new Date(d.getTime()):clone$$module$node_modules$rambda$dist$rambda_mjs(d):d}return b}function complement$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>!a(...b)}\nclass ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs{constructor(a){this.value=a}}function reduceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(c))throw new TypeError("reduce: list must be array or iterable");let d=0;const e=c.length;for(;d<e;){b=a(b,c[d],d,c);if(b instanceof ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs)return b.value;d++}return b}\nconst reduce$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(reduceFn$$module$node_modules$rambda$dist$rambda_mjs),reduceStopper$$module$node_modules$rambda$dist$rambda_mjs=a=>new ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs(a);\nfunction _arity$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};\ncase 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,m){return b.apply(this,arguments)};case 10:return function(c,d,e,f,g,h,k,l,m,n){return b.apply(this,arguments)};default:throw Error("First argument to _arity must be a non-negative integer no greater than ten");}}\nfunction _pipe$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(){return b.call(this,a.apply(this,arguments))}}\nfunction pipe$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("pipe requires at least one argument");return _arity$$module$node_modules$rambda$dist$rambda_mjs(arguments[0].length,reduceFn$$module$node_modules$rambda$dist$rambda_mjs(_pipe$$module$node_modules$rambda$dist$rambda_mjs,arguments[0],Array.prototype.slice.call(arguments,1,Infinity)))}\nfunction compose$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("compose requires at least one argument");return pipe$$module$node_modules$rambda$dist$rambda_mjs.apply(this,Array.prototype.slice.call(arguments,0).reverse())}function concat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>concat$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof a?`${a}${b}`:[...a,...b]}\nfunction cond$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>{let c=!1,d;a.forEach(([e,f])=>{!c&&e(b)&&(c=!0,d=f(b))});return d}}const {keys:keys$1$$module$node_modules$rambda$dist$rambda_mjs}=Object;function mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=Array(b.length);for(;d<b.length;)e[d]=c?a(b[d],d):a(b[d]),d++;return e}\nfunction mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,g);let c=0;const d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b),e=d.length,f={};for(;c<e;){const g=d[c];f[g]=a(b[g],g,b);c++}return f}const mapObjIndexed$$module$node_modules$rambda$dist$rambda_mjs=mapObject$$module$node_modules$rambda$dist$rambda_mjs;\nfunction map$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>map$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error(INCORRECT_ITERABLE_INPUT);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction max$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>max$$module$node_modules$rambda$dist$rambda_mjs(a,c):b>a?b:a}\nfunction converge$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>converge$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=reduce$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>max$$module$node_modules$rambda$dist$rambda_mjs(d,e.length),0,b);return curryN$$module$node_modules$rambda$dist$rambda_mjs(c,function(){return a.apply(this,map$$module$node_modules$rambda$dist$rambda_mjs(d=>d.apply(this,arguments),b))})}\nfunction count$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>count$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?b.filter(c=>a(c)).length:0}function countBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>countBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};b.forEach(d=>{d=a(d);c[d]?c[d]++:c[d]=1});return c}\nconst dec$$module$node_modules$rambda$dist$rambda_mjs=a=>a-1;function isFalsy$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a||!0===Number.isNaN(a)}function defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c):isFalsy$$module$node_modules$rambda$dist$rambda_mjs(b)?a:b}\nfunction type$$module$node_modules$rambda$dist$rambda_mjs(a){if(null===a)return"Null";if(void 0===a)return"Undefined";if(Number.isNaN(a))return"NaN";a=Object.prototype.toString.call(a).slice(8,-1);return"AsyncFunction"===a?"Promise":a}\nfunction _lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property \'indexOf\' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.lastIndexOf(a);({length:c}=b);let d=-1;for(;-1<--c&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}\nfunction _indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property \'indexOf\' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.indexOf(a);let d=c=-1;const {length:e}=b;for(;++c<e&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}\nfunction _arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a){const b=[];let c;for(;!(c=a.next()).done;)b.push(c.value);return b}function _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(a.size!==b.size)return!1;a=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a.values());const c=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(b.values());return 0===a.filter(d=>-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,c)).length}\nfunction parseError$$module$node_modules$rambda$dist$rambda_mjs(a){const b=a.__proto__.toString();return["Error","TypeError"].includes(b)?[b,a.message]:[]}function parseDate$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toDateString?[!0,a.getTime()]:[!1]}function parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a){return a.constructor!==RegExp?[!1]:[!0,a.toString()]}\nfunction equals$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>equals$$module$node_modules$rambda$dist$rambda_mjs(a,f);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(c!==type$$module$node_modules$rambda$dist$rambda_mjs(b))return!1;if("Function"===c)return void 0===a.name?!1:a.name===b.name;if(["NaN","Undefined","Null"].includes(c))return!0;if("Number"===c)return Object.is(-0,a)!==Object.is(-0,b)?!1:a.toString()===b.toString();if(["String","Boolean"].includes(c))return a.toString()===\nb.toString();if("Array"===c){c=Array.from(a);const f=Array.from(b);if(c.toString()!==f.toString())return!1;let g=!0;c.forEach((h,k)=>{g&&(h===f[k]||equals$$module$node_modules$rambda$dist$rambda_mjs(h,f[k])||(g=!1))});return g}var d=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a),e=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseDate$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseDate$$module$node_modules$rambda$dist$rambda_mjs(b);\nif(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseError$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseError$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[0]===e[0]&&d[1]===e[1]:!1;if("Set"===c)return _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b);if("Object"===c){c=Object.keys(a);if(c.length!==Object.keys(b).length)return!1;let f=!0;c.forEach(g=>{if(f){const h=a[g];g=b[g];h===g||equals$$module$node_modules$rambda$dist$rambda_mjs(h,g)||(f=!1)}});\nreturn f}return!1}function includes$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>includes$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof b)return b.includes(a);if(!b)throw new TypeError(`Cannot read property \\\'indexOf\\\' of ${b}`);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b):!1}\nclass _Set$$module$node_modules$rambda$dist$rambda_mjs{constructor(){this.set=new Set;this.items={}}checkUniqueness(a){var b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Null","Undefined","NaN"].includes(b)?b in this.items?!1:this.items[b]=!0:["Object","Array"].includes(b)?b in this.items?-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,this.items[b])?(this.items[b].push(a),!0):!1:(this.items[b]=[a],!0):(b=this.set.size,this.set.add(a),this.set.size!==b)}}\nfunction uniq$$module$node_modules$rambda$dist$rambda_mjs(a){const b=new _Set$$module$node_modules$rambda$dist$rambda_mjs,c=[];a.forEach(d=>{b.checkUniqueness(d)&&c.push(d)});return c}function difference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>difference$$module$node_modules$rambda$dist$rambda_mjs(a,c):uniq$$module$node_modules$rambda$dist$rambda_mjs(a).filter(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(null===b||void 0===b)return{};const c={};for(const d in b)c[d]=b[d];delete c[a];return c}function divide$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>divide$$module$node_modules$rambda$dist$rambda_mjs(a,c):a/b}\nfunction drop$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>drop$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.slice(0<a?a:0)}function dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,c):0<a?b.slice(0,-a):b.slice()}\nfunction dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(0===b.length)return b;const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if("function"!==typeof a)throw Error(`\'predicate\' is from wrong type ${typeof a}`);if(!c&&"string"!==typeof b)throw Error(`\'iterable\' is from wrong type ${typeof b}`);let d=!1;const e=[];let f=b.length;for(;0<f;)f--,d||!1!==a(b[f])?d&&e.push(b[f]):\n(d=!0,e.push(b[f]));return c?e.reverse():e.reverse().join("")}function dropRepeats$$module$node_modules$rambda$dist$rambda_mjs(a){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`${a} is not a list`);const b=[];a.reduce((c,d)=>{equals$$module$node_modules$rambda$dist$rambda_mjs(c,d)||b.push(d);return d},void 0);return b}\nfunction dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`${b} is not a list`);const c=[];b.reduce((d,e)=>{if(void 0===d)return c.push(e),e;a(d,e)||c.push(e);return e},void 0);return c}\nfunction dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!1;const e=[];let f=-1;for(;f++<b.length-1;)d?e.push(b[f]):a(b[f])||(d||(d=!0),e.push(b[f]));return c?e:e.join("")}\nfunction either$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>either$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>!(!a(...c)&&!b(...c))}\nfunction endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);if("string"===typeof b)return b.endsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;const c=b.length-a.length;let d=!0;return a.filter((e,f)=>{if(!d)return!1;(e=equals$$module$node_modules$rambda$dist$rambda_mjs(e,b[f+c]))||(d=!1);return e}).length===a.length}\nfunction prop$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>prop$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(b)return b[a]}function eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a,b),prop$$module$node_modules$rambda$dist$rambda_mjs(a,c))}const eqProps$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapArray$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c,b,!0)}\nfunction evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapObject$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>{if("Object"===type$$module$node_modules$rambda$dist$rambda_mjs(c)){const e=type$$module$node_modules$rambda$dist$rambda_mjs(a[d]);return"Function"===e?a[d](c):"Object"===e?evolve$$module$node_modules$rambda$dist$rambda_mjs(a[d],c):c}return"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c},b)}\nfunction evolve$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>evolve$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=type$$module$node_modules$rambda$dist$rambda_mjs(a),d=type$$module$node_modules$rambda$dist$rambda_mjs(b);if(d!==c)throw Error("iterableType !== rulesType");if(!["Object","Array"].includes(c))throw Error(`\'iterable\' and \'rules\' are from wrong type ${c}`);return"Object"===d?evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b):evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,\nb)}function F$$module$node_modules$rambda$dist$rambda_mjs(){return!1}function filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(const d in b)a(b[d],d,b)&&(c[d]=b[d]);return c}function filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=b.length,f=[];for(;d<e;)(c?a(b[d],d):a(b[d]))&&f.push(b[d]),d++;return f}\nfunction filter$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>filter$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error("Incorrect iterable input");return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,!1):filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction find$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>find$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=0;const d=b.length;for(;c<d;){const e=b[c];if(a(e))return e;c++}}function findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;let d=-1;for(;++d<c;)if(a(b[d]))return d;return-1}\nfunction findLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLast$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return b[c]}function findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return c;return-1}\nfunction flatten$$module$node_modules$rambda$dist$rambda_mjs(a,b){b=void 0===b?[]:b;for(let c=0;c<a.length;c++)isArray$$module$node_modules$rambda$dist$rambda_mjs(a[c])?flatten$$module$node_modules$rambda$dist$rambda_mjs(a[c],b):b.push(a[c]);return b}\nfunction flipFn$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{if(1===b.length)return c=>a(c,b[0]);if(2===b.length)return a(b[1],b[0]);if(3===b.length)return a(b[1],b[0],b[2]);if(4===b.length)return a(b[1],b[0],b[2],b[3]);throw Error("R.flip doesn\'t work with arity > 4");}}function flip$$module$node_modules$rambda$dist$rambda_mjs(a){return flipFn$$module$node_modules$rambda$dist$rambda_mjs(a)}\nfunction forEach$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>forEach$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(void 0!==b){if(isArray$$module$node_modules$rambda$dist$rambda_mjs(b))for(var c=0,d=b.length;c<d;)a(b[c]),c++;else{c=0;d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b);const e=d.length;for(;c<e;){const f=d[c];a(b[f],f,b);c++}}return b}}\nfunction fromPairs$$module$node_modules$rambda$dist$rambda_mjs(a){const b={};a.forEach(([c,d])=>b[c]=d);return b}function groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};for(let d=0;d<b.length;d++){const e=b[d],f=a(e);c[f]||(c[f]=[]);c[f].push(e)}return c}\nfunction groupWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw new TypeError("list.reduce is not a function");const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);if(1===b.length)return[c];const d=[];let e=[];c.reduce((f,g,h)=>{if(0===h)return g;const k=a(f,g),l=0===e.length;h=h===b.length-1;if(k)return l&&e.push(f),e.push(g),h&&d.push(e),g;if(l)return d.push([f]),h&&d.push([g]),g;d.push(e);h&&d.push([g]);e=[];return g},\nvoid 0);return d}function has$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>has$$module$node_modules$rambda$dist$rambda_mjs(a,c):b?b.hasOwnProperty(a):!1}function createPath$$module$node_modules$rambda$dist$rambda_mjs(a,b="."){return"string"===typeof a?a.split(b):a}\nfunction path$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>path$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=b,d=0,e=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);d<e.length;){if(null===c||void 0===c||null===c[e[d]])return;c=c[e[d]];d++}return c}}\nfunction hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,c):void 0!==path$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function head$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[0]||"":a[0]}function _objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b}const objectIs$$module$node_modules$rambda$dist$rambda_mjs=Object.is||_objectIs$$module$node_modules$rambda$dist$rambda_mjs;\nfunction identical$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>identical$$module$node_modules$rambda$dist$rambda_mjs(a,c):objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function identity$$module$node_modules$rambda$dist$rambda_mjs(a){return a}function ifElseFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return(...d)=>!0===("boolean"===typeof a?a:a(...d))?b(...d):c(...d)}\nconst ifElse$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(ifElseFn$$module$node_modules$rambda$dist$rambda_mjs),inc$$module$node_modules$rambda$dist$rambda_mjs=a=>a+1;function indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(let d=0;d<b.length;d++){const e=b[d];c[path$$module$node_modules$rambda$dist$rambda_mjs(a,e)]=e}return c}\nfunction indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof a)return indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b);const c={};for(let d=0;d<b.length;d++){const e=b[d];c[a(e)]=e}return c}\nfunction indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=-1,{length:e}=a;c=c>e?e:c;0>c&&(c+=e);e=b>c?0:c-b>>>0;b>>>=0;for(c=Array(e);++d<e;)c[d]=a[d+b];return c}\nfunction init$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.slice(0,-1):a.length?baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,0,-1):[]}function intersection$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>intersection$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b)}\nfunction intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,f);let c=-1;const d=b.length,e=[];for(;++c<d;)c===d-1?e.push(b[c]):e.push(b[c],a);return e}function is$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>is$$module$node_modules$rambda$dist$rambda_mjs(a,c):null!=b&&b.constructor===a||b instanceof a}\nfunction isEmpty$$module$node_modules$rambda$dist$rambda_mjs(a){const b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Undefined","NaN","Number","Null"].includes(b)?!1:a?"Object"===b?0===Object.keys(a).length:"Array"===b?0===a.length:!1:!0}function isNil$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a}\nfunction join$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>join$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.join(a)}function juxt$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>a.map(c=>c(...b))}function keys$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.keys(a)}function last$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[a.length-1]||"":a[a.length-1]}\nfunction lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function length$$module$node_modules$rambda$dist$rambda_mjs(a){return isArray$$module$node_modules$rambda$dist$rambda_mjs(a)||"string"===typeof a?a.length:NaN}\nfunction lens$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(c){return function(d){return c(a(d)).map(e=>b(e,d))}}}function nth$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>nth$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=0>a?b.length+a:a;return"[object String]"===Object.prototype.toString.call(b)?b.charAt(c):b[c]}\nfunction updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);return-1===a?c.fill(b,a):c.fill(b,a,a+1)}const update$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(updateFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction lensIndex$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(nth$$module$node_modules$rambda$dist$rambda_mjs(a),update$$module$node_modules$rambda$dist$rambda_mjs(a))}function lensPath$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a),assocPath$$module$node_modules$rambda$dist$rambda_mjs(a))}\nfunction lensProp$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a),assoc$$module$node_modules$rambda$dist$rambda_mjs(a))}function match$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>match$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=b.match(a);return null===c?[]:c}\nfunction mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,c):!isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)||!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||1>b?NaN:(a%b+b)%b}function maxByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)>a(b)?c:b}const maxBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(maxByFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction sum$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>b+c,0)}function mean$$module$node_modules$rambda$dist$rambda_mjs(a){return sum$$module$node_modules$rambda$dist$rambda_mjs(a)/a.length}function median$$module$node_modules$rambda$dist$rambda_mjs(a){var b=a.length;if(0===b)return NaN;const c=2-b%2;b=(b-c)/2;return mean$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,0).sort((d,e)=>d===e?0:d<e?-1:1).slice(b,b+c))}\nfunction mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,c):Object.assign({},a||{},b||{})}function mergeAll$$module$node_modules$rambda$dist$rambda_mjs(a){let b={};map$$module$node_modules$rambda$dist$rambda_mjs(c=>{b=mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,c)},a);return b}\nfunction mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=clone$$module$node_modules$rambda$dist$rambda_mjs(a);Object.keys(b).forEach(d=>{"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(b[d])?"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?c[d]=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a[d],b[d]):c[d]=b[d]:c[d]=b[d]});return c}\nfunction mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,c):mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,a)}function mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d={};Object.keys(b).forEach(e=>{d[e]=void 0===c[e]?b[e]:a(b[e],c[e])});Object.keys(c).forEach(e=>{void 0===d[e]&&(d[e]=void 0===b[e]?c[e]:a(b[e],c[e]))});return d}\nconst mergeWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs);function min$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>min$$module$node_modules$rambda$dist$rambda_mjs(a,c):b<a?b:a}function minByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)<a(b)?c:b}const minBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(minByFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction ownKeys$$module$node_modules$rambda$dist$rambda_mjs(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(e){return Object.getOwnPropertyDescriptor(a,e).enumerable}));c.push.apply(c,d)}return c}\nfunction _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(a){for(var b=1;b<arguments.length;b++){var c=null!=arguments[b]?arguments[b]:{};b%2?ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c),!0).forEach(function(d){_defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,d,c[d])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(c)):ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c)).forEach(function(d){Object.defineProperty(a,\nd,Object.getOwnPropertyDescriptor(c,d))})}return a}function _defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c;return a}function isIterable$$module$node_modules$rambda$dist$rambda_mjs(a){return Array.isArray(a)||"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a)}\nfunction modifyFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return isIterable$$module$node_modules$rambda$dist$rambda_mjs(c)&&void 0!==c[a]?isArray$$module$node_modules$rambda$dist$rambda_mjs(c)?updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b(c[a]),c):_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a]:b(c[a])}):c}const modify$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){a=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);if(1===a.length)return _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a[0]]:b(c[a[0]])});if(void 0===path$$module$node_modules$rambda$dist$rambda_mjs(a,c))return c;b=modifyPath$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,1),b,c[a[0]]);return b===c[a[0]]?c:assoc$$module$node_modules$rambda$dist$rambda_mjs(a[0],\nb,c)}const modifyPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs);function modulo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>modulo$$module$node_modules$rambda$dist$rambda_mjs(a,c):a%b}\nfunction moveFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(0>a||0>b)throw Error("Rambda.move does not support negative indexes");if(a>c.length-1||b>c.length-1)return c;const d=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);d[a]=c[b];d[b]=c[a];return d}const move$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(moveFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction multiply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>multiply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a*b}function negate$$module$node_modules$rambda$dist$rambda_mjs(a){return-a}function none$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>none$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(a(b[c]))return!1;return!0}\nfunction not$$module$node_modules$rambda$dist$rambda_mjs(a){return!a}function objOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>objOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):{[a]:b}}function of$$module$node_modules$rambda$dist$rambda_mjs(a){return[a]}\nfunction omit$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>omit$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(null!==b&&void 0!==b){var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={};for(const e in b)c.includes(e)||(d[e]=b[e]);return d}}\nfunction on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,d){return 3===arguments.length?e=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,e):2===arguments.length?(e,f)=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,e,f):a(b(c),b(d))}function onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b){let c;return function(){a&&(c=a.apply(b||this,arguments),a=null);return c}}\nfunction once$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length){const c=onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b);return curry$$module$node_modules$rambda$dist$rambda_mjs(c)}return onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function or$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>or$$module$node_modules$rambda$dist$rambda_mjs(a,c):a||b}const Identity$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(a))});\nfunction overFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(d=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(d)))(c).x}const over$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(overFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction partial$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=a.length;return(...d)=>b.length+d.length>=c?a(...b,...d):partial$$module$node_modules$rambda$dist$rambda_mjs(a,...[...b,...d])}function partialObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return c=>a(mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={},d={};Object.entries(b).forEach(([e,f])=>{a(f,e)?c[e]=f:d[e]=f});return[c,d]}function partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){const d=[],e=[];let f=-1;for(;f++<b.length-1;)(c?a(b[f],f):a(b[f]))?d.push(b[f]):e.push(b[f]);return[d,e]}\nfunction partition$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>partition$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction pathEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a,c),b)}const pathEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathEqFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction pathOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,path$$module$node_modules$rambda$dist$rambda_mjs(b,c))}const pathOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathOrFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction paths$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>paths$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.map(c=>path$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction pick$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pick$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)c[e]in b&&(d[c[e]]=b[c[e]]),e++;return d}}\nfunction pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)d[c[e]]=c[e]in b?b[c[e]]:void 0,e++;return d}}\nfunction pluck$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>pluck$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=[];map$$module$node_modules$rambda$dist$rambda_mjs(d=>{void 0!==d[a]&&c.push(d[a])},b);return c}function prepend$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>prepend$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof b?[a].concat(b.split("")):[a].concat(b)}\nconst product$$module$node_modules$rambda$dist$rambda_mjs=reduce$$module$node_modules$rambda$dist$rambda_mjs(multiply$$module$node_modules$rambda$dist$rambda_mjs,1);function propEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?equals$$module$node_modules$rambda$dist$rambda_mjs(b,prop$$module$node_modules$rambda$dist$rambda_mjs(a,c)):!1}const propEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propEqFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction propIsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return is$$module$node_modules$rambda$dist$rambda_mjs(a,c[b])}const propIs$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propIsFn$$module$node_modules$rambda$dist$rambda_mjs);function propOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c[b]):a}const propOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propOrFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction props$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>props$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error("propsToPick is not a list");return mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>b[c],a)}function propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(prop$$module$node_modules$rambda$dist$rambda_mjs(b,c))}\nconst propSatisfies$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction range$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>range$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(Number.isNaN(Number(a))||Number.isNaN(Number(b)))throw new TypeError("Both arguments to range must be numbers");if(b<a)return[];const c=b-a,d=Array(c);for(let e=0;e<c;e++)d[e]=a+e;return d}\nfunction reject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>reject$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!a(c),b)}function repeat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>repeat$$module$node_modules$rambda$dist$rambda_mjs(a,c):Array(b).fill(a)}function replaceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.replace(a,b)}\nconst replace$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(replaceFn$$module$node_modules$rambda$dist$rambda_mjs);function reverse$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.split("").reverse().join(""):a.slice().reverse()}function setFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return over$$module$node_modules$rambda$dist$rambda_mjs(a,always$$module$node_modules$rambda$dist$rambda_mjs(b),c)}\nconst set$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(setFn$$module$node_modules$rambda$dist$rambda_mjs);function sliceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.slice(a,b)}const slice$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(sliceFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction sort$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sort$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort(a)}function sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort((c,d)=>{c=a(c);d=a(d);return c===d?0:c<d?-1:1})}\nfunction split$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>split$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.split(a)}function maybe$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b=a&&"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(b)?b():b;c=a||"Function"!==type$$module$node_modules$rambda$dist$rambda_mjs(c)?c:c();return a?b:c}\nfunction take$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>take$$module$node_modules$rambda$dist$rambda_mjs(a,c):0>a?b.slice():"string"===typeof b?b.slice(0,a):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,0,a)}\nfunction splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!b)throw new TypeError(`Cannot read property \'slice\' of ${b}`);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b)&&"string"!==typeof b)return[[],[]];const c=maybe$$module$node_modules$rambda$dist$rambda_mjs(0>a,0>b.length+a?0:b.length+a,a);return[take$$module$node_modules$rambda$dist$rambda_mjs(c,b),drop$$module$node_modules$rambda$dist$rambda_mjs(c,\nb)]}function splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(1>a)throw Error("First argument to splitEvery must be a positive integer");const c=[];let d=0;for(;d<b.length;)c.push(b.slice(d,d+=a));return c}\nfunction splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(!b)throw new TypeError(`Cannot read property \'length\' of ${b}`);const c=[],d=[];let e=!1,f=-1;for(;f++<b.length-1;)e?d.push(b[f]):a(b[f])?(d.push(b[f]),e=!0):c.push(b[f]);return[c,d]}\nfunction startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.startsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;let c=!0;return a.filter((d,e)=>{if(!c)return!1;(d=equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]))||(c=!1);return d}).length===a.length}\nfunction subtract$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>subtract$$module$node_modules$rambda$dist$rambda_mjs(a,c):a-b}\nfunction symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,c):concat$$module$node_modules$rambda$dist$rambda_mjs(filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b),a),filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b))}\nfunction T$$module$node_modules$rambda$dist$rambda_mjs(){return!0}function tail$$module$node_modules$rambda$dist$rambda_mjs(a){return drop$$module$node_modules$rambda$dist$rambda_mjs(1,a)}\nfunction takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;if(0>a)return b.slice();let d=a>c?c:a;return"string"===typeof b?b.slice(c-d):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,c-d,c)}\nfunction takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(0===b.length)return b;let c=!1;const d=[];let e=b.length;for(;!c||0===e;)e--,!1===a(b[e])?c=!0:c||d.push(b[e]);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?d.reverse():d.reverse().join("")}\nfunction takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!0;const e=[];let f=-1;for(;f++<b.length-1;)a(b[f])?d&&e.push(b[f]):d&&(d=!1);return c?e:e.join("")}\nfunction tap$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>tap$$module$node_modules$rambda$dist$rambda_mjs(a,c);a(b);return b}function test$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>test$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof a)throw new TypeError(`\\u2018test\\u2019 requires a value of type RegExp as its first argument; received "${a}"`);return-1!==b.search(a)}\nfunction times$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>times$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||0>b)throw new RangeError("n must be an integer");return map$$module$node_modules$rambda$dist$rambda_mjs(a,range$$module$node_modules$rambda$dist$rambda_mjs(0,b))}function toLower$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toLowerCase()}\nfunction toPairs$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.entries(a)}function toString$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toString()}function toUpper$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toUpperCase()}function transpose$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>{c.forEach((d,e)=>isArray$$module$node_modules$rambda$dist$rambda_mjs(b[e])?b[e].push(d):b.push([d]));return b},[])}\nfunction trim$$module$node_modules$rambda$dist$rambda_mjs(a){return a.trim()}const isFunction$$module$node_modules$rambda$dist$rambda_mjs=a=>["Promise","Function"].includes(type$$module$node_modules$rambda$dist$rambda_mjs(a));\nfunction tryCatch$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isFunction$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`R.tryCatch | fn \'${a}\'`);const c=isFunction$$module$node_modules$rambda$dist$rambda_mjs(b);return(...d)=>{try{return a(...d)}catch(e){return c?b(e,...d):b}}}function unapply$$module$node_modules$rambda$dist$rambda_mjs(a){return function(...b){return a.call(this,b)}}\nfunction union$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>union$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(a);b.forEach(d=>{includes$$module$node_modules$rambda$dist$rambda_mjs(d,a)||c.push(d)});return c}\nfunction uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=new Set;return b.filter(d=>{if(c.has(a(d)))return!1;c.add(a(d));return!0})}function includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=!1,e=-1;for(;++e<c.length&&!d;)a(b,c[e])&&(d=!0);return d}\nfunction uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=-1;const d=[];for(;++c<b.length;){const e=b[c];includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,e,d)||d.push(e)}return d}function unless$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unless$$module$node_modules$rambda$dist$rambda_mjs(a,c):c=>a(c)?c:b(c)}\nfunction unwind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unwind$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b[a])?mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},b),{},{[a]:c}),b[a]):[b]}\nfunction values$$module$node_modules$rambda$dist$rambda_mjs(a){return"Object"!==type$$module$node_modules$rambda$dist$rambda_mjs(a)?[]:Object.values(a)}const Const$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Const$$module$node_modules$rambda$dist$rambda_mjs(a)});function view$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>view$$module$node_modules$rambda$dist$rambda_mjs(a,c):a(Const$$module$node_modules$rambda$dist$rambda_mjs)(b).x}\nfunction whenFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)?b(c):c}const when$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(whenFn$$module$node_modules$rambda$dist$rambda_mjs);function where$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return d=>where$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=!0;for(const d in a){if(!c)continue;const e=a[d](b[d]);c&&!1===e&&(c=!1)}return c}\nfunction whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return c=>whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(const c in a)if(a[c](b[c]))return!0;return!1}\nfunction whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=filter$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]),a);return Object.keys(c).length===Object.keys(a).length}\nfunction without$$module$node_modules$rambda$dist$rambda_mjs(a,b){return void 0===b?c=>without$$module$node_modules$rambda$dist$rambda_mjs(a,c):reduce$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,a)?c:c.concat(d),[],b)}function xor$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>xor$$module$node_modules$rambda$dist$rambda_mjs(a,c):!!a&&!b||!!b&&!a}\nfunction zip$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>zip$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=[],d=Math.min(a.length,b.length);for(let e=0;e<d;e++)c[e]=[a[e],b[e]];return c}function zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,c):take$$module$node_modules$rambda$dist$rambda_mjs(b.length,a).reduce((c,d,e)=>{c[d]=b[e];return c},{})}\nfunction zipWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return take$$module$node_modules$rambda$dist$rambda_mjs(b.length>c.length?c.length:b.length,b).map((d,e)=>a(d,c[e]))}const zipWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(zipWithFn$$module$node_modules$rambda$dist$rambda_mjs);var module$node_modules$rambda$dist$rambda_mjs={};module$node_modules$rambda$dist$rambda_mjs.F=F$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.T=T$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.__findHighestArity=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._arity=_arity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._indexOf=_indexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._lastIndexOf=_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs._pipe=_pipe$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.add=add$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.adjust=adjust$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.all=all$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.allPass=allPass$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.always=always$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.and=and$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.any=any$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.anyPass=anyPass$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.append=append$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.apply=apply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.applySpec=applySpec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assoc=assoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assocPath=assocPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.bind=bind$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.both=both$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.chain=chain$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clamp=clamp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clone=clone$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.complement=complement$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.compose=compose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.concat=concat$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.cond=cond$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.converge=converge$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.count=count$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.countBy=countBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curry=curry$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curryN=curryN$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dec=dec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.defaultTo=defaultTo$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.difference=difference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dissoc=dissoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.divide=divide$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.drop=drop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropLast=dropLast$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.dropLastWhile=dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeats=dropRepeats$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeatsWith=dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropWhile=dropWhile$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.either=either$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.endsWith=endsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.eqProps=eqProps$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.equals=equals$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolve=evolve$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.evolveArray=evolveArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolveObject=evolveObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filter=filter$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterArray=filterArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterObject=filterObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.find=find$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findIndex=findIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLast=findLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLastIndex=findLastIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.flatten=flatten$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.flip=flip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.forEach=forEach$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.fromPairs=fromPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupBy=groupBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupWith=groupWith$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.has=has$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.hasPath=hasPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.head=head$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identical=identical$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identity=identity$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.ifElse=ifElse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.inc=inc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.includes=includes$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexBy=indexBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexOf=indexOf$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.init=init$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersection=intersection$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersperse=intersperse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.is=is$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.isEmpty=isEmpty$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.isNil=isNil$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.join=join$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.juxt=juxt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.keys=keys$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.last=last$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.lastIndexOf=lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.length=length$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lens=lens$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensIndex=lensIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensPath=lensPath$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.lensProp=lensProp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.map=map$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapArray=mapArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObjIndexed=mapObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObject=mapObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.match=match$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mathMod=mathMod$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.max=max$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxBy=maxBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxByFn=maxByFn$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.mean=mean$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.median=median$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.merge=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeAll=mergeAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeDeepRight=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.mergeLeft=mergeLeft$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeRight=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeWith=mergeWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.min=min$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.minBy=minBy$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.minByFn=minByFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modify=modify$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPath=modifyPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPathFn=modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modulo=modulo$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.move=move$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.multiply=multiply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.negate=negate$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.none=none$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.not=not$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.nth=nth$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.objOf=objOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.of=of$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.omit=omit$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.on=on$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.once=once$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.or=or$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.over=over$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partial=partial$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partialObject=partialObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.partition=partition$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionArray=partitionArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionObject=partitionObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.path=path$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pathEq=pathEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.pathOr=pathOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.paths=paths$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pick=pick$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pickAll=pickAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pipe=pipe$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.pluck=pluck$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prepend=prepend$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.product=product$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prop=prop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propEq=propEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.propIs=propIs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propOr=propOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propSatisfies=propSatisfies$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.props=props$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.range=range$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.reduce=reduce$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceFn=reduceFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceStopper=reduceStopper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reject=reject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.repeat=repeat$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.replace=replace$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reverse=reverse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.set=set$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.slice=slice$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sort=sort$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.sortBy=sortBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.split=split$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitAt=splitAt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitEvery=splitEvery$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitWhen=splitWhen$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.startsWith=startsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.subtract=subtract$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sum=sum$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.symmetricDifference=symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tail=tail$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.take=take$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLast=takeLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLastWhile=takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeWhile=takeWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tap=tap$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.test=test$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.times=times$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toLower=toLower$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toPairs=toPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toString=toString$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.toUpper=toUpper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.transpose=transpose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.trim=trim$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tryCatch=tryCatch$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.type=type$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.unapply=unapply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.union=union$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniq=uniq$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqBy=uniqBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqWith=uniqWith$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.unless=unless$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.unwind=unwind$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.update=update$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.updateFn=updateFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.values=values$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.view=view$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.when=when$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.where=where$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereAny=whereAny$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereEq=whereEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.without=without$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.xor=xor$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zip=zip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipObj=zipObj$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipWith=zipWith$$module$node_modules$rambda$dist$rambda_mjs;const csoundSetMidiCallbacks$$module$src$modules$rtmidi=a=>b=>{a.exports.csoundSetMidiCallbacks(b)},csoundGetMIDIDevList$$module$src$modules$rtmidi=a=>(b,c)=>{const {buffer:d}=a.wasi.memory,e=a.exports.csoundGetMIDIDevList(b,void 0,c?1:0);if(0===e)return[];const f=sizeofStruct$$module$src$utils$native_sizes(CS_MIDIDEVICE$$module$src$structures),g=a.exports.allocCsMidiDeviceStruct(e);a.exports.csoundGetMIDIDevList(b,g,c?1:0);const h=new Uint8Array(d,g,f*e);b=range$$module$node_modules$rambda$dist$rambda_mjs(0,\ne).map(k=>structBufferToObject$$module$src$utils$structure_buffer_to_object(CS_MIDIDEVICE$$module$src$structures,h.subarray(k*f,f)));a.exports.freeCsMidiDeviceStruct(g);return b};csoundGetMIDIDevList$$module$src$modules$rtmidi.toString=()=>"getMIDIDevList = async (isOutput) => Object;";\nconst csoundGetRtMidiName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getRtMidiName(b);c=new Uint8Array(c,b,128);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetRtMidiName$$module$src$modules$rtmidi.toString=()=>"getRtMidiName = async () => String;";\nconst csoundGetMidiOutFileName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getMidiOutFileName(b);c=new Uint8Array(c,b,128);b&&0<b.length&&freeStringPtr$$module$src$utils$string_pointers(a,b);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""},_isRequestingRtMidiInput$$module$src$modules$rtmidi=a=>b=>a.exports.isRequestingRtMidiInput(b),csoundPushMidiMessage$$module$src$modules$rtmidi=a=>(b,c,d,e)=>{a.exports.pushMidiMessage(b,\nc,d,e)};csoundPushMidiMessage$$module$src$modules$rtmidi.toString=()=>"midiMessage = async (status, data1, data2) => undefined;";var module$src$modules$rtmidi={};module$src$modules$rtmidi._isRequestingRtMidiInput=_isRequestingRtMidiInput$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMIDIDevList=csoundGetMIDIDevList$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMidiOutFileName=csoundGetMidiOutFileName$$module$src$modules$rtmidi;\nmodule$src$modules$rtmidi.csoundGetRtMidiName=csoundGetRtMidiName$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundPushMidiMessage=csoundPushMidiMessage$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundSetMidiCallbacks=csoundSetMidiCallbacks$$module$src$modules$rtmidi;const csoundInputMessage$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessage(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessage$$module$src$modules$control_events.toString=()=>"inputMessage = async (scoreEvent) => Number;";\nconst csoundInputMessageAsync$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessageAsync(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessageAsync$$module$src$modules$control_events.toString=()=>"inputMessageAsync = async (scoreEvent) => Number;";\nconst csoundGetControlChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetControlChannelWasi(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundGetControlChannel$$module$src$modules$control_events.toString=()=>"getControlChannel = async (channelName) => Number;";\nconst csoundSetControlChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);a.exports.csoundSetControlChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c)};csoundSetControlChannel$$module$src$modules$control_events.toString=()=>"setControlChannel = async (channelName, value) => void;";\nconst csoundGetStringChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetStringChannelWasi(b,c);const d=ptr2string$$module$src$utils$string_pointers(a,b);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,b);return d};csoundGetStringChannel$$module$src$modules$control_events.toString=()=>"getStringChannel = async (channelName) => String;";\nconst csoundSetStringChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);a.exports.csoundSetStringChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d)};csoundSetStringChannel$$module$src$modules$control_events.toString=()=>"setStringChannel = async (channelName, value) => void;";var module$src$modules$control_events={};\nmodule$src$modules$control_events.csoundGetControlChannel=csoundGetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundGetStringChannel=csoundGetStringChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessage=csoundInputMessage$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessageAsync=csoundInputMessageAsync$$module$src$modules$control_events;\nmodule$src$modules$control_events.csoundSetControlChannel=csoundSetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundSetStringChannel=csoundSetStringChannel$$module$src$modules$control_events;const csoundGetOutputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetOutputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetOutputName$$module$src$modules$general_io.toString=()=>"getOutputName = async () => String;";\nconst csoundGetInputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetInputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetInputName$$module$src$modules$general_io.toString=()=>"getInputName = async (csound) => String;";var module$src$modules$general_io={};module$src$modules$general_io.csoundGetInputName=csoundGetInputName$$module$src$modules$general_io;\nmodule$src$modules$general_io.csoundGetOutputName=csoundGetOutputName$$module$src$modules$general_io;const csoundAppendEnv$$module$src$modules$extra=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);b=a.exports.csoundAppendEnv(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d);return b};csoundAppendEnv$$module$src$modules$extra.toString=()=>"appendEnv = async (csound, variable, value) => Number;";const csoundShouldDaemonize$$module$src$modules$extra=a=>b=>a.exports.csoundShouldDaemonize(b);\nvar module$src$modules$extra={};module$src$modules$extra.csoundAppendEnv=csoundAppendEnv$$module$src$modules$extra;module$src$modules$extra.csoundShouldDaemonize=csoundShouldDaemonize$$module$src$modules$extra;const csoundIsScorePending$$module$src$modules$score_handling=a=>b=>a.exports.csoundIsScorePending(b);csoundIsScorePending$$module$src$modules$score_handling.toString=()=>"isScorePending = async () => Number;";const csoundSetScorePending$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScorePending(b,c);csoundSetScorePending$$module$src$modules$score_handling.toString=()=>"setScorePending = async (pending) => Number;";\nconst csoundReadScore$$module$src$modules$score_handling=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundReadScore(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundReadScore$$module$src$modules$score_handling.toString=()=>"readScore = async (score) => Number;";const csoundGetScoreTime$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreTime(b);csoundGetScoreTime$$module$src$modules$score_handling.toString=()=>"getScoreTime = async () => Number;";\nconst csoundGetScoreOffsetSeconds$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreOffsetSeconds(b);csoundGetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"getScoreOffsetSeconds = async () => Number;";const csoundSetScoreOffsetSeconds$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScoreOffsetSeconds(b,c);csoundSetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"setScoreOffsetSeconds = async () => Number;";\nconst csoundRewindScore$$module$src$modules$score_handling=a=>b=>a.exports.csoundRewindScore(b);csoundRewindScore$$module$src$modules$score_handling.toString=()=>"rewindScore = async () => undefined;";var module$src$modules$score_handling={};module$src$modules$score_handling.csoundGetScoreOffsetSeconds=csoundGetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundGetScoreTime=csoundGetScoreTime$$module$src$modules$score_handling;\nmodule$src$modules$score_handling.csoundIsScorePending=csoundIsScorePending$$module$src$modules$score_handling;module$src$modules$score_handling.csoundReadScore=csoundReadScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundRewindScore=csoundRewindScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScoreOffsetSeconds=csoundSetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScorePending=csoundSetScorePending$$module$src$modules$score_handling;const csoundTableLength$$module$src$modules$table=a=>(b,c)=>a.exports.csoundTableLength(b,c);csoundTableLength$$module$src$modules$table.toString=()=>"tableLength = async (tableNum) => Number;";const csoundTableGet$$module$src$modules$table=a=>(b,c,d)=>a.exports.csoundTableGet(b,c,d);csoundTableGet$$module$src$modules$table.toString=()=>"tableGet = async (tableNum, tableIndex) => Number;";const csoundTableSet$$module$src$modules$table=a=>(b,c,d,e)=>a.exports.csoundTableSet(b,c,d,e);\ncsoundTableSet$$module$src$modules$table.toString=()=>"tableSet = async (tableNum, tableIndex, value) => undefined;";const csoundTableCopyIn$$module$src$modules$table=a=>(b,c,d)=>{const e=a.exports.allocFloatArray(d.length);(new Float64Array(a.wasi.memory.buffer,e,d.length)).set(d);a.exports.csoundTableCopyIn(b,c,e);a.exports.freeFloatArrayMem(e)};csoundTableCopyIn$$module$src$modules$table.toString=()=>"tableCopyIn = async (tableNum, float64Array) => undefined;";\nconst csoundTableCopyOut$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundTableLength(b,c);if(0<d){const e=a.exports.allocFloatArray(d);a.exports.csoundTableCopyOut(b,c,e);({buffer:b}=a.wasi.memory);d=new Float64Array(b,e,d);a.exports.freeFloatArrayMem(e);return Float64Array.from(d)}};csoundTableCopyOut$$module$src$modules$table.toString=()=>"tableCopyOut = async (tableNum) => ?Float64Array;";const csoundGetTable$$module$src$modules$table=csoundTableCopyOut$$module$src$modules$table;\ncsoundTableCopyOut$$module$src$modules$table.toString=csoundTableCopyOut$$module$src$modules$table.toString;const csoundGetTableArgs$$module$src$modules$table=a=>(b,c)=>{const d=a.exports.allocFloatArray(1024);a.exports.csoundGetTableArgs(b,d,c);({buffer:b}=a.wasi.memory);b=new Float64Array(b,d,1024);a.exports.freeFloatArrayMem(d);return b};csoundGetTableArgs$$module$src$modules$table.toString=()=>"getTableArgs = async (tableNum) => ?Float64Array;";\nconst csoundIsNamedGEN$$module$src$modules$table=a=>(b,c)=>a.exports.csoundIsNamedGEN(b,c);csoundIsNamedGEN$$module$src$modules$table.toString=()=>"isNamedGEN = async (tableNum) => number;";const csoundGetNamedGEN$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundIsNamedGEN(b,c);if(0<d){const e=a.exports.allocStringMem(d);a.exports.csoundGetNamedGEN(b,e,c,d);({buffer:b}=a.wasi.memory);d=new Uint8Array(b,e,d);return uint2String$$module$src$utils$text_encoders(d)}};\ncsoundGetNamedGEN$$module$src$modules$table.toString=()=>"getNamedGEN = async (tableNum) => ?string;";var module$src$modules$table={};module$src$modules$table.csoundGetNamedGEN=csoundGetNamedGEN$$module$src$modules$table;module$src$modules$table.csoundGetTable=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundGetTableArgs=csoundGetTableArgs$$module$src$modules$table;module$src$modules$table.csoundIsNamedGEN=csoundIsNamedGEN$$module$src$modules$table;\nmodule$src$modules$table.csoundTableCopyIn=csoundTableCopyIn$$module$src$modules$table;module$src$modules$table.csoundTableCopyOut=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundTableGet=csoundTableGet$$module$src$modules$table;module$src$modules$table.csoundTableLength=csoundTableLength$$module$src$modules$table;module$src$modules$table.csoundTableSet=csoundTableSet$$module$src$modules$table;function writeFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.writeFile(c,b)}}writeFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";function appendFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.appendFile(c,b)}}appendFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";\nfunction readFile$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readFile(c)}readFile$$module$src$filesystem$worker_fs.toString=()=>"async (path) => ?Uint8Array";function unlink$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.unlink(c)}unlink$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";function readdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readdir(c)}readdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => string[]";\nfunction mkdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.mkdir(c)}mkdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";var module$src$filesystem$worker_fs={};module$src$filesystem$worker_fs.appendFile=appendFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.mkdir=mkdir$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readFile=readFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readdir=readdir$$module$src$filesystem$worker_fs;\nmodule$src$filesystem$worker_fs.unlink=unlink$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.writeFile=writeFile$$module$src$filesystem$worker_fs;const api$$module$src$libcsound={csoundCreate:csoundCreate$$module$src$modules$instantiation,csoundDestroy:csoundDestroy$$module$src$modules$instantiation,csoundGetAPIVersion:csoundGetAPIVersion$$module$src$modules$instantiation,csoundGetVersion:csoundGetVersion$$module$src$modules$instantiation,csoundInitialize:csoundInitialize$$module$src$modules$instantiation,csoundParseOrc:csoundParseOrc$$module$src$modules$performance,csoundCompileTree:csoundCompileTree$$module$src$modules$performance,csoundCompileOrc:csoundCompileOrc$$module$src$modules$performance,\ncsoundEvalCode:csoundEvalCode$$module$src$modules$performance,csoundStart:csoundStart$$module$src$modules$performance,csoundCompileCsd:csoundCompileCsd$$module$src$modules$performance,csoundCompileCsdText:csoundCompileCsdText$$module$src$modules$performance,csoundPerform:csoundPerform$$module$src$modules$performance,csoundPerformKsmps:csoundPerformKsmps$$module$src$modules$performance,csoundPerformBuffer:csoundPerformBuffer$$module$src$modules$performance,csoundStop:csoundStop$$module$src$modules$performance,\ncsoundCleanup:csoundCleanup$$module$src$modules$performance,csoundReset:csoundReset$$module$src$modules$performance,csoundGetSr:csoundGetSr$$module$src$modules$attributes,csoundGetKr:csoundGetKr$$module$src$modules$attributes,csoundGetKsmps:csoundGetKsmps$$module$src$modules$attributes,csoundGetNchnls:csoundGetNchnls$$module$src$modules$attributes,csoundGetNchnlsInput:csoundGetNchnlsInput$$module$src$modules$attributes,csoundGet0dBFS:csoundGet0dBFS$$module$src$modules$attributes,csoundGetA4:csoundGetA4$$module$src$modules$attributes,\ncsoundGetCurrentTimeSamples:csoundGetCurrentTimeSamples$$module$src$modules$attributes,csoundGetSizeOfMYFLT:csoundGetSizeOfMYFLT$$module$src$modules$attributes,csoundSetOption:csoundSetOption$$module$src$modules$attributes,csoundSetParams:csoundSetParams$$module$src$modules$attributes,csoundGetParams:csoundGetParams$$module$src$modules$attributes,csoundGetDebug:csoundGetDebug$$module$src$modules$attributes,csoundSetDebug:csoundSetDebug$$module$src$modules$attributes,csoundGetInputBufferSize:csoundGetInputBufferSize$$module$src$modules$rtaudio,\ncsoundGetOutputBufferSize:csoundGetOutputBufferSize$$module$src$modules$rtaudio,csoundGetInputBuffer:csoundGetInputBuffer$$module$src$modules$rtaudio,csoundGetOutputBuffer:csoundGetOutputBuffer$$module$src$modules$rtaudio,csoundGetSpin:csoundGetSpin$$module$src$modules$rtaudio,csoundGetSpout:csoundGetSpout$$module$src$modules$rtaudio,csoundGetMIDIDevList:csoundGetMIDIDevList$$module$src$modules$rtmidi,csoundSetMidiCallbacks:csoundSetMidiCallbacks$$module$src$modules$rtmidi,csoundGetRtMidiName:csoundGetRtMidiName$$module$src$modules$rtmidi,\ncsoundGetMidiOutFileName:csoundGetMidiOutFileName$$module$src$modules$rtmidi,csoundPushMidiMessage:csoundPushMidiMessage$$module$src$modules$rtmidi,_isRequestingRtMidiInput:_isRequestingRtMidiInput$$module$src$modules$rtmidi,csoundInputMessage:csoundInputMessage$$module$src$modules$control_events,csoundInputMessageAsync:csoundInputMessageAsync$$module$src$modules$control_events,csoundGetControlChannel:csoundGetControlChannel$$module$src$modules$control_events,csoundSetControlChannel:csoundSetControlChannel$$module$src$modules$control_events,\ncsoundGetStringChannel:csoundGetStringChannel$$module$src$modules$control_events,csoundSetStringChannel:csoundSetStringChannel$$module$src$modules$control_events,csoundGetInputName:csoundGetInputName$$module$src$modules$general_io,csoundGetOutputName:csoundGetOutputName$$module$src$modules$general_io,csoundAppendEnv:csoundAppendEnv$$module$src$modules$extra,csoundShouldDaemonize:csoundShouldDaemonize$$module$src$modules$extra,csoundIsScorePending:csoundIsScorePending$$module$src$modules$score_handling,\ncsoundSetScorePending:csoundSetScorePending$$module$src$modules$score_handling,csoundReadScore:csoundReadScore$$module$src$modules$score_handling,csoundGetScoreTime:csoundGetScoreTime$$module$src$modules$score_handling,csoundGetScoreOffsetSeconds:csoundGetScoreOffsetSeconds$$module$src$modules$score_handling,csoundSetScoreOffsetSeconds:csoundSetScoreOffsetSeconds$$module$src$modules$score_handling,csoundRewindScore:csoundRewindScore$$module$src$modules$score_handling,csoundTableLength:csoundTableLength$$module$src$modules$table,\ncsoundTableGet:csoundTableGet$$module$src$modules$table,csoundTableSet:csoundTableSet$$module$src$modules$table,csoundTableCopyIn:csoundTableCopyIn$$module$src$modules$table,csoundTableCopyOut:csoundTableCopyOut$$module$src$modules$table,csoundGetTable:csoundTableCopyOut$$module$src$modules$table,csoundGetTableArgs:csoundGetTableArgs$$module$src$modules$table,csoundIsNamedGEN:csoundIsNamedGEN$$module$src$modules$table,csoundGetNamedGEN:csoundGetNamedGEN$$module$src$modules$table,fs:module$src$filesystem$worker_fs};\nvar $jscompDefaultExport$$module$src$libcsound=function(a){return mergeAll$$module$node_modules$rambda$dist$rambda_mjs([reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,api$$module$src$libcsound[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(dissoc$$module$node_modules$rambda$dist$rambda_mjs("fs")(api$$module$src$libcsound))),reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,\napi$$module$src$libcsound.fs[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(module$src$filesystem$worker_fs))])},module$src$libcsound={};module$src$libcsound.api=api$$module$src$libcsound;module$src$libcsound.default=$jscompDefaultExport$$module$src$libcsound;const dlinit$$module$src$dlinit=(a,b,c,d)=>{if(b.exports.csoundModuleInit){var e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=new WebAssembly.Global({value:"i32",mutable:!0},0);const h=new WebAssembly.Global({value:"i32",mutable:!0},0);let k=c.length;"function"===typeof b.exports.csoundModuleCreate&&(c.grow(1),e.value=k,c.set(k,b.exports.csoundModuleCreate),k+=1);"function"===typeof b.exports.csoundModuleInit&&(c.grow(1),f.value=k,c.set(k,\nb.exports.csoundModuleInit),k+=1);"function"===typeof b.exports.csoundModuleDestroy&&(c.grow(1),g.value=k,c.set(k,b.exports.csoundModuleDestroy),k+=1);"function"===typeof b.exports.csoundModuleErrorCodeToString&&(c.grow(1),h.value=k,c.set(k,b.exports.csoundModuleErrorCodeToString));a.exports.csoundWasiLoadPlugin(d,e,f,g,h)}else b.exports.csound_opcode_init||b.exports.csound_fgen_init?(e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=c.length,\n"function"===typeof b.exports.csound_opcode_init&&(e.value=g,c.grow(1),c.set(g,b.exports.csound_opcode_init),g+=1),"function"===typeof b.exports.csound_fgen_init&&(f.value=g,c.grow(1),c.set(g,b.exports.csound_fgen_init)),a.exports.csoundWasiLoadOpcodeLibrary(d,f,e)):console.error("Plugin doesn\'t export nececcary functions to quality as csound plugin.")};var module$src$dlinit={};module$src$dlinit.dlinit=dlinit$$module$src$dlinit;void 0!==goog.global&&(goog.global={});goog.global.BigInt||(goog.global.BigInt=void 0===BigInt?Number:BigInt);\nconst WASI_ESUCCESS$$module$src$filesystem$constants=0,WASI_E2BIG$$module$src$filesystem$constants=1,WASI_EACCES$$module$src$filesystem$constants=2,WASI_EADDRINUSE$$module$src$filesystem$constants=3,WASI_EADDRNOTAVAIL$$module$src$filesystem$constants=4,WASI_EAFNOSUPPORT$$module$src$filesystem$constants=5,WASI_EAGAIN$$module$src$filesystem$constants=6,WASI_EALREADY$$module$src$filesystem$constants=7,WASI_EBADF$$module$src$filesystem$constants=8,WASI_EBADMSG$$module$src$filesystem$constants=9,WASI_EBUSY$$module$src$filesystem$constants=\n10,WASI_ECANCELED$$module$src$filesystem$constants=11,WASI_ECHILD$$module$src$filesystem$constants=12,WASI_ECONNABORTED$$module$src$filesystem$constants=13,WASI_ECONNREFUSED$$module$src$filesystem$constants=14,WASI_ECONNRESET$$module$src$filesystem$constants=15,WASI_EDEADLK$$module$src$filesystem$constants=16,WASI_EDESTADDRREQ$$module$src$filesystem$constants=17,WASI_EDOM$$module$src$filesystem$constants=18,WASI_EDQUOT$$module$src$filesystem$constants=19,WASI_EEXIST$$module$src$filesystem$constants=\n20,WASI_EFAULT$$module$src$filesystem$constants=21,WASI_EFBIG$$module$src$filesystem$constants=22,WASI_EHOSTUNREACH$$module$src$filesystem$constants=23,WASI_EIDRM$$module$src$filesystem$constants=24,WASI_EILSEQ$$module$src$filesystem$constants=25,WASI_EINPROGRESS$$module$src$filesystem$constants=26,WASI_EINTR$$module$src$filesystem$constants=27,WASI_EINVAL$$module$src$filesystem$constants=28,WASI_EIO$$module$src$filesystem$constants=29,WASI_EISCONN$$module$src$filesystem$constants=30,WASI_EISDIR$$module$src$filesystem$constants=\n31,WASI_ELOOP$$module$src$filesystem$constants=32,WASI_EMFILE$$module$src$filesystem$constants=33,WASI_EMLINK$$module$src$filesystem$constants=34,WASI_EMSGSIZE$$module$src$filesystem$constants=35,WASI_EMULTIHOP$$module$src$filesystem$constants=36,WASI_ENAMETOOLONG$$module$src$filesystem$constants=37,WASI_ENETDOWN$$module$src$filesystem$constants=38,WASI_ENETRESET$$module$src$filesystem$constants=39,WASI_ENETUNREACH$$module$src$filesystem$constants=40,WASI_ENFILE$$module$src$filesystem$constants=41,\nWASI_ENOBUFS$$module$src$filesystem$constants=42,WASI_ENODEV$$module$src$filesystem$constants=43,WASI_ENOENT$$module$src$filesystem$constants=44,WASI_ENOEXEC$$module$src$filesystem$constants=45,WASI_ENOLCK$$module$src$filesystem$constants=46,WASI_ENOLINK$$module$src$filesystem$constants=47,WASI_ENOMEM$$module$src$filesystem$constants=48,WASI_ENOMSG$$module$src$filesystem$constants=49,WASI_ENOPROTOOPT$$module$src$filesystem$constants=50,WASI_ENOSPC$$module$src$filesystem$constants=51,WASI_ENOSYS$$module$src$filesystem$constants=\n52,WASI_ENOTCONN$$module$src$filesystem$constants=53,WASI_ENOTDIR$$module$src$filesystem$constants=54,WASI_ENOTEMPTY$$module$src$filesystem$constants=55,WASI_ENOTRECOVERABLE$$module$src$filesystem$constants=56,WASI_ENOTSOCK$$module$src$filesystem$constants=57,WASI_ENOTSUP$$module$src$filesystem$constants=58,WASI_ENOTTY$$module$src$filesystem$constants=59,WASI_ENXIO$$module$src$filesystem$constants=60,WASI_EOVERFLOW$$module$src$filesystem$constants=61,WASI_EOWNERDEAD$$module$src$filesystem$constants=\n62,WASI_EPERM$$module$src$filesystem$constants=63,WASI_EPIPE$$module$src$filesystem$constants=64,WASI_EPROTO$$module$src$filesystem$constants=65,WASI_EPROTONOSUPPORT$$module$src$filesystem$constants=66,WASI_EPROTOTYPE$$module$src$filesystem$constants=67,WASI_ERANGE$$module$src$filesystem$constants=68,WASI_EROFS$$module$src$filesystem$constants=69,WASI_ESPIPE$$module$src$filesystem$constants=70,WASI_ESRCH$$module$src$filesystem$constants=71,WASI_ESTALE$$module$src$filesystem$constants=72,WASI_ETIMEDOUT$$module$src$filesystem$constants=\n73,WASI_ETXTBSY$$module$src$filesystem$constants=74,WASI_EXDEV$$module$src$filesystem$constants=75,WASI_ENOTCAPABLE$$module$src$filesystem$constants=76,WASI_SIGABRT$$module$src$filesystem$constants=0,WASI_SIGALRM$$module$src$filesystem$constants=1,WASI_SIGBUS$$module$src$filesystem$constants=2,WASI_SIGCHLD$$module$src$filesystem$constants=3,WASI_SIGCONT$$module$src$filesystem$constants=4,WASI_SIGFPE$$module$src$filesystem$constants=5,WASI_SIGHUP$$module$src$filesystem$constants=6,WASI_SIGILL$$module$src$filesystem$constants=\n7,WASI_SIGINT$$module$src$filesystem$constants=8,WASI_SIGKILL$$module$src$filesystem$constants=9,WASI_SIGPIPE$$module$src$filesystem$constants=10,WASI_SIGQUIT$$module$src$filesystem$constants=11,WASI_SIGSEGV$$module$src$filesystem$constants=12,WASI_SIGSTOP$$module$src$filesystem$constants=13,WASI_SIGTERM$$module$src$filesystem$constants=14,WASI_SIGTRAP$$module$src$filesystem$constants=15,WASI_SIGTSTP$$module$src$filesystem$constants=16,WASI_SIGTTIN$$module$src$filesystem$constants=17,WASI_SIGTTOU$$module$src$filesystem$constants=\n18,WASI_SIGURG$$module$src$filesystem$constants=19,WASI_SIGUSR1$$module$src$filesystem$constants=20,WASI_SIGUSR2$$module$src$filesystem$constants=21,WASI_SIGVTALRM$$module$src$filesystem$constants=22,WASI_SIGXCPU$$module$src$filesystem$constants=23,WASI_SIGXFSZ$$module$src$filesystem$constants=24,WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants=0,WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants=1,WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants=2,WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants=\n3,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants=4,WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants=5,WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants=6,WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants=7,WASI_FDFLAG_APPEND$$module$src$filesystem$constants=1,WASI_FDFLAG_DSYNC$$module$src$filesystem$constants=2,WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants=4,WASI_FDFLAG_RSYNC$$module$src$filesystem$constants=8,WASI_FDFLAG_SYNC$$module$src$filesystem$constants=\n16,WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants=goog.global.BigInt(1),WASI_RIGHT_FD_READ$$module$src$filesystem$constants=goog.global.BigInt(2),WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants=goog.global.BigInt(4),WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants=goog.global.BigInt(8),WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants=goog.global.BigInt(16),WASI_RIGHT_FD_TELL$$module$src$filesystem$constants=goog.global.BigInt(32),WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants=\ngoog.global.BigInt(64),WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants=goog.global.BigInt(128),WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants=goog.global.BigInt(256),WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(512),WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants=goog.global.BigInt(1024),WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(2048),WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants=\ngoog.global.BigInt(4096),WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants=goog.global.BigInt(8192),WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants=goog.global.BigInt(16384),WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants=goog.global.BigInt(32768),WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(65536),WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants=goog.global.BigInt(131072),WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants=\ngoog.global.BigInt(262144),WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(524288),WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(1048576),WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants=goog.global.BigInt(2097152),WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(4194304),WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(8388608),WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants=\ngoog.global.BigInt(16777216),WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(33554432),WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants=goog.global.BigInt(67108864),WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants=goog.global.BigInt(134217728),WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants=goog.global.BigInt(268435456),RIGHTS_ALL$$module$src$filesystem$constants=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|\nWASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|\nWASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants=\nWASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|\nWASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|\nWASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants|RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants,RIGHTS_SOCKET_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|\nWASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_SOCKET_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_TTY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,\nRIGHTS_TTY_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),WASI_CLOCK_REALTIME$$module$src$filesystem$constants=0,WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants=1,WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants=2,WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants=3,WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants=0,WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants=1,WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants=\n1,WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants=4,WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants=8,WASI_O_CREAT$$module$src$filesystem$constants=1,WASI_O_DIRECTORY$$module$src$filesystem$constants=2,WASI_O_EXCL$$module$src$filesystem$constants=4,WASI_O_TRUNC$$module$src$filesystem$constants=8,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants=0,WASI_DIRCOOKIE_START$$module$src$filesystem$constants=0,WASI_STDIN_FILENO$$module$src$filesystem$constants=\n0,WASI_STDOUT_FILENO$$module$src$filesystem$constants=1,WASI_STDERR_FILENO$$module$src$filesystem$constants=2,WASI_WHENCE_SET$$module$src$filesystem$constants=0,WASI_WHENCE_CUR$$module$src$filesystem$constants=1,WASI_WHENCE_END$$module$src$filesystem$constants=2;var module$src$filesystem$constants={};module$src$filesystem$constants.RIGHTS_ALL=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_BASE=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_INHERITING=RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.RIGHTS_REGULAR_FILE_BASE=RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_REGULAR_FILE_INHERITING=RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_BASE=RIGHTS_SOCKET_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_TTY_BASE=RIGHTS_TTY_BASE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.RIGHTS_TTY_INHERITING=RIGHTS_TTY_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_MONOTONIC=WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_PROCESS_CPUTIME_ID=WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_REALTIME=WASI_CLOCK_REALTIME$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_CLOCK_THREAD_CPUTIME_ID=WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_DIRCOOKIE_START=WASI_DIRCOOKIE_START$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_E2BIG=WASI_E2BIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EACCES=WASI_EACCES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EADDRINUSE=WASI_EADDRINUSE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EADDRNOTAVAIL=WASI_EADDRNOTAVAIL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAFNOSUPPORT=WASI_EAFNOSUPPORT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAGAIN=WASI_EAGAIN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EALREADY=WASI_EALREADY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBADF=WASI_EBADF$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EBADMSG=WASI_EBADMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBUSY=WASI_EBUSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECANCELED=WASI_ECANCELED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECHILD=WASI_ECHILD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNABORTED=WASI_ECONNABORTED$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ECONNREFUSED=WASI_ECONNREFUSED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNRESET=WASI_ECONNRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDEADLK=WASI_EDEADLK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDESTADDRREQ=WASI_EDESTADDRREQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDOM=WASI_EDOM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EDQUOT=WASI_EDQUOT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EEXIST=WASI_EEXIST$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFAULT=WASI_EFAULT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFBIG=WASI_EFBIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EHOSTUNREACH=WASI_EHOSTUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIDRM=WASI_EIDRM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EILSEQ=WASI_EILSEQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINPROGRESS=WASI_EINPROGRESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINTR=WASI_EINTR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINVAL=WASI_EINVAL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIO=WASI_EIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EISCONN=WASI_EISCONN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EISDIR=WASI_EISDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ELOOP=WASI_ELOOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMFILE=WASI_EMFILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMLINK=WASI_EMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMSGSIZE=WASI_EMSGSIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMULTIHOP=WASI_EMULTIHOP$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENAMETOOLONG=WASI_ENAMETOOLONG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETDOWN=WASI_ENETDOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETRESET=WASI_ENETRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETUNREACH=WASI_ENETUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENFILE=WASI_ENFILE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOBUFS=WASI_ENOBUFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENODEV=WASI_ENODEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOENT=WASI_ENOENT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOEXEC=WASI_ENOEXEC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLCK=WASI_ENOLCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLINK=WASI_ENOLINK$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOMEM=WASI_ENOMEM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOMSG=WASI_ENOMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOPROTOOPT=WASI_ENOPROTOOPT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSPC=WASI_ENOSPC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSYS=WASI_ENOSYS$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOTCAPABLE=WASI_ENOTCAPABLE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTCONN=WASI_ENOTCONN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTDIR=WASI_ENOTDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTEMPTY=WASI_ENOTEMPTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTRECOVERABLE=WASI_ENOTRECOVERABLE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOTSOCK=WASI_ENOTSOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTSUP=WASI_ENOTSUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTTY=WASI_ENOTTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENXIO=WASI_ENXIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EOVERFLOW=WASI_EOVERFLOW$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EOWNERDEAD=WASI_EOWNERDEAD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPERM=WASI_EPERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPIPE=WASI_EPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTO=WASI_EPROTO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTONOSUPPORT=WASI_EPROTONOSUPPORT$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EPROTOTYPE=WASI_EPROTOTYPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ERANGE=WASI_ERANGE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EROFS=WASI_EROFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESPIPE=WASI_ESPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESRCH=WASI_ESRCH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESTALE=WASI_ESTALE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ESUCCESS=WASI_ESUCCESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETIMEDOUT=WASI_ETIMEDOUT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETXTBSY=WASI_ETXTBSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_CLOCK=WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_FD_READ=WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EVENTTYPE_FD_WRITE=WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EXDEV=WASI_EXDEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_APPEND=WASI_FDFLAG_APPEND$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_DSYNC=WASI_FDFLAG_DSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_NONBLOCK=WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FDFLAG_RSYNC=WASI_FDFLAG_RSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_SYNC=WASI_FDFLAG_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM=WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM_NOW=WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_MTIM=WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FILESTAT_SET_MTIM_NOW=WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_BLOCK_DEVICE=WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_CHARACTER_DEVICE=WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_DIRECTORY=WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FILETYPE_REGULAR_FILE=WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_DGRAM=WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_STREAM=WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SYMBOLIC_LINK=WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FILETYPE_UNKNOWN=WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_CREAT=WASI_O_CREAT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_DIRECTORY=WASI_O_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_EXCL=WASI_O_EXCL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_TRUNC=WASI_O_TRUNC$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_PREOPENTYPE_DIR=WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ADVISE=WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ALLOCATE=WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_DATASYNC=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FDSTAT_SET_FLAGS=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_GET=WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_SIZE=WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_TIMES=WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_READ=WASI_RIGHT_FD_READ$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_FD_READDIR=WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SEEK=WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SYNC=WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_TELL=WASI_RIGHT_FD_TELL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_WRITE=WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_DIRECTORY=WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_FILE=WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_GET=WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_SIZE=WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_TIMES=WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_SOURCE=WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_TARGET=WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_OPEN=WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_READLINK=WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_REMOVE_DIRECTORY=WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_SOURCE=WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_TARGET=WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_SYMLINK=WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_UNLINK_FILE=WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_POLL_FD_READWRITE=WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_SOCK_SHUTDOWN=WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGABRT=WASI_SIGABRT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGALRM=WASI_SIGALRM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGBUS=WASI_SIGBUS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCHLD=WASI_SIGCHLD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCONT=WASI_SIGCONT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGFPE=WASI_SIGFPE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGHUP=WASI_SIGHUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGILL=WASI_SIGILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGINT=WASI_SIGINT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGKILL=WASI_SIGKILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGPIPE=WASI_SIGPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGQUIT=WASI_SIGQUIT$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGSEGV=WASI_SIGSEGV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGSTOP=WASI_SIGSTOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTERM=WASI_SIGTERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTRAP=WASI_SIGTRAP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTSTP=WASI_SIGTSTP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTTIN=WASI_SIGTTIN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGTTOU=WASI_SIGTTOU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGURG=WASI_SIGURG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR1=WASI_SIGUSR1$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR2=WASI_SIGUSR2$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGVTALRM=WASI_SIGVTALRM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGXCPU=WASI_SIGXCPU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGXFSZ=WASI_SIGXFSZ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDERR_FILENO=WASI_STDERR_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDIN_FILENO=WASI_STDIN_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDOUT_FILENO=WASI_STDOUT_FILENO$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_WHENCE_CUR=WASI_WHENCE_CUR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_END=WASI_WHENCE_END$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_SET=WASI_WHENCE_SET$$module$src$filesystem$constants;goog.debug={};function module$contents$goog$debug$Error_DebugError(a,b){if(Error.captureStackTrace)Error.captureStackTrace(this,module$contents$goog$debug$Error_DebugError);else{const c=Error().stack;c&&(this.stack=c)}a&&(this.message=String(a));void 0!==b&&(this.cause=b);this.reportErrorToServer=!0}goog.inherits(module$contents$goog$debug$Error_DebugError,Error);module$contents$goog$debug$Error_DebugError.prototype.name="CustomError";goog.debug.Error=module$contents$goog$debug$Error_DebugError;goog.dom={};goog.dom.NodeType={ELEMENT:1,ATTRIBUTE:2,TEXT:3,CDATA_SECTION:4,ENTITY_REFERENCE:5,ENTITY:6,PROCESSING_INSTRUCTION:7,COMMENT:8,DOCUMENT:9,DOCUMENT_TYPE:10,DOCUMENT_FRAGMENT:11,NOTATION:12};goog.asserts={};goog.asserts.ENABLE_ASSERTS=goog.DEBUG;function module$contents$goog$asserts_AssertionError(a,b){module$contents$goog$debug$Error_DebugError.call(this,module$contents$goog$asserts_subs(a,b));this.messagePattern=a}goog.inherits(module$contents$goog$asserts_AssertionError,module$contents$goog$debug$Error_DebugError);goog.asserts.AssertionError=module$contents$goog$asserts_AssertionError;module$contents$goog$asserts_AssertionError.prototype.name="AssertionError";\ngoog.asserts.DEFAULT_ERROR_HANDLER=function(a){throw a;};let module$contents$goog$asserts_errorHandler_=goog.asserts.DEFAULT_ERROR_HANDLER;function module$contents$goog$asserts_subs(a,b){a=a.split("%s");let c="";const d=a.length-1;for(let e=0;e<d;e++)c+=a[e]+(e<b.length?b[e]:"%s");return c+a[d]}\nfunction module$contents$goog$asserts_doAssertFailure(a,b,c,d){let e="Assertion failed",f;c?(e+=": "+c,f=d):a&&(e+=": "+a,f=b);a=new module$contents$goog$asserts_AssertionError(""+e,f||[]);module$contents$goog$asserts_errorHandler_(a)}goog.asserts.setErrorHandler=function(a){goog.asserts.ENABLE_ASSERTS&&(module$contents$goog$asserts_errorHandler_=a)};\ngoog.asserts.assert=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!a&&module$contents$goog$asserts_doAssertFailure("",null,b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertExists=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&null==a&&module$contents$goog$asserts_doAssertFailure("Expected to exist: %s.",[a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.fail=function(a,b){goog.asserts.ENABLE_ASSERTS&&module$contents$goog$asserts_errorHandler_(new module$contents$goog$asserts_AssertionError("Failure"+(a?": "+a:""),Array.prototype.slice.call(arguments,1)))};goog.asserts.assertNumber=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"number"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected number but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertString=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"string"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected string but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertFunction=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"function"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected function but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertObject=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isObject(a)&&module$contents$goog$asserts_doAssertFailure("Expected object but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertArray=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!Array.isArray(a)&&module$contents$goog$asserts_doAssertFailure("Expected array but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertBoolean=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"boolean"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected boolean but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertElement=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT||module$contents$goog$asserts_doAssertFailure("Expected Element but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertInstanceof=function(a,b,c,d){!goog.asserts.ENABLE_ASSERTS||a instanceof b||module$contents$goog$asserts_doAssertFailure("Expected instanceof %s but got %s.",[module$contents$goog$asserts_getType(b),module$contents$goog$asserts_getType(a)],c,Array.prototype.slice.call(arguments,3));return a};\ngoog.asserts.assertFinite=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||"number"==typeof a&&isFinite(a)||module$contents$goog$asserts_doAssertFailure("Expected %s to be a finite number but it is not.",[a],b,Array.prototype.slice.call(arguments,2));return a};\nfunction module$contents$goog$asserts_getType(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.array={};goog.NATIVE_ARRAY_PROTOTYPES=goog.TRUSTED_SITE;const module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS=2012<goog.FEATURESET_YEAR;goog.array.ASSUME_NATIVE_FUNCTIONS=module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS;function module$contents$goog$array_peek(a){return a[a.length-1]}goog.array.peek=module$contents$goog$array_peek;goog.array.last=module$contents$goog$array_peek;\nconst module$contents$goog$array_indexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.indexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.indexOf(b,c);for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1};goog.array.indexOf=module$contents$goog$array_indexOf;\nconst module$contents$goog$array_lastIndexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.lastIndexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.lastIndexOf.call(a,b,null==c?a.length-1:c)}:function(a,b,c){c=null==c?a.length-1:c;0>c&&(c=Math.max(0,a.length+c));if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.lastIndexOf(b,c);for(;0<=c;c--)if(c in a&&a[c]===b)return c;return-1};\ngoog.array.lastIndexOf=module$contents$goog$array_lastIndexOf;const module$contents$goog$array_forEach=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.forEach)?function(a,b,c){goog.asserts.assert(null!=a.length);Array.prototype.forEach.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)};goog.array.forEach=module$contents$goog$array_forEach;\nfunction module$contents$goog$array_forEachRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;--d)d in e&&b.call(c,e[d],d,a)}goog.array.forEachRight=module$contents$goog$array_forEachRight;\nconst module$contents$goog$array_filter=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.filter)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.filter.call(a,b,c)}:function(a,b,c){const d=a.length,e=[];let f=0;const g="string"===typeof a?a.split(""):a;for(let h=0;h<d;h++)if(h in g){const k=g[h];b.call(c,k,h,a)&&(e[f++]=k)}return e};goog.array.filter=module$contents$goog$array_filter;\nconst module$contents$goog$array_map=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.map)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.map.call(a,b,c)}:function(a,b,c){const d=a.length,e=Array(d),f="string"===typeof a?a.split(""):a;for(let g=0;g<d;g++)g in f&&(e[g]=b.call(c,f[g],g,a));return e};goog.array.map=module$contents$goog$array_map;\nconst module$contents$goog$array_reduce=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduce)?function(a,b,c,d){goog.asserts.assert(null!=a.length);d&&(b=goog.bind(b,d));return Array.prototype.reduce.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEach(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduce=module$contents$goog$array_reduce;\nconst module$contents$goog$array_reduceRight=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduceRight)?function(a,b,c,d){goog.asserts.assert(null!=a.length);goog.asserts.assert(null!=b);d&&(b=goog.bind(b,d));return Array.prototype.reduceRight.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEachRight(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduceRight=module$contents$goog$array_reduceRight;\nconst module$contents$goog$array_some=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.some)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.some.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return!0;return!1};goog.array.some=module$contents$goog$array_some;\nconst module$contents$goog$array_every=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.every)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.every.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&!b.call(c,e[f],f,a))return!1;return!0};goog.array.every=module$contents$goog$array_every;\nfunction module$contents$goog$array_count(a,b,c){let d=0;module$contents$goog$array_forEach(a,function(e,f,g){b.call(c,e,f,g)&&++d},c);return d}goog.array.count=module$contents$goog$array_count;function module$contents$goog$array_find(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.find=module$contents$goog$array_find;\nfunction module$contents$goog$array_findIndex(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return f;return-1}goog.array.findIndex=module$contents$goog$array_findIndex;function module$contents$goog$array_findRight(a,b,c){b=module$contents$goog$array_findIndexRight(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.findRight=module$contents$goog$array_findRight;\nfunction module$contents$goog$array_findIndexRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;d--)if(d in e&&b.call(c,e[d],d,a))return d;return-1}goog.array.findIndexRight=module$contents$goog$array_findIndexRight;function module$contents$goog$array_contains(a,b){return 0<=module$contents$goog$array_indexOf(a,b)}goog.array.contains=module$contents$goog$array_contains;function module$contents$goog$array_isEmpty(a){return 0==a.length}goog.array.isEmpty=module$contents$goog$array_isEmpty;\nfunction module$contents$goog$array_clear(a){if(!Array.isArray(a))for(let b=a.length-1;0<=b;b--)delete a[b];a.length=0}goog.array.clear=module$contents$goog$array_clear;function module$contents$goog$array_insert(a,b){module$contents$goog$array_contains(a,b)||a.push(b)}goog.array.insert=module$contents$goog$array_insert;function module$contents$goog$array_insertAt(a,b,c){module$contents$goog$array_splice(a,c,0,b)}goog.array.insertAt=module$contents$goog$array_insertAt;\nfunction module$contents$goog$array_insertArrayAt(a,b,c){goog.partial(module$contents$goog$array_splice,a,c,0).apply(null,b)}goog.array.insertArrayAt=module$contents$goog$array_insertArrayAt;function module$contents$goog$array_insertBefore(a,b,c){let d;2==arguments.length||0>(d=module$contents$goog$array_indexOf(a,c))?a.push(b):module$contents$goog$array_insertAt(a,b,d)}goog.array.insertBefore=module$contents$goog$array_insertBefore;\nfunction module$contents$goog$array_remove(a,b){b=module$contents$goog$array_indexOf(a,b);let c;(c=0<=b)&&module$contents$goog$array_removeAt(a,b);return c}goog.array.remove=module$contents$goog$array_remove;function module$contents$goog$array_removeLast(a,b){b=module$contents$goog$array_lastIndexOf(a,b);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeLast=module$contents$goog$array_removeLast;\nfunction module$contents$goog$array_removeAt(a,b){goog.asserts.assert(null!=a.length);return 1==Array.prototype.splice.call(a,b,1).length}goog.array.removeAt=module$contents$goog$array_removeAt;function module$contents$goog$array_removeIf(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeIf=module$contents$goog$array_removeIf;\nfunction module$contents$goog$array_removeAllIf(a,b,c){let d=0;module$contents$goog$array_forEachRight(a,function(e,f){b.call(c,e,f,a)&&module$contents$goog$array_removeAt(a,f)&&d++});return d}goog.array.removeAllIf=module$contents$goog$array_removeAllIf;function module$contents$goog$array_concat(a){return Array.prototype.concat.apply([],arguments)}goog.array.concat=module$contents$goog$array_concat;function module$contents$goog$array_join(a){return Array.prototype.concat.apply([],arguments)}\ngoog.array.join=module$contents$goog$array_join;function module$contents$goog$array_toArray(a){const b=a.length;if(0<b){const c=Array(b);for(let d=0;d<b;d++)c[d]=a[d];return c}return[]}const module$contents$goog$array_clone=goog.array.toArray=module$contents$goog$array_toArray;goog.array.clone=module$contents$goog$array_toArray;\nfunction module$contents$goog$array_extend(a,b){for(let c=1;c<arguments.length;c++){const d=arguments[c];if(goog.isArrayLike(d)){const e=a.length||0,f=d.length||0;a.length=e+f;for(let g=0;g<f;g++)a[e+g]=d[g]}else a.push(d)}}goog.array.extend=module$contents$goog$array_extend;function module$contents$goog$array_splice(a,b,c,d){goog.asserts.assert(null!=a.length);return Array.prototype.splice.apply(a,module$contents$goog$array_slice(arguments,1))}goog.array.splice=module$contents$goog$array_splice;\nfunction module$contents$goog$array_slice(a,b,c){goog.asserts.assert(null!=a.length);return 2>=arguments.length?Array.prototype.slice.call(a,b):Array.prototype.slice.call(a,b,c)}goog.array.slice=module$contents$goog$array_slice;\nfunction module$contents$goog$array_removeDuplicates(a,b,c){b=b||a;var d=function(g){return goog.isObject(g)?"o"+goog.getUid(g):(typeof g).charAt(0)+g};c=c||d;let e=d=0;const f={};for(;e<a.length;){const g=a[e++],h=c(g);Object.prototype.hasOwnProperty.call(f,h)||(f[h]=!0,b[d++]=g)}b.length=d}goog.array.removeDuplicates=module$contents$goog$array_removeDuplicates;\nfunction module$contents$goog$array_binarySearch(a,b,c){return module$contents$goog$array_binarySearch_(a,c||module$contents$goog$array_defaultCompare,!1,b)}goog.array.binarySearch=module$contents$goog$array_binarySearch;function module$contents$goog$array_binarySelect(a,b,c){return module$contents$goog$array_binarySearch_(a,b,!0,void 0,c)}goog.array.binarySelect=module$contents$goog$array_binarySelect;\nfunction module$contents$goog$array_binarySearch_(a,b,c,d,e){let f=0,g=a.length,h;for(;f<g;){const k=f+(g-f>>>1);let l;l=c?b.call(e,a[k],k,a):b(d,a[k]);0<l?f=k+1:(g=k,h=!l)}return h?f:-f-1}function module$contents$goog$array_sort(a,b){a.sort(b||module$contents$goog$array_defaultCompare)}goog.array.sort=module$contents$goog$array_sort;\nfunction module$contents$goog$array_stableSort(a,b){const c=Array(a.length);for(let e=0;e<a.length;e++)c[e]={index:e,value:a[e]};const d=b||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(c,function(e,f){return d(e.value,f.value)||e.index-f.index});for(b=0;b<a.length;b++)a[b]=c[b].value}goog.array.stableSort=module$contents$goog$array_stableSort;\nfunction module$contents$goog$array_sortByKey(a,b,c){const d=c||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(a,function(e,f){return d(b(e),b(f))})}goog.array.sortByKey=module$contents$goog$array_sortByKey;function module$contents$goog$array_sortObjectsByKey(a,b,c){module$contents$goog$array_sortByKey(a,function(d){return d[b]},c)}goog.array.sortObjectsByKey=module$contents$goog$array_sortObjectsByKey;\nfunction module$contents$goog$array_isSorted(a,b,c){b=b||module$contents$goog$array_defaultCompare;for(let d=1;d<a.length;d++){const e=b(a[d-1],a[d]);if(0<e||0==e&&c)return!1}return!0}goog.array.isSorted=module$contents$goog$array_isSorted;function module$contents$goog$array_equals(a,b,c){if(!goog.isArrayLike(a)||!goog.isArrayLike(b)||a.length!=b.length)return!1;const d=a.length;c=c||module$contents$goog$array_defaultCompareEquality;for(let e=0;e<d;e++)if(!c(a[e],b[e]))return!1;return!0}\ngoog.array.equals=module$contents$goog$array_equals;function module$contents$goog$array_compare3(a,b,c){c=c||module$contents$goog$array_defaultCompare;const d=Math.min(a.length,b.length);for(let e=0;e<d;e++){const f=c(a[e],b[e]);if(0!=f)return f}return module$contents$goog$array_defaultCompare(a.length,b.length)}goog.array.compare3=module$contents$goog$array_compare3;function module$contents$goog$array_defaultCompare(a,b){return a>b?1:a<b?-1:0}goog.array.defaultCompare=module$contents$goog$array_defaultCompare;\nfunction module$contents$goog$array_inverseDefaultCompare(a,b){return-module$contents$goog$array_defaultCompare(a,b)}goog.array.inverseDefaultCompare=module$contents$goog$array_inverseDefaultCompare;function module$contents$goog$array_defaultCompareEquality(a,b){return a===b}goog.array.defaultCompareEquality=module$contents$goog$array_defaultCompareEquality;\nfunction module$contents$goog$array_binaryInsert(a,b,c){c=module$contents$goog$array_binarySearch(a,b,c);return 0>c?(module$contents$goog$array_insertAt(a,b,-(c+1)),!0):!1}goog.array.binaryInsert=module$contents$goog$array_binaryInsert;function module$contents$goog$array_binaryRemove(a,b,c){b=module$contents$goog$array_binarySearch(a,b,c);return 0<=b?module$contents$goog$array_removeAt(a,b):!1}goog.array.binaryRemove=module$contents$goog$array_binaryRemove;\nfunction module$contents$goog$array_bucket(a,b,c){const d={};for(let e=0;e<a.length;e++){const f=a[e],g=b.call(c,f,e,a);void 0!==g&&(d[g]||(d[g]=[])).push(f)}return d}goog.array.bucket=module$contents$goog$array_bucket;function module$contents$goog$array_bucketToMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d],f=b(e,d,a);if(void 0!==f){let g=c.get(f);g||(g=[],c.set(f,g));g.push(e)}}return c}goog.array.bucketToMap=module$contents$goog$array_bucketToMap;\nfunction module$contents$goog$array_toObject(a,b,c){const d={};module$contents$goog$array_forEach(a,function(e,f){d[b.call(c,e,f,a)]=e});return d}goog.array.toObject=module$contents$goog$array_toObject;function module$contents$goog$array_toMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d];c.set(b(e,d,a),e)}return c}goog.array.toMap=module$contents$goog$array_toMap;\nfunction module$contents$goog$array_range(a,b,c){const d=[];let e=0,f=a;c=c||1;void 0!==b&&(e=a,f=b);if(0>c*(f-e))return[];if(0<c)for(a=e;a<f;a+=c)d.push(a);else for(a=e;a>f;a+=c)d.push(a);return d}goog.array.range=module$contents$goog$array_range;function module$contents$goog$array_repeat(a,b){const c=[];for(let d=0;d<b;d++)c[d]=a;return c}goog.array.repeat=module$contents$goog$array_repeat;\nfunction module$contents$goog$array_flatten(a){const b=[];for(let d=0;d<arguments.length;d++){const e=arguments[d];if(Array.isArray(e))for(let f=0;f<e.length;f+=8192){var c=module$contents$goog$array_slice(e,f,f+8192);c=module$contents$goog$array_flatten.apply(null,c);for(let g=0;g<c.length;g++)b.push(c[g])}else b.push(e)}return b}goog.array.flatten=module$contents$goog$array_flatten;\nfunction module$contents$goog$array_rotate(a,b){goog.asserts.assert(null!=a.length);a.length&&(b%=a.length,0<b?Array.prototype.unshift.apply(a,a.splice(-b,b)):0>b&&Array.prototype.push.apply(a,a.splice(0,-b)));return a}goog.array.rotate=module$contents$goog$array_rotate;function module$contents$goog$array_moveItem(a,b,c){goog.asserts.assert(0<=b&&b<a.length);goog.asserts.assert(0<=c&&c<a.length);b=Array.prototype.splice.call(a,b,1);Array.prototype.splice.call(a,c,0,b[0])}goog.array.moveItem=module$contents$goog$array_moveItem;\nfunction module$contents$goog$array_zip(a){if(!arguments.length)return[];const b=[];let c=arguments[0].length;for(var d=1;d<arguments.length;d++)arguments[d].length<c&&(c=arguments[d].length);for(d=0;d<c;d++){const e=[];for(let f=0;f<arguments.length;f++)e.push(arguments[f][d]);b.push(e)}return b}goog.array.zip=module$contents$goog$array_zip;function module$contents$goog$array_shuffle(a,b){b=b||Math.random;for(let c=a.length-1;0<c;c--){const d=Math.floor(b()*(c+1)),e=a[c];a[c]=a[d];a[d]=e}}\ngoog.array.shuffle=module$contents$goog$array_shuffle;function module$contents$goog$array_copyByIndex(a,b){const c=[];module$contents$goog$array_forEach(b,function(d){c.push(a[d])});return c}goog.array.copyByIndex=module$contents$goog$array_copyByIndex;function module$contents$goog$array_concatMap(a,b,c){return module$contents$goog$array_concat.apply([],module$contents$goog$array_map(a,b,c))}goog.array.concatMap=module$contents$goog$array_concatMap;goog.dom.asserts={};goog.dom.asserts.assertIsLocation=function(a){if(goog.asserts.ENABLE_ASSERTS){var b=goog.dom.asserts.getWindow_(a);b&&(!a||!(a instanceof b.Location)&&a instanceof b.Element)&&goog.asserts.fail("Argument is not a Location (or a non-Element mock); got: %s",goog.dom.asserts.debugStringForType_(a))}return a};\ngoog.dom.asserts.assertIsElementType_=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=goog.dom.asserts.getWindow_(a);c&&"undefined"!=typeof c[b]&&(a&&(a instanceof c[b]||!(a instanceof c.Location||a instanceof c.Element))||goog.asserts.fail("Argument is not a %s (or a non-Element, non-Location mock); got: %s",b,goog.dom.asserts.debugStringForType_(a)))}return a};goog.dom.asserts.assertIsHTMLAnchorElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAnchorElement")};\ngoog.dom.asserts.assertIsHTMLButtonElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLButtonElement")};goog.dom.asserts.assertIsHTMLLinkElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLLinkElement")};goog.dom.asserts.assertIsHTMLImageElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLImageElement")};goog.dom.asserts.assertIsHTMLAudioElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAudioElement")};\ngoog.dom.asserts.assertIsHTMLVideoElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLVideoElement")};goog.dom.asserts.assertIsHTMLInputElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLInputElement")};goog.dom.asserts.assertIsHTMLTextAreaElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLTextAreaElement")};goog.dom.asserts.assertIsHTMLCanvasElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLCanvasElement")};\ngoog.dom.asserts.assertIsHTMLEmbedElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLEmbedElement")};goog.dom.asserts.assertIsHTMLFormElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFormElement")};goog.dom.asserts.assertIsHTMLFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFrameElement")};goog.dom.asserts.assertIsHTMLIFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLIFrameElement")};\ngoog.dom.asserts.assertIsHTMLObjectElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLObjectElement")};goog.dom.asserts.assertIsHTMLScriptElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLScriptElement")};\ngoog.dom.asserts.debugStringForType_=function(a){if(goog.isObject(a))try{return a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a)}catch(b){return"<object could not be stringified>"}else return void 0===a?"undefined":null===a?"null":typeof a};goog.dom.asserts.getWindow_=function(a){try{var b=a&&a.ownerDocument,c=b&&(b.defaultView||b.parentWindow);c=c||goog.global;if(c.Element&&c.Location)return c}catch(d){}return null};goog.functions={};goog.functions.constant=function(a){return function(){return a}};goog.functions.FALSE=function(){return!1};goog.functions.TRUE=function(){return!0};goog.functions.NULL=function(){return null};goog.functions.UNDEFINED=function(){};goog.functions.EMPTY=goog.functions.UNDEFINED;goog.functions.identity=function(a,b){return a};goog.functions.error=function(a){return function(){throw Error(a);}};goog.functions.fail=function(a){return function(){throw a;}};\ngoog.functions.lock=function(a,b){b=b||0;return function(){return a.apply(this,Array.prototype.slice.call(arguments,0,b))}};goog.functions.nth=function(a){return function(){return arguments[a]}};goog.functions.partialRight=function(a,b){const c=Array.prototype.slice.call(arguments,1);return function(){let d=this;d===goog.global&&(d=void 0);const e=Array.prototype.slice.call(arguments);e.push.apply(e,c);return a.apply(d,e)}};\ngoog.functions.withReturnValue=function(a,b){return goog.functions.sequence(a,goog.functions.constant(b))};goog.functions.equalTo=function(a,b){return function(c){return b?a==c:a===c}};goog.functions.compose=function(a,b){const c=arguments,d=c.length;return function(){let e;d&&(e=c[d-1].apply(this,arguments));for(let f=d-2;0<=f;f--)e=c[f].call(this,e);return e}};\ngoog.functions.sequence=function(a){const b=arguments,c=b.length;return function(){let d;for(let e=0;e<c;e++)d=b[e].apply(this,arguments);return d}};goog.functions.and=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(!b[d].apply(this,arguments))return!1;return!0}};goog.functions.or=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(b[d].apply(this,arguments))return!0;return!1}};\ngoog.functions.not=function(a){return function(){return!a.apply(this,arguments)}};goog.functions.create=function(a,b){var c=function(){};c.prototype=a.prototype;c=new c;a.apply(c,Array.prototype.slice.call(arguments,1));return c};goog.functions.CACHE_RETURN_VALUE=!0;goog.functions.cacheReturnValue=function(a){let b=!1,c;return function(){if(!goog.functions.CACHE_RETURN_VALUE)return a();b||(c=a(),b=!0);return c}};goog.functions.once=function(a){let b=a;return function(){if(b){const c=b;b=null;c()}}};\ngoog.functions.debounce=function(a,b,c){let d=0;return function(e){goog.global.clearTimeout(d);const f=arguments;d=goog.global.setTimeout(function(){a.apply(c,f)},b)}};goog.functions.throttle=function(a,b,c){let d=0,e=!1,f=[];const g=function(){d=0;e&&(e=!1,h())},h=function(){d=goog.global.setTimeout(g,b);let k=f;f=[];a.apply(c,k)};return function(k){f=arguments;d?e=!0:h()}};\ngoog.functions.rateLimit=function(a,b,c){let d=0;const e=function(){d=0};return function(f){d||(d=goog.global.setTimeout(e,b),a.apply(c,arguments))}};goog.functions.isFunction=a=>"function"===typeof a;goog.string={};goog.string.TypedString=function(){};goog.string.Const=function(a,b){this.stringConstValueWithSecurityContract__googStringSecurityPrivate_=a===goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_&&b||"";this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_=goog.string.Const.TYPE_MARKER_};goog.string.Const.prototype.implementsGoogStringTypedString=!0;goog.string.Const.prototype.getTypedStringValue=function(){return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_};\ngoog.DEBUG&&(goog.string.Const.prototype.toString=function(){return"Const{"+this.stringConstValueWithSecurityContract__googStringSecurityPrivate_+"}"});goog.string.Const.unwrap=function(a){if(a instanceof goog.string.Const&&a.constructor===goog.string.Const&&a.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_===goog.string.Const.TYPE_MARKER_)return a.stringConstValueWithSecurityContract__googStringSecurityPrivate_;goog.asserts.fail("expected object of type Const, got \'"+a+"\'");return"type_error:Const"};\ngoog.string.Const.from=function(a){return new goog.string.Const(goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_,a)};goog.string.Const.TYPE_MARKER_={};goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_={};goog.string.Const.EMPTY=goog.string.Const.from("");goog.html={};goog.html.trustedtypes={};goog.html.trustedtypes.POLICY_NAME=goog.TRUSTED_TYPES_POLICY_NAME?goog.TRUSTED_TYPES_POLICY_NAME+"#html":"";goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse=function(){if(!goog.html.trustedtypes.POLICY_NAME)return null;void 0===goog.html.trustedtypes.cachedPolicy_&&(goog.html.trustedtypes.cachedPolicy_=goog.createTrustedTypesPolicy(goog.html.trustedtypes.POLICY_NAME));return goog.html.trustedtypes.cachedPolicy_};const module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeScript_SafeScript{constructor(a,b){this.privateDoNotAccessOrElseSafeScriptWrappedValue_=b===module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static fromConstant(a){a=goog.string.Const.unwrap(a);return 0===a.length?module$contents$goog$html$SafeScript_SafeScript.EMPTY:module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(a)}static fromJson(a){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(module$contents$goog$html$SafeScript_SafeScript.stringify_(a))}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(a).toString()}static unwrapTrustedScript(a){if(a instanceof\nmodule$contents$goog$html$SafeScript_SafeScript&&a.constructor===module$contents$goog$html$SafeScript_SafeScript)return a.privateDoNotAccessOrElseSafeScriptWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeScript, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:SafeScript"}static stringify_(a){return JSON.stringify(a).replace(/</g,"\\\\x3c")}static createSafeScriptSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScript(a):\na;return new module$contents$goog$html$SafeScript_SafeScript(a,module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE)}}module$contents$goog$html$SafeScript_SafeScript.EMPTY=function(){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("")}();goog.html.SafeScript=module$contents$goog$html$SafeScript_SafeScript;goog.fs={};goog.fs.url={};goog.fs.url.createObjectUrl=function(a){return goog.fs.url.getUrlObject_().createObjectURL(a)};goog.fs.url.revokeObjectUrl=function(a){goog.fs.url.getUrlObject_().revokeObjectURL(a)};goog.fs.url.UrlObject_=function(){};goog.fs.url.UrlObject_.prototype.createObjectURL=function(a){};goog.fs.url.UrlObject_.prototype.revokeObjectURL=function(a){};\ngoog.fs.url.getUrlObject_=function(){const a=goog.fs.url.findUrlObject_();if(null!=a)return a;throw Error("This browser doesn\'t seem to support blob URLs");};goog.fs.url.findUrlObject_=function(){return void 0!==goog.global.URL&&void 0!==goog.global.URL.createObjectURL?goog.global.URL:void 0!==goog.global.createObjectURL?goog.global:null};goog.fs.url.browserSupportsObjectUrls=function(){return null!=goog.fs.url.findUrlObject_()};goog.fs.blob={};goog.fs.blob.getBlob=function(a){var b=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==b){b=new b;for(let c=0;c<arguments.length;c++)b.append(arguments[c]);return b.getBlob()}return goog.fs.blob.getBlobWithProperties(Array.prototype.slice.call(arguments))};\ngoog.fs.blob.getBlobWithProperties=function(a,b,c){var d=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==d){d=new d;for(let e=0;e<a.length;e++)d.append(a[e],c);return d.getBlob(b)}if(void 0!==goog.global.Blob)return d={},b&&(d.type=b),c&&(d.endings=c),new Blob(a,d);throw Error("This browser doesn\'t seem to support creating Blobs");};goog.html.TrustedResourceUrl=class{constructor(a,b){this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_=b===goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_+""}};goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString=!0;goog.html.TrustedResourceUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_.toString()};\ngoog.html.TrustedResourceUrl.prototype.cloneWithParams=function(a,b){var c=goog.html.TrustedResourceUrl.unwrap(this);c=goog.html.TrustedResourceUrl.URL_PARAM_PARSER_.exec(c);var d=c[3]||"";return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(c[1]+goog.html.TrustedResourceUrl.stringifyParams_("?",c[2]||"",a)+goog.html.TrustedResourceUrl.stringifyParams_("#",d,b))};goog.html.TrustedResourceUrl.unwrap=function(a){return goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(a).toString()};\ngoog.html.TrustedResourceUrl.unwrapTrustedScriptURL=function(a){if(a instanceof goog.html.TrustedResourceUrl&&a.constructor===goog.html.TrustedResourceUrl)return a.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;goog.asserts.fail("expected object of type TrustedResourceUrl, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:TrustedResourceUrl"};\ngoog.html.TrustedResourceUrl.format=function(a,b){var c=goog.string.Const.unwrap(a);if(!goog.html.TrustedResourceUrl.BASE_URL_.test(c))throw Error("Invalid TrustedResourceUrl format: "+c);a=c.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_,function(d,e){if(!Object.prototype.hasOwnProperty.call(b,e))throw Error(\'Found marker, "\'+e+\'", in format string, "\'+c+\'", but no valid label mapping found in args: \'+JSON.stringify(b));d=b[e];return d instanceof goog.string.Const?goog.string.Const.unwrap(d):\nencodeURIComponent(String(d))});return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.FORMAT_MARKER_=/%{(\\w+)}/g;goog.html.TrustedResourceUrl.BASE_URL_=RegExp("^((https:)?//[0-9a-z.:[\\\\]-]+/|/[^/\\\\\\\\]|[^:/\\\\\\\\%]+/|[^:/\\\\\\\\%]*[?#]|about:blank#)","i");goog.html.TrustedResourceUrl.URL_PARAM_PARSER_=/^([^?#]*)(\\?[^#]*)?(#[\\s\\S]*)?/;\ngoog.html.TrustedResourceUrl.formatWithParams=function(a,b,c,d){return goog.html.TrustedResourceUrl.format(a,b).cloneWithParams(c,d)};goog.html.TrustedResourceUrl.fromConstant=function(a){return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};goog.html.TrustedResourceUrl.fromConstants=function(a){for(var b="",c=0;c<a.length;c++)b+=goog.string.Const.unwrap(a[c]);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.TrustedResourceUrl.fromSafeScript=function(a){a=goog.fs.blob.getBlobWithProperties([module$contents$goog$html$SafeScript_SafeScript.unwrap(a)],"text/javascript");a=goog.fs.url.createObjectUrl(a);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};\ngoog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse=function(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScriptURL(a):a;return new goog.html.TrustedResourceUrl(a,goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};\ngoog.html.TrustedResourceUrl.stringifyParams_=function(a,b,c){if(null==c)return b;if("string"===typeof c)return c?a+encodeURIComponent(c):"";for(var d in c)if(Object.prototype.hasOwnProperty.call(c,d)){var e=c[d];e=Array.isArray(e)?e:[e];for(var f=0;f<e.length;f++){var g=e[f];null!=g&&(b||(b=a),b+=(b.length>a.length?"&":"")+encodeURIComponent(d)+"="+encodeURIComponent(String(g)))}}return b};goog.string.internal={};goog.string.internal.startsWith=function(a,b){return 0==a.lastIndexOf(b,0)};goog.string.internal.endsWith=function(a,b){const c=a.length-b.length;return 0<=c&&a.indexOf(b,c)==c};goog.string.internal.caseInsensitiveStartsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(0,b.length))};goog.string.internal.caseInsensitiveEndsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(a.length-b.length))};\ngoog.string.internal.caseInsensitiveEquals=function(a,b){return a.toLowerCase()==b.toLowerCase()};goog.string.internal.isEmptyOrWhitespace=function(a){return/^[\\s\\xa0]*$/.test(a)};goog.string.internal.trim=goog.TRUSTED_SITE&&String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(a)[1]};goog.string.internal.caseInsensitiveCompare=function(a,b){a=String(a).toLowerCase();b=String(b).toLowerCase();return a<b?-1:a==b?0:1};\ngoog.string.internal.newLineToBr=function(a,b){return a.replace(/(\\r\\n|\\r|\\n)/g,b?"<br />":"<br>")};\ngoog.string.internal.htmlEscape=function(a,b){if(b)a=a.replace(goog.string.internal.AMP_RE_,"&amp;").replace(goog.string.internal.LT_RE_,"&lt;").replace(goog.string.internal.GT_RE_,"&gt;").replace(goog.string.internal.QUOT_RE_,"&quot;").replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;").replace(goog.string.internal.NULL_RE_,"&#0;");else{if(!goog.string.internal.ALL_RE_.test(a))return a;-1!=a.indexOf("&")&&(a=a.replace(goog.string.internal.AMP_RE_,"&amp;"));-1!=a.indexOf("<")&&(a=a.replace(goog.string.internal.LT_RE_,\n"&lt;"));-1!=a.indexOf(">")&&(a=a.replace(goog.string.internal.GT_RE_,"&gt;"));-1!=a.indexOf(\'"\')&&(a=a.replace(goog.string.internal.QUOT_RE_,"&quot;"));-1!=a.indexOf("\'")&&(a=a.replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;"));-1!=a.indexOf("\\x00")&&(a=a.replace(goog.string.internal.NULL_RE_,"&#0;"))}return a};goog.string.internal.AMP_RE_=/&/g;goog.string.internal.LT_RE_=/</g;goog.string.internal.GT_RE_=/>/g;goog.string.internal.QUOT_RE_=/"/g;goog.string.internal.SINGLE_QUOTE_RE_=/\'/g;\ngoog.string.internal.NULL_RE_=/\\x00/g;goog.string.internal.ALL_RE_=/[\\x00&<>"\']/;goog.string.internal.whitespaceEscape=function(a,b){return goog.string.internal.newLineToBr(a.replace(/  /g," &#160;"),b)};goog.string.internal.contains=function(a,b){return-1!=a.indexOf(b)};goog.string.internal.caseInsensitiveContains=function(a,b){return goog.string.internal.contains(a.toLowerCase(),b.toLowerCase())};\ngoog.string.internal.compareVersions=function(a,b){var c=0;a=goog.string.internal.trim(String(a)).split(".");b=goog.string.internal.trim(String(b)).split(".");const d=Math.max(a.length,b.length);for(let g=0;0==c&&g<d;g++){var e=a[g]||"",f=b[g]||"";do{e=/(\\d*)(\\D*)(.*)/.exec(e)||["","","",""];f=/(\\d*)(\\D*)(.*)/.exec(f)||["","","",""];if(0==e[0].length&&0==f[0].length)break;c=0==e[1].length?0:parseInt(e[1],10);const h=0==f[1].length?0:parseInt(f[1],10);c=goog.string.internal.compareElements_(c,h)||\ngoog.string.internal.compareElements_(0==e[2].length,0==f[2].length)||goog.string.internal.compareElements_(e[2],f[2]);e=e[3];f=f[3]}while(0==c)}return c};goog.string.internal.compareElements_=function(a,b){return a<b?-1:a>b?1:0};goog.html.SafeUrl=class{constructor(a,b){this.privateDoNotAccessOrElseSafeUrlWrappedValue_=b===goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()}};goog.html.SafeUrl.INNOCUOUS_STRING="about:invalid#zClosurez";goog.html.SafeUrl.prototype.implementsGoogStringTypedString=!0;goog.html.SafeUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()};\ngoog.html.SafeUrl.unwrap=function(a){if(a instanceof goog.html.SafeUrl&&a.constructor===goog.html.SafeUrl)return a.privateDoNotAccessOrElseSafeUrlWrappedValue_;goog.asserts.fail("expected object of type SafeUrl, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:SafeUrl"};goog.html.SafeUrl.fromConstant=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};\ngoog.html.SAFE_MIME_TYPE_PATTERN_=RegExp(\'^(?:audio/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-matroska|x-wav|wav|webm)|font/\\\\w+|image/(?:bmp|gif|jpeg|jpg|png|tiff|webp|x-icon|heic|heif)|video/(?:mpeg|mp4|ogg|webm|quicktime|x-matroska))(?:;\\\\w+=(?:\\\\w+|"[\\\\w;,= ]+"))*$\',"i");goog.html.SafeUrl.isSafeMimeType=function(a){return goog.html.SAFE_MIME_TYPE_PATTERN_.test(a)};\ngoog.html.SafeUrl.fromBlob=function(a){a=goog.html.SafeUrl.isSafeMimeType(a.type)?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.revokeObjectUrl=function(a){a=a.getTypedStringValue();a!==goog.html.SafeUrl.INNOCUOUS_STRING&&goog.fs.url.revokeObjectUrl(a)};\ngoog.html.SafeUrl.fromMediaSource=function(a){goog.asserts.assert("MediaSource"in goog.global,"No support for MediaSource");a=a instanceof MediaSource?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.DATA_URL_PATTERN_=/^data:(.*);base64,[a-z0-9+\\/]+=*$/i;\ngoog.html.SafeUrl.tryFromDataUrl=function(a){a=String(a);a=a.replace(/(%0A|%0D)/g,"");return a.match(goog.html.DATA_URL_PATTERN_)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):null};goog.html.SafeUrl.fromDataUrl=function(a){return goog.html.SafeUrl.tryFromDataUrl(a)||goog.html.SafeUrl.INNOCUOUS_URL};goog.html.SafeUrl.fromTelUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"tel:")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SIP_URL_PATTERN_=RegExp("^sip[s]?:[+a-z0-9_.!$%&\'*\\\\/=^`{|}~-]+@([a-z0-9-]+\\\\.)+[a-z0-9]{2,63}$","i");goog.html.SafeUrl.fromSipUrl=function(a){goog.html.SIP_URL_PATTERN_.test(decodeURIComponent(a))||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromFacebookMessengerUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"fb-messenger://share")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.fromWhatsAppUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"whatsapp://send")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromSmsUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"sms:")&&goog.html.SafeUrl.isSmsUrlBodyValid_(a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.isSmsUrlBodyValid_=function(a){var b=a.indexOf("#");0<b&&(a=a.substring(0,b));b=a.match(/[?&]body=/gi);if(!b)return!0;if(1<b.length)return!1;a=a.match(/[?&]body=([^&]*)/)[1];if(!a)return!0;try{decodeURIComponent(a)}catch(c){return!1}return/^(?:[a-z0-9\\-_.~]|%[0-9a-f]{2})+$/i.test(a)};goog.html.SafeUrl.fromSshUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"ssh://")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.sanitizeChromeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^chrome-extension:\\/\\/([^\\/]+)\\//,a,b)};goog.html.SafeUrl.sanitizeFirefoxExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^moz-extension:\\/\\/([^\\/]+)\\//,a,b)};goog.html.SafeUrl.sanitizeEdgeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^ms-browser-extension:\\/\\/([^\\/]+)\\//,a,b)};\ngoog.html.SafeUrl.sanitizeExtensionUrl_=function(a,b,c){(a=a.exec(b))?(a=a[1],-1==(c instanceof goog.string.Const?[goog.string.Const.unwrap(c)]:c.map(function(d){return goog.string.Const.unwrap(d)})).indexOf(a)&&(b=goog.html.SafeUrl.INNOCUOUS_STRING)):b=goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};goog.html.SafeUrl.fromTrustedResourceUrl=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.TrustedResourceUrl.unwrap(a))};\ngoog.html.SAFE_URL_PATTERN_=/^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;goog.html.SafeUrl.SAFE_URL_PATTERN=goog.html.SAFE_URL_PATTERN_;goog.html.SafeUrl.trySanitize=function(a){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return goog.html.SAFE_URL_PATTERN_.test(a)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):goog.html.SafeUrl.tryFromDataUrl(a)};\ngoog.html.SafeUrl.sanitize=function(a){return goog.html.SafeUrl.trySanitize(a)||goog.html.SafeUrl.INNOCUOUS_URL};\ngoog.html.SafeUrl.sanitizeAssertUnchanged=function(a,b){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);if(b&&/^data:/i.test(a)&&(b=goog.html.SafeUrl.fromDataUrl(a),b.getTypedStringValue()==a))return b;goog.asserts.assert(goog.html.SAFE_URL_PATTERN_.test(a),"%s does not match the safe URL pattern",a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse=function(a){return new goog.html.SafeUrl(a,goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};goog.html.SafeUrl.INNOCUOUS_URL=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.SafeUrl.INNOCUOUS_STRING);goog.html.SafeUrl.ABOUT_BLANK=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse("about:blank");const module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeStyle_SafeStyle{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleWrappedValue_=b===module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyle_SafeStyle.EMPTY;(0,goog.asserts.assert)((0,goog.string.internal.endsWith)(a,";"),`Last character of style string is not \';\': ${a}`);(0,goog.asserts.assert)((0,goog.string.internal.contains)(a,\n":"),"Style string must contain at least one \':\', to specify a \\"name: value\\" pair: "+a);return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_}toString(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_.toString()}static unwrap(a){if(a instanceof module$contents$goog$html$SafeStyle_SafeStyle&&a.constructor===module$contents$goog$html$SafeStyle_SafeStyle)return a.privateDoNotAccessOrElseSafeStyleWrappedValue_;\n(0,goog.asserts.fail)(`expected object of type SafeStyle, got \'${a}`+"\' of type "+goog.typeOf(a));return"type_error:SafeStyle"}static createSafeStyleSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyle_SafeStyle(a,module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE)}static create(a){let b="";for(let c in a)if(Object.prototype.hasOwnProperty.call(a,c)){if(!/^[-_a-zA-Z0-9]+$/.test(c))throw Error(`Name allows only [-_a-zA-Z0-9], got: ${c}`);let d=a[c];null!=d&&\n(d=Array.isArray(d)?d.map(module$contents$goog$html$SafeStyle_sanitizePropertyValue).join(" "):module$contents$goog$html$SafeStyle_sanitizePropertyValue(d),b+=`${c}:${d};`)}return b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(d)};Array.prototype.forEach.call(arguments,c);\nreturn b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}}module$contents$goog$html$SafeStyle_SafeStyle.EMPTY=module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse("");module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING="zClosurez";\nfunction module$contents$goog$html$SafeStyle_sanitizePropertyValue(a){if(a instanceof goog.html.SafeUrl)return\'url("\'+goog.html.SafeUrl.unwrap(a).replace(/</g,"%3c").replace(/[\\\\"]/g,"\\\\$&")+\'")\';a=a instanceof goog.string.Const?goog.string.Const.unwrap(a):module$contents$goog$html$SafeStyle_sanitizePropertyValueString(String(a));if(/[{;}]/.test(a))throw new module$contents$goog$asserts_AssertionError("Value does not allow [{;}], got: %s.",[a]);return a}\nfunction module$contents$goog$html$SafeStyle_sanitizePropertyValueString(a){const b=a.replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_URL_RE,"url");if(module$contents$goog$html$SafeStyle_VALUE_RE.test(b)){if(module$contents$goog$html$SafeStyle_COMMENT_RE.test(a))return(0,goog.asserts.fail)(`String value disallows comments, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;\nif(!module$contents$goog$html$SafeStyle_hasBalancedQuotes(a))return(0,goog.asserts.fail)(`String value requires balanced quotes, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;if(!module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a))return(0,goog.asserts.fail)("String value requires balanced square brackets and one identifier per pair of brackets, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING}else return(0,goog.asserts.fail)(`String value allows only ${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}`+\n" and simple functions, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;return module$contents$goog$html$SafeStyle_sanitizeUrl(a)}function module$contents$goog$html$SafeStyle_hasBalancedQuotes(a){let b=!0,c=!0;for(let d=0;d<a.length;d++){const e=a.charAt(d);"\'"==e&&c?b=!b:\'"\'==e&&b&&(c=!c)}return b&&c}\nfunction module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a){let b=!0;const c=/^[-_a-zA-Z0-9]$/;for(let d=0;d<a.length;d++){const e=a.charAt(d);if("]"==e){if(b)return!1;b=!0}else if("["==e){if(!b)return!1;b=!1}else if(!b&&!c.test(e))return!1}return b}\nconst module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS="[-,.\\"\'%_!#/ a-zA-Z0-9\\\\[\\\\]]",module$contents$goog$html$SafeStyle_VALUE_RE=new RegExp(`^${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}+\\$`),module$contents$goog$html$SafeStyle_URL_RE=RegExp("\\\\b(url\\\\([ \\t\\n]*)(\'[ -&(-\\\\[\\\\]-~]*\'|\\"[ !#-\\\\[\\\\]-~]*\\"|[!#-&*-\\\\[\\\\]-~]*)([ \\t\\n]*\\\\))","g"),module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS="calc cubic-bezier fit-content hsl hsla linear-gradient matrix minmax radial-gradient repeat rgb rgba (rotate|scale|translate)(X|Y|Z|3d)? steps var".split(" "),\nmodule$contents$goog$html$SafeStyle_FUNCTIONS_RE=new RegExp("\\\\b("+module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS.join("|")+")\\\\([-+*/0-9a-zA-Z.%#\\\\[\\\\], ]+\\\\)","g"),module$contents$goog$html$SafeStyle_COMMENT_RE=/\\/\\*/;function module$contents$goog$html$SafeStyle_sanitizeUrl(a){return a.replace(module$contents$goog$html$SafeStyle_URL_RE,(b,c,d,e)=>{let f="";d=d.replace(/^([\'"])(.*)\\1$/,(g,h,k)=>{f=h;return k});b=goog.html.SafeUrl.sanitize(d).getTypedStringValue();return c+f+b+f+e})}\ngoog.html.SafeStyle=module$contents$goog$html$SafeStyle_SafeStyle;goog.object={};function module$contents$goog$object_forEach(a,b,c){for(const d in a)b.call(c,a[d],d,a)}function module$contents$goog$object_filter(a,b,c){const d={};for(const e in a)b.call(c,a[e],e,a)&&(d[e]=a[e]);return d}function module$contents$goog$object_map(a,b,c){const d={};for(const e in a)d[e]=b.call(c,a[e],e,a);return d}function module$contents$goog$object_some(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return!0;return!1}\nfunction module$contents$goog$object_every(a,b,c){for(const d in a)if(!b.call(c,a[d],d,a))return!1;return!0}function module$contents$goog$object_getCount(a){let b=0;for(const c in a)b++;return b}function module$contents$goog$object_getAnyKey(a){for(const b in a)return b}function module$contents$goog$object_getAnyValue(a){for(const b in a)return a[b]}function module$contents$goog$object_contains(a,b){return module$contents$goog$object_containsValue(a,b)}\nfunction module$contents$goog$object_getValues(a){const b=[];let c=0;for(const d in a)b[c++]=a[d];return b}function module$contents$goog$object_getKeys(a){const b=[];let c=0;for(const d in a)b[c++]=d;return b}function module$contents$goog$object_getValueByKeys(a,b){var c=goog.isArrayLike(b);const d=c?b:arguments;for(c=c?0:1;c<d.length;c++){if(null==a)return;a=a[d[c]]}return a}function module$contents$goog$object_containsKey(a,b){return null!==a&&b in a}\nfunction module$contents$goog$object_containsValue(a,b){for(const c in a)if(a[c]==b)return!0;return!1}function module$contents$goog$object_findKey(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return d}function module$contents$goog$object_findValue(a,b,c){return(b=module$contents$goog$object_findKey(a,b,c))&&a[b]}function module$contents$goog$object_isEmpty(a){for(const b in a)return!1;return!0}function module$contents$goog$object_clear(a){for(const b in a)delete a[b]}\nfunction module$contents$goog$object_remove(a,b){let c;(c=b in a)&&delete a[b];return c}function module$contents$goog$object_add(a,b,c){if(null!==a&&b in a)throw Error(`The object already contains the key "${b}"`);module$contents$goog$object_set(a,b,c)}function module$contents$goog$object_get(a,b,c){return null!==a&&b in a?a[b]:c}function module$contents$goog$object_set(a,b,c){a[b]=c}function module$contents$goog$object_setIfUndefined(a,b,c){return b in a?a[b]:a[b]=c}\nfunction module$contents$goog$object_setWithReturnValueIfNotSet(a,b,c){if(b in a)return a[b];c=c();return a[b]=c}function module$contents$goog$object_equals(a,b){for(const c in a)if(!(c in b)||a[c]!==b[c])return!1;for(const c in b)if(!(c in a))return!1;return!0}function module$contents$goog$object_clone(a){const b={};for(const c in a)b[c]=a[c];return b}\nfunction module$contents$goog$object_unsafeClone(a){if(!a||"object"!==typeof a)return a;if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);if(a instanceof Date)return new Date(a.getTime());const b=Array.isArray(a)?[]:"function"!==typeof ArrayBuffer||"function"!==typeof ArrayBuffer.isView||!ArrayBuffer.isView(a)||a instanceof DataView?{}:new a.constructor(a.length);for(const c in a)b[c]=\nmodule$contents$goog$object_unsafeClone(a[c]);return b}function module$contents$goog$object_transpose(a){const b={};for(const c in a)b[a[c]]=c;return b}const module$contents$goog$object_PROTOTYPE_FIELDS="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");\nfunction module$contents$goog$object_extend(a,b){let c,d;for(let e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(let f=0;f<module$contents$goog$object_PROTOTYPE_FIELDS.length;f++)c=module$contents$goog$object_PROTOTYPE_FIELDS[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}}\nfunction module$contents$goog$object_create(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_create.apply(null,arguments[0]);if(b%2)throw Error("Uneven number of arguments");const c={};for(let d=0;d<b;d+=2)c[arguments[d]]=arguments[d+1];return c}\nfunction module$contents$goog$object_createSet(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_createSet.apply(null,arguments[0]);const c={};for(let d=0;d<b;d++)c[arguments[d]]=!0;return c}function module$contents$goog$object_createImmutableView(a){let b=a;Object.isFrozen&&!Object.isFrozen(a)&&(b=Object.create(a),Object.freeze(b));return b}function module$contents$goog$object_isImmutableView(a){return!!Object.isFrozen&&Object.isFrozen(a)}\nfunction module$contents$goog$object_getAllPropertyNames(a,b,c){if(!a)return[];if(!Object.getOwnPropertyNames||!Object.getPrototypeOf)return module$contents$goog$object_getKeys(a);const d={};for(;a&&(a!==Object.prototype||b)&&(a!==Function.prototype||c);){const e=Object.getOwnPropertyNames(a);for(let f=0;f<e.length;f++)d[e[f]]=!0;a=Object.getPrototypeOf(a)}return module$contents$goog$object_getKeys(d)}\nfunction module$contents$goog$object_getSuperClass(a){return(a=Object.getPrototypeOf(a.prototype))&&a.constructor}goog.object.add=module$contents$goog$object_add;goog.object.clear=module$contents$goog$object_clear;goog.object.clone=module$contents$goog$object_clone;goog.object.contains=module$contents$goog$object_contains;goog.object.containsKey=module$contents$goog$object_containsKey;goog.object.containsValue=module$contents$goog$object_containsValue;goog.object.create=module$contents$goog$object_create;\ngoog.object.createImmutableView=module$contents$goog$object_createImmutableView;goog.object.createSet=module$contents$goog$object_createSet;goog.object.equals=module$contents$goog$object_equals;goog.object.every=module$contents$goog$object_every;goog.object.extend=module$contents$goog$object_extend;goog.object.filter=module$contents$goog$object_filter;goog.object.findKey=module$contents$goog$object_findKey;goog.object.findValue=module$contents$goog$object_findValue;goog.object.forEach=module$contents$goog$object_forEach;\ngoog.object.get=module$contents$goog$object_get;goog.object.getAllPropertyNames=module$contents$goog$object_getAllPropertyNames;goog.object.getAnyKey=module$contents$goog$object_getAnyKey;goog.object.getAnyValue=module$contents$goog$object_getAnyValue;goog.object.getCount=module$contents$goog$object_getCount;goog.object.getKeys=module$contents$goog$object_getKeys;goog.object.getSuperClass=module$contents$goog$object_getSuperClass;goog.object.getValueByKeys=module$contents$goog$object_getValueByKeys;\ngoog.object.getValues=module$contents$goog$object_getValues;goog.object.isEmpty=module$contents$goog$object_isEmpty;goog.object.isImmutableView=module$contents$goog$object_isImmutableView;goog.object.map=module$contents$goog$object_map;goog.object.remove=module$contents$goog$object_remove;goog.object.set=module$contents$goog$object_set;goog.object.setIfUndefined=module$contents$goog$object_setIfUndefined;goog.object.setWithReturnValueIfNotSet=module$contents$goog$object_setWithReturnValueIfNotSet;\ngoog.object.some=module$contents$goog$object_some;goog.object.transpose=module$contents$goog$object_transpose;goog.object.unsafeClone=module$contents$goog$object_unsafeClone;const module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeStyleSheet_SafeStyleSheet{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_=b===module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_.toString()}static createRule(a,b){if((0,goog.string.internal.contains)(a,"<"))throw Error(`Selector does not allow \'<\', got: ${a}`);const c=a.replace(/(\'|")((?!\\1)[^\\r\\n\\f\\\\]|\\\\[\\s\\S])*\\1/g,\n"");if(!/^[-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|]+$/.test(c))throw Error("Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\\\]()=^$|] and strings, got: "+a);if(!module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.hasBalancedBrackets_(c))throw Error("() and [] in selector must be balanced, got: "+a);b instanceof module$contents$goog$html$SafeStyle_SafeStyle||(b=module$contents$goog$html$SafeStyle_SafeStyle.create(b));a=`${a}{`+module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b).replace(/</g,"\\\\3C ")+"}";\nreturn module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}static hasBalancedBrackets_(a){const b={"(":")","[":"]"},c=[];for(let d=0;d<a.length;d++){const e=a[d];if(b[e])c.push(b[e]);else if(module$contents$goog$object_contains(b,e)&&c.pop()!=e)return!1}return 0==c.length}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(d)};Array.prototype.forEach.call(arguments,\nc);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY;(0,goog.asserts.assert)(!(0,goog.string.internal.contains)(a,"<"),`Forbidden \'<\' character in style sheet string: ${a}`);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_}static unwrap(a){if(a instanceof\nmodule$contents$goog$html$SafeStyleSheet_SafeStyleSheet&&a.constructor===module$contents$goog$html$SafeStyleSheet_SafeStyleSheet)return a.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeStyleSheet, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:SafeStyleSheet"}static createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyleSheet_SafeStyleSheet(a,module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE)}}\nmodule$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse("");goog.html.SafeStyleSheet=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet;goog.dom.HtmlElement=function(){};goog.dom.TagName=class{static cast(a,b){return a}constructor(){}toString(){}};goog.dom.TagName.A="A";goog.dom.TagName.ABBR="ABBR";goog.dom.TagName.ACRONYM="ACRONYM";goog.dom.TagName.ADDRESS="ADDRESS";goog.dom.TagName.APPLET="APPLET";goog.dom.TagName.AREA="AREA";goog.dom.TagName.ARTICLE="ARTICLE";goog.dom.TagName.ASIDE="ASIDE";goog.dom.TagName.AUDIO="AUDIO";goog.dom.TagName.B="B";goog.dom.TagName.BASE="BASE";goog.dom.TagName.BASEFONT="BASEFONT";goog.dom.TagName.BDI="BDI";goog.dom.TagName.BDO="BDO";\ngoog.dom.TagName.BIG="BIG";goog.dom.TagName.BLOCKQUOTE="BLOCKQUOTE";goog.dom.TagName.BODY="BODY";goog.dom.TagName.BR="BR";goog.dom.TagName.BUTTON="BUTTON";goog.dom.TagName.CANVAS="CANVAS";goog.dom.TagName.CAPTION="CAPTION";goog.dom.TagName.CENTER="CENTER";goog.dom.TagName.CITE="CITE";goog.dom.TagName.CODE="CODE";goog.dom.TagName.COL="COL";goog.dom.TagName.COLGROUP="COLGROUP";goog.dom.TagName.COMMAND="COMMAND";goog.dom.TagName.DATA="DATA";goog.dom.TagName.DATALIST="DATALIST";goog.dom.TagName.DD="DD";\ngoog.dom.TagName.DEL="DEL";goog.dom.TagName.DETAILS="DETAILS";goog.dom.TagName.DFN="DFN";goog.dom.TagName.DIALOG="DIALOG";goog.dom.TagName.DIR="DIR";goog.dom.TagName.DIV="DIV";goog.dom.TagName.DL="DL";goog.dom.TagName.DT="DT";goog.dom.TagName.EM="EM";goog.dom.TagName.EMBED="EMBED";goog.dom.TagName.FIELDSET="FIELDSET";goog.dom.TagName.FIGCAPTION="FIGCAPTION";goog.dom.TagName.FIGURE="FIGURE";goog.dom.TagName.FONT="FONT";goog.dom.TagName.FOOTER="FOOTER";goog.dom.TagName.FORM="FORM";\ngoog.dom.TagName.FRAME="FRAME";goog.dom.TagName.FRAMESET="FRAMESET";goog.dom.TagName.H1="H1";goog.dom.TagName.H2="H2";goog.dom.TagName.H3="H3";goog.dom.TagName.H4="H4";goog.dom.TagName.H5="H5";goog.dom.TagName.H6="H6";goog.dom.TagName.HEAD="HEAD";goog.dom.TagName.HEADER="HEADER";goog.dom.TagName.HGROUP="HGROUP";goog.dom.TagName.HR="HR";goog.dom.TagName.HTML="HTML";goog.dom.TagName.I="I";goog.dom.TagName.IFRAME="IFRAME";goog.dom.TagName.IMG="IMG";goog.dom.TagName.INPUT="INPUT";\ngoog.dom.TagName.INS="INS";goog.dom.TagName.ISINDEX="ISINDEX";goog.dom.TagName.KBD="KBD";goog.dom.TagName.KEYGEN="KEYGEN";goog.dom.TagName.LABEL="LABEL";goog.dom.TagName.LEGEND="LEGEND";goog.dom.TagName.LI="LI";goog.dom.TagName.LINK="LINK";goog.dom.TagName.MAIN="MAIN";goog.dom.TagName.MAP="MAP";goog.dom.TagName.MARK="MARK";goog.dom.TagName.MATH="MATH";goog.dom.TagName.MENU="MENU";goog.dom.TagName.MENUITEM="MENUITEM";goog.dom.TagName.META="META";goog.dom.TagName.METER="METER";\ngoog.dom.TagName.NAV="NAV";goog.dom.TagName.NOFRAMES="NOFRAMES";goog.dom.TagName.NOSCRIPT="NOSCRIPT";goog.dom.TagName.OBJECT="OBJECT";goog.dom.TagName.OL="OL";goog.dom.TagName.OPTGROUP="OPTGROUP";goog.dom.TagName.OPTION="OPTION";goog.dom.TagName.OUTPUT="OUTPUT";goog.dom.TagName.P="P";goog.dom.TagName.PARAM="PARAM";goog.dom.TagName.PICTURE="PICTURE";goog.dom.TagName.PRE="PRE";goog.dom.TagName.PROGRESS="PROGRESS";goog.dom.TagName.Q="Q";goog.dom.TagName.RP="RP";goog.dom.TagName.RT="RT";\ngoog.dom.TagName.RTC="RTC";goog.dom.TagName.RUBY="RUBY";goog.dom.TagName.S="S";goog.dom.TagName.SAMP="SAMP";goog.dom.TagName.SCRIPT="SCRIPT";goog.dom.TagName.SECTION="SECTION";goog.dom.TagName.SELECT="SELECT";goog.dom.TagName.SMALL="SMALL";goog.dom.TagName.SOURCE="SOURCE";goog.dom.TagName.SPAN="SPAN";goog.dom.TagName.STRIKE="STRIKE";goog.dom.TagName.STRONG="STRONG";goog.dom.TagName.STYLE="STYLE";goog.dom.TagName.SUB="SUB";goog.dom.TagName.SUMMARY="SUMMARY";goog.dom.TagName.SUP="SUP";\ngoog.dom.TagName.SVG="SVG";goog.dom.TagName.TABLE="TABLE";goog.dom.TagName.TBODY="TBODY";goog.dom.TagName.TD="TD";goog.dom.TagName.TEMPLATE="TEMPLATE";goog.dom.TagName.TEXTAREA="TEXTAREA";goog.dom.TagName.TFOOT="TFOOT";goog.dom.TagName.TH="TH";goog.dom.TagName.THEAD="THEAD";goog.dom.TagName.TIME="TIME";goog.dom.TagName.TITLE="TITLE";goog.dom.TagName.TR="TR";goog.dom.TagName.TRACK="TRACK";goog.dom.TagName.TT="TT";goog.dom.TagName.U="U";goog.dom.TagName.UL="UL";goog.dom.TagName.VAR="VAR";\ngoog.dom.TagName.VIDEO="VIDEO";goog.dom.TagName.WBR="WBR";goog.labs={};goog.labs.userAgent={};const module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE="",module$contents$goog$labs$userAgent_USE_CLIENT_HINTS=!1;let module$contents$goog$labs$userAgent_forceClientHintsInTests=!1;goog.labs.userAgent.setUseClientHintsForTesting=a=>{module$contents$goog$labs$userAgent_forceClientHintsInTests=a};\nconst module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride=module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE?!!goog.getObjectByName(module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE):!1;goog.labs.userAgent.useClientHints=()=>module$contents$goog$labs$userAgent_USE_CLIENT_HINTS||module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride||module$contents$goog$labs$userAgent_forceClientHintsInTests;goog.labs.userAgent.util={};const module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT=!1;function module$contents$goog$labs$userAgent$util_getNativeUserAgentString(){var a=module$contents$goog$labs$userAgent$util_getNavigator();return a&&(a=a.userAgent)?a:""}function module$contents$goog$labs$userAgent$util_getNativeUserAgentData(){const a=module$contents$goog$labs$userAgent$util_getNavigator();return a?a.userAgentData||null:null}\nfunction module$contents$goog$labs$userAgent$util_getNavigator(){return goog.global.navigator}let module$contents$goog$labs$userAgent$util_userAgentInternal=null,module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData();\nfunction module$contents$goog$labs$userAgent$util_setUserAgent(a){module$contents$goog$labs$userAgent$util_userAgentInternal="string"===typeof a?a:module$contents$goog$labs$userAgent$util_getNativeUserAgentString()}function module$contents$goog$labs$userAgent$util_getUserAgent(){return null==module$contents$goog$labs$userAgent$util_userAgentInternal?module$contents$goog$labs$userAgent$util_getNativeUserAgentString():module$contents$goog$labs$userAgent$util_userAgentInternal}\nfunction module$contents$goog$labs$userAgent$util_setUserAgentData(a){module$contents$goog$labs$userAgent$util_userAgentDataInternal=a}function module$contents$goog$labs$userAgent$util_resetUserAgentData(){module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData()}function module$contents$goog$labs$userAgent$util_getUserAgentData(){return module$contents$goog$labs$userAgent$util_userAgentDataInternal}\nfunction module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(a){if(!(0,goog.labs.userAgent.useClientHints)())return!1;const b=module$contents$goog$labs$userAgent$util_getUserAgentData();return b?b.brands.some(({brand:c})=>c&&(0,goog.string.internal.contains)(c,a)):!1}function module$contents$goog$labs$userAgent$util_matchUserAgent(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.contains)(b,a)}\nfunction module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.caseInsensitiveContains)(b,a)}function module$contents$goog$labs$userAgent$util_extractVersionTuples(a){const b=RegExp("([A-Z][\\\\w ]+)/([^\\\\s]+)\\\\s*(?:\\\\((.*?)\\\\))?","g"),c=[];let d;for(;d=b.exec(a);)c.push([d[1],d[2],d[3]||void 0]);return c}goog.labs.userAgent.util.ASSUME_CLIENT_HINTS_SUPPORT=module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT;\ngoog.labs.userAgent.util.extractVersionTuples=module$contents$goog$labs$userAgent$util_extractVersionTuples;goog.labs.userAgent.util.getNativeUserAgentString=module$contents$goog$labs$userAgent$util_getNativeUserAgentString;goog.labs.userAgent.util.getUserAgent=module$contents$goog$labs$userAgent$util_getUserAgent;goog.labs.userAgent.util.getUserAgentData=module$contents$goog$labs$userAgent$util_getUserAgentData;goog.labs.userAgent.util.matchUserAgent=module$contents$goog$labs$userAgent$util_matchUserAgent;\ngoog.labs.userAgent.util.matchUserAgentDataBrand=module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand;goog.labs.userAgent.util.matchUserAgentIgnoreCase=module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase;goog.labs.userAgent.util.resetUserAgentData=module$contents$goog$labs$userAgent$util_resetUserAgentData;goog.labs.userAgent.util.setUserAgent=module$contents$goog$labs$userAgent$util_setUserAgent;goog.labs.userAgent.util.setUserAgentData=module$contents$goog$labs$userAgent$util_setUserAgentData;var module$exports$goog$labs$userAgent$highEntropy$highEntropyValue={AsyncValue:class{getIfLoaded(){}load(){}},HighEntropyValue:class{constructor(a){this.key_=a;this.promise_=this.value_=void 0;this.pending_=!1}getIfLoaded(){if(module$contents$goog$labs$userAgent$util_getUserAgentData())return this.value_}async load(){const a=module$contents$goog$labs$userAgent$util_getUserAgentData();if(a)return this.promise_||(this.pending_=!0,this.promise_=(async()=>{try{return this.value_=(await a.getHighEntropyValues([this.key_]))[this.key_]}finally{this.pending_=\n!1}})()),await this.promise_}resetForTesting(){if(this.pending_)throw Error("Unsafe call to resetForTesting");this.value_=this.promise_=void 0;this.pending_=!1}},Version:class{constructor(a){this.versionString_=a}toVersionStringForLogging(){return this.versionString_}isAtLeast(a){return 0<=(0,goog.string.internal.compareVersions)(this.versionString_,a)}}};var module$exports$goog$labs$userAgent$highEntropy$highEntropyData={};module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("fullVersionList");module$exports$goog$labs$userAgent$highEntropy$highEntropyData.platformVersion=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("platformVersion");goog.labs.userAgent.browser={};const module$contents$goog$labs$userAgent$browser_Brand={ANDROID_BROWSER:"Android Browser",CHROMIUM:"Chromium",EDGE:"Microsoft Edge",FIREFOX:"Firefox",IE:"Internet Explorer",OPERA:"Opera",SAFARI:"Safari",SILK:"Silk"};goog.labs.userAgent.browser.Brand=module$contents$goog$labs$userAgent$browser_Brand;\nfunction module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(a=!1){if(module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT)return!0;if(!a&&!(0,goog.labs.userAgent.useClientHints)())return!1;a=module$contents$goog$labs$userAgent$util_getUserAgentData();return!!a&&0<a.brands.length}\nfunction module$contents$goog$labs$userAgent$browser_hasFullVersionList(){return module$contents$goog$labs$userAgent$browser_isAtLeast(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM,98)}function module$contents$goog$labs$userAgent$browser_matchOpera(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Opera")}\nfunction module$contents$goog$labs$userAgent$browser_matchIE(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Trident")||module$contents$goog$labs$userAgent$util_matchUserAgent("MSIE")}function module$contents$goog$labs$userAgent$browser_matchEdgeHtml(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Edge")}\nfunction module$contents$goog$labs$userAgent$browser_matchEdgeChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.EDGE):module$contents$goog$labs$userAgent$util_matchUserAgent("Edg/")}\nfunction module$contents$goog$labs$userAgent$browser_matchOperaChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.OPERA):module$contents$goog$labs$userAgent$util_matchUserAgent("OPR")}\nfunction module$contents$goog$labs$userAgent$browser_matchFirefox(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Firefox")||module$contents$goog$labs$userAgent$util_matchUserAgent("FxiOS")}\nfunction module$contents$goog$labs$userAgent$browser_matchSafari(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Safari")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchCoast()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_matchEdgeChromium()||module$contents$goog$labs$userAgent$browser_matchOperaChromium()||\nmodule$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_isSilk()||module$contents$goog$labs$userAgent$util_matchUserAgent("Android"))}function module$contents$goog$labs$userAgent$browser_matchCoast(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Coast")}\nfunction module$contents$goog$labs$userAgent$browser_matchIosWebview(){return(module$contents$goog$labs$userAgent$util_matchUserAgent("iPad")||module$contents$goog$labs$userAgent$util_matchUserAgent("iPhone"))&&!module$contents$goog$labs$userAgent$browser_matchSafari()&&!module$contents$goog$labs$userAgent$browser_matchChrome()&&!module$contents$goog$labs$userAgent$browser_matchCoast()&&!module$contents$goog$labs$userAgent$browser_matchFirefox()&&module$contents$goog$labs$userAgent$util_matchUserAgent("AppleWebKit")}\nfunction module$contents$goog$labs$userAgent$browser_matchChrome(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM):(module$contents$goog$labs$userAgent$util_matchUserAgent("Chrome")||module$contents$goog$labs$userAgent$util_matchUserAgent("CriOS"))&&!module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_isSilk()}\nfunction module$contents$goog$labs$userAgent$browser_matchAndroidBrowser(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Android")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_isSilk())}const module$contents$goog$labs$userAgent$browser_isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;\ngoog.labs.userAgent.browser.isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;const module$contents$goog$labs$userAgent$browser_isIE=module$contents$goog$labs$userAgent$browser_matchIE;goog.labs.userAgent.browser.isIE=module$contents$goog$labs$userAgent$browser_matchIE;const module$contents$goog$labs$userAgent$browser_isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;goog.labs.userAgent.browser.isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;\nconst module$contents$goog$labs$userAgent$browser_isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;goog.labs.userAgent.browser.isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;const module$contents$goog$labs$userAgent$browser_isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;goog.labs.userAgent.browser.isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;\nconst module$contents$goog$labs$userAgent$browser_isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;goog.labs.userAgent.browser.isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;const module$contents$goog$labs$userAgent$browser_isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;goog.labs.userAgent.browser.isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;const module$contents$goog$labs$userAgent$browser_isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;\ngoog.labs.userAgent.browser.isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;const module$contents$goog$labs$userAgent$browser_isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;goog.labs.userAgent.browser.isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;const module$contents$goog$labs$userAgent$browser_isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;goog.labs.userAgent.browser.isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;\nconst module$contents$goog$labs$userAgent$browser_isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;goog.labs.userAgent.browser.isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;function module$contents$goog$labs$userAgent$browser_isSilk(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Silk")}goog.labs.userAgent.browser.isSilk=module$contents$goog$labs$userAgent$browser_isSilk;\nfunction module$contents$goog$labs$userAgent$browser_createVersionMap(a){const b={};a.forEach(c=>{b[c[0]]=c[1]});return c=>b[c.find(d=>d in b)]||""}\nfunction module$contents$goog$labs$userAgent$browser_getVersion(){var a=module$contents$goog$labs$userAgent$util_getUserAgent();if(module$contents$goog$labs$userAgent$browser_matchIE())return module$contents$goog$labs$userAgent$browser_getIEVersion(a);a=module$contents$goog$labs$userAgent$util_extractVersionTuples(a);const b=module$contents$goog$labs$userAgent$browser_createVersionMap(a);return module$contents$goog$labs$userAgent$browser_matchOpera()?b(["Version","Opera"]):module$contents$goog$labs$userAgent$browser_matchEdgeHtml()?\nb(["Edge"]):module$contents$goog$labs$userAgent$browser_matchEdgeChromium()?b(["Edg"]):module$contents$goog$labs$userAgent$browser_isSilk()?b(["Silk"]):module$contents$goog$labs$userAgent$browser_matchChrome()?b(["Chrome","CriOS","HeadlessChrome"]):(a=a[2])&&a[1]||""}goog.labs.userAgent.browser.getVersion=module$contents$goog$labs$userAgent$browser_getVersion;\nfunction module$contents$goog$labs$userAgent$browser_isVersionOrHigher(a){return 0<=(0,goog.string.internal.compareVersions)(module$contents$goog$labs$userAgent$browser_getVersion(),a)}goog.labs.userAgent.browser.isVersionOrHigher=module$contents$goog$labs$userAgent$browser_isVersionOrHigher;\nfunction module$contents$goog$labs$userAgent$browser_getIEVersion(a){var b=/rv: *([\\d\\.]*)/.exec(a);if(b&&b[1])return b[1];b="";const c=/MSIE +([\\d\\.]+)/.exec(a);if(c&&c[1])if(a=/Trident\\/(\\d.\\d)/.exec(a),"7.0"==c[1])if(a&&a[1])switch(a[1]){case "4.0":b="8.0";break;case "5.0":b="9.0";break;case "6.0":b="10.0";break;case "7.0":b="11.0"}else b="7.0";else b=c[1];return b}\nfunction module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a){var b=module$contents$goog$labs$userAgent$util_getUserAgent();if(a===module$contents$goog$labs$userAgent$browser_Brand.IE)return module$contents$goog$labs$userAgent$browser_matchIE()?module$contents$goog$labs$userAgent$browser_getIEVersion(b):"";b=module$contents$goog$labs$userAgent$util_extractVersionTuples(b);const c=module$contents$goog$labs$userAgent$browser_createVersionMap(b);switch(a){case module$contents$goog$labs$userAgent$browser_Brand.OPERA:if(module$contents$goog$labs$userAgent$browser_matchOpera())return c(["Version",\n"Opera"]);if(module$contents$goog$labs$userAgent$browser_matchOperaChromium())return c(["OPR"]);break;case module$contents$goog$labs$userAgent$browser_Brand.EDGE:if(module$contents$goog$labs$userAgent$browser_matchEdgeHtml())return c(["Edge"]);if(module$contents$goog$labs$userAgent$browser_matchEdgeChromium())return c(["Edg"]);break;case module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM:if(module$contents$goog$labs$userAgent$browser_matchChrome())return c(["Chrome","CriOS","HeadlessChrome"])}return a===\nmodule$contents$goog$labs$userAgent$browser_Brand.FIREFOX&&module$contents$goog$labs$userAgent$browser_matchFirefox()||a===module$contents$goog$labs$userAgent$browser_Brand.SAFARI&&module$contents$goog$labs$userAgent$browser_matchSafari()||a===module$contents$goog$labs$userAgent$browser_Brand.ANDROID_BROWSER&&module$contents$goog$labs$userAgent$browser_matchAndroidBrowser()||a===module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_isSilk()?(a=b[2])&&\na[1]||"":""}\nfunction module$contents$goog$labs$userAgent$browser_versionOf_(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()&&a!==module$contents$goog$labs$userAgent$browser_Brand.SILK){var b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);if(!b||!b.version)return NaN;b=b.version.split(".")}else{b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a);if(""===b)return NaN;b=b.split(".")}return 0===b.length?NaN:Number(b[0])}\nfunction module$contents$goog$labs$userAgent$browser_isAtLeast(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)>=b}goog.labs.userAgent.browser.isAtLeast=module$contents$goog$labs$userAgent$browser_isAtLeast;\nfunction module$contents$goog$labs$userAgent$browser_isAtMost(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)<=b}goog.labs.userAgent.browser.isAtMost=module$contents$goog$labs$userAgent$browser_isAtMost;\nclass module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion{constructor(a,b,c){this.brand_=a;this.version_=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(c);this.useUach_=b}getIfLoaded(){if(this.useUach_){var a=module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.getIfLoaded();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}if(module$contents$goog$labs$userAgent$browser_preUachHasLoaded)return this.version_}async load(){if(this.useUach_){var a=\nawait module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}else await 0;module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0;return this.version_}}let module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;\nasync function module$contents$goog$labs$userAgent$browser_loadFullVersions(){module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)&&await module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0}goog.labs.userAgent.browser.loadFullVersions=module$contents$goog$labs$userAgent$browser_loadFullVersions;\ngoog.labs.userAgent.browser.resetForTesting=()=>{module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.resetForTesting()};\nfunction module$contents$goog$labs$userAgent$browser_fullVersionOf(a){let b="";module$contents$goog$labs$userAgent$browser_hasFullVersionList()||(b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a));const c=a!==module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0);if(c){if(!module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:d})=>d===a))return}else if(""===b)return;return new module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion(a,\nc,b)}goog.labs.userAgent.browser.fullVersionOf=module$contents$goog$labs$userAgent$browser_fullVersionOf;\nfunction module$contents$goog$labs$userAgent$browser_getVersionStringForLogging(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)){var b=module$contents$goog$labs$userAgent$browser_fullVersionOf(a);if(b){if(b=b.getIfLoaded())return b.toVersionStringForLogging();b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);(0,goog.asserts.assertExists)(b);return b.version}return""}return module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a)}\ngoog.labs.userAgent.browser.getVersionStringForLogging=module$contents$goog$labs$userAgent$browser_getVersionStringForLogging;goog.dom.tags={};goog.dom.tags.VOID_TAGS_={area:!0,base:!0,br:!0,col:!0,command:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};goog.dom.tags.isVoidTag=function(a){return!0===goog.dom.tags.VOID_TAGS_[a]};const module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeHtml_SafeHtml{constructor(a,b){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_=b===module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}toString(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(a).toString()}static unwrapTrustedHTML(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml&&\na.constructor===module$contents$goog$html$SafeHtml_SafeHtml)return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_;goog.asserts.fail(`expected object of type SafeHtml, got \'${a}\' of type `+goog.typeOf(a));return"type_error:SafeHtml"}static htmlEscape(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.htmlEscape(a))}static htmlEscapePreservingNewlines(a){if(a instanceof\nmodule$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.newLineToBr(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static htmlEscapePreservingNewlinesAndSpaces(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.whitespaceEscape(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static comment(a){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("\\x3c!--"+\ngoog.string.internal.htmlEscape(a)+"--\\x3e")}static create(a,b,c){module$contents$goog$html$SafeHtml_SafeHtml.verifyTagName(String(a));return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(String(a),b,c)}static verifyTagName(a){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Invalid tag name <${a}>.`:"");if(a.toUpperCase()in module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n`Tag name <${a}> is not allowed for SafeHtml.`:"");}static createIframe(a,b,c,d){a&&goog.html.TrustedResourceUrl.unwrap(a);const e={};e.src=a||null;e.srcdoc=b&&module$contents$goog$html$SafeHtml_SafeHtml.unwrap(b);a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{sandbox:""},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static createSandboxIframe(a,b,c,d){if(!module$contents$goog$html$SafeHtml_SafeHtml.canUseSandboxIframe())throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n"The browser does not support sandboxed iframes.":"");const e={};e.src=a?goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a)):null;e.srcdoc=b||null;e.sandbox="";a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static canUseSandboxIframe(){return goog.global.HTMLIFrameElement&&"sandbox"in goog.global.HTMLIFrameElement.prototype}static createScriptSrc(a,b){goog.html.TrustedResourceUrl.unwrap(a);\na=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({src:a},{},b);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",a)}static createScript(a,b){for(var c in b)if(Object.prototype.hasOwnProperty.call(b,c)){var d=c.toLowerCase();if("language"==d||"src"==d||"text"==d)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot set "${d}" attribute`:"");}c="";a=module$contents$goog$array_concat(a);for(d=0;d<\na.length;d++)c+=module$contents$goog$html$SafeScript_SafeScript.unwrap(a[d]);a=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",b,a)}static createStyle(a,b){b=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({type:"text/css"},{},b);let c="";a=module$contents$goog$array_concat(a);for(let d=0;d<a.length;d++)c+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(a[d]);\na=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("style",b,a)}static createMetaRefresh(a,b){a=goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a));(module$contents$goog$labs$userAgent$browser_matchIE()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml())&&goog.string.internal.contains(a,";")&&(a="\'"+a.replace(/\'/g,"%27")+"\'");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("meta",\n{"http-equiv":"refresh",content:(b||0)+"; url="+a})}static join(a,b){a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);const c=[],d=e=>{Array.isArray(e)?e.forEach(d):(e=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(e),c.push(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(e)))};b.forEach(d);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c.join(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static concat(a){return module$contents$goog$html$SafeHtml_SafeHtml.join(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY,\nArray.prototype.slice.call(arguments))}static createSafeHtmlSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createHTML(a):a;return new module$contents$goog$html$SafeHtml_SafeHtml(a,module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE)}static createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(a,b,c){b=`<${a}`+module$contents$goog$html$SafeHtml_SafeHtml.stringifyAttributes(a,b);null==c?c=[]:Array.isArray(c)||(c=[c]);goog.dom.tags.isVoidTag(a.toLowerCase())?\n(goog.asserts.assert(!c.length,`Void tag <${a}> does not allow content.`),b+=">"):(c=module$contents$goog$html$SafeHtml_SafeHtml.concat(c),b+=">"+module$contents$goog$html$SafeHtml_SafeHtml.unwrap(c)+"</"+a+">");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)}static stringifyAttributes(a,b){let c="";if(b)for(let d in b)if(Object.prototype.hasOwnProperty.call(b,d)){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(d))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n`Invalid attribute name "${d}".`:"");const e=b[d];null!=e&&(c+=" "+module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,d,e))}return c}static combineAttributes(a,b,c){const d={};for(var e in a)Object.prototype.hasOwnProperty.call(a,e)&&(goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=a[e]);for(const f in b)Object.prototype.hasOwnProperty.call(b,f)&&(goog.asserts.assert(f.toLowerCase()==f,"Must be lower case"),d[f]=b[f]);if(c)for(const f in c)if(Object.prototype.hasOwnProperty.call(c,\nf)){e=f.toLowerCase();if(e in a)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot override "${e}" attribute, got "`+f+\'" with value "\'+c[f]+\'"\':"");e in b&&delete d[e];d[f]=c[f]}return d}}module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES=goog.DEBUG;module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE=!0;module$contents$goog$html$SafeHtml_SafeHtml.from=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape;\nconst module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG=/^[a-zA-Z0-9-]+$/,module$contents$goog$html$SafeHtml_URL_ATTRIBUTES={action:!0,cite:!0,data:!0,formaction:!0,href:!0,manifest:!0,poster:!0,src:!0},module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES={[goog.dom.TagName.APPLET]:!0,[goog.dom.TagName.BASE]:!0,[goog.dom.TagName.EMBED]:!0,[goog.dom.TagName.IFRAME]:!0,[goog.dom.TagName.LINK]:!0,[goog.dom.TagName.MATH]:!0,[goog.dom.TagName.META]:!0,[goog.dom.TagName.OBJECT]:!0,[goog.dom.TagName.SCRIPT]:!0,\n[goog.dom.TagName.STYLE]:!0,[goog.dom.TagName.SVG]:!0,[goog.dom.TagName.TEMPLATE]:!0};\nfunction module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,b,c){if(c instanceof goog.string.Const)c=goog.string.Const.unwrap(c);else if("style"==b.toLowerCase())if(module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE)c=module$contents$goog$html$SafeHtml_getStyleValue(c);else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\'Attribute "style" not supported.\':"");else{if(/^on/i.test(b))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n`Attribute "${b}`+\'" requires goog.string.Const value, "\'+c+\'" given.\':"");if(b.toLowerCase()in module$contents$goog$html$SafeHtml_URL_ATTRIBUTES)if(c instanceof goog.html.TrustedResourceUrl)c=goog.html.TrustedResourceUrl.unwrap(c);else if(c instanceof goog.html.SafeUrl)c=goog.html.SafeUrl.unwrap(c);else if("string"===typeof c)c=goog.html.SafeUrl.sanitize(c).getTypedStringValue();else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Attribute "${b}" on tag "${a}`+\'" requires goog.html.SafeUrl, goog.string.Const, or string, value "\'+\nc+\'" given.\':"");}c.implementsGoogStringTypedString&&(c=c.getTypedStringValue());goog.asserts.assert("string"===typeof c||"number"===typeof c,"String or number value expected, got "+typeof c+" with value: "+c);return`${b}="`+goog.string.internal.htmlEscape(String(c))+\'"\'}\nfunction module$contents$goog$html$SafeHtml_getStyleValue(a){if(!goog.isObject(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\'The "style" attribute requires goog.html.SafeStyle or map of style properties, \'+typeof a+" given: "+a:"");a instanceof module$contents$goog$html$SafeStyle_SafeStyle||(a=module$contents$goog$html$SafeStyle_SafeStyle.create(a));return module$contents$goog$html$SafeStyle_SafeStyle.unwrap(a)}\nmodule$contents$goog$html$SafeHtml_SafeHtml.DOCTYPE_HTML=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<!DOCTYPE html>")}();module$contents$goog$html$SafeHtml_SafeHtml.EMPTY=new module$contents$goog$html$SafeHtml_SafeHtml(goog.global.trustedTypes&&goog.global.trustedTypes.emptyHTML||"",module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE);module$contents$goog$html$SafeHtml_SafeHtml.BR=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<br>")}();\ngoog.html.SafeHtml=module$contents$goog$html$SafeHtml_SafeHtml;goog.html.uncheckedconversions={};goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.dom.safe={};goog.dom.safe.InsertAdjacentHtmlPosition={AFTERBEGIN:"afterbegin",AFTEREND:"afterend",BEFOREBEGIN:"beforebegin",BEFOREEND:"beforeend"};goog.dom.safe.insertAdjacentHtml=function(a,b,c){a.insertAdjacentHTML(b,module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(c))};goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_={MATH:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};\ngoog.dom.safe.isInnerHtmlCleanupRecursive_=goog.functions.cacheReturnValue(function(){if(goog.DEBUG&&"undefined"===typeof document)return!1;var a=document.createElement("div"),b=document.createElement("div");b.appendChild(document.createElement("div"));a.appendChild(b);if(goog.DEBUG&&!a.firstChild)return!1;b=a.firstChild.firstChild;a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY);return!b.parentElement});\ngoog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse=function(a,b){if(goog.dom.safe.isInnerHtmlCleanupRecursive_())for(;a.lastChild;)a.removeChild(a.lastChild);a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};\ngoog.dom.safe.setInnerHtml=function(a,b){if(goog.asserts.ENABLE_ASSERTS&&a.tagName){var c=a.tagName.toUpperCase();if(goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[c])throw Error("goog.dom.safe.setInnerHtml cannot be used to set content of "+a.tagName+".");}goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse(a,b)};\ngoog.dom.safe.setInnerHtmlFromConstant=function(a,b){goog.dom.safe.setInnerHtml(a,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Constant HTML to be immediatelly used."),goog.string.Const.unwrap(b)))};goog.dom.safe.setOuterHtml=function(a,b){a.outerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};\ngoog.dom.safe.setFormElementAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLFormElement(a).action=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setButtonFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLButtonElement(a).formAction=goog.html.SafeUrl.unwrap(b)};\ngoog.dom.safe.setInputFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLInputElement(a).formAction=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setStyle=function(a,b){a.style.cssText=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b)};goog.dom.safe.documentWrite=function(a,b){a.write(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};\ngoog.dom.safe.setAnchorHref=function(a,b){goog.dom.asserts.assertIsHTMLAnchorElement(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setAudioSrc=function(a,b){goog.dom.asserts.assertIsHTMLAudioElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:audio\\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};\ngoog.dom.safe.setVideoSrc=function(a,b){goog.dom.asserts.assertIsHTMLVideoElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:video\\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setEmbedSrc=function(a,b){goog.dom.asserts.assertIsHTMLEmbedElement(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setFrameSrc=function(a,b){goog.dom.asserts.assertIsHTMLFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};\ngoog.dom.safe.setIframeSrc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrcdoc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.srcdoc=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};\ngoog.dom.safe.setLinkHrefAndRel=function(a,b,c){goog.dom.asserts.assertIsHTMLLinkElement(a);a.rel=c;goog.string.internal.caseInsensitiveContains(c,"stylesheet")?(goog.asserts.assert(b instanceof goog.html.TrustedResourceUrl,\'URL must be TrustedResourceUrl because "rel" contains "stylesheet"\'),a.href=goog.html.TrustedResourceUrl.unwrap(b),(b=goog.dom.safe.getStyleNonce(a.ownerDocument&&a.ownerDocument.defaultView))&&a.setAttribute("nonce",b)):a.href=b instanceof goog.html.TrustedResourceUrl?goog.html.TrustedResourceUrl.unwrap(b):\nb instanceof goog.html.SafeUrl?goog.html.SafeUrl.unwrap(b):goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitizeAssertUnchanged(b))};goog.dom.safe.setObjectData=function(a,b){goog.dom.asserts.assertIsHTMLObjectElement(a);a.data=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setScriptSrc=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};\ngoog.dom.safe.setScriptContent=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.textContent=module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(b)};goog.dom.safe.setNonceForScriptElement_=function(a){const b=goog.dom.safe.getScriptNonce(a.ownerDocument&&a.ownerDocument.defaultView);b&&a.setAttribute("nonce",b)};\ngoog.dom.safe.setLocationHref=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.assignLocation=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.assign(goog.html.SafeUrl.unwrap(b))};\ngoog.dom.safe.replaceLocation=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.replace(goog.html.SafeUrl.unwrap(b))};goog.dom.safe.openInWindow=function(a,b,c,d){a=a instanceof goog.html.SafeUrl?a:goog.html.SafeUrl.sanitizeAssertUnchanged(a);b=b||goog.global;c=c instanceof goog.string.Const?goog.string.Const.unwrap(c):c||"";return void 0!==d?b.open(goog.html.SafeUrl.unwrap(a),c,d):b.open(goog.html.SafeUrl.unwrap(a),c)};\ngoog.dom.safe.parseFromStringHtml=function(a,b){return goog.dom.safe.parseFromString(a,b,"text/html")};goog.dom.safe.parseFromString=function(a,b,c){return a.parseFromString(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b),c)};\ngoog.dom.safe.createImageFromBlob=function(a){if(!/^image\\/.*/g.test(a.type))throw Error("goog.dom.safe.createImageFromBlob only accepts MIME type image/.*.");var b=goog.global.URL.createObjectURL(a);a=new goog.global.Image;a.onload=function(){goog.global.URL.revokeObjectURL(b)};a.src=b;return a};goog.dom.safe.createContextualFragment=function(a,b){return a.createContextualFragment(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};\ngoog.dom.safe.getScriptNonce=function(a){return goog.dom.safe.getNonce_("script[nonce]",a)};goog.dom.safe.getStyleNonce=function(a){return goog.dom.safe.getNonce_(\'style[nonce],link[rel="stylesheet"][nonce]\',a)};goog.dom.safe.NONCE_PATTERN_=/^[\\w+/_-]+[=]{0,2}$/;goog.dom.safe.getNonce_=function(a,b){b=(b||goog.global).document;return b.querySelector?(a=b.querySelector(a))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.dom.safe.NONCE_PATTERN_.test(a)?a:"":""};goog.string.DETECT_DOUBLE_ESCAPING=!1;goog.string.FORCE_NON_DOM_HTML_UNESCAPING=!1;goog.string.Unicode={NBSP:"\\u00a0",ZERO_WIDTH_SPACE:"\\u200b"};goog.string.startsWith=goog.string.internal.startsWith;goog.string.endsWith=goog.string.internal.endsWith;goog.string.caseInsensitiveStartsWith=goog.string.internal.caseInsensitiveStartsWith;goog.string.caseInsensitiveEndsWith=goog.string.internal.caseInsensitiveEndsWith;goog.string.caseInsensitiveEquals=goog.string.internal.caseInsensitiveEquals;\ngoog.string.subs=function(a,b){const c=a.split("%s");let d="";const e=Array.prototype.slice.call(arguments,1);for(;e.length&&1<c.length;)d+=c.shift()+e.shift();return d+c.join("%s")};goog.string.collapseWhitespace=function(a){return a.replace(/[\\s\\xa0]+/g," ").replace(/^\\s+|\\s+$/g,"")};goog.string.isEmptyOrWhitespace=goog.string.internal.isEmptyOrWhitespace;goog.string.isEmptyString=function(a){return 0==a.length};goog.string.isEmpty=goog.string.isEmptyOrWhitespace;\ngoog.string.isEmptyOrWhitespaceSafe=function(a){return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(a))};goog.string.isEmptySafe=goog.string.isEmptyOrWhitespaceSafe;goog.string.isBreakingWhitespace=function(a){return!/[^\\t\\n\\r ]/.test(a)};goog.string.isAlpha=function(a){return!/[^a-zA-Z]/.test(a)};goog.string.isNumeric=function(a){return!/[^0-9]/.test(a)};goog.string.isAlphaNumeric=function(a){return!/[^a-zA-Z0-9]/.test(a)};goog.string.isSpace=function(a){return" "==a};\ngoog.string.isUnicodeChar=function(a){return 1==a.length&&" "<=a&&"~">=a||"\\u0080"<=a&&"\\ufffd">=a};goog.string.stripNewlines=function(a){return a.replace(/(\\r\\n|\\r|\\n)+/g," ")};goog.string.canonicalizeNewlines=function(a){return a.replace(/(\\r\\n|\\r|\\n)/g,"\\n")};goog.string.normalizeWhitespace=function(a){return a.replace(/\\xa0|\\s/g," ")};goog.string.normalizeSpaces=function(a){return a.replace(/\\xa0|[ \\t]+/g," ")};\ngoog.string.collapseBreakingSpaces=function(a){return a.replace(/[\\t\\r\\n ]+/g," ").replace(/^[\\t\\r\\n ]+|[\\t\\r\\n ]+$/g,"")};goog.string.trim=goog.string.internal.trim;goog.string.trimLeft=function(a){return a.replace(/^[\\s\\xa0]+/,"")};goog.string.trimRight=function(a){return a.replace(/[\\s\\xa0]+$/,"")};goog.string.caseInsensitiveCompare=goog.string.internal.caseInsensitiveCompare;\ngoog.string.numberAwareCompare_=function(a,b,c){if(a==b)return 0;if(!a)return-1;if(!b)return 1;const d=a.toLowerCase().match(c),e=b.toLowerCase().match(c),f=Math.min(d.length,e.length);for(let g=0;g<f;g++){c=d[g];const h=e[g];if(c!=h)return a=parseInt(c,10),!isNaN(a)&&(b=parseInt(h,10),!isNaN(b)&&a-b)?a-b:c<h?-1:1}return d.length!=e.length?d.length-e.length:a<b?-1:1};goog.string.intAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\\d+|\\D+/g)};\ngoog.string.floatAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\\d+|\\.\\d+|\\D+/g)};goog.string.numerateCompare=goog.string.floatAwareCompare;goog.string.urlEncode=function(a){return encodeURIComponent(String(a))};goog.string.urlDecode=function(a){return decodeURIComponent(a.replace(/\\+/g," "))};goog.string.newLineToBr=goog.string.internal.newLineToBr;\ngoog.string.htmlEscape=function(a,b){a=goog.string.internal.htmlEscape(a,b);goog.string.DETECT_DOUBLE_ESCAPING&&(a=a.replace(goog.string.E_RE_,"&#101;"));return a};goog.string.E_RE_=/e/g;goog.string.unescapeEntities=function(a){return goog.string.contains(a,"&")?!goog.string.FORCE_NON_DOM_HTML_UNESCAPING&&"document"in goog.global?goog.string.unescapeEntitiesUsingDom_(a):goog.string.unescapePureXmlEntities_(a):a};\ngoog.string.unescapeEntitiesWithDocument=function(a,b){return goog.string.contains(a,"&")?goog.string.unescapeEntitiesUsingDom_(a,b):a};\ngoog.string.unescapeEntitiesUsingDom_=function(a,b){const c={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":\'"\'};let d;d=b?b.createElement("div"):goog.global.document.createElement("div");return a.replace(goog.string.HTML_ENTITY_PATTERN_,function(e,f){let g=c[e];if(g)return g;"#"==f.charAt(0)&&(f=Number("0"+f.slice(1)),isNaN(f)||(g=String.fromCharCode(f)));g||(goog.dom.safe.setInnerHtml(d,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Single HTML entity."),\ne+" ")),g=d.firstChild.nodeValue.slice(0,-1));return c[e]=g})};goog.string.unescapePureXmlEntities_=function(a){return a.replace(/&([^;]+);/g,function(b,c){switch(c){case "amp":return"&";case "lt":return"<";case "gt":return">";case "quot":return\'"\';default:return"#"!=c.charAt(0)||(c=Number("0"+c.slice(1)),isNaN(c))?b:String.fromCharCode(c)}})};goog.string.HTML_ENTITY_PATTERN_=/&([^;\\s<&]+);?/g;goog.string.whitespaceEscape=function(a,b){return goog.string.newLineToBr(a.replace(/  /g," &#160;"),b)};\ngoog.string.preserveSpaces=function(a){return a.replace(/(^|[\\n ]) /g,"$1"+goog.string.Unicode.NBSP)};goog.string.stripQuotes=function(a,b){const c=b.length;for(let d=0;d<c;d++){const e=1==c?b:b.charAt(d);if(a.charAt(0)==e&&a.charAt(a.length-1)==e)return a.substring(1,a.length-1)}return a};goog.string.truncate=function(a,b,c){c&&(a=goog.string.unescapeEntities(a));a.length>b&&(a=a.substring(0,b-3)+"...");c&&(a=goog.string.htmlEscape(a));return a};\ngoog.string.truncateMiddle=function(a,b,c,d){c&&(a=goog.string.unescapeEntities(a));if(d&&a.length>b){d>b&&(d=b);var e=a.length-d;a=a.substring(0,b-d)+"..."+a.substring(e)}else a.length>b&&(d=Math.floor(b/2),e=a.length-d,a=a.substring(0,d+b%2)+"..."+a.substring(e));c&&(a=goog.string.htmlEscape(a));return a};goog.string.specialEscapeChars_={"\\x00":"\\\\0","\\b":"\\\\b","\\f":"\\\\f","\\n":"\\\\n","\\r":"\\\\r","\\t":"\\\\t","\\v":"\\\\x0B",\'"\':\'\\\\"\',"\\\\":"\\\\\\\\","<":"\\\\u003C"};goog.string.jsEscapeCache_={"\'":"\\\\\'"};\ngoog.string.quote=function(a){a=String(a);const b=[\'"\'];for(let c=0;c<a.length;c++){const d=a.charAt(c),e=d.charCodeAt(0);b[c+1]=goog.string.specialEscapeChars_[d]||(31<e&&127>e?d:goog.string.escapeChar(d))}b.push(\'"\');return b.join("")};goog.string.escapeString=function(a){const b=[];for(let c=0;c<a.length;c++)b[c]=goog.string.escapeChar(a.charAt(c));return b.join("")};\ngoog.string.escapeChar=function(a){if(a in goog.string.jsEscapeCache_)return goog.string.jsEscapeCache_[a];if(a in goog.string.specialEscapeChars_)return goog.string.jsEscapeCache_[a]=goog.string.specialEscapeChars_[a];let b;const c=a.charCodeAt(0);if(31<c&&127>c)b=a;else{if(256>c){if(b="\\\\x",16>c||256<c)b+="0"}else b="\\\\u",4096>c&&(b+="0");b+=c.toString(16).toUpperCase()}return goog.string.jsEscapeCache_[a]=b};goog.string.contains=goog.string.internal.contains;\ngoog.string.caseInsensitiveContains=goog.string.internal.caseInsensitiveContains;goog.string.countOf=function(a,b){return a&&b?a.split(b).length-1:0};goog.string.removeAt=function(a,b,c){let d=a;0<=b&&b<a.length&&0<c&&(d=a.slice(0,b)+a.slice(b+c));return d};goog.string.remove=function(a,b){return a.replace(b,"")};goog.string.removeAll=function(a,b){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,"")};\ngoog.string.replaceAll=function(a,b,c){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,c.replace(/\\$/g,"$$$$"))};goog.string.regExpEscape=function(a){return String(a).replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g,"\\\\$1").replace(/\\x08/g,"\\\\x08")};goog.string.repeat=String.prototype.repeat?function(a,b){return a.repeat(b)}:function(a,b){return Array(b+1).join(a)};\ngoog.string.padNumber=function(a,b,c){if(!Number.isFinite(a))return String(a);a=void 0!==c?a.toFixed(c):String(a);c=a.indexOf(".");-1===c&&(c=a.length);const d="-"===a[0]?"-":"";d&&(a=a.substring(1));return d+goog.string.repeat("0",Math.max(0,b-c))+a};goog.string.makeSafe=function(a){return null==a?"":String(a)};goog.string.getRandomString=function(){return Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^goog.now()).toString(36)};\ngoog.string.compareVersions=goog.string.internal.compareVersions;goog.string.hashCode=function(a){let b=0;for(let c=0;c<a.length;++c)b=31*b+a.charCodeAt(c)>>>0;return b};goog.string.uniqueStringCounter_=2147483648*Math.random()|0;goog.string.createUniqueString=function(){return"goog_"+goog.string.uniqueStringCounter_++};goog.string.toNumber=function(a){const b=Number(a);return 0==b&&goog.string.isEmptyOrWhitespace(a)?NaN:b};goog.string.isLowerCamelCase=function(a){return/^[a-z]+([A-Z][a-z]*)*$/.test(a)};\ngoog.string.isUpperCamelCase=function(a){return/^([A-Z][a-z]*)+$/.test(a)};goog.string.toCamelCase=function(a){return String(a).replace(/\\-([a-z])/g,function(b,c){return c.toUpperCase()})};goog.string.toSelectorCase=function(a){return String(a).replace(/([A-Z])/g,"-$1").toLowerCase()};goog.string.toTitleCase=function(a,b){b="string"===typeof b?goog.string.regExpEscape(b):"\\\\s";return a.replace(new RegExp("(^"+(b?"|["+b+"]+":"")+")([a-z])","g"),function(c,d,e){return d+e.toUpperCase()})};\ngoog.string.capitalize=function(a){return String(a.charAt(0)).toUpperCase()+String(a.slice(1)).toLowerCase()};goog.string.parseInt=function(a){isFinite(a)&&(a=String(a));return"string"===typeof a?/^\\s*-?0x/i.test(a)?parseInt(a,16):parseInt(a,10):NaN};goog.string.splitLimit=function(a,b,c){a=a.split(b);const d=[];for(;0<c&&a.length;)d.push(a.shift()),c--;a.length&&d.push(a.join(b));return d};\ngoog.string.lastComponent=function(a,b){if(b)"string"==typeof b&&(b=[b]);else return a;let c=-1;for(let d=0;d<b.length;d++){if(""==b[d])continue;const e=a.lastIndexOf(b[d]);e>c&&(c=e)}return-1==c?a:a.slice(c+1)};\ngoog.string.editDistance=function(a,b){const c=[],d=[];if(a==b)return 0;if(!a.length||!b.length)return Math.max(a.length,b.length);for(var e=0;e<b.length+1;e++)c[e]=e;for(e=0;e<a.length;e++){d[0]=e+1;for(var f=0;f<b.length;f++)d[f+1]=Math.min(d[f]+1,c[f+1]+1,c[f]+Number(a[e]!=b[f]));for(f=0;f<c.length;f++)c[f]=d[f]}return d[b.length]};goog.string.path={};goog.string.path.baseName=function(a){const b=a.lastIndexOf("/")+1;return a.slice(b)};goog.string.path.basename=goog.string.path.baseName;goog.string.path.dirname=function(a){const b=a.lastIndexOf("/")+1;a=a.slice(0,b);/^\\/+$/.test(a)||(a=a.replace(/\\/+$/,""));return a};goog.string.path.extension=function(a){a=goog.string.path.baseName(a).replace(/\\.+/g,".");const b=a.lastIndexOf(".");return 0>=b?"":a.slice(b+1)};\ngoog.string.path.join=function(a){let b=arguments[0];for(let c=1;c<arguments.length;c++){const d=arguments[c];b=goog.string.startsWith(d,"/")?d:""==b||goog.string.endsWith(b,"/")?b+d:b+("/"+d)}return b};\ngoog.string.path.normalizePath=function(a){if(""==a)return".";let b="";goog.string.startsWith(a,"/")&&(b="/",goog.string.startsWith(a,"//")&&!goog.string.startsWith(a,"///")&&(b="//"));a=a.split("/");const c=[];for(let d=0;d<a.length;d++){const e=a[d];""!=e&&"."!=e&&(".."!=e||!b&&!c.length||".."==module$contents$goog$array_peek(c)?c.push(e):c.pop())}return b+c.join("/")||"."};goog.string.path.split=function(a){const b=goog.string.path.dirname(a);a=goog.string.path.baseName(a);return[b,a]};const DEBUG_WASI$$module$src$filesystem$wasi=!1;function assertLeadingSlash$$module$src$filesystem$wasi(a){return/^\\//g.test(a)?a:`/${a}`}function removeLeadingSlash$$module$src$filesystem$wasi(a){return a.replace(/^\\//g,"")}function shouldOpenReader$$module$src$filesystem$wasi(a){return(a&(WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants))!==goog.global.BigInt(0)}\nfunction performanceNowPoly$$module$src$filesystem$wasi(){if("undefined"===typeof performance||"undefined"===typeof performance.now){const a=Date.now();return Date.now()-a}return performance.now()}function concatUint8Arrays$$module$src$filesystem$wasi(a){var b=a.reduce((d,e)=>d+e.length,0);if(0!==a.length){b=new Uint8Array(b);var c=0;for(const d of a)b.set(d,c),c+=d.length;return b}}\nconst WASI$$module$src$filesystem$wasi=function({}){this.fd=Array.from({length:4});this.fd[0]={fd:0,path:"/dev/stdin",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[1]={fd:1,path:"/dev/stdout",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[2]={fd:2,path:"/dev/stderr",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[3]={fd:3,path:"/",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.getMemory=this.getMemory.bind(this);this.CPUTIME_START=0};\nWASI$$module$src$filesystem$wasi.prototype.start=function(a){this.CPUTIME_START=performanceNowPoly$$module$src$filesystem$wasi();a.exports._start()};WASI$$module$src$filesystem$wasi.prototype.getImports=function(a){const b={};a=WebAssembly.Module.imports(a);for(const c of a)"function"===c.kind&&c.module.startsWith("wasi_")&&("object"!==typeof b[c.module]&&(b[c.module]={}),b[c.module][c.name]=this[c.name].bind(this));return b};\nWASI$$module$src$filesystem$wasi.prototype.setMemory=function(a){this.memory=a};WASI$$module$src$filesystem$wasi.prototype.getMemory=function(){this.view&&this.view.buffer&&this.view.buffer.byteLength||(this.view=new DataView(this.memory.buffer));return this.view};WASI$$module$src$filesystem$wasi.prototype.msToNs=function(a){const b=Math.trunc(a);a=goog.global.BigInt(Math.round(1E6*(a-b)));return goog.global.BigInt(b)*goog.global.BigInt(1E6)+a};\nWASI$$module$src$filesystem$wasi.prototype.now=function(a){switch(a){case WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi());case WASI_CLOCK_REALTIME$$module$src$filesystem$constants:return this.msToNs(Date.now());case WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants:case WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi()-this.CPUTIME_START);\ndefault:return 0}};WASI$$module$src$filesystem$wasi.prototype.args_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,module$src$filesystem$constants);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.args_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.clock_res_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.clock_time_get=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("clock_time_get",a,b,c,arguments);const d=this.getMemory(),e=this.now(a);d.setBigUint64(c,goog.global.BigInt(e),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.environ_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.environ_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_advise=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_advise",a,b,c,d,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_allocate=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_allocate",a,b,c,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_close=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_close",a,arguments);this.fd[a]&&(this.fd[a].open=!1);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_datasync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_datasync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_fdstat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_get",a,b,arguments);const c=this.getMemory();c.setUint8(b+4,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);c.setUint16(b+2,0,!0);c.setUint16(b+4,0,!0);c.setBigUint64(b+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants),!0);c.setBigUint64(b+8+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants),\n!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_flags=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_flags",a,b,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_rights=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_rights",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_filestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_get",a,b,arguments);let c=0;this.fd[a]&&(c=this.fd[a].buffers.reduce(function(e,f){return e+(null==f?void 0:f.byteLength)?null==f?void 0:f.byteLength:0},0));const d=this.getMemory();d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setUint8(b,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);b+=8;d.setBigUint64(b,\ngoog.global.BigInt(1),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(c),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);d.setBigUint64(b+8,this.msToNs(this.CPUTIME_START),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_size=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_size",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_times=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_times",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_pread=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_pread",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_prestat_dir_name=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_dir_name",a,b,c,this.fd[a]);if(!this.fd[a]&&!this.fd[a-1])return WASI_EBADF$$module$src$filesystem$constants;({path:c}=this.fd[a]);a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);(new Uint8Array(a.buffer)).set(c,b);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_prestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_get",a,b,this.fd[a]);if(!this.fd[a])return WASI_EBADF$$module$src$filesystem$constants;var {path:c}=this.fd[a];a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);a.setUint8(b,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants);a.setUint32(b+4,c.byteLength,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_pwrite=function(a,b,c,d,e){console.log("fd_pwrite",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_read=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_read",a,b,c,d,arguments);const e=this.fd[a]&&this.fd[a].buffers;var f=e.reduce((n,p)=>n+p.length,0);const g=this.getMemory();if(e&&0!==e.length){var h=Number(this.fd[a].seekPos),k=0,l=!1;if(h>=f)return k=g.getUint32(b,!0),g.setUint8(k,"\\x00"),g.setUint32(d,0,!0),WASI_ESUCCESS$$module$src$filesystem$constants;for(f=0;f<c;f++){var m=b+8*f;const n=g.getUint32(m,!0);m=g.getUint32(m+\n4,!0);l||(k+=m,Array.from({length:m},(p,q)=>q).reduce((p,q)=>{if(l)return p;const [w,r]=p;let u=p=0,A=!1,x=0,t;if(0===q)for(;!A;)t=e[p]?e[p].byteLength:0,x<=h&&t+x>h?(A=!0,u=h-x):(x+=t,p+=1);else p=w,u=r;e[p]?(g.setUint8(n+q,e[p][u]),u+1>=e[p].byteLength?(p=w+1,u=0):u+=1):(g.setUint8(n+q,"\\x00"),h+=q,l=!0);return[p,u]},[0,0]),l||(h+=m))}this.fd[a].seekPos=goog.global.BigInt(h);g.setUint32(d,k,!0);return WASI_ESUCCESS$$module$src$filesystem$constants}console.error("Reading non existent file",a,this.fd[a])};\nWASI$$module$src$filesystem$wasi.prototype.fd_readdir=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_readdir",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_renumber=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_renumber",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_seek=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_seek",a,b,c,d,arguments);const e=this.getMemory();switch(c){case WASI_WHENCE_CUR$$module$src$filesystem$constants:var f;this.fd[a].seekPos=(null!=(f=this.fd[a].seekPos)?f:goog.global.BigInt(0))+goog.global.BigInt(b);break;case WASI_WHENCE_END$$module$src$filesystem$constants:f=(this.fd[a].buffers||[]).reduce((g,h)=>g+h.length,0);this.fd[a].seekPos=BigInt(f)+BigInt(b);break;\ncase WASI_WHENCE_SET$$module$src$filesystem$constants:this.fd[a].seekPos=BigInt(b)}e.setBigUint64(d,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_sync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_sync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_tell=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_tell",a,b,arguments);const c=this.getMemory();this.fd[a].seekPos||(this.fd[a].seekPos=goog.global.BigInt(0));c.setBigUint64(b,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_write=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_write",{fd:a,iovs:b,iovsLength:c,nwritten:d});const e=this.getMemory();this.fd[a].buffers=this.fd[a].buffers||[];this.fd[a].buffers=0<this.fd[a].buffers.length?[concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)]:this.fd[a].buffers;let f=0;for(let k=0;k<c;k++){var g=b+8*k,h=e.getUint32(g,!0);g=e.getUint32(g+4,!0);f+=g;h=new Uint8Array(e.buffer,h,g);if(this.fd[a].buffers[0]&&\nthis.fd[a].seekPos<this.fd[a].buffers[0].length){const l=Number(this.fd[a].seekPos);h.slice(0,g).forEach((m,n)=>{this.fd[a].buffers[0][l+n]=m})}else this.fd[a].buffers.push(h.slice(0,g))}this.fd[a].seekPos+=goog.global.BigInt(f);e.setUint32(d,f,!0);[1,2].includes(a)&&console.log(decoder$$module$src$utils$text_encoders.decode(concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)));return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_create_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_create_directory",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_filestat_get=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_get",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_filestat_set_times=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_set_times",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_link=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_link",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_open=function(a,b,c,d,e,f,g,h,k){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_open",a,b,c,d,e,f,g,h,k,arguments);const l=this.getMemory();var m=(this.fd[a]||{path:"/"}).path,n=new Uint8Array(l.buffer,c,d);n=decoder$$module$src$utils$text_encoders.decode(n);const p=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(goog.string.path.join(3===a?"":m,n)));DEBUG_WASI$$module$src$filesystem$wasi&&console.log(";; opening path",\np,"withREader",shouldOpenReader$$module$src$filesystem$wasi(f));if(p.startsWith("/..")||"/._"===p||"/.AppleDouble"===p)return WASI_EBADF$$module$src$filesystem$constants;(m=Object.values(this.fd).find(q=>q.path===p&&Array.isArray(q.buffers)))?n=m.fd:(n=this.fd.length,this.fd[n]={fd:n});this.fd[n]={...this.fd[n],path:p,type:"file",seekPos:goog.global.BigInt(0),buffers:m?this.fd[n].buffers:[],open:!0};shouldOpenReader$$module$src$filesystem$wasi(f)&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("should open a read handle for",\np);l.setUint32(k,n,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_readlink=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_readlink",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_remove_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_remove_directory",a,b,c);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_rename=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_rename",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_symlink=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_symlink",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_unlink_file=function(a,b,c){3<a&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_unlink_file",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.poll_oneoff=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("poll_oneoff",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.proc_exit=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_exit",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.proc_raise=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_raise",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.random_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("random_get",a,b);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sched_yield=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sched_yield",arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.sock_recv=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_recv",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sock_send=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_send",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.sock_shutdown=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_shutdown",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.findBuffers=function(a){const b=Object.values(this.fd).find(({path:c})=>c===a);return[b&&b.buffers,b.fd]};\nWASI$$module$src$filesystem$wasi.prototype.readdir=function(a){const b=(assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a))+"/").replace("//","/"),c=[];Object.values(this.fd).forEach(({path:d})=>!/\\//g.test(d.replace(b,""))&&c.push(d));return c.map(d=>removeLeadingSlash$$module$src$filesystem$wasi(d.replace(b,""))).filter(d=>!!d)};\nWASI$$module$src$filesystem$wasi.prototype.writeFile=function(a,b){const c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));a=Object.keys(this.fd).length;const d=Object.values(this.fd).find(({path:e})=>e===c);this.fd[a]={fd:a,path:c,seekPos:goog.global.BigInt(0),buffers:[b]};d&&delete this.fd[d]};\nWASI$$module$src$filesystem$wasi.prototype.appendFile=function(a,b){var c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));[c]=this.findBuffers(c);c?c.push(b):console.error(`Can\'t append to non-existing file ${a}`)};\nWASI$$module$src$filesystem$wasi.prototype.readFile=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),[c,d]=this.findBuffers(b);this.fd[d]&&this.fd[d].open&&console.warn(`readFile: file ${a} hasn\'t been closed yet!`);if(c)return concatUint8Arrays$$module$src$filesystem$wasi(c)};\nWASI$$module$src$filesystem$wasi.prototype.readStdOut=function(){const a=Object.values(this.fd[0]);return concatUint8Arrays$$module$src$filesystem$wasi(a&&a.buffers||[])};WASI$$module$src$filesystem$wasi.prototype.unlink=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));(a=Object.values(this.fd).find(({path:c})=>c===b))?delete this.fd[a]:console.error(`While trying to unlink ${b}, path not found`)};\nWASI$$module$src$filesystem$wasi.prototype.mkdir=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),c=[];Object.values(this.fd).forEach(({path:d})=>d.startsWith(b)&&c.push(d));0<c.length?console.warn(`mkdir: path ${a} already exists`):(a=Object.keys(this.fd).length,this.fd[a]={fd:a,path:b})};var module$src$filesystem$wasi={};module$src$filesystem$wasi.WASI=WASI$$module$src$filesystem$wasi;function clearArray$$module$src$utils$clear_array(a){for(;0<a.length;)a.pop()}var module$src$utils$clear_array={};module$src$utils$clear_array.clearArray=clearArray$$module$src$utils$clear_array;const CompressionMethod$$module$src$zlib$zlib={DEFLATE:8,RESERVED:15};var module$src$zlib$zlib={};module$src$zlib$zlib.CompressionMethod=CompressionMethod$$module$src$zlib$zlib;/*\n zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */\nfunction Huffman$$module$src$zlib$huffman(a){const b=a.length;let c=0,d=Number.POSITIVE_INFINITY,e,f,g,h;let k,l;for(k=0;k<b;++k)a[k]>c&&(c=a[k]),a[k]<d&&(d=a[k]);const m=1<<c,n=new Uint32Array(m);e=1;f=0;for(g=2;e<=c;){for(k=0;k<b;++k)if(a[k]===e){h=0;var p=f;for(l=0;l<e;++l)h=h<<1|p&1,p>>=1;p=e<<16|k;for(l=h;l<m;l+=g)n[l]=p;++f}++e;f<<=1;g<<=1}return[n,c,d]}var module$src$zlib$huffman={};module$src$zlib$huffman.Huffman=Huffman$$module$src$zlib$huffman;const ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate=32768;\nfunction RawInflate$$module$src$zlib$rawinflate(a,b){this.blocks=[];this.bufferSize=ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate;this.bitsbuflen=this.bitsbuf=this.ip=this.totalpos=0;this.input=new Uint8Array(a);this.bfinal=!1;this.bufferType=RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE;this.resize=!1;if(b||!(b={}))b.index&&(this.ip=b.index),b.bufferSize&&(this.bufferSize=b.bufferSize),b.bufferType&&(this.bufferType=b.bufferType),b.resize&&(this.resize=b.resize);switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.op=\nRawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;this.output=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength+this.bufferSize+RawInflate$$module$src$zlib$rawinflate.MaxCopyLength);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.op=0;this.output=new Uint8Array(this.bufferSize);break;default:throw Error("invalid inflate mode");}}RawInflate$$module$src$zlib$rawinflate.BufferType={BLOCK:0,ADAPTIVE:1};\nRawInflate$$module$src$zlib$rawinflate.prototype.decompress=function(){for(;!this.bfinal;)this.parseBlock();switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:return this.concatBufferBlock();case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:return this.concatBufferDynamic();default:throw Error("invalid inflate mode");}};RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength=32768;RawInflate$$module$src$zlib$rawinflate.MaxCopyLength=258;\nRawInflate$$module$src$zlib$rawinflate.Order=function(a){return new Uint16Array(a)}([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]);RawInflate$$module$src$zlib$rawinflate.LengthCodeTable=function(a){return new Uint16Array(a)}([3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258]);RawInflate$$module$src$zlib$rawinflate.LengthExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0]);\nRawInflate$$module$src$zlib$rawinflate.DistCodeTable=function(a){return new Uint16Array(a)}([1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577]);RawInflate$$module$src$zlib$rawinflate.DistExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]);\nRawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable=function(a){return a}(function(){const a=new Uint8Array(288);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=143>=b?8:255>=b?9:279>=b?7:8;return Huffman$$module$src$zlib$huffman(a)}());RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable=function(a){return a}(function(){const a=new Uint8Array(30);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=5;return Huffman$$module$src$zlib$huffman(a)}());\nRawInflate$$module$src$zlib$rawinflate.prototype.parseBlock=function(){let a=this.readBits(3);a&1&&(this.bfinal=!0);a>>>=1;switch(a){case 0:this.parseUncompressedBlock();break;case 1:this.parseFixedHuffmanBlock();break;case 2:this.parseDynamicHuffmanBlock();break;default:throw Error("unknown BTYPE: "+a);}};\nRawInflate$$module$src$zlib$rawinflate.prototype.readBits=function(a){let b=this.bitsbuf,c=this.bitsbuflen;const d=this.input;let e=this.ip;if(e+(a-c+7>>3)>=d.length)throw Error("input buffer is broken");for(;c<a;)b|=d[e++]<<c,c+=8;this.bitsbuf=b>>>a;this.bitsbuflen=c-a;this.ip=e;return b&(1<<a)-1};\nRawInflate$$module$src$zlib$rawinflate.prototype.readCodeByTable=function(a){let b=this.bitsbuf,c=this.bitsbuflen;var d=this.input;let e=this.ip;var f=d.length;const g=a[0];for(a=a[1];c<a&&!(e>=f);)b|=d[e++]<<c,c+=8;d=g[b&(1<<a)-1];f=d>>>16;if(f>c)throw Error("invalid code length: "+f);this.bitsbuf=b>>f;this.bitsbuflen=c-f;this.ip=e;return d&65535};\nRawInflate$$module$src$zlib$rawinflate.prototype.parseUncompressedBlock=function(){const a=this.input;let b=this.ip,c=this.output,d=this.op;var e=a.length;let f;const g=c.length;this.bitsbuflen=this.bitsbuf=0;if(b+1>=e)throw Error("invalid uncompressed block header: LEN");f=a[b++]|a[b++]<<8;if(b+1>=e)throw Error("invalid uncompressed block header: NLEN");e=a[b++]|a[b++]<<8;if(f===~e)throw Error("invalid uncompressed block header: length verify");if(b+f>a.length)throw Error("input buffer is broken");\nswitch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:for(;d+f>c.length;)e=g-d,f-=e,c.set(a.subarray(b,b+e),d),d+=e,b+=e,this.op=d,c=this.expandBufferBlock(),d=this.op;break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:for(;d+f>c.length;)c=this.expandBufferAdaptive({fixRatio:2});break;default:throw Error("invalid inflate mode");}c.set(a.subarray(b,b+f),d);this.ip=b+f;this.op=d+f;this.output=c};\nRawInflate$$module$src$zlib$rawinflate.prototype.parseFixedHuffmanBlock=function(){switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);\nbreak;default:throw Error("invalid inflate mode");}};\nRawInflate$$module$src$zlib$rawinflate.prototype.parseDynamicHuffmanBlock=function(){var a=this.readBits(5)+257,b=this.readBits(5)+1,c=this.readBits(4)+4,d=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.Order.length);let e;for(e=0;e<c;++e)d[RawInflate$$module$src$zlib$rawinflate.Order[e]]=this.readBits(3);d=Huffman$$module$src$zlib$huffman(d);c=new Uint8Array(a+b);e=0;for(b=a+b;e<b;){var f=this.readCodeByTable(d);switch(f){case 16:for(f=3+this.readBits(2);f--;)c[e++]=g;break;case 17:for(f=\n3+this.readBits(3);f--;)c[e++]=0;var g=0;break;case 18:for(f=11+this.readBits(7);f--;)c[e++]=0;g=0;break;default:g=c[e++]=f}}g=Huffman$$module$src$zlib$huffman(c.subarray(0,a));a=Huffman$$module$src$zlib$huffman(c.subarray(a));switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(g,a);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(g,a);break;default:throw Error("invalid inflate mode");}};\nRawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanBlock=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;const e=c.length-RawInflate$$module$src$zlib$rawinflate.MaxCopyLength;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,l=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,m=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,n=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=\ne&&(this.op=d,c=this.expandBufferBlock(),d=this.op),c[d++]=f;else for(f-=257,h=k[f],0<l[f]&&(h+=this.readBits(l[f])),f=this.readCodeByTable(b),g=m[f],0<n[f]&&(g+=this.readBits(n[f])),d>=e&&(this.op=d,c=this.expandBufferBlock(),d=this.op);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};\nRawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanAdaptive=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;let e=c.length;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,l=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,m=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,n=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=e&&(c=this.expandBufferAdaptive(),e=c.length),c[d++]=\nf;else for(f-=257,h=k[f],0<l[f]&&(h+=this.readBits(l[f])),f=this.readCodeByTable(b),g=m[f],0<n[f]&&(g+=this.readBits(n[f])),d+h>e&&(c=this.expandBufferAdaptive(),e=c.length);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};\nRawInflate$$module$src$zlib$rawinflate.prototype.expandBufferBlock=function(a){a=new Uint8Array(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength);const b=this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,c=this.output;a.set(c.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,a.length));this.blocks.push(a);this.totalpos+=a.length;c.set(c.subarray(b,b+RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));this.op=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;\nreturn c};RawInflate$$module$src$zlib$rawinflate.prototype.expandBufferAdaptive=function(a){let b=Math.trunc(this.input.length/this.ip+1);const c=this.input,d=this.output;a&&("number"===typeof a.fixRatio&&(b=a.fixRatio),"number"===typeof a.addRatio&&(b+=a.addRatio));2>b?(a=(c.length-this.ip)/this.currentLitlenTable[2],a=Math.trunc(a/2*258),a=a<d.length?d.length+a:d.length<<1):a=d.length*b;a=new Uint8Array(a);a.set(d);return this.output=a};\nRawInflate$$module$src$zlib$rawinflate.prototype.concatBufferBlock=function(){let a=0;const b=this.output,c=this.blocks;let d;const e=new Uint8Array(this.totalpos+(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));let f,g,h,k;if(0===c.length)return this.output.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,this.op);f=0;for(g=c.length;f<g;++f)for(d=c[f],h=0,k=d.length;h<k;++h)e[a++]=d[h];f=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;for(g=this.op;f<\ng;++f)e[a++]=b[f];this.blocks=[];return this.buffer=e};RawInflate$$module$src$zlib$rawinflate.prototype.concatBufferDynamic=function(){let a;const b=this.op;this.resize?(a=new Uint8Array(b),a.set(this.output.subarray(0,b))):a=this.output.subarray(0,b);return this.buffer=a};var module$src$zlib$rawinflate={};module$src$zlib$rawinflate.RawInflate=RawInflate$$module$src$zlib$rawinflate;function Util$$module$src$zlib$util(){}Util$$module$src$zlib$util.stringToByteArray=function(a){a=[...a];let b,c;b=0;for(c=a.length;b<c;b++)a[b]=(a[b].charPointAt(0)&255)>>>0;return new Uint8Array([a])};var module$src$zlib$util={};module$src$zlib$util.Util=Util$$module$src$zlib$util;function Adler32$$module$src$zlib$adler32(a){"string"===typeof a&&(a=Util$$module$src$zlib$util.stringToByteArray(a));return Adler32$$module$src$zlib$adler32.update(1,a)}Adler32$$module$src$zlib$adler32.update=function(a,b){let c=a&65535;a=a>>>16&65535;let d=b.length,e,f=0;for(;0<d;){e=d>Adler32$$module$src$zlib$adler32.OptimizationParameter?Adler32$$module$src$zlib$adler32.OptimizationParameter:d;d-=e;do c+=b[f++],a+=c;while(--e);c%=65521;a%=65521}return(a<<16|c)>>>0};\nAdler32$$module$src$zlib$adler32.OptimizationParameter=1024;var module$src$zlib$adler32={};module$src$zlib$adler32.Adler32=Adler32$$module$src$zlib$adler32;function Inflate$$module$src$zlib$inflate(a,b){this.input=a;this.ip=0;if(b||!(b={}))b.index&&(this.ip=b.index),b.verify&&(this.verify=b.verify);const c=a[this.ip++],d=a[this.ip++];switch(c&15){case CompressionMethod$$module$src$zlib$zlib.DEFLATE:this.method=CompressionMethod$$module$src$zlib$zlib.DEFLATE;break;default:throw Error("unsupported compression method");}if(0!==((c<<8)+d)%31)throw Error("invalid fcheck flag:"+((c<<8)+d)%31);if(d&32)throw Error("fdict flag is not supported");this.rawinflate=\nnew RawInflate$$module$src$zlib$rawinflate(a,{index:this.ip,bufferSize:b.bufferSize,bufferType:b.bufferType,resize:b.resize})}Inflate$$module$src$zlib$inflate.BufferType=RawInflate$$module$src$zlib$rawinflate.BufferType;\nInflate$$module$src$zlib$inflate.prototype.decompress=function(){var a=this.input;const b=this.rawinflate.decompress();this.ip=this.rawinflate.ip;if(this.verify&&(a=(a[this.ip++]<<24|a[this.ip++]<<16|a[this.ip++]<<8|a[this.ip++])>>>0,a!==Adler32$$module$src$zlib$adler32(b)))throw Error("invalid adler-32 checksum");return b};var module$src$zlib$inflate={};module$src$zlib$inflate.Inflate=Inflate$$module$src$zlib$inflate;const PAGE_SIZE$$module$src$module=65536,PAGES_PER_MB$$module$src$module=16,csoundWasiJsMessageCallback$$module$src$module=({memory:a,messagePort:b,streamBuffer:c})=>function(d,e,f,g){if(a){d=new Uint8Array(a.buffer,g,f);d=uint2String$$module$src$utils$text_encoders(d);var h=/\\n$/g.test(d);e=/^\\n/g.test(d);var k=d.split("\\n").filter(m=>0<m.length),l=[];if(0===k.length&&h||e)l.push(c.join("")),clearArray$$module$src$utils$clear_array(c);k.forEach((m,n)=>{n+1===k.length?h?0===n?(l.push(c.join("")+m),\nclearArray$$module$src$utils$clear_array(c)):l.push(m):c.push(m):0===n?(l.push(c.join("")+m),clearArray$$module$src$utils$clear_array(c)):l.push(m)});l.forEach(m=>{m.replace(/(\\r\\n|\\n|\\r)/gm,"")&&b.post({log:m})})}},assertPluginExports$$module$src$module=a=>{if(a&&"object"===typeof a&&"object"===typeof a.exports){if(a.exports.__wasm_call_ctors){if(a.exports.csoundModuleCreate||a.exports.csound_opcode_init||a.exports.csound_fgen_init)return!0;console.error(a.exports,"A csound plugin turns out to be neither a plugin, opcode or module.\\nPerhaps csdl.h or module.h wasn\'t imported correctly?");\nreturn!1}console.error("A csound plugin didn\'t export __wasm_call_ctors.\\nPlease re-run wasm-ld with either --export-all or include --export=__wasm_call_ctors");return!1}console.error("Error instantiating a csound plugin, instance and/or export is missing!");return!1},getBinaryHeaderData$$module$src$module=a=>{function b(){let l=0,m=1;for(;;){const n=a[c++];l+=(n&127)*m;m*=128;if(!(n&128))break}return l}1836278016!==(new Uint32Array((new Uint8Array(a.subarray(0,24))).buffer))[0]&&console.error("Wasm magic number is missing!");\nif(0!==a[8])return logWasmModule$$module$src$logger("Dylink section wasn\'t found in wasm binary, assuming static wasm."),"static";let c=9;const d=b();c++;(0,goog.asserts.assert)(a[c]==="d".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="y".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="l".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="i".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="n".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="k".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]===\n".".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="0".codePointAt(0));c+=3;const e=b(),f=b(),g=b(),h=b(),k=b();return{sectionSize:d,memorySize:e,memoryAlign:f,neededDynlibsCount:k,tableSize:g,tableAlign:h}},loadStaticWasm$$module$src$module=async({wasmBytes:a,wasi:b,messagePort:c})=>{const d=await WebAssembly.compile(a);a=new WebAssembly.Memory({initial:16384});const e=b.getImports(d);e.env=e.env||{};e.env.csoundLoadModules=()=>0;e.env.memory=a;e.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:e.env.memory,\nstreamBuffer:[],messagePort:c});c=await WebAssembly.instantiate(d,e);b.setMemory(a);b.start(c);c.exports.__wasi_js_csoundSetMessageStringCallback();return[c,b]};\nvar $jscompDefaultExport$$module$src$module=async function({wasmDataURI:a,withPlugins:b=[],messagePort:c}){var d={};const e=new WASI$$module$src$filesystem$wasi({preopens:{"/":"/"}});a=new Uint8Array(a);a=(new Inflate$$module$src$zlib$inflate(a)).decompress();var f=getBinaryHeaderData$$module$src$module(a);if("static"===f)return await loadStaticWasm$$module$src$module({messagePort:c,wasmBytes:a,wasmFs:d,wasi:e});const {memorySize:g,memoryAlign:h,tableSize:k}=f;b=await b.reduce(async(t,z)=>{t=await t;\nlet v,y;try{v=new Uint8Array(z),y=getBinaryHeaderData$$module$src$module(v)}catch(C){console.error("Error in plugin",C)}y&&t.push({headerData:y,wasmPluginBytes:v});return t},[]);var l=128*PAGES_PER_MB$$module$src$module;d=Math.ceil((g+h)/PAGE_SIZE$$module$src$module);f=Math.ceil(b.reduce((t,{headerData:z})=>"static"===z?0:t+(z.memorySize+h),0)/PAGE_SIZE$$module$src$module);f=d+f+l;const m=new WebAssembly.Memory({initial:f,maximum:1024*PAGES_PER_MB$$module$src$module}),n=new WebAssembly.Table({initial:k+\n1,element:"anyfunc"});e.setMemory(m);const p=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);f=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);l=new WebAssembly.Global({value:"i32",mutable:!1},l);const q=new WebAssembly.Global({value:"i32",mutable:!1},1),w=new WebAssembly.Global({value:"i32",mutable:!0},0);a=await WebAssembly.compile(a);const r=e.getImports(a);let u=[],A=d;r.env=r.env||{};r.env.memory=m;r.env.__indirect_function_table=\nn;r.env.__stack_pointer=p;r.env.__memory_base=l;r.env.__table_base=q;r.env.csoundLoadModules=t=>{u.forEach(z=>{void 0===x?console.error("csound-wasm internal: timing problem detected!"):dlinit$$module$src$dlinit(x,z,n,t)});return 0};r.env._ZTH5errno=function(){};r.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:m,messagePort:c,streamBuffer:[]});r.env.printDebugCallback=(t,z)=>{t=new Uint8Array(m.buffer,t,z);t=uint2String$$module$src$utils$text_encoders(t);console.log(t)};\nr["GOT.mem"]=r["GOT.mem"]||{};r["GOT.mem"].__heap_base=f;r["GOT.func"]=r["GOT.func"]||{};const x=await WebAssembly.instantiate(a,r);c=Object.assign({},x.exports);a={};a.exports=Object.assign(c,{memory:m});u=await b.reduce(async(t,{headerData:z,wasmPluginBytes:v})=>{t=await t;try{const {memorySize:y,memoryAlign:C,tableSize:F}=z,E=await WebAssembly.compile(v),B=e.getImports(E),G=new WebAssembly.Global({value:"i32",mutable:!1},A*PAGE_SIZE$$module$src$module);n.grow(F);B.env=Object.assign({},B.env);B.env.memory=\nm;B.env.__indirect_function_table=n;B.env.__memory_base=G;B.env.__stack_pointer=p;B.env.__table_base=q;B.env.csoundLoadModules=w;delete B.env.csoundWasiJsMessageCallback;A+=Math.ceil((y+C)/PAGE_SIZE$$module$src$module);const D=await WebAssembly.instantiate(E,B);assertPluginExports$$module$src$module(D)&&(D.exports.__wasm_call_ctors(),t.push(D))}catch(y){console.error("Error while compiling csound-plugin",y)}return t},[]);e.start(a);a.exports.__wasi_js_csoundSetMessageStringCallback();return[a,e]},\nmodule$src$module={};module$src$module.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module;module$src$module.default=$jscompDefaultExport$$module$src$module;let combined$$module$src$workers$vanilla_worker,audioProcessCallback$$module$src$workers$vanilla_worker=()=>{};\nconst rtmidiQueue$$module$src$workers$vanilla_worker=[],createAudioInputBuffers$$module$src$workers$vanilla_worker=(a,b)=>{for(let c=0;c<b;++c)a.buffers.push(new Float64Array(RING_BUFFER_SIZE$$module$src$constants))},generateAudioFrames$$module$src$workers$vanilla_worker=(a,b)=>{if("realtimePerformanceEnded"!==b.vanillaWorkerState)return audioProcessCallback$$module$src$workers$vanilla_worker(a)},createRealtimeAudioThread$$module$src$workers$vanilla_worker=({libraryCsound:a,wasm:b,workerMessagePort:c,\naudioInputs:d,inputChannelCount:e,outputChannelCount:f,sampleRate:g})=>({csound:h})=>{var k=a.csoundGetInputName(h).includes("adc");g&&a.csoundSetOption(h,`--sr=${g}`);f&&a.csoundSetOption(h,`--nchnls=${f}`);e&&a.csoundSetOption(h,`--nchnls_i=${e}`);const l=a.csoundGetNchnls(h),m=0<e?e:k?a.csoundGetNchnlsInput(h):0,n=a.csoundGet0dBFS(h);k=a.csoundGetSpin(h);const p=a.csoundGetSpout(h),q=a.csoundGetKsmps(h);let w=new Float64Array(b.wasi.memory.buffer,k,q*m),r=new Float64Array(b.wasi.memory.buffer,\np,q*l),u=0,A=0;c.broadcastPlayState("realtimePerformanceStarted");audioProcessCallback$$module$src$workers$vanilla_worker=({numFrames:x})=>{const t=instantiateAudioPacket$$module$src$workers$common_utils(l,x),z=0<d.buffers.length&&d.availableFrames>=x;0<rtmidiQueue$$module$src$workers$vanilla_worker.length&&(rtmidiQueue$$module$src$workers$vanilla_worker.forEach(v=>{a.csoundPushMidiMessage(h,v[0],v[1],v[2])}),clearArray$$module$src$utils$clear_array(rtmidiQueue$$module$src$workers$vanilla_worker));\nfor(let v=0;v<x;v++){A=(A+1)%q;if("realtimePerformanceEnded"===c.vanillaWorkerState)return 0===u&&(a.csoundStop(h),u=a.csoundPerformKsmps(h)),c.broadcastPlayState("realtimePerformanceEnded"),audioProcessCallback$$module$src$workers$vanilla_worker=()=>{},clearArray$$module$src$utils$clear_array(rtmidiQueue$$module$src$workers$vanilla_worker),d.port=void 0,{framesLeft:v};if(0===A&&0===u&&(u=a.csoundPerformKsmps(h),0!==u))return c.broadcastPlayState("realtimePerformanceEnded"),audioProcessCallback$$module$src$workers$vanilla_worker=\n()=>{},clearArray$$module$src$utils$clear_array(rtmidiQueue$$module$src$workers$vanilla_worker),d.port=void 0,{framesLeft:v};0===w.length&&(w=new Float64Array(b.wasi.memory.buffer,a.csoundGetSpin(h),q*m));0===r.length&&(r=new Float64Array(b.wasi.memory.buffer,a.csoundGetSpout(h),q*l));t.forEach((y,C)=>{0<r.length&&(y[v]=(r[A*l+C]||0)/n)});if(z)for(let y=0;y<m;y++)w[A*m+y]=(d.buffers[y][v+d.inputReadIndex%RING_BUFFER_SIZE$$module$src$constants]||0)*n}z&&(d.availableFrames-=x,d.inputReadIndex+=x%RING_BUFFER_SIZE$$module$src$constants);\nreturn{audioPacket:t,framesLeft:0}}},callUncloned$$module$src$workers$vanilla_worker=async(a,b)=>(a=combined$$module$src$workers$vanilla_worker.get(a))&&a.apply({},b||[]),initMessagePort$$module$src$workers$vanilla_worker=({port:a})=>{logVANWorker$$module$src$logger("initMessagePort")();const b=new $jscompDefaultExport$$module$src$utils$message_port_state;b.port=a;b.post=c=>a.postMessage({log:c});b.broadcastPlayState=c=>{b.vanillaWorkerState=c;a.postMessage({playStateChange:c})};b.ready=!0;return b},\ninitRequestPort$$module$src$workers$vanilla_worker=({csoundWorkerFrameRequestPort:a,workerMessagePort:b})=>{logVANWorker$$module$src$logger("initRequestPort")();a.addEventListener("message",c=>{const {framesLeft:d=0,audioPacket:e}=generateAudioFrames$$module$src$workers$vanilla_worker(c.data,b)||{};a.postMessage({numFrames:c.data.numFrames-d,audioPacket:e,...c.data})});a.start();return a},initAudioInputPort$$module$src$workers$vanilla_worker=({port:a})=>{logVANWorker$$module$src$logger("initAudioInputPort")();\nconst b={availableFrames:0,buffers:[],inputReadIndex:0,inputWriteIndex:0,port:a};b.port.addEventListener("message",({data:c})=>{0===b.buffers.length&&createAudioInputBuffers$$module$src$workers$vanilla_worker(b,c.length);b.buffers.forEach((d,e)=>{d.set(c[e],b.inputWriteIndex)});b.inputWriteIndex+=c[0].length;b.availableFrames+=c[0].length;b.inputWriteIndex>=RING_BUFFER_SIZE$$module$src$constants&&(b.inputWriteIndex=0)});b.port.start();return b},initRtMidiEventPort$$module$src$workers$vanilla_worker=\n({rtmidiPort:a})=>{logVANWorker$$module$src$logger("initRtMidiEventPort")();a.addEventListener("message",({data:b})=>{rtmidiQueue$$module$src$workers$vanilla_worker.push(b)});a.start();return a},initialize$$module$src$workers$vanilla_worker=async({audioInputPort:a,inputChannelCount:b,messagePort:c,outputChannelCount:d,requestPort:e,rtmidiPort:f,wasmDataURI:g,wasmTransformerDataURI:h,withPlugins:k=[]})=>{logVANWorker$$module$src$logger("initializing wasm and exposing csoundAPI functions from worker to main")();\nconst l=initMessagePort$$module$src$workers$vanilla_worker({port:c}),m=initAudioInputPort$$module$src$workers$vanilla_worker({port:a});initRequestPort$$module$src$workers$vanilla_worker({csoundWorkerFrameRequestPort:e,workerMessagePort:l});initRtMidiEventPort$$module$src$workers$vanilla_worker({rtmidiPort:f});const [n,p]=await $jscompDefaultExport$$module$src$module({wasmDataURI:g,wasmTransformerDataURI:h,withPlugins:k,messagePort:l});n.wasi=p;const q=$jscompDefaultExport$$module$src$libcsound(n);\na=pipe$$module$node_modules$rambda$dist$rambda_mjs(assoc$$module$node_modules$rambda$dist$rambda_mjs("csoundStart",(r,u)=>handleCsoundStart$$module$src$workers$common_utils(l,q,p,createRealtimeAudioThread$$module$src$workers$vanilla_worker({audioInputs:m,inputChannelCount:b,libraryCsound:q,outputChannelCount:d,wasm:n,wasi:p,workerMessagePort:l}),renderFunction$$module$src$workers$common_utils({inputChannelCount:b,libraryCsound:q,outputChannelCount:d,wasm:n,workerMessagePort:l}))(u)),assoc$$module$node_modules$rambda$dist$rambda_mjs("wasm",\nn))(q);combined$$module$src$workers$vanilla_worker=new Map(Object.entries(a));q.csoundInitialize(0);const w=q.csoundCreate();l.port.addEventListener("message",r=>{r.data&&r.data.newPlayState&&("realtimePerformanceEnded"===r.data.newPlayState&&(q.csoundStop(w),"realtimePerformanceEnded"!==l.vanillaWorkerState&&q.csoundPerformKsmps(w),l.broadcastPlayState("realtimePerformanceEnded")),l.vanillaWorkerState=r.data.newPlayState)});l.port.start();return w};\nexpose$$module$node_modules$comlink$dist$esm$comlink_mjs({initialize:initialize$$module$src$workers$vanilla_worker,callUncloned:callUncloned$$module$src$workers$vanilla_worker});var module$src$workers$vanilla_worker={};}).call(this);\n//# sourceMappingURL=__compiled.vanilla.worker.js.map\n'])),
+module$dist$__compiled_vanilla_worker_inline={};module$dist$__compiled_vanilla_worker_inline.default=$jscompDefaultExport$$module$dist$__compiled_vanilla_worker_inline;class VanillaWorkerMainThread$$module$src$mains$vanilla_main{constructor({audioContext:a,audioWorker:b,audioContextIsProvided:c,inputChannelCount:d,outputChannelCount:e}){this.ipcMessagePorts=new IPCMessagePorts$$module$src$mains$messages_main;this.eventPromises=new EventPromises$$module$src$utils$event_promises;this.publicEvents=new PublicEventAPI$$module$src$events(this);b.ipcMessagePorts=this.ipcMessagePorts;b.csoundWorkerMain=this;b.publicEvents=this.publicEvents;this.audioWorker=b;if(this.audioContextIsProvided=
+c)this.sampleRate=a.sampleRate;d&&(this.inputChannelCount=d);e&&(this.outputChannelCount=e);this.exportApi={};this.currentPlayState=this.csoundInstance=void 0;this.midiPortStarted=!1;this.onPlayStateChange=this.onPlayStateChange.bind(this)}async terminateInstance(){this.csoundWorker&&(this.csoundWorker.terminate(),delete this.csoundWorker);this.audioWorker&&this.audioWorker.terminateInstance&&(await this.audioWorker.terminateInstance(),delete this.audioWorker.terminateInstance);this.proxyPort&&(this.proxyPort[releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs](),
+delete this.proxyPort);this.publicEvents&&this.publicEvents.terminateInstance();Object.keys(this.exportApi).forEach(a=>delete this.exportApi[a]);Object.keys(this).forEach(a=>delete this[a])}get api(){return this.exportApi}handleMidiInput({data:a}){this.ipcMessagePorts.csoundMainRtMidiPort.postMessage&&this.ipcMessagePorts.csoundMainRtMidiPort.postMessage(a)}async prepareRealtimePerformance(){if(this.csoundInstance){this.audioWorker.sampleRate=await this.exportApi.getSr(this.csoundInstance);var a=
+await this.exportApi.getInputName(this.csoundInstance);this.audioWorker.isRequestingInput=a.includes("adc");this.audioWorker.isRequestingMidi=await this.exportApi._isRequestingRtMidiInput(this.csoundInstance);this.audioWorker.outputsCount=await this.exportApi.getNchnls(this.csoundInstance);this.audioWorker.inputsCount=this.audioWorker.isRequestingInput?1:0;logVANMain$$module$src$logger("vars for rtPerf set")()}else console.error("fatal error: csound instance not found?")}async onPlayStateChange(a){if(this.publicEvents){this.currentPlayState=
+a;switch(a){case "realtimePerformanceStarted":logVANMain$$module$src$logger("event: realtimePerformanceStarted from worker, now preparingRT..")();await this.prepareRealtimePerformance();break;case "realtimePerformanceEnded":logVANMain$$module$src$logger("event: realtimePerformanceEnded")();this.eventPromises.createStopPromise();this.midiPortStarted=!1;this.publicEvents.triggerRealtimePerformanceEnded(this);await this.eventPromises.releaseStopPromise();break;case "renderStarted":await this.eventPromises.releaseStartPromise();
+this.publicEvents.triggerRenderStarted(this);break;case "renderEnded":logVANMain$$module$src$logger("event: renderEnded received, beginning cleanup")(),this.publicEvents.triggerRenderEnded(this),await this.eventPromises.releaseStopPromise()}this.audioWorker.ipcMessagePorts||(this.audioWorker.ipcMessagePorts=this.ipcMessagePorts);await this.audioWorker.onPlayStateChange(a)}}async csoundPause(){if(this.eventPromises.isWaiting("pause"))return-1;this.eventPromises.createPausePromise();this.audioWorker&&
+void 0!==this.audioWorker.workletProxy?await this.audioWorker.workletProxy.pause():await this.audioWorker.onPlayStateChange("realtimePerformancePaused");await this.eventPromises.waitForPause();return 0}async csoundResume(){if(this.eventPromises.isWaiting("resume"))return-1;this.eventPromises.createResumePromise();this.audioWorker&&void 0!==this.audioWorker.workletProxy?await this.audioWorker.workletProxy.resume():await this.audioWorker.onPlayStateChange("realtimePerformanceResumed");await this.eventPromises.waitForResume();
+return 0}async initialize({wasmDataURI:a,withPlugins:b}){a=a();"function"===typeof this.audioWorker.initIframe&&await this.audioWorker.initIframe();b&&!isEmpty$$module$node_modules$rambda$dist$rambda_mjs(b)&&(b=await fetchPlugins$$module$src$utils(b));logVANMain$$module$src$logger("vanilla.main: initialize")();this.csoundWorker=this.csoundWorker||new Worker($jscompDefaultExport$$module$dist$__compiled_vanilla_worker_inline());this.ipcMessagePorts.mainMessagePort.addEventListener("message",messageEventHandler$$module$src$mains$messages_main(this));
+this.ipcMessagePorts.mainMessagePort2.addEventListener("message",messageEventHandler$$module$src$mains$messages_main(this));this.ipcMessagePorts.mainMessagePort.start();const c=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(this.csoundWorker);this.proxyPort=c;this.csoundInstance=await c.initialize(transfer$$module$node_modules$comlink$dist$esm$comlink_mjs({wasmDataURI:a,messagePort:this.ipcMessagePorts.workerMessagePort,requestPort:this.ipcMessagePorts.csoundWorkerFrameRequestPort,audioInputPort:this.ipcMessagePorts.csoundWorkerAudioInputPort,
+rtmidiPort:this.ipcMessagePorts.csoundWorkerRtMidiPort,sampleRate:this.sampleRate,inputChannelCount:this.inputChannelCount,outputChannelCount:this.outputChannelCount,withPlugins:b},[a,this.ipcMessagePorts.workerMessagePort,this.ipcMessagePorts.csoundWorkerFrameRequestPort,this.ipcMessagePorts.csoundWorkerAudioInputPort,this.ipcMessagePorts.csoundWorkerRtMidiPort]));this.exportApi.pause=this.csoundPause.bind(this);this.exportApi.resume=this.csoundResume.bind(this);this.exportApi.terminateInstance=
+this.terminateInstance.bind(this);this.exportApi.getAudioContext=async()=>this.audioWorker.audioContext;this.exportApi.getNode=async()=>{const d=this.audioWorker.audioWorkletNode;return d?d:await new Promise(e=>{this.exportApi.once("onAudioNodeCreated",e)})};this.exportApi=this.publicEvents.decorateAPI(this.exportApi);this.exportApi.enableAudioInput=()=>console.warn("enableAudioInput was ignored: please use -iadc option before calling start with useWorker=true");this.exportApi.addListener("message",
+console.log);for(const d of Object.keys(api$$module$src$libcsound)){const e=api$$module$src$libcsound[d],f=makeProxyCallback$$module$src$utils(c,this.csoundInstance,d,this.currentPlayState);switch(d){case "csoundCreate":break;case "csoundStart":b=async function(){if(this.eventPromises.isWaiting("start"))return-1;this.eventPromises.createStartPromise();const g=await f({csound:this.csoundInstance});await this.eventPromises.waitForStart();return g};b.toString=()=>e.toString();this.exportApi.start=b.bind(this);
+break;case "csoundStop":b=async function(){if(this.eventPromises.isWaiting("stop"))return-1;this.eventPromises.createStopPromise();this.ipcMessagePorts.mainMessagePort.postMessage({newPlayState:"renderStarted"===this.currentPlayState?"renderEnded":"realtimePerformanceEnded"});await this.eventPromises.waitForStop();return 0};this.exportApi.stop=b.bind(this);b.toString=e.toString;break;case "csoundReset":b=async()=>{if(this.currentPlayState){if(this.eventPromises.isWaiting("reset"))return-1;stopableStates$$module$src$utils.has(this.currentPlayState)&&
+await this.exportApi.stop();const g=await f([]);this.audioContextIsProvided||(await this.audioWorker.terminateInstance(),delete this.audioWorker.audioContext);this.ipcMessagePorts.restartAudioWorkerPorts();return g}};this.exportApi.reset=b.bind(this);b.toString=e.toString;break;case "fs":this.exportApi.fs={};Object.keys(e).forEach(g=>{const h=makeProxyCallback$$module$src$utils(c,this.csoundInstance,g,this.currentPlayState);h.toString=e[g].toString;this.exportApi.fs[g]=h});break;default:f.toString=
+e.toString,this.exportApi[csoundApiRename$$module$src$utils(d)]=f}}logVANMain$$module$src$logger("exportAPI generated")()}}var $jscompDefaultExport$$module$src$mains$vanilla_main=VanillaWorkerMainThread$$module$src$mains$vanilla_main,module$src$mains$vanilla_main={};module$src$mains$vanilla_main.default=$jscompDefaultExport$$module$src$mains$vanilla_main;/*
+ unmute-ios-audio. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+var module$node_modules$unmute_ios_audio$index={default:function(){function a(m){"blocked"===e&&(e="pending",b());"blocked"===f&&(f="pending",h=new d,k=h.createBufferSource(),k.buffer=h.createBuffer(1,1,22050),k.connect(h.destination),k.start(),"running"===h.state?(f="allowed",c()):(f="blocked",k.disconnect(h.destination),k=null,h.close(),h=null))}function b(){g=document.createElement("audio");g.setAttribute("x-webkit-airplay","deny");g.preload="auto";g.loop=!0;g.src=n;g.load();g.play().then(()=>
+{e="allowed";c()},()=>{e="blocked";g.pause();g.removeAttribute("src");g.load();g=null})}function c(){"allowed"===e&&"allowed"===f&&USER_ACTIVATION_EVENTS$$module$node_modules$unmute_ios_audio$index.forEach(m=>{window.removeEventListener(m,a,{capture:!0,passive:!0})})}const d=window.webkitAudioContext;if(0<navigator.maxTouchPoints&&null!=d){var e="blocked",f="blocked",g,h,k,n=function(m){const l=new ArrayBuffer(10),p=new DataView(l);p.setUint32(0,m,!0);p.setUint32(4,m,!0);p.setUint16(8,1,!0);return`data:audio/wav;base64,UklGRisAAABXQVZFZm10IBAAAAABAAEA${window.btoa(String.fromCharCode(...(new Uint8Array(l)))).slice(0,
+13)}AgAZGF0YQcAAACAgICAgICAAAA=`}((new d).sampleRate);USER_ACTIVATION_EVENTS$$module$node_modules$unmute_ios_audio$index.forEach(m=>{window.addEventListener(m,a,{capture:!0,passive:!0})})}}};const USER_ACTIVATION_EVENTS$$module$node_modules$unmute_ios_audio$index="auxclick click contextmenu dblclick keydown keyup mousedown mouseup touchend".split(" ");const DEFAULT_BUFFER_LEN$$module$src$constants=128,MAX_CHANNELS$$module$src$constants=32,RING_BUFFER_SIZE$$module$src$constants=16384,MIDI_BUFFER_SIZE$$module$src$constants=1024,MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants=3,CALLBACK_DATA_BUFFER_SIZE$$module$src$constants=16384,initialSharedState$$module$src$constants=[0,4096,0,0,0,0,-1,-1,-1,-1,0,DEFAULT_BUFFER_LEN$$module$src$constants,0,0,0,0,0,0,0,0],AUDIO_STATE$$module$src$constants={CSOUND_LOCK:0,FRAMES_REQUESTED:1,IS_PERFORMING:2,IS_RENDERING:3,
+IS_PAUSED:4,STOP:5,SAMPLE_RATE:6,KSMPS:7,NCHNLS:8,NCHNLS_I:9,IS_REQUESTING_MIC:10,BUFFER_LEN:11,OUTPUT_READ_INDEX:12,OUTPUT_WRITE_INDEX:13,AVAIL_IN_BUFS:14,AVAIL_OUT_BUFS:15,IS_REQUESTING_RTMIDI:16,RTMIDI_INDEX:17,AVAIL_RTMIDI_EVENTS:18,HAS_PENDING_CALLBACKS:19},DATA_TYPE$$module$src$constants={NUMBER:0,STRING:1,FLOAT_32:2,FLOAT_64:3};var module$src$constants={};module$src$constants.AUDIO_STATE=AUDIO_STATE$$module$src$constants;module$src$constants.CALLBACK_DATA_BUFFER_SIZE=CALLBACK_DATA_BUFFER_SIZE$$module$src$constants;
+module$src$constants.DATA_TYPE=DATA_TYPE$$module$src$constants;module$src$constants.DEFAULT_BUFFER_LEN=DEFAULT_BUFFER_LEN$$module$src$constants;module$src$constants.MAX_CHANNELS=MAX_CHANNELS$$module$src$constants;module$src$constants.MIDI_BUFFER_PAYLOAD_SIZE=MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants;module$src$constants.MIDI_BUFFER_SIZE=MIDI_BUFFER_SIZE$$module$src$constants;module$src$constants.RING_BUFFER_SIZE=RING_BUFFER_SIZE$$module$src$constants;module$src$constants.initialSharedState=initialSharedState$$module$src$constants;var $jscompDefaultExport$$module$dist$__compiled_sab_worker_inline=()=>(window.URL||window.webkitURL).createObjectURL(new Blob(['(function(){/*\n\n Copyright The Closure Library Authors.\n SPDX-License-Identifier: Apache-2.0\n*/\nvar $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this||self;goog.exportPath_=function(a,b,c,d){a=a.split(".");d=d||goog.global;a[0]in d||"undefined"==typeof d.execScript||d.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)if(a.length||void 0===b)d=d[e]&&d[e]!==Object.prototype[e]?d[e]:d[e]={};else if(!c&&goog.isObject(b)&&goog.isObject(d[e]))for(var f in b)b.hasOwnProperty(f)&&(d[e][f]=b[f]);else d[e]=b};\ngoog.define=function(a,b){if(!COMPILED){var c=goog.global.CLOSURE_UNCOMPILED_DEFINES,d=goog.global.CLOSURE_DEFINES;c&&void 0===c.nodeType&&Object.prototype.hasOwnProperty.call(c,a)?b=c[a]:d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)&&(b=d[a])}return b};goog.FEATURESET_YEAR=2020;goog.DEBUG=!0;goog.LOCALE="en";goog.getLocale=function(){return goog.LOCALE};goog.TRUSTED_SITE=!0;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;\ngoog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error(\'Namespace "\'+a+\'" already declared.\');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b,c){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var d=a;(d=d.substring(0,d.lastIndexOf(".")))&&!goog.getObjectByName(d);)goog.implicitNamespaces_[d]=!0}goog.exportPath_(a,b,c)};goog.NONCE_PATTERN_=/^[\\w+/_-]+[=]{0,2}$/;\ngoog.getScriptNonce_=function(a){a=(a||goog.global).document;return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;\ngoog.module=function(a){if("string"!==typeof a||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You\'re likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");\ngoog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error(\'Namespace "\'+a+\'" already declared.\');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;\ngoog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG};goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1};\ngoog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0};\ngoog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error(\'Module with namespace "\'+a+\'" already exists.\');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error(\'Module with namespace "\'+\na+\'" has been loaded incorrectly.\');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){};COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&null!=goog.getObjectByName(a)},goog.implicitNamespaces_={"goog.module":!0});\ngoog.getObjectByName=function(a,b){a=a.split(".");b=b||goog.global;for(var c=0;c<a.length;c++)if(b=b[a[c]],null==b)return null;return b};goog.addDependency=function(a,b,c,d){!COMPILED&&goog.DEPENDENCIES_ENABLED&&goog.debugLoader_.addDependency(a,b,c,d)};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};\ngoog.require=function(a){if(!COMPILED){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_.requested(a);if(goog.isProvided_(a)){if(goog.isInModuleLoader_())return goog.module.getInternal_(a)}else if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{goog.debugLoader_.load_(a)}finally{goog.moduleLoaderState_=b}}return null}};goog.requireType=function(a){return{}};goog.basePath="";goog.abstractMethod=function(){throw Error("unimplemented abstract method");};\ngoog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";goog.ASSUME_ES_MODULES_TRANSPILED=!1;goog.TRUSTED_TYPES_POLICY_NAME="goog";\ngoog.hasBadLetScoping=null;\ngoog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:"",declareLegacyNamespace:!1,type:goog.ModuleType.GOOG};var c={},d=c;if("function"===typeof a)d=a.call(void 0,d);else if("string"===typeof a)d=goog.loadModuleFromSource_.call(void 0,d,a);else throw Error("Invalid module definition");var e=goog.moduleLoaderState_.moduleName;if("string"===typeof e&&e)goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(e,d,c!==d):goog.SEAL_MODULE_EXPORTS&&\nObject.seal&&"object"==typeof d&&null!=d&&Object.seal(d),goog.loadedModules_[e]={exports:d,type:goog.ModuleType.GOOG,moduleId:goog.moduleLoaderState_.moduleName};else throw Error(\'Invalid module name "\'+e+\'"\');}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a,b){eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(b));return a};goog.normalizePath_=function(a){a=a.split("/");for(var b=0;b<a.length;)"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++;return a.join("/")};\ngoog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC)return goog.global.CLOSURE_LOAD_FILE_SYNC(a);try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};goog.typeOf=function(a){var b=typeof a;return"object"!=b?b:a?Array.isArray(a)?"array":b:"null"};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};\ngoog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear};goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return Object.prototype.hasOwnProperty.call(a,goog.UID_PROPERTY_)&&a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return!!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute"in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};\ngoog.UID_PROPERTY_="closure_uid_"+(1E9*Math.random()>>>0);goog.uidCounter_=0;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};\ngoog.bindJs_=function(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var e=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(e,d);return a.apply(b,e)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};\ngoog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var d=c.slice();d.push.apply(d,arguments);return a.apply(this,d)}};goog.now=function(){return Date.now()};goog.globalEval=function(a){(0,eval)(a)};\ngoog.getCssName=function(a,b){if("."==String(a).charAt(0))throw Error(\'className passed in goog.getCssName must not start with ".". You passed: \'+a);var c=function(e){return goog.cssNameMapping_[e]||e},d=function(e){e=e.split("-");for(var f=[],g=0;g<e.length;g++)f.push(c(e[g]));return f.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(e){return e};a=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(a):a};\ngoog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.GetMsgOptions=function(){};\ngoog.getMsg=function(a,b,c){c&&c.html&&(a=a.replace(/</g,"&lt;"));c&&c.unescapeHtmlEntities&&(a=a.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&apos;/g,"\'").replace(/&quot;/g,\'"\').replace(/&amp;/g,"&"));b&&(a=a.replace(/\\{\\$([^}]+)}/g,function(d,e){return null!=b&&e in b?b[e]:d}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,!0,c)};goog.exportProperty=function(a,b,c){a[b]=c};\ngoog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(d,e,f){for(var g=Array(arguments.length-2),h=2;h<arguments.length;h++)g[h-2]=arguments[h];return b.prototype[e].apply(d,g)}};goog.scope=function(a){if(goog.isInModuleLoader_())throw Error("goog.scope is not supported within a module.");a.call(goog.global)};COMPILED||(goog.global.COMPILED=COMPILED);\ngoog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).");});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;\ngoog.defineClass.createSealingConstructor_=function(a,b){return goog.defineClass.SEAL_CLASS_INSTANCES?function(){var c=a.apply(this,arguments)||this;c[goog.UID_PROPERTY_]=c[goog.UID_PROPERTY_];return c}:a};goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");\ngoog.defineClass.applyProperties_=function(a,b){for(var c in b)Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c]);for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++)c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])};goog.identity_=function(a){return a};\ngoog.createTrustedTypesPolicy=function(a){var b=null,c=goog.global.trustedTypes;if(!c||!c.createPolicy)return b;try{b=c.createPolicy(a,{createHTML:goog.identity_,createScript:goog.identity_,createScriptURL:goog.identity_})}catch(d){goog.logToConsole_(d.message)}return b};\n!COMPILED&&goog.DEPENDENCIES_ENABLED&&(goog.isEdge_=function(){return!!(goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"").match(/Edge\\/(\\d+)(\\.\\d)*/i)},goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write"in a},goog.isDocumentLoading_=function(){var a=goog.global.document;return a.attachEvent?"complete"!=a.readyState:"loading"==a.readyState},goog.findBasePath_=function(){if(void 0!=goog.global.CLOSURE_BASE_PATH&&"string"===typeof goog.global.CLOSURE_BASE_PATH)goog.basePath=\ngoog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.slice(d-7,d)){goog.basePath=c.slice(0,d-7);break}}}},goog.findBasePath_(),goog.protectScriptTag_=function(a){return a.replace(/<\\/(SCRIPT)/ig,"\\\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_={};this.idToPath_={};this.written_={};this.loadingDeps_=\n[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory;this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){b=[];for(var e=0;e<a.length;e++){var f=this.getPathFromDeps_(a[e]);if(!f)throw Error("Unregonized namespace: "+a[e]);b.push(this.dependencies_[f])}f=goog.require;var g=0;for(e=0;e<a.length;e++)f(a[e]),b[e].onLoad(function(){++g==a.length&&c()})}else c()},\ngoog.DebugLoader_.prototype.loadClosureDeps=function(){this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath+"deps.js"),"deps.js",[],[],{}));this.loadDeps_()},goog.DebugLoader_.prototype.requested=function(a,b){(a=this.getPathFromDeps_(a))&&(b||this.areDepsLoaded_(this.dependencies_[a].requires))&&(b=this.deferredCallbacks_[a])&&(delete this.deferredCallbacks_[a],b())},goog.DebugLoader_.prototype.setDependencyFactory=function(a){this.factory_=a},goog.DebugLoader_.prototype.load_=\nfunction(a){if(this.getPathFromDeps_(a)){var b=this,c=[],d=function(e){var f=b.getPathFromDeps_(e);if(!f)throw Error("Bad dependency path or symbol: "+e);if(!b.written_[f]){b.written_[f]=!0;e=b.dependencies_[f];for(f=0;f<e.requires.length;f++)goog.isProvided_(e.requires[f])||d(e.requires[f]);c.push(e)}};d(a);a=!!this.depsToLoad_.length;this.depsToLoad_=this.depsToLoad_.concat(c);this.paused_||a||this.loadDeps_()}else goog.logToConsole_("goog.require could not find: "+a)},goog.DebugLoader_.prototype.loadDeps_=\nfunction(){for(var a=this,b=this.paused_;this.depsToLoad_.length&&!b;)(function(){var c=!1,d=a.depsToLoad_.shift(),e=!1;a.loading_(d);var f={pause:function(){if(c)throw Error("Cannot call pause after the call to load.");b=!0},resume:function(){c?a.resume_():b=!1},loaded:function(){if(e)throw Error("Double call to loaded.");e=!0;a.loaded_(d)},pending:function(){for(var g=[],h=0;h<a.loadingDeps_.length;h++)g.push(a.loadingDeps_[h]);return g},setModuleState:function(g){goog.moduleLoaderState_={type:g,\nmoduleName:"",declareLegacyNamespace:!1}},registerEs6ModuleExports:function(g,h,k){k&&(goog.loadedModules_[k]={exports:h,type:goog.ModuleType.ES6,moduleId:k||""})},registerGoogModuleExports:function(g,h){goog.loadedModules_[g]={exports:h,type:goog.ModuleType.GOOG,moduleId:g}},clearModuleState:function(){goog.moduleLoaderState_=null},defer:function(g){if(c)throw Error("Cannot register with defer after the call to load.");a.defer_(d,g)},areDepsLoaded:function(){return a.areDepsLoaded_(d.requires)}};\ntry{d.load(f)}finally{c=!0}})();b&&this.pause_()},goog.DebugLoader_.prototype.pause_=function(){this.paused_=!0},goog.DebugLoader_.prototype.resume_=function(){this.paused_&&(this.paused_=!1,this.loadDeps_())},goog.DebugLoader_.prototype.loading_=function(a){this.loadingDeps_.push(a)},goog.DebugLoader_.prototype.loaded_=function(a){for(var b=0;b<this.loadingDeps_.length;b++)if(this.loadingDeps_[b]==a){this.loadingDeps_.splice(b,1);break}for(b=0;b<this.deferredQueue_.length;b++)if(this.deferredQueue_[b]==\na.path){this.deferredQueue_.splice(b,1);break}if(this.loadingDeps_.length==this.deferredQueue_.length&&!this.depsToLoad_.length)for(;this.deferredQueue_.length;)this.requested(this.deferredQueue_.shift(),!0);a.loaded()},goog.DebugLoader_.prototype.areDepsLoaded_=function(a){for(var b=0;b<a.length;b++){var c=this.getPathFromDeps_(a[b]);if(!c||!(c in this.deferredCallbacks_||goog.isProvided_(a[b])))return!1}return!0},goog.DebugLoader_.prototype.getPathFromDeps_=function(a){return a in this.idToPath_?\nthis.idToPath_[a]:a in this.dependencies_?a:null},goog.DebugLoader_.prototype.defer_=function(a,b){this.deferredCallbacks_[a.path]=b;this.deferredQueue_.push(a.path)},goog.LoadController=function(){},goog.LoadController.prototype.pause=function(){},goog.LoadController.prototype.resume=function(){},goog.LoadController.prototype.loaded=function(){},goog.LoadController.prototype.pending=function(){},goog.LoadController.prototype.registerEs6ModuleExports=function(a,b,c){},goog.LoadController.prototype.setModuleState=\nfunction(a){},goog.LoadController.prototype.clearModuleState=function(){},goog.LoadController.prototype.defer=function(a){},goog.LoadController.prototype.areDepsLoaded=function(){},goog.Dependency=function(a,b,c,d,e){this.path=a;this.relativePath=b;this.provides=c;this.requires=d;this.loadFlags=e;this.loaded_=!1;this.loadCallbacks_=[]},goog.Dependency.prototype.getPathName=function(){var a=this.path,b=a.indexOf("://");0<=b&&(a=a.substring(b+3),b=a.indexOf("/"),0<=b&&(a=a.substring(b+1)));return a},\ngoog.Dependency.prototype.onLoad=function(a){this.loaded_?a():this.loadCallbacks_.push(a)},goog.Dependency.prototype.loaded=function(){this.loaded_=!0;var a=this.loadCallbacks_;this.loadCallbacks_=[];for(var b=0;b<a.length;b++)a[b]()},goog.Dependency.defer_=!1,goog.Dependency.callbackMap_={},goog.Dependency.registerCallback_=function(a){var b=Math.random().toString(32);goog.Dependency.callbackMap_[b]=a;return b},goog.Dependency.unregisterCallback_=function(a){delete goog.Dependency.callbackMap_[a]},\ngoog.Dependency.callback_=function(a,b){if(a in goog.Dependency.callbackMap_){for(var c=goog.Dependency.callbackMap_[a],d=[],e=1;e<arguments.length;e++)d.push(arguments[e]);c.apply(void 0,d)}else throw Error("Callback key "+a+" does not exist (was base.js loaded more than once?).");},goog.Dependency.prototype.load=function(a){if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var b=goog.global.document;if("complete"==\nb.readyState&&!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING){if(/\\bdeps.js$/.test(this.path)){a.loaded();return}throw Error(\'Cannot write "\'+this.path+\'" after document load\');}var c=goog.getScriptNonce_();if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&goog.isDocumentLoading_()){var d=function(h){h.readyState&&"complete"!=h.readyState?h.onload=d:(goog.Dependency.unregisterCallback_(e),a.loaded())};var e=goog.Dependency.registerCallback_(d);c=c?\' nonce="\'+c+\'"\':"";var f=\'<script src="\'+this.path+\'"\'+\nc+(goog.Dependency.defer_?" defer":"")+\' id="script-\'+e+\'">\\x3c/script>\';f+="<script"+c+">";f=goog.Dependency.defer_?f+("document.getElementById(\'script-"+e+"\').onload = function() {\\n  goog.Dependency.callback_(\'"+e+"\', this);\\n};\\n"):f+("goog.Dependency.callback_(\'"+e+"\', document.getElementById(\'script-"+e+"\'));");f+="\\x3c/script>";b.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(f):f)}else{var g=b.createElement("script");g.defer=goog.Dependency.defer_;g.async=!1;c&&(g.nonce=\nc);g.onload=function(){g.onload=null;a.loaded()};g.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path):this.path;b.head.appendChild(g)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."),a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,\nb,c,d,e)},goog.inherits(goog.Es6ModuleDependency,goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(l,n){var m="",p=goog.getScriptNonce_();p&&(m=\' nonce="\'+p+\'"\');l=n?\'<script type="module" crossorigin\'+m+">"+n+"\\x3c/script>":\'<script type="module" crossorigin src="\'+l+\'"\'+m+">\\x3c/script>";d.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(l):l)}function c(l,n){var m=d.createElement("script");m.defer=!0;m.async=!1;m.type="module";m.setAttribute("crossorigin",\n!0);var p=goog.getScriptNonce_();p&&(m.nonce=p);n?m.text=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScript(n):n:m.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(l):l;d.head.appendChild(m)}if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var d=goog.global.document,e=this;if(goog.isDocumentLoading_()){var f=b;goog.Dependency.defer_=!0}else f=c;var g=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(g);\na.setModuleState(goog.ModuleType.ES6)});f(void 0,\'goog.Dependency.callback_("\'+g+\'")\');f(this.path,void 0);var h=goog.Dependency.registerCallback_(function(l){goog.Dependency.unregisterCallback_(h);a.registerEs6ModuleExports(e.path,l,goog.moduleLoaderState_.moduleName)});f(void 0,\'import * as m from "\'+this.path+\'"; goog.Dependency.callback_("\'+h+\'", m)\');var k=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(k);a.clearModuleState();a.loaded()});f(void 0,\'goog.Dependency.callback_("\'+\nk+\'")\')}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),a.pause()},goog.TransformedDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e);this.contents_=null;this.lazyFetch_=!goog.inHtmlDocument_()||!("noModule"in goog.global.document.createElement("script"))},goog.inherits(goog.TransformedDependency,goog.Dependency),goog.TransformedDependency.prototype.load=function(a){function b(){e.contents_=goog.loadFileSync_(e.path);e.contents_&&(e.contents_=\ne.transform(e.contents_),e.contents_&&(e.contents_+="\\n//# sourceURL="+e.path))}function c(){e.lazyFetch_&&b();if(e.contents_){f&&a.setModuleState(goog.ModuleType.ES6);try{var l=e.contents_;e.contents_=null;goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(l));if(f)var n=goog.moduleLoaderState_.moduleName}finally{f&&a.clearModuleState()}f&&goog.global.$jscomp.require.ensure([e.getPathName()],function(){a.registerEs6ModuleExports(e.path,goog.global.$jscomp.require(e.getPathName()),n)});a.loaded()}}\nfunction d(){var l=goog.global.document,n=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(n);c()}),m=goog.getScriptNonce_();m="<script"+(m?\' nonce="\'+m+\'"\':"")+">"+goog.protectScriptTag_(\'goog.Dependency.callback_("\'+n+\'");\')+"\\x3c/script>";l.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(m):m)}var e=this;if(goog.global.CLOSURE_IMPORT_SCRIPT)b(),this.contents_&&goog.global.CLOSURE_IMPORT_SCRIPT("",this.contents_)?(this.contents_=null,a.loaded()):\na.pause();else{var f=this.loadFlags.module==goog.ModuleType.ES6;this.lazyFetch_||b();var g=1<a.pending().length;if(goog.Dependency.defer_&&(g||goog.isDocumentLoading_()))a.defer(function(){c()});else{var h=goog.global.document;g=goog.inHtmlDocument_()&&("ActiveXObject"in goog.global||goog.isEdge_());if(f&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()&&!g){goog.Dependency.defer_=!0;a.pause();var k=h.onreadystatechange;h.onreadystatechange=function(){"interactive"==h.readyState&&(h.onreadystatechange=\nk,c(),a.resume());"function"===typeof k&&k.apply(void 0,arguments)}}else goog.inHtmlDocument_()&&goog.isDocumentLoading_()?d():c()}}},goog.TransformedDependency.prototype.transform=function(a){},goog.PreTranspiledEs6ModuleDependency=function(a,b,c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.PreTranspiledEs6ModuleDependency,goog.TransformedDependency),goog.PreTranspiledEs6ModuleDependency.prototype.transform=function(a){return a},goog.GoogModuleDependency=function(a,b,\nc,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.GoogModuleDependency,goog.TransformedDependency),goog.GoogModuleDependency.prototype.transform=function(a){return goog.LOAD_MODULE_USING_EVAL&&void 0!==goog.global.JSON?"goog.loadModule("+goog.global.JSON.stringify(a+"\\n//# sourceURL="+this.path+"\\n")+");":\'goog.loadModule(function(exports) {"use strict";\'+a+"\\n;return exports});\\n//# sourceURL="+this.path+"\\n"},goog.DebugLoader_.prototype.addDependency=function(a,b,c,d){b=\nb||[];a=a.replace(/\\\\/g,"/");var e=goog.normalizePath_(goog.basePath+a);d&&"boolean"!==typeof d||(d=d?{module:goog.ModuleType.GOOG}:{});c=this.factory_.createDependency(e,a,b,c,d);this.dependencies_[e]=c;for(c=0;c<b.length;c++)this.idToPath_[b[c]]=e;this.idToPath_[a]=e},goog.DependencyFactory=function(){},goog.DependencyFactory.prototype.createDependency=function(a,b,c,d,e){return e.module==goog.ModuleType.GOOG?new goog.GoogModuleDependency(a,b,c,d,e):e.module==goog.ModuleType.ES6?goog.ASSUME_ES_MODULES_TRANSPILED?\nnew goog.PreTranspiledEs6ModuleDependency(a,b,c,d,e):new goog.Es6ModuleDependency(a,b,c,d,e):new goog.Dependency(a,b,c,d,e)},goog.debugLoader_=new goog.DebugLoader_,goog.loadClosureDeps=function(){goog.debugLoader_.loadClosureDeps()},goog.setDependencyFactory=function(a){goog.debugLoader_.setDependencyFactory(a)},goog.TRUSTED_TYPES_POLICY_=goog.TRUSTED_TYPES_POLICY_NAME?goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME+"#base"):null,goog.global.CLOSURE_NO_DEPS||goog.debugLoader_.loadClosureDeps(),\ngoog.bootstrap=function(a,b){goog.debugLoader_.bootstrap(a,b)});if(!COMPILED){var isChrome87=!1;try{isChrome87=eval(goog.global.trustedTypes.emptyScript)!==goog.global.trustedTypes.emptyScript}catch(a){}goog.CLOSURE_EVAL_PREFILTER_=goog.global.trustedTypes&&isChrome87&&goog.createTrustedTypesPolicy("goog#base#devonly#eval")||{createScript:goog.identity_}};const proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.proxy"),createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.endpoint"),releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.releaseProxy"),throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.thrown"),isObject$$module$node_modules$comlink$dist$esm$comlink_mjs=a=>"object"===typeof a&&null!==a||"function"===typeof a,proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs=\n{canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs],serialize(a){const {port1:b,port2:c}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b);return[c,[c]]},deserialize(a){a.start();return wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a)}},throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs={canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&\nthrowMarker$$module$node_modules$comlink$dist$esm$comlink_mjs in a,serialize({value:a}){return[a instanceof Error?{isError:!0,value:{message:a.message,name:a.name,stack:a.stack}}:{isError:!1,value:a},[]]},deserialize(a){if(a.isError)throw Object.assign(Error(a.value.message),a.value);throw a.value;}},transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs=new Map([["proxy",proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs],["throw",throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs]]);\nfunction expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self){b.addEventListener("message",function e(d){if(d&&d.data){var {id:f,type:g,path:h}=Object.assign({path:[]},d.data),k=(d.data.argumentList||[]).map(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);try{const n=h.slice(0,-1).reduce((p,q)=>p[q],a),m=h.reduce((p,q)=>p[q],a);switch(g){case "GET":var l=m;break;case "SET":n[h.slice(-1)[0]]=fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(d.data.value);\nl=!0;break;case "APPLY":l=m.apply(n,k);break;case "CONSTRUCT":const p=new m(...k);l=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(p);break;case "ENDPOINT":const {port1:q,port2:B}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,B);l=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(q,[q]);break;case "RELEASE":l=void 0;break;default:return}}catch(n){l={value:n,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0}}Promise.resolve(l).catch(n=>\n({value:n,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0})).then(n=>{const [m,p]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(n);b.postMessage(Object.assign(Object.assign({},m),{id:f}),p);"RELEASE"===g&&(b.removeEventListener("message",e),closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(b))})}});b.start&&b.start()}function isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return"MessagePort"===a.constructor.name}\nfunction closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a){isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a.close()}function wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[],b)}function throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(a){if(a)throw Error("Proxy has been released and is not useable");}\nfunction createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=[],c=function(){}){let d=!1;const e=new Proxy(c,{get(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);if(g===releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs)return()=>requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"RELEASE",path:b.map(h=>h.toString())}).then(()=>{closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a);d=!0});if("then"===\ng){if(0===b.length)return{then:()=>e};f=requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"GET",path:b.map(h=>h.toString())}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return f.then.bind(f)}return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[...b,g])},set(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [k,l]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\n{type:"SET",path:[...b,g].map(n=>n.toString()),value:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},apply(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);f=b[b.length-1];if(f===createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs)return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"ENDPOINT"}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);if("bind"===f)return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\nb.slice(0,-1));const [k,l]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"APPLY",path:b.map(n=>n.toString()),argumentList:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},construct(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [h,k]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(g);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\n{type:"CONSTRUCT",path:b.map(l=>l.toString()),argumentList:h},k).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)}});return e}function myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Array.prototype.concat.apply([],a)}\nfunction processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(a){a=a.map(toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return[a.map(b=>b[0]),myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a.map(b=>b[1]))]}const transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs=new WeakMap;function transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.set(a,b);return a}\nfunction proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Object.assign(a,{[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:!0})}function windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self,c="*"){return{postMessage:(d,e)=>a.postMessage(d,c,e),addEventListener:b.addEventListener.bind(b),removeEventListener:b.removeEventListener.bind(b)}}\nfunction toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){for(const [b,c]of transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs)if(c.canHandle(a)){const [d,e]=c.serialize(a);return[{type:"HANDLER",name:b,value:d},e]}return[{type:"RAW",value:a},transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a)||[]]}\nfunction fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){switch(a.type){case "HANDLER":return transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a.name).deserialize(a.value);case "RAW":return a.value}}\nfunction requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b,c){return new Promise(d=>{const e=generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs();a.addEventListener("message",function h(g){g.data&&g.data.id&&g.data.id===e&&(a.removeEventListener("message",h),d(g.data))});a.start&&a.start();a.postMessage(Object.assign({id:e},b),c)})}\nfunction generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs(){return Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}var module$node_modules$comlink$dist$esm$comlink_mjs={};module$node_modules$comlink$dist$esm$comlink_mjs.createEndpoint=createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.expose=expose$$module$node_modules$comlink$dist$esm$comlink_mjs;\nmodule$node_modules$comlink$dist$esm$comlink_mjs.proxy=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.proxyMarker=proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.releaseProxy=releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.transfer=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs;\nmodule$node_modules$comlink$dist$esm$comlink_mjs.transferHandlers=transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.windowEndpoint=windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.wrap=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs;function MessagePortState$$module$src$utils$message_port_state(){}MessagePortState$$module$src$utils$message_port_state.prototype.ready=!1;MessagePortState$$module$src$utils$message_port_state.prototype.port=void 0;MessagePortState$$module$src$utils$message_port_state.prototype.post=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.broadcastPlayState=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.workerState=void 0;\nMessagePortState$$module$src$utils$message_port_state.prototype.vanillaWorkerState=void 0;var $jscompDefaultExport$$module$src$utils$message_port_state=MessagePortState$$module$src$utils$message_port_state,module$src$utils$message_port_state={};module$src$utils$message_port_state.MessagePortState=MessagePortState$$module$src$utils$message_port_state;module$src$utils$message_port_state.default=$jscompDefaultExport$$module$src$utils$message_port_state;const csoundCreate$$module$src$modules$instantiation=a=>()=>a.exports.csoundCreateWasi();csoundCreate$$module$src$modules$instantiation.toString=()=>"create = async () => undefined;";const csoundDestroy$$module$src$modules$instantiation=a=>b=>a.exports.csoundDestroy(b);csoundDestroy$$module$src$modules$instantiation.toString=()=>"destroy = async () => undefined;";const csoundGetAPIVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetAPIVersion();\ncsoundGetAPIVersion$$module$src$modules$instantiation.toString=()=>"getAPIVersion = async () => Number;";const csoundGetVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetVersion();csoundGetVersion$$module$src$modules$instantiation.toString=()=>"getVersion = async () => Number;";const csoundInitialize$$module$src$modules$instantiation=a=>(b,c)=>a.exports.csoundInitialize(c);csoundInitialize$$module$src$modules$instantiation.toString=()=>"initialize = async () => Number;";\nvar module$src$modules$instantiation={};module$src$modules$instantiation.csoundCreate=csoundCreate$$module$src$modules$instantiation;module$src$modules$instantiation.csoundDestroy=csoundDestroy$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetAPIVersion=csoundGetAPIVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetVersion=csoundGetVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundInitialize=csoundInitialize$$module$src$modules$instantiation;const WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders=!1;function TextEncoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";return this}TextEncoderPoly$$module$src$utils$text_encoders.prototype.encode=function(a){if("string"!==typeof a)throw new TypeError("passed argument must be of type string "+a+" "+typeof a);a=unescape(encodeURIComponent(a));const b=new Uint8Array(a.length);[...a].forEach(function(c,d){b[d]=c.codePointAt(0)});return b};\nfunction TextDecoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";this.ignoreBOM=!1;this.trimNull=a=>{const b=a.indexOf("\\x00");return-1<b?a.slice(0,Math.max(0,b)):a};this.decode=function(a,b){if(void 0===a)return"";if("boolean"!==typeof(void 0!==b&&"stream"in b?b.stream:!1))throw new TypeError("stream option must be boolean");if(ArrayBuffer.isView(a)){a=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);const c=Array.from({length:a.length});a.forEach(function(d,e){c[e]=String.fromCodePoint(d)});\nreturn this.trimNull(c.join(""))}throw new TypeError("passed argument must be an array buffer view");}}\nconst decoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextDecoderPoly$$module$src$utils$text_encoders:new TextDecoder("utf8"),encoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextEncoderPoly$$module$src$utils$text_encoders:new TextEncoder("utf8"),uint2String$$module$src$utils$text_encoders=a=>decoder$$module$src$utils$text_encoders.decode(a);var module$src$utils$text_encoders={};\nmodule$src$utils$text_encoders.decoder=decoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.encoder=encoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.uint2String=uint2String$$module$src$utils$text_encoders;const trimNull$$module$src$utils$trim_null=a=>{const b=a.indexOf("\\x00");return-1<b?a.substr(0,b):a};var module$src$utils$trim_null={};module$src$utils$trim_null.trimNull=trimNull$$module$src$utils$trim_null;const freeStringPtr$$module$src$utils$string_pointers=(a,b)=>{a.exports.freeStringMem(b)},ptr2string$$module$src$utils$string_pointers=(a,b)=>{({buffer:a}=a.wasi.memory);b=new Uint8Array(a,b);b=uint2String$$module$src$utils$text_encoders(b);return trimNull$$module$src$utils$trim_null(b)},string2ptr$$module$src$utils$string_pointers=(a,b)=>{if("string"!==typeof b)console.error("Expected string but got",typeof b);else{b=encoder$$module$src$utils$text_encoders.encode(b);var c=a.exports.allocStringMem(b.length);\n({buffer:a}=a.wasi.memory);(new Uint8Array(a,c,b.length+1)).set(b);return c}};var module$src$utils$string_pointers={};module$src$utils$string_pointers.freeStringPtr=freeStringPtr$$module$src$utils$string_pointers;module$src$utils$string_pointers.ptr2string=ptr2string$$module$src$utils$string_pointers;module$src$utils$string_pointers.string2ptr=string2ptr$$module$src$utils$string_pointers;const csoundParseOrc$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundParseOrc(b,c);csoundParseOrc$$module$src$modules$performance.toString=()=>"parseOrc = async (orchestra) => Object;";const csoundCompileTree$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundCompileTree(b,c);csoundCompileTree$$module$src$modules$performance.toString=()=>"compileTree = async (tree) => Number;";\nconst csoundCompileOrc$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileOrc(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileOrc$$module$src$modules$performance.toString=()=>"compileOrc = async (orchestra) => Number;";\nconst csoundEvalCode$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundEvalCode(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundEvalCode$$module$src$modules$performance.toString=()=>"csoundEvalCode = async (orchestra) => Number;";const csoundStart$$module$src$modules$performance=a=>b=>a.exports.csoundStartWasi(b);csoundStart$$module$src$modules$performance.toString=()=>"start = async () => Number;";\nconst csoundCompileCsd$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);let d;try{d=a.exports.csoundCompileCsd(b,c)}catch(e){console.error(e)}freeStringPtr$$module$src$utils$string_pointers(a,c);return d};csoundCompileCsd$$module$src$modules$performance.toString=()=>"compileCsd = async (path) => Number;";\nconst csoundCompileCsdText$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileCsdText(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileCsdText$$module$src$modules$performance.toString=()=>"compileCsdText = async (csoundDocument) => Number;";const csoundPerform$$module$src$modules$performance=a=>b=>a.exports.csoundPerform(b);csoundPerform$$module$src$modules$performance.toString=()=>"perform = async () => Number;";\nconst csoundPerformKsmps$$module$src$modules$performance=a=>b=>a.exports.csoundPerformKsmpsWasi(b);csoundPerformKsmps$$module$src$modules$performance.toString=()=>"performKsmps = async (csound) => Number;";const csoundPerformBuffer$$module$src$modules$performance=a=>b=>a.exports.csoundPerformBuffer(b);csoundPerformBuffer$$module$src$modules$performance.toString=()=>"performBuffer = async (csound) => Number;";const csoundStop$$module$src$modules$performance=a=>b=>a.exports.csoundStop(b);\ncsoundStop$$module$src$modules$performance.toString=()=>"stop = async () => undefined;";const csoundCleanup$$module$src$modules$performance=a=>b=>a.exports.csoundCleanup(b);csoundCleanup$$module$src$modules$performance.toString=()=>"cleanup = async () => Number;";const csoundReset$$module$src$modules$performance=a=>b=>a.exports.csoundResetWasi(b);csoundReset$$module$src$modules$performance.toString=()=>"reset = async () => Number;";var module$src$modules$performance={};\nmodule$src$modules$performance.csoundCleanup=csoundCleanup$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsd=csoundCompileCsd$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsdText=csoundCompileCsdText$$module$src$modules$performance;module$src$modules$performance.csoundCompileOrc=csoundCompileOrc$$module$src$modules$performance;module$src$modules$performance.csoundCompileTree=csoundCompileTree$$module$src$modules$performance;\nmodule$src$modules$performance.csoundEvalCode=csoundEvalCode$$module$src$modules$performance;module$src$modules$performance.csoundParseOrc=csoundParseOrc$$module$src$modules$performance;module$src$modules$performance.csoundPerform=csoundPerform$$module$src$modules$performance;module$src$modules$performance.csoundPerformBuffer=csoundPerformBuffer$$module$src$modules$performance;module$src$modules$performance.csoundPerformKsmps=csoundPerformKsmps$$module$src$modules$performance;\nmodule$src$modules$performance.csoundReset=csoundReset$$module$src$modules$performance;module$src$modules$performance.csoundStart=csoundStart$$module$src$modules$performance;module$src$modules$performance.csoundStop=csoundStop$$module$src$modules$performance;const sizeOfPrimitive$$module$src$utils$native_sizes={int:4,MYFLT:4,char:1},sizeofStruct$$module$src$utils$native_sizes=a=>a.reduce((b,[,c,...d])=>b+("char"===c?sizeOfPrimitive$$module$src$utils$native_sizes[c]*d[0]:sizeOfPrimitive$$module$src$utils$native_sizes[c]),0);var module$src$utils$native_sizes={};module$src$utils$native_sizes.sizeOfPrimitive=sizeOfPrimitive$$module$src$utils$native_sizes;module$src$utils$native_sizes.sizeofStruct=sizeofStruct$$module$src$utils$native_sizes;const structBufferToObject$$module$src$utils$structure_buffer_to_object=(a,b)=>{[a]=a.reduce(([c,d],[e,f,...g])=>{g="char"===f?sizeOfPrimitive$$module$src$utils$native_sizes[f]*g[0]:sizeOfPrimitive$$module$src$utils$native_sizes[f];f="char"===f?trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(b.subarray(d,g)))||"":b[d];c[e]=f;return[c,d+g]},[{},0]);return a};var module$src$utils$structure_buffer_to_object={};\nmodule$src$utils$structure_buffer_to_object.structBufferToObject=structBufferToObject$$module$src$utils$structure_buffer_to_object;const CSOUND_PARAMS$$module$src$structures=[["debug_mode","int"],["buffer_frames","int"],["hardware_buffer_frames","int"],["displays","int"],["ascii_graphs","int"],["postscript_graphs","int"],["message_level","int"],["tempo","int"],["ring_bell","int"],["use_cscore","int"],["terminate_on_midi","int"],["heartbeat","int"],["defer_gen01_load","int"],["midi_key","int"],["midi_key_cps","int"],["midi_key_oct","int"],["midi_key_pch","int"],["midi_velocity","int"],["midi_velocity_amp","int"],["no_default_paths",\n"int"],["number_of_threads","int"],["syntax_check_only","int"],["csd_line_counts","int"],["compute_weights","int"],["realtime_mode","int"],["sample_accurate","int"],["sample_rate_override","MYFLT"],["control_rate_override","MYFLT"],["nchnls_override","int"],["nchnls_i_override","int"],["e0dbfs_override","MYFLT"],["daemon","int"],["ksmps_override","int"],["FFT_library","int"]],CS_MIDIDEVICE$$module$src$structures=[["device_name","char",64],["interface_name","char",64],["device_id","char",64],["midi_module",\n"char",64],["isOutput","int"]];var module$src$structures={};const csoundGetSr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSr(b);csoundGetSr$$module$src$modules$attributes.toString=()=>"getSr = async () => Number;";const csoundGetKr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKr(b);csoundGetKr$$module$src$modules$attributes.toString=()=>"getKr = async () => Number;";const csoundGetKsmps$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKsmps(b);csoundGetKsmps$$module$src$modules$attributes.toString=()=>"getKsmps = async () => Number;";\nconst csoundGetNchnls$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnls(b);csoundGetNchnls$$module$src$modules$attributes.toString=()=>"getNchnls = async () => Number;";const csoundGetNchnlsInput$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnlsInput(b);csoundGetNchnlsInput$$module$src$modules$attributes.toString=()=>"getNchnlsInput = async () => Number;";const csoundGet0dBFS$$module$src$modules$attributes=a=>b=>a.exports.csoundGet0dBFS(b);\ncsoundGet0dBFS$$module$src$modules$attributes.toString=()=>"get0dBFS = async () => Number;";const csoundGetA4$$module$src$modules$attributes=a=>b=>a.exports.csoundGetA4(b);csoundGetA4$$module$src$modules$attributes.toString=()=>"getA4 = async () => Number;";const csoundGetCurrentTimeSamples$$module$src$modules$attributes=a=>b=>a.exports.csoundGetCurrentTimeSamples(b);csoundGetCurrentTimeSamples$$module$src$modules$attributes.toString=()=>"getCurrentTimeSamples = async () => Number;";\nconst csoundGetSizeOfMYFLT$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSizeOfMYFLT(b);csoundGetSizeOfMYFLT$$module$src$modules$attributes.toString=()=>"getSizeOfMYFLT = async () => Number;";const csoundSetOption$$module$src$modules$attributes=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundSetOption(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundSetOption$$module$src$modules$attributes.toString=()=>"setOption = async (option) => Number;";\nconst csoundSetParams$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetParams(b,c)};csoundSetParams$$module$src$modules$attributes.toString=()=>"setParams = async (csoundParams) => undefined;";\nconst csoundGetParams$$module$src$modules$attributes=a=>b=>{var {buffer:c}=a.wasi.memory;const d=sizeofStruct$$module$src$utils$native_sizes(CSOUND_PARAMS$$module$src$structures),e=a.exports.allocCsoundParamsStruct();c=new Uint8Array(c,e,d);a.exports.csoundGetParams(b,e);b=structBufferToObject$$module$src$utils$structure_buffer_to_object(CSOUND_PARAMS$$module$src$structures,c);a.exports.freeCsoundParams(e);return b};csoundGetParams$$module$src$modules$attributes.toString=()=>"getParams = async () => CSOUND_PARAMS;";\nconst csoundGetDebug$$module$src$modules$attributes=a=>b=>a.exports.csoundGetDebug(b);csoundGetDebug$$module$src$modules$attributes.toString=()=>"getDebug = async () => Number;";const csoundSetDebug$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetDebug(b,c)};csoundSetDebug$$module$src$modules$attributes.toString=()=>"setDebug = async (number) => undefined;";var module$src$modules$attributes={};module$src$modules$attributes.csoundGet0dBFS=csoundGet0dBFS$$module$src$modules$attributes;\nmodule$src$modules$attributes.csoundGetA4=csoundGetA4$$module$src$modules$attributes;module$src$modules$attributes.csoundGetCurrentTimeSamples=csoundGetCurrentTimeSamples$$module$src$modules$attributes;module$src$modules$attributes.csoundGetDebug=csoundGetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKr=csoundGetKr$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKsmps=csoundGetKsmps$$module$src$modules$attributes;\nmodule$src$modules$attributes.csoundGetNchnls=csoundGetNchnls$$module$src$modules$attributes;module$src$modules$attributes.csoundGetNchnlsInput=csoundGetNchnlsInput$$module$src$modules$attributes;module$src$modules$attributes.csoundGetParams=csoundGetParams$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSizeOfMYFLT=csoundGetSizeOfMYFLT$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSr=csoundGetSr$$module$src$modules$attributes;\nmodule$src$modules$attributes.csoundSetDebug=csoundSetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundSetOption=csoundSetOption$$module$src$modules$attributes;module$src$modules$attributes.csoundSetParams=csoundSetParams$$module$src$modules$attributes;const csoundGetInputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBufferSize(b);csoundGetInputBufferSize$$module$src$modules$rtaudio.toString=()=>"getInputBufferSize = async () => Number;";const csoundGetOutputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBufferSize(b);csoundGetOutputBufferSize$$module$src$modules$rtaudio.toString=()=>"getOutputBufferSize = async () => Number;";const csoundGetInputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBuffer(b);\ncsoundGetInputBuffer$$module$src$modules$rtaudio.toString=()=>"getInputBuffer = async () => Number;";const csoundGetOutputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBuffer(b);csoundGetOutputBuffer$$module$src$modules$rtaudio.toString=()=>"getOutputBuffer = async () => Number;";const csoundGetSpin$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpin(b);csoundGetSpin$$module$src$modules$rtaudio.toString=()=>"getSpin = async (csound) => Number;";\nconst csoundGetSpout$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpout(b);csoundGetSpout$$module$src$modules$rtaudio.toString=()=>"getSpout = async () => Number;";var module$src$modules$rtaudio={};module$src$modules$rtaudio.csoundGetInputBuffer=csoundGetInputBuffer$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetInputBufferSize=csoundGetInputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetOutputBuffer=csoundGetOutputBuffer$$module$src$modules$rtaudio;\nmodule$src$modules$rtaudio.csoundGetOutputBufferSize=csoundGetOutputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpin=csoundGetSpin$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpout=csoundGetSpout$$module$src$modules$rtaudio;function add$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>add$$module$node_modules$rambda$dist$rambda_mjs(a,c):Number(a)+Number(b)}const cloneList$$module$node_modules$rambda$dist$rambda_mjs=a=>Array.prototype.slice.call(a);function curry$$module$node_modules$rambda$dist$rambda_mjs(a,b=[]){return(...c)=>{c=[...b,...c];return c.length>=a.length?a(...c):curry$$module$node_modules$rambda$dist$rambda_mjs(a,c)}}\nfunction adjustFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d=0>a?c.length+a:a;if(a>=c.length||0>d)return c;a=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);a[d]=b(a[d]);return a}const adjust$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(adjustFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction all$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>all$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(!a(b[c]))return!1;return!0}function allPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(!a[c](...b))return!1;c++}return!0}}function always$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>a}\nfunction and$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>and$$module$node_modules$rambda$dist$rambda_mjs(a,c):a&&b}function any$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>any$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=0;for(;c<b.length;){if(a(b[c],c))return!0;c++}return!1}\nfunction anyPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(a[c](...b))return!0;c++}return!1}}function append$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>append$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.split("").concat(a);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);c.push(a);return c}\nfunction apply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>apply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.apply(this,b)}const {isArray:isArray$$module$node_modules$rambda$dist$rambda_mjs}=Array;\nfunction __findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a,b=0){for(const c in a)!1!==a.hasOwnProperty(c)&&"constructor"!==c&&("object"===typeof a[c]&&(b=Math.max(b,__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a[c]))),"function"===typeof a[c]&&(b=Math.max(b,a[c].length)));return b}\nfunction __filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(){const a=[];let b=0;const c=arguments.length;for(;b<c&&"undefined"!==typeof arguments[b];)a[b]=arguments[b],b++;return a}\nfunction __applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){var d=b-c.length;if(1===d)return f=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f));if(2===d)return(f,g)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g));if(3===d)return(f,g,h)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,\nb,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h));if(4===d)return(f,g,h,k)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h,k));if(4<d)return(...f)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,...f));if(isArray$$module$node_modules$rambda$dist$rambda_mjs(a)){var e=[];d=0;const f=a.length;\nfor(;d<f;d++){if("object"===typeof a[d]||isArray$$module$node_modules$rambda$dist$rambda_mjs(a[d]))e[d]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[d],b,c);"function"===typeof a[d]&&(e[d]=a[d](...c))}return e}d={};for(e in a)!1!==a.hasOwnProperty(e)&&"constructor"!==e&&("object"===typeof a[e]?d[e]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[e],b,c):"function"===typeof a[e]&&(d[e]=a[e](...c)));return d}\nfunction applySpec$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a);return 0===c?()=>({}):__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,c,b)}function assocFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return Object.assign({},c,{[a]:b})}const assoc$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction _isInteger$$module$node_modules$rambda$dist$rambda_mjs(a){return a<<0===a}const isInteger$$module$node_modules$rambda$dist$rambda_mjs=Number.isInteger||_isInteger$$module$node_modules$rambda$dist$rambda_mjs;\nfunction assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d="string"===typeof a?a.split(".").map(e=>isInteger$$module$node_modules$rambda$dist$rambda_mjs(Number(e))?Number(e):e):a;if(0===d.length)return b;a=d[0];if(1<d.length){const e="object"===typeof c&&null!==c&&c.hasOwnProperty(a)?c[a]:isInteger$$module$node_modules$rambda$dist$rambda_mjs(d[1])?[]:{};b=assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(d,1),b,e)}return isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)&&\nisArray$$module$node_modules$rambda$dist$rambda_mjs(c)?(c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c),c[a]=b,c):assoc$$module$node_modules$rambda$dist$rambda_mjs(a,b,c)}const assocPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocPathFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction _curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return function(){var d=0;let e=0;const f=b.length,g=arguments.length,h=Array(f+g);for(;d<f;)h[d]=b[d],d++;for(;e<g;)h[f+e]=arguments[e],e++;d=a-h.length;return h.length>=a?c.apply(this,h):_arity$1$$module$node_modules$rambda$dist$rambda_mjs(d,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,h,c))}}\nfunction _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};\ncase 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,n){return b.apply(this,arguments)};default:return function(c,d,e,f,g,h,k,l,n,m){return b.apply(this,arguments)}}}\nfunction curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>curryN$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(10<a)throw Error("First argument to _arity must be a non-negative integer no greater than ten");return _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,[],b))}\nfunction bind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>bind$$module$node_modules$rambda$dist$rambda_mjs(a,c):curryN$$module$node_modules$rambda$dist$rambda_mjs(a.length,(...c)=>a.apply(b,c))}function both$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>both$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>a(...c)&&b(...c)}\nfunction chain$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>chain$$module$node_modules$rambda$dist$rambda_mjs(a,c):[].concat(...b.map(a))}function clampFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(a>b)throw Error("min must not be greater than max in clamp(min, max, value)");if(c>=a&&c<=b)return c;if(c>b)return b;if(c<a)return a}const clamp$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(clampFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction clone$$module$node_modules$rambda$dist$rambda_mjs(a){const b=isArray$$module$node_modules$rambda$dist$rambda_mjs(a)?Array(a.length):{};if(a&&a.getTime)return new Date(a.getTime());for(const c in a){const d=a[c];b[c]="object"===typeof d&&null!==d?d.getTime?new Date(d.getTime()):clone$$module$node_modules$rambda$dist$rambda_mjs(d):d}return b}function complement$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>!a(...b)}\nclass ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs{constructor(a){this.value=a}}function reduceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(c))throw new TypeError("reduce: list must be array or iterable");let d=0;const e=c.length;for(;d<e;){b=a(b,c[d],d,c);if(b instanceof ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs)return b.value;d++}return b}\nconst reduce$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(reduceFn$$module$node_modules$rambda$dist$rambda_mjs),reduceStopper$$module$node_modules$rambda$dist$rambda_mjs=a=>new ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs(a);\nfunction _arity$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};\ncase 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,n){return b.apply(this,arguments)};case 10:return function(c,d,e,f,g,h,k,l,n,m){return b.apply(this,arguments)};default:throw Error("First argument to _arity must be a non-negative integer no greater than ten");}}\nfunction _pipe$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(){return b.call(this,a.apply(this,arguments))}}\nfunction pipe$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("pipe requires at least one argument");return _arity$$module$node_modules$rambda$dist$rambda_mjs(arguments[0].length,reduceFn$$module$node_modules$rambda$dist$rambda_mjs(_pipe$$module$node_modules$rambda$dist$rambda_mjs,arguments[0],Array.prototype.slice.call(arguments,1,Infinity)))}\nfunction compose$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("compose requires at least one argument");return pipe$$module$node_modules$rambda$dist$rambda_mjs.apply(this,Array.prototype.slice.call(arguments,0).reverse())}function concat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>concat$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof a?`${a}${b}`:[...a,...b]}\nfunction cond$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>{let c=!1,d;a.forEach(([e,f])=>{!c&&e(b)&&(c=!0,d=f(b))});return d}}const {keys:keys$1$$module$node_modules$rambda$dist$rambda_mjs}=Object;function mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=Array(b.length);for(;d<b.length;)e[d]=c?a(b[d],d):a(b[d]),d++;return e}\nfunction mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,g);let c=0;const d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b),e=d.length,f={};for(;c<e;){const g=d[c];f[g]=a(b[g],g,b);c++}return f}const mapObjIndexed$$module$node_modules$rambda$dist$rambda_mjs=mapObject$$module$node_modules$rambda$dist$rambda_mjs;\nfunction map$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>map$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error(INCORRECT_ITERABLE_INPUT);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction max$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>max$$module$node_modules$rambda$dist$rambda_mjs(a,c):b>a?b:a}\nfunction converge$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>converge$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=reduce$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>max$$module$node_modules$rambda$dist$rambda_mjs(d,e.length),0,b);return curryN$$module$node_modules$rambda$dist$rambda_mjs(c,function(){return a.apply(this,map$$module$node_modules$rambda$dist$rambda_mjs(d=>d.apply(this,arguments),b))})}\nfunction count$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>count$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?b.filter(c=>a(c)).length:0}function countBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>countBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};b.forEach(d=>{d=a(d);c[d]?c[d]++:c[d]=1});return c}\nconst dec$$module$node_modules$rambda$dist$rambda_mjs=a=>a-1;function isFalsy$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a||!0===Number.isNaN(a)}function defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c):isFalsy$$module$node_modules$rambda$dist$rambda_mjs(b)?a:b}\nfunction type$$module$node_modules$rambda$dist$rambda_mjs(a){if(null===a)return"Null";if(void 0===a)return"Undefined";if(Number.isNaN(a))return"NaN";a=Object.prototype.toString.call(a).slice(8,-1);return"AsyncFunction"===a?"Promise":a}\nfunction _lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property \'indexOf\' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.lastIndexOf(a);({length:c}=b);let d=-1;for(;-1<--c&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}\nfunction _indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property \'indexOf\' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.indexOf(a);let d=c=-1;const {length:e}=b;for(;++c<e&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}\nfunction _arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a){const b=[];let c;for(;!(c=a.next()).done;)b.push(c.value);return b}function _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(a.size!==b.size)return!1;a=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a.values());const c=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(b.values());return 0===a.filter(d=>-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,c)).length}\nfunction parseError$$module$node_modules$rambda$dist$rambda_mjs(a){const b=a.__proto__.toString();return["Error","TypeError"].includes(b)?[b,a.message]:[]}function parseDate$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toDateString?[!0,a.getTime()]:[!1]}function parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a){return a.constructor!==RegExp?[!1]:[!0,a.toString()]}\nfunction equals$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>equals$$module$node_modules$rambda$dist$rambda_mjs(a,f);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(c!==type$$module$node_modules$rambda$dist$rambda_mjs(b))return!1;if("Function"===c)return void 0===a.name?!1:a.name===b.name;if(["NaN","Undefined","Null"].includes(c))return!0;if("Number"===c)return Object.is(-0,a)!==Object.is(-0,b)?!1:a.toString()===b.toString();if(["String","Boolean"].includes(c))return a.toString()===\nb.toString();if("Array"===c){c=Array.from(a);const f=Array.from(b);if(c.toString()!==f.toString())return!1;let g=!0;c.forEach((h,k)=>{g&&(h===f[k]||equals$$module$node_modules$rambda$dist$rambda_mjs(h,f[k])||(g=!1))});return g}var d=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a),e=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseDate$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseDate$$module$node_modules$rambda$dist$rambda_mjs(b);\nif(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseError$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseError$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[0]===e[0]&&d[1]===e[1]:!1;if("Set"===c)return _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b);if("Object"===c){c=Object.keys(a);if(c.length!==Object.keys(b).length)return!1;let f=!0;c.forEach(g=>{if(f){const h=a[g];g=b[g];h===g||equals$$module$node_modules$rambda$dist$rambda_mjs(h,g)||(f=!1)}});\nreturn f}return!1}function includes$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>includes$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof b)return b.includes(a);if(!b)throw new TypeError(`Cannot read property \\\'indexOf\\\' of ${b}`);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b):!1}\nclass _Set$$module$node_modules$rambda$dist$rambda_mjs{constructor(){this.set=new Set;this.items={}}checkUniqueness(a){var b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Null","Undefined","NaN"].includes(b)?b in this.items?!1:this.items[b]=!0:["Object","Array"].includes(b)?b in this.items?-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,this.items[b])?(this.items[b].push(a),!0):!1:(this.items[b]=[a],!0):(b=this.set.size,this.set.add(a),this.set.size!==b)}}\nfunction uniq$$module$node_modules$rambda$dist$rambda_mjs(a){const b=new _Set$$module$node_modules$rambda$dist$rambda_mjs,c=[];a.forEach(d=>{b.checkUniqueness(d)&&c.push(d)});return c}function difference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>difference$$module$node_modules$rambda$dist$rambda_mjs(a,c):uniq$$module$node_modules$rambda$dist$rambda_mjs(a).filter(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(null===b||void 0===b)return{};const c={};for(const d in b)c[d]=b[d];delete c[a];return c}function divide$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>divide$$module$node_modules$rambda$dist$rambda_mjs(a,c):a/b}\nfunction drop$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>drop$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.slice(0<a?a:0)}function dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,c):0<a?b.slice(0,-a):b.slice()}\nfunction dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(0===b.length)return b;const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if("function"!==typeof a)throw Error(`\'predicate\' is from wrong type ${typeof a}`);if(!c&&"string"!==typeof b)throw Error(`\'iterable\' is from wrong type ${typeof b}`);let d=!1;const e=[];let f=b.length;for(;0<f;)f--,d||!1!==a(b[f])?d&&e.push(b[f]):\n(d=!0,e.push(b[f]));return c?e.reverse():e.reverse().join("")}function dropRepeats$$module$node_modules$rambda$dist$rambda_mjs(a){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`${a} is not a list`);const b=[];a.reduce((c,d)=>{equals$$module$node_modules$rambda$dist$rambda_mjs(c,d)||b.push(d);return d},void 0);return b}\nfunction dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`${b} is not a list`);const c=[];b.reduce((d,e)=>{if(void 0===d)return c.push(e),e;a(d,e)||c.push(e);return e},void 0);return c}\nfunction dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!1;const e=[];let f=-1;for(;f++<b.length-1;)d?e.push(b[f]):a(b[f])||(d||(d=!0),e.push(b[f]));return c?e:e.join("")}\nfunction either$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>either$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>!(!a(...c)&&!b(...c))}\nfunction endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);if("string"===typeof b)return b.endsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;const c=b.length-a.length;let d=!0;return a.filter((e,f)=>{if(!d)return!1;(e=equals$$module$node_modules$rambda$dist$rambda_mjs(e,b[f+c]))||(d=!1);return e}).length===a.length}\nfunction prop$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>prop$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(b)return b[a]}function eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a,b),prop$$module$node_modules$rambda$dist$rambda_mjs(a,c))}const eqProps$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapArray$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c,b,!0)}\nfunction evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapObject$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>{if("Object"===type$$module$node_modules$rambda$dist$rambda_mjs(c)){const e=type$$module$node_modules$rambda$dist$rambda_mjs(a[d]);return"Function"===e?a[d](c):"Object"===e?evolve$$module$node_modules$rambda$dist$rambda_mjs(a[d],c):c}return"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c},b)}\nfunction evolve$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>evolve$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=type$$module$node_modules$rambda$dist$rambda_mjs(a),d=type$$module$node_modules$rambda$dist$rambda_mjs(b);if(d!==c)throw Error("iterableType !== rulesType");if(!["Object","Array"].includes(c))throw Error(`\'iterable\' and \'rules\' are from wrong type ${c}`);return"Object"===d?evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b):evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,\nb)}function F$$module$node_modules$rambda$dist$rambda_mjs(){return!1}function filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(const d in b)a(b[d],d,b)&&(c[d]=b[d]);return c}function filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=b.length,f=[];for(;d<e;)(c?a(b[d],d):a(b[d]))&&f.push(b[d]),d++;return f}\nfunction filter$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>filter$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error("Incorrect iterable input");return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,!1):filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction find$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>find$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=0;const d=b.length;for(;c<d;){const e=b[c];if(a(e))return e;c++}}function findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;let d=-1;for(;++d<c;)if(a(b[d]))return d;return-1}\nfunction findLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLast$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return b[c]}function findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return c;return-1}\nfunction flatten$$module$node_modules$rambda$dist$rambda_mjs(a,b){b=void 0===b?[]:b;for(let c=0;c<a.length;c++)isArray$$module$node_modules$rambda$dist$rambda_mjs(a[c])?flatten$$module$node_modules$rambda$dist$rambda_mjs(a[c],b):b.push(a[c]);return b}\nfunction flipFn$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{if(1===b.length)return c=>a(c,b[0]);if(2===b.length)return a(b[1],b[0]);if(3===b.length)return a(b[1],b[0],b[2]);if(4===b.length)return a(b[1],b[0],b[2],b[3]);throw Error("R.flip doesn\'t work with arity > 4");}}function flip$$module$node_modules$rambda$dist$rambda_mjs(a){return flipFn$$module$node_modules$rambda$dist$rambda_mjs(a)}\nfunction forEach$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>forEach$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(void 0!==b){if(isArray$$module$node_modules$rambda$dist$rambda_mjs(b))for(var c=0,d=b.length;c<d;)a(b[c]),c++;else{c=0;d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b);const e=d.length;for(;c<e;){const f=d[c];a(b[f],f,b);c++}}return b}}\nfunction fromPairs$$module$node_modules$rambda$dist$rambda_mjs(a){const b={};a.forEach(([c,d])=>b[c]=d);return b}function groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};for(let d=0;d<b.length;d++){const e=b[d],f=a(e);c[f]||(c[f]=[]);c[f].push(e)}return c}\nfunction groupWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw new TypeError("list.reduce is not a function");const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);if(1===b.length)return[c];const d=[];let e=[];c.reduce((f,g,h)=>{if(0===h)return g;const k=a(f,g),l=0===e.length;h=h===b.length-1;if(k)return l&&e.push(f),e.push(g),h&&d.push(e),g;if(l)return d.push([f]),h&&d.push([g]),g;d.push(e);h&&d.push([g]);e=[];return g},\nvoid 0);return d}function has$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>has$$module$node_modules$rambda$dist$rambda_mjs(a,c):b?b.hasOwnProperty(a):!1}function createPath$$module$node_modules$rambda$dist$rambda_mjs(a,b="."){return"string"===typeof a?a.split(b):a}\nfunction path$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>path$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=b,d=0,e=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);d<e.length;){if(null===c||void 0===c||null===c[e[d]])return;c=c[e[d]];d++}return c}}\nfunction hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,c):void 0!==path$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function head$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[0]||"":a[0]}function _objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b}const objectIs$$module$node_modules$rambda$dist$rambda_mjs=Object.is||_objectIs$$module$node_modules$rambda$dist$rambda_mjs;\nfunction identical$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>identical$$module$node_modules$rambda$dist$rambda_mjs(a,c):objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function identity$$module$node_modules$rambda$dist$rambda_mjs(a){return a}function ifElseFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return(...d)=>!0===("boolean"===typeof a?a:a(...d))?b(...d):c(...d)}\nconst ifElse$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(ifElseFn$$module$node_modules$rambda$dist$rambda_mjs),inc$$module$node_modules$rambda$dist$rambda_mjs=a=>a+1;function indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(let d=0;d<b.length;d++){const e=b[d];c[path$$module$node_modules$rambda$dist$rambda_mjs(a,e)]=e}return c}\nfunction indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof a)return indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b);const c={};for(let d=0;d<b.length;d++){const e=b[d];c[a(e)]=e}return c}\nfunction indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=-1,{length:e}=a;c=c>e?e:c;0>c&&(c+=e);e=b>c?0:c-b>>>0;b>>>=0;for(c=Array(e);++d<e;)c[d]=a[d+b];return c}\nfunction init$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.slice(0,-1):a.length?baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,0,-1):[]}function intersection$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>intersection$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b)}\nfunction intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,f);let c=-1;const d=b.length,e=[];for(;++c<d;)c===d-1?e.push(b[c]):e.push(b[c],a);return e}function is$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>is$$module$node_modules$rambda$dist$rambda_mjs(a,c):null!=b&&b.constructor===a||b instanceof a}\nfunction isEmpty$$module$node_modules$rambda$dist$rambda_mjs(a){const b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Undefined","NaN","Number","Null"].includes(b)?!1:a?"Object"===b?0===Object.keys(a).length:"Array"===b?0===a.length:!1:!0}function isNil$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a}\nfunction join$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>join$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.join(a)}function juxt$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>a.map(c=>c(...b))}function keys$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.keys(a)}function last$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[a.length-1]||"":a[a.length-1]}\nfunction lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function length$$module$node_modules$rambda$dist$rambda_mjs(a){return isArray$$module$node_modules$rambda$dist$rambda_mjs(a)||"string"===typeof a?a.length:NaN}\nfunction lens$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(c){return function(d){return c(a(d)).map(e=>b(e,d))}}}function nth$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>nth$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=0>a?b.length+a:a;return"[object String]"===Object.prototype.toString.call(b)?b.charAt(c):b[c]}\nfunction updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);return-1===a?c.fill(b,a):c.fill(b,a,a+1)}const update$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(updateFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction lensIndex$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(nth$$module$node_modules$rambda$dist$rambda_mjs(a),update$$module$node_modules$rambda$dist$rambda_mjs(a))}function lensPath$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a),assocPath$$module$node_modules$rambda$dist$rambda_mjs(a))}\nfunction lensProp$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a),assoc$$module$node_modules$rambda$dist$rambda_mjs(a))}function match$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>match$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=b.match(a);return null===c?[]:c}\nfunction mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,c):!isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)||!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||1>b?NaN:(a%b+b)%b}function maxByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)>a(b)?c:b}const maxBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(maxByFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction sum$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>b+c,0)}function mean$$module$node_modules$rambda$dist$rambda_mjs(a){return sum$$module$node_modules$rambda$dist$rambda_mjs(a)/a.length}function median$$module$node_modules$rambda$dist$rambda_mjs(a){var b=a.length;if(0===b)return NaN;const c=2-b%2;b=(b-c)/2;return mean$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,0).sort((d,e)=>d===e?0:d<e?-1:1).slice(b,b+c))}\nfunction mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,c):Object.assign({},a||{},b||{})}function mergeAll$$module$node_modules$rambda$dist$rambda_mjs(a){let b={};map$$module$node_modules$rambda$dist$rambda_mjs(c=>{b=mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,c)},a);return b}\nfunction mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=clone$$module$node_modules$rambda$dist$rambda_mjs(a);Object.keys(b).forEach(d=>{"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(b[d])?"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?c[d]=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a[d],b[d]):c[d]=b[d]:c[d]=b[d]});return c}\nfunction mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,c):mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,a)}function mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d={};Object.keys(b).forEach(e=>{d[e]=void 0===c[e]?b[e]:a(b[e],c[e])});Object.keys(c).forEach(e=>{void 0===d[e]&&(d[e]=void 0===b[e]?c[e]:a(b[e],c[e]))});return d}\nconst mergeWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs);function min$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>min$$module$node_modules$rambda$dist$rambda_mjs(a,c):b<a?b:a}function minByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)<a(b)?c:b}const minBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(minByFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction ownKeys$$module$node_modules$rambda$dist$rambda_mjs(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(e){return Object.getOwnPropertyDescriptor(a,e).enumerable}));c.push.apply(c,d)}return c}\nfunction _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(a){for(var b=1;b<arguments.length;b++){var c=null!=arguments[b]?arguments[b]:{};b%2?ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c),!0).forEach(function(d){_defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,d,c[d])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(c)):ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c)).forEach(function(d){Object.defineProperty(a,\nd,Object.getOwnPropertyDescriptor(c,d))})}return a}function _defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c;return a}function isIterable$$module$node_modules$rambda$dist$rambda_mjs(a){return Array.isArray(a)||"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a)}\nfunction modifyFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return isIterable$$module$node_modules$rambda$dist$rambda_mjs(c)&&void 0!==c[a]?isArray$$module$node_modules$rambda$dist$rambda_mjs(c)?updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b(c[a]),c):_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a]:b(c[a])}):c}const modify$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){a=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);if(1===a.length)return _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a[0]]:b(c[a[0]])});if(void 0===path$$module$node_modules$rambda$dist$rambda_mjs(a,c))return c;b=modifyPath$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,1),b,c[a[0]]);return b===c[a[0]]?c:assoc$$module$node_modules$rambda$dist$rambda_mjs(a[0],\nb,c)}const modifyPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs);function modulo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>modulo$$module$node_modules$rambda$dist$rambda_mjs(a,c):a%b}\nfunction moveFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(0>a||0>b)throw Error("Rambda.move does not support negative indexes");if(a>c.length-1||b>c.length-1)return c;const d=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);d[a]=c[b];d[b]=c[a];return d}const move$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(moveFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction multiply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>multiply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a*b}function negate$$module$node_modules$rambda$dist$rambda_mjs(a){return-a}function none$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>none$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(a(b[c]))return!1;return!0}\nfunction not$$module$node_modules$rambda$dist$rambda_mjs(a){return!a}function objOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>objOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):{[a]:b}}function of$$module$node_modules$rambda$dist$rambda_mjs(a){return[a]}\nfunction omit$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>omit$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(null!==b&&void 0!==b){var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={};for(const e in b)c.includes(e)||(d[e]=b[e]);return d}}\nfunction on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,d){return 3===arguments.length?e=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,e):2===arguments.length?(e,f)=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,e,f):a(b(c),b(d))}function onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b){let c;return function(){a&&(c=a.apply(b||this,arguments),a=null);return c}}\nfunction once$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length){const c=onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b);return curry$$module$node_modules$rambda$dist$rambda_mjs(c)}return onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function or$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>or$$module$node_modules$rambda$dist$rambda_mjs(a,c):a||b}const Identity$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(a))});\nfunction overFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(d=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(d)))(c).x}const over$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(overFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction partial$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=a.length;return(...d)=>b.length+d.length>=c?a(...b,...d):partial$$module$node_modules$rambda$dist$rambda_mjs(a,...[...b,...d])}function partialObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return c=>a(mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={},d={};Object.entries(b).forEach(([e,f])=>{a(f,e)?c[e]=f:d[e]=f});return[c,d]}function partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){const d=[],e=[];let f=-1;for(;f++<b.length-1;)(c?a(b[f],f):a(b[f]))?d.push(b[f]):e.push(b[f]);return[d,e]}\nfunction partition$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>partition$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction pathEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a,c),b)}const pathEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathEqFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction pathOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,path$$module$node_modules$rambda$dist$rambda_mjs(b,c))}const pathOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathOrFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction paths$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>paths$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.map(c=>path$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction pick$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pick$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)c[e]in b&&(d[c[e]]=b[c[e]]),e++;return d}}\nfunction pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)d[c[e]]=c[e]in b?b[c[e]]:void 0,e++;return d}}\nfunction pluck$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>pluck$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=[];map$$module$node_modules$rambda$dist$rambda_mjs(d=>{void 0!==d[a]&&c.push(d[a])},b);return c}function prepend$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>prepend$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof b?[a].concat(b.split("")):[a].concat(b)}\nconst product$$module$node_modules$rambda$dist$rambda_mjs=reduce$$module$node_modules$rambda$dist$rambda_mjs(multiply$$module$node_modules$rambda$dist$rambda_mjs,1);function propEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?equals$$module$node_modules$rambda$dist$rambda_mjs(b,prop$$module$node_modules$rambda$dist$rambda_mjs(a,c)):!1}const propEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propEqFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction propIsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return is$$module$node_modules$rambda$dist$rambda_mjs(a,c[b])}const propIs$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propIsFn$$module$node_modules$rambda$dist$rambda_mjs);function propOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c[b]):a}const propOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propOrFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction props$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>props$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error("propsToPick is not a list");return mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>b[c],a)}function propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(prop$$module$node_modules$rambda$dist$rambda_mjs(b,c))}\nconst propSatisfies$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction range$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>range$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(Number.isNaN(Number(a))||Number.isNaN(Number(b)))throw new TypeError("Both arguments to range must be numbers");if(b<a)return[];const c=b-a,d=Array(c);for(let e=0;e<c;e++)d[e]=a+e;return d}\nfunction reject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>reject$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!a(c),b)}function repeat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>repeat$$module$node_modules$rambda$dist$rambda_mjs(a,c):Array(b).fill(a)}function replaceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.replace(a,b)}\nconst replace$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(replaceFn$$module$node_modules$rambda$dist$rambda_mjs);function reverse$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.split("").reverse().join(""):a.slice().reverse()}function setFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return over$$module$node_modules$rambda$dist$rambda_mjs(a,always$$module$node_modules$rambda$dist$rambda_mjs(b),c)}\nconst set$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(setFn$$module$node_modules$rambda$dist$rambda_mjs);function sliceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.slice(a,b)}const slice$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(sliceFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction sort$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sort$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort(a)}function sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort((c,d)=>{c=a(c);d=a(d);return c===d?0:c<d?-1:1})}\nfunction split$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>split$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.split(a)}function maybe$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b=a&&"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(b)?b():b;c=a||"Function"!==type$$module$node_modules$rambda$dist$rambda_mjs(c)?c:c();return a?b:c}\nfunction take$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>take$$module$node_modules$rambda$dist$rambda_mjs(a,c):0>a?b.slice():"string"===typeof b?b.slice(0,a):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,0,a)}\nfunction splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!b)throw new TypeError(`Cannot read property \'slice\' of ${b}`);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b)&&"string"!==typeof b)return[[],[]];const c=maybe$$module$node_modules$rambda$dist$rambda_mjs(0>a,0>b.length+a?0:b.length+a,a);return[take$$module$node_modules$rambda$dist$rambda_mjs(c,b),drop$$module$node_modules$rambda$dist$rambda_mjs(c,\nb)]}function splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(1>a)throw Error("First argument to splitEvery must be a positive integer");const c=[];let d=0;for(;d<b.length;)c.push(b.slice(d,d+=a));return c}\nfunction splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(!b)throw new TypeError(`Cannot read property \'length\' of ${b}`);const c=[],d=[];let e=!1,f=-1;for(;f++<b.length-1;)e?d.push(b[f]):a(b[f])?(d.push(b[f]),e=!0):c.push(b[f]);return[c,d]}\nfunction startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.startsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;let c=!0;return a.filter((d,e)=>{if(!c)return!1;(d=equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]))||(c=!1);return d}).length===a.length}\nfunction subtract$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>subtract$$module$node_modules$rambda$dist$rambda_mjs(a,c):a-b}\nfunction symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,c):concat$$module$node_modules$rambda$dist$rambda_mjs(filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b),a),filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b))}\nfunction T$$module$node_modules$rambda$dist$rambda_mjs(){return!0}function tail$$module$node_modules$rambda$dist$rambda_mjs(a){return drop$$module$node_modules$rambda$dist$rambda_mjs(1,a)}\nfunction takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;if(0>a)return b.slice();let d=a>c?c:a;return"string"===typeof b?b.slice(c-d):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,c-d,c)}\nfunction takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(0===b.length)return b;let c=!1;const d=[];let e=b.length;for(;!c||0===e;)e--,!1===a(b[e])?c=!0:c||d.push(b[e]);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?d.reverse():d.reverse().join("")}\nfunction takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!0;const e=[];let f=-1;for(;f++<b.length-1;)a(b[f])?d&&e.push(b[f]):d&&(d=!1);return c?e:e.join("")}\nfunction tap$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>tap$$module$node_modules$rambda$dist$rambda_mjs(a,c);a(b);return b}function test$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>test$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof a)throw new TypeError(`\\u2018test\\u2019 requires a value of type RegExp as its first argument; received "${a}"`);return-1!==b.search(a)}\nfunction times$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>times$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||0>b)throw new RangeError("n must be an integer");return map$$module$node_modules$rambda$dist$rambda_mjs(a,range$$module$node_modules$rambda$dist$rambda_mjs(0,b))}function toLower$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toLowerCase()}\nfunction toPairs$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.entries(a)}function toString$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toString()}function toUpper$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toUpperCase()}function transpose$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>{c.forEach((d,e)=>isArray$$module$node_modules$rambda$dist$rambda_mjs(b[e])?b[e].push(d):b.push([d]));return b},[])}\nfunction trim$$module$node_modules$rambda$dist$rambda_mjs(a){return a.trim()}const isFunction$$module$node_modules$rambda$dist$rambda_mjs=a=>["Promise","Function"].includes(type$$module$node_modules$rambda$dist$rambda_mjs(a));\nfunction tryCatch$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isFunction$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`R.tryCatch | fn \'${a}\'`);const c=isFunction$$module$node_modules$rambda$dist$rambda_mjs(b);return(...d)=>{try{return a(...d)}catch(e){return c?b(e,...d):b}}}function unapply$$module$node_modules$rambda$dist$rambda_mjs(a){return function(...b){return a.call(this,b)}}\nfunction union$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>union$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(a);b.forEach(d=>{includes$$module$node_modules$rambda$dist$rambda_mjs(d,a)||c.push(d)});return c}\nfunction uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=new Set;return b.filter(d=>{if(c.has(a(d)))return!1;c.add(a(d));return!0})}function includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=!1,e=-1;for(;++e<c.length&&!d;)a(b,c[e])&&(d=!0);return d}\nfunction uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=-1;const d=[];for(;++c<b.length;){const e=b[c];includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,e,d)||d.push(e)}return d}function unless$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unless$$module$node_modules$rambda$dist$rambda_mjs(a,c):c=>a(c)?c:b(c)}\nfunction unwind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unwind$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b[a])?mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},b),{},{[a]:c}),b[a]):[b]}\nfunction values$$module$node_modules$rambda$dist$rambda_mjs(a){return"Object"!==type$$module$node_modules$rambda$dist$rambda_mjs(a)?[]:Object.values(a)}const Const$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Const$$module$node_modules$rambda$dist$rambda_mjs(a)});function view$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>view$$module$node_modules$rambda$dist$rambda_mjs(a,c):a(Const$$module$node_modules$rambda$dist$rambda_mjs)(b).x}\nfunction whenFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)?b(c):c}const when$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(whenFn$$module$node_modules$rambda$dist$rambda_mjs);function where$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return d=>where$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=!0;for(const d in a){if(!c)continue;const e=a[d](b[d]);c&&!1===e&&(c=!1)}return c}\nfunction whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return c=>whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(const c in a)if(a[c](b[c]))return!0;return!1}\nfunction whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=filter$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]),a);return Object.keys(c).length===Object.keys(a).length}\nfunction without$$module$node_modules$rambda$dist$rambda_mjs(a,b){return void 0===b?c=>without$$module$node_modules$rambda$dist$rambda_mjs(a,c):reduce$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,a)?c:c.concat(d),[],b)}function xor$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>xor$$module$node_modules$rambda$dist$rambda_mjs(a,c):!!a&&!b||!!b&&!a}\nfunction zip$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>zip$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=[],d=Math.min(a.length,b.length);for(let e=0;e<d;e++)c[e]=[a[e],b[e]];return c}function zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,c):take$$module$node_modules$rambda$dist$rambda_mjs(b.length,a).reduce((c,d,e)=>{c[d]=b[e];return c},{})}\nfunction zipWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return take$$module$node_modules$rambda$dist$rambda_mjs(b.length>c.length?c.length:b.length,b).map((d,e)=>a(d,c[e]))}const zipWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(zipWithFn$$module$node_modules$rambda$dist$rambda_mjs);var module$node_modules$rambda$dist$rambda_mjs={};module$node_modules$rambda$dist$rambda_mjs.F=F$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.T=T$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.__findHighestArity=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._arity=_arity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._indexOf=_indexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._lastIndexOf=_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs._pipe=_pipe$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.add=add$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.adjust=adjust$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.all=all$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.allPass=allPass$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.always=always$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.and=and$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.any=any$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.anyPass=anyPass$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.append=append$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.apply=apply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.applySpec=applySpec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assoc=assoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assocPath=assocPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.bind=bind$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.both=both$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.chain=chain$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clamp=clamp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clone=clone$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.complement=complement$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.compose=compose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.concat=concat$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.cond=cond$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.converge=converge$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.count=count$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.countBy=countBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curry=curry$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curryN=curryN$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dec=dec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.defaultTo=defaultTo$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.difference=difference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dissoc=dissoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.divide=divide$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.drop=drop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropLast=dropLast$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.dropLastWhile=dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeats=dropRepeats$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeatsWith=dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropWhile=dropWhile$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.either=either$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.endsWith=endsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.eqProps=eqProps$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.equals=equals$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolve=evolve$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.evolveArray=evolveArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolveObject=evolveObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filter=filter$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterArray=filterArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterObject=filterObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.find=find$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findIndex=findIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLast=findLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLastIndex=findLastIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.flatten=flatten$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.flip=flip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.forEach=forEach$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.fromPairs=fromPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupBy=groupBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupWith=groupWith$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.has=has$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.hasPath=hasPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.head=head$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identical=identical$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identity=identity$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.ifElse=ifElse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.inc=inc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.includes=includes$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexBy=indexBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexOf=indexOf$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.init=init$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersection=intersection$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersperse=intersperse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.is=is$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.isEmpty=isEmpty$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.isNil=isNil$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.join=join$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.juxt=juxt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.keys=keys$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.last=last$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.lastIndexOf=lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.length=length$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lens=lens$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensIndex=lensIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensPath=lensPath$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.lensProp=lensProp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.map=map$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapArray=mapArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObjIndexed=mapObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObject=mapObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.match=match$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mathMod=mathMod$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.max=max$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxBy=maxBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxByFn=maxByFn$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.mean=mean$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.median=median$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.merge=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeAll=mergeAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeDeepRight=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.mergeLeft=mergeLeft$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeRight=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeWith=mergeWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.min=min$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.minBy=minBy$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.minByFn=minByFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modify=modify$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPath=modifyPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPathFn=modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modulo=modulo$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.move=move$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.multiply=multiply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.negate=negate$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.none=none$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.not=not$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.nth=nth$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.objOf=objOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.of=of$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.omit=omit$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.on=on$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.once=once$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.or=or$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.over=over$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partial=partial$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partialObject=partialObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.partition=partition$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionArray=partitionArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionObject=partitionObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.path=path$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pathEq=pathEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.pathOr=pathOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.paths=paths$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pick=pick$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pickAll=pickAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pipe=pipe$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.pluck=pluck$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prepend=prepend$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.product=product$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prop=prop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propEq=propEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.propIs=propIs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propOr=propOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propSatisfies=propSatisfies$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.props=props$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.range=range$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.reduce=reduce$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceFn=reduceFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceStopper=reduceStopper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reject=reject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.repeat=repeat$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.replace=replace$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reverse=reverse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.set=set$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.slice=slice$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sort=sort$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.sortBy=sortBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.split=split$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitAt=splitAt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitEvery=splitEvery$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitWhen=splitWhen$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.startsWith=startsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.subtract=subtract$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sum=sum$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.symmetricDifference=symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tail=tail$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.take=take$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLast=takeLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLastWhile=takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeWhile=takeWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tap=tap$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.test=test$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.times=times$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toLower=toLower$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toPairs=toPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toString=toString$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.toUpper=toUpper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.transpose=transpose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.trim=trim$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tryCatch=tryCatch$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.type=type$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.unapply=unapply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.union=union$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniq=uniq$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqBy=uniqBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqWith=uniqWith$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.unless=unless$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.unwind=unwind$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.update=update$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.updateFn=updateFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.values=values$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.view=view$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.when=when$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.where=where$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereAny=whereAny$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereEq=whereEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.without=without$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.xor=xor$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zip=zip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipObj=zipObj$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipWith=zipWith$$module$node_modules$rambda$dist$rambda_mjs;const csoundSetMidiCallbacks$$module$src$modules$rtmidi=a=>b=>{a.exports.csoundSetMidiCallbacks(b)},csoundGetMIDIDevList$$module$src$modules$rtmidi=a=>(b,c)=>{const {buffer:d}=a.wasi.memory,e=a.exports.csoundGetMIDIDevList(b,void 0,c?1:0);if(0===e)return[];const f=sizeofStruct$$module$src$utils$native_sizes(CS_MIDIDEVICE$$module$src$structures),g=a.exports.allocCsMidiDeviceStruct(e);a.exports.csoundGetMIDIDevList(b,g,c?1:0);const h=new Uint8Array(d,g,f*e);b=range$$module$node_modules$rambda$dist$rambda_mjs(0,\ne).map(k=>structBufferToObject$$module$src$utils$structure_buffer_to_object(CS_MIDIDEVICE$$module$src$structures,h.subarray(k*f,f)));a.exports.freeCsMidiDeviceStruct(g);return b};csoundGetMIDIDevList$$module$src$modules$rtmidi.toString=()=>"getMIDIDevList = async (isOutput) => Object;";\nconst csoundGetRtMidiName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getRtMidiName(b);c=new Uint8Array(c,b,128);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetRtMidiName$$module$src$modules$rtmidi.toString=()=>"getRtMidiName = async () => String;";\nconst csoundGetMidiOutFileName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getMidiOutFileName(b);c=new Uint8Array(c,b,128);b&&0<b.length&&freeStringPtr$$module$src$utils$string_pointers(a,b);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""},_isRequestingRtMidiInput$$module$src$modules$rtmidi=a=>b=>a.exports.isRequestingRtMidiInput(b),csoundPushMidiMessage$$module$src$modules$rtmidi=a=>(b,c,d,e)=>{a.exports.pushMidiMessage(b,\nc,d,e)};csoundPushMidiMessage$$module$src$modules$rtmidi.toString=()=>"midiMessage = async (status, data1, data2) => undefined;";var module$src$modules$rtmidi={};module$src$modules$rtmidi._isRequestingRtMidiInput=_isRequestingRtMidiInput$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMIDIDevList=csoundGetMIDIDevList$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMidiOutFileName=csoundGetMidiOutFileName$$module$src$modules$rtmidi;\nmodule$src$modules$rtmidi.csoundGetRtMidiName=csoundGetRtMidiName$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundPushMidiMessage=csoundPushMidiMessage$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundSetMidiCallbacks=csoundSetMidiCallbacks$$module$src$modules$rtmidi;const csoundInputMessage$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessage(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessage$$module$src$modules$control_events.toString=()=>"inputMessage = async (scoreEvent) => Number;";\nconst csoundInputMessageAsync$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessageAsync(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessageAsync$$module$src$modules$control_events.toString=()=>"inputMessageAsync = async (scoreEvent) => Number;";\nconst csoundGetControlChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetControlChannelWasi(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundGetControlChannel$$module$src$modules$control_events.toString=()=>"getControlChannel = async (channelName) => Number;";\nconst csoundSetControlChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);a.exports.csoundSetControlChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c)};csoundSetControlChannel$$module$src$modules$control_events.toString=()=>"setControlChannel = async (channelName, value) => void;";\nconst csoundGetStringChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetStringChannelWasi(b,c);const d=ptr2string$$module$src$utils$string_pointers(a,b);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,b);return d};csoundGetStringChannel$$module$src$modules$control_events.toString=()=>"getStringChannel = async (channelName) => String;";\nconst csoundSetStringChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);a.exports.csoundSetStringChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d)};csoundSetStringChannel$$module$src$modules$control_events.toString=()=>"setStringChannel = async (channelName, value) => void;";var module$src$modules$control_events={};\nmodule$src$modules$control_events.csoundGetControlChannel=csoundGetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundGetStringChannel=csoundGetStringChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessage=csoundInputMessage$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessageAsync=csoundInputMessageAsync$$module$src$modules$control_events;\nmodule$src$modules$control_events.csoundSetControlChannel=csoundSetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundSetStringChannel=csoundSetStringChannel$$module$src$modules$control_events;const csoundGetOutputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetOutputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetOutputName$$module$src$modules$general_io.toString=()=>"getOutputName = async () => String;";\nconst csoundGetInputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetInputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetInputName$$module$src$modules$general_io.toString=()=>"getInputName = async (csound) => String;";var module$src$modules$general_io={};module$src$modules$general_io.csoundGetInputName=csoundGetInputName$$module$src$modules$general_io;\nmodule$src$modules$general_io.csoundGetOutputName=csoundGetOutputName$$module$src$modules$general_io;const csoundAppendEnv$$module$src$modules$extra=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);b=a.exports.csoundAppendEnv(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d);return b};csoundAppendEnv$$module$src$modules$extra.toString=()=>"appendEnv = async (csound, variable, value) => Number;";const csoundShouldDaemonize$$module$src$modules$extra=a=>b=>a.exports.csoundShouldDaemonize(b);\nvar module$src$modules$extra={};module$src$modules$extra.csoundAppendEnv=csoundAppendEnv$$module$src$modules$extra;module$src$modules$extra.csoundShouldDaemonize=csoundShouldDaemonize$$module$src$modules$extra;const csoundIsScorePending$$module$src$modules$score_handling=a=>b=>a.exports.csoundIsScorePending(b);csoundIsScorePending$$module$src$modules$score_handling.toString=()=>"isScorePending = async () => Number;";const csoundSetScorePending$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScorePending(b,c);csoundSetScorePending$$module$src$modules$score_handling.toString=()=>"setScorePending = async (pending) => Number;";\nconst csoundReadScore$$module$src$modules$score_handling=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundReadScore(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundReadScore$$module$src$modules$score_handling.toString=()=>"readScore = async (score) => Number;";const csoundGetScoreTime$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreTime(b);csoundGetScoreTime$$module$src$modules$score_handling.toString=()=>"getScoreTime = async () => Number;";\nconst csoundGetScoreOffsetSeconds$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreOffsetSeconds(b);csoundGetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"getScoreOffsetSeconds = async () => Number;";const csoundSetScoreOffsetSeconds$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScoreOffsetSeconds(b,c);csoundSetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"setScoreOffsetSeconds = async () => Number;";\nconst csoundRewindScore$$module$src$modules$score_handling=a=>b=>a.exports.csoundRewindScore(b);csoundRewindScore$$module$src$modules$score_handling.toString=()=>"rewindScore = async () => undefined;";var module$src$modules$score_handling={};module$src$modules$score_handling.csoundGetScoreOffsetSeconds=csoundGetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundGetScoreTime=csoundGetScoreTime$$module$src$modules$score_handling;\nmodule$src$modules$score_handling.csoundIsScorePending=csoundIsScorePending$$module$src$modules$score_handling;module$src$modules$score_handling.csoundReadScore=csoundReadScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundRewindScore=csoundRewindScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScoreOffsetSeconds=csoundSetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScorePending=csoundSetScorePending$$module$src$modules$score_handling;const csoundTableLength$$module$src$modules$table=a=>(b,c)=>a.exports.csoundTableLength(b,c);csoundTableLength$$module$src$modules$table.toString=()=>"tableLength = async (tableNum) => Number;";const csoundTableGet$$module$src$modules$table=a=>(b,c,d)=>a.exports.csoundTableGet(b,c,d);csoundTableGet$$module$src$modules$table.toString=()=>"tableGet = async (tableNum, tableIndex) => Number;";const csoundTableSet$$module$src$modules$table=a=>(b,c,d,e)=>a.exports.csoundTableSet(b,c,d,e);\ncsoundTableSet$$module$src$modules$table.toString=()=>"tableSet = async (tableNum, tableIndex, value) => undefined;";const csoundTableCopyIn$$module$src$modules$table=a=>(b,c,d)=>{const e=a.exports.allocFloatArray(d.length);(new Float64Array(a.wasi.memory.buffer,e,d.length)).set(d);a.exports.csoundTableCopyIn(b,c,e);a.exports.freeFloatArrayMem(e)};csoundTableCopyIn$$module$src$modules$table.toString=()=>"tableCopyIn = async (tableNum, float64Array) => undefined;";\nconst csoundTableCopyOut$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundTableLength(b,c);if(0<d){const e=a.exports.allocFloatArray(d);a.exports.csoundTableCopyOut(b,c,e);({buffer:b}=a.wasi.memory);d=new Float64Array(b,e,d);a.exports.freeFloatArrayMem(e);return Float64Array.from(d)}};csoundTableCopyOut$$module$src$modules$table.toString=()=>"tableCopyOut = async (tableNum) => ?Float64Array;";const csoundGetTable$$module$src$modules$table=csoundTableCopyOut$$module$src$modules$table;\ncsoundTableCopyOut$$module$src$modules$table.toString=csoundTableCopyOut$$module$src$modules$table.toString;const csoundGetTableArgs$$module$src$modules$table=a=>(b,c)=>{const d=a.exports.allocFloatArray(1024);a.exports.csoundGetTableArgs(b,d,c);({buffer:b}=a.wasi.memory);b=new Float64Array(b,d,1024);a.exports.freeFloatArrayMem(d);return b};csoundGetTableArgs$$module$src$modules$table.toString=()=>"getTableArgs = async (tableNum) => ?Float64Array;";\nconst csoundIsNamedGEN$$module$src$modules$table=a=>(b,c)=>a.exports.csoundIsNamedGEN(b,c);csoundIsNamedGEN$$module$src$modules$table.toString=()=>"isNamedGEN = async (tableNum) => number;";const csoundGetNamedGEN$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundIsNamedGEN(b,c);if(0<d){const e=a.exports.allocStringMem(d);a.exports.csoundGetNamedGEN(b,e,c,d);({buffer:b}=a.wasi.memory);d=new Uint8Array(b,e,d);return uint2String$$module$src$utils$text_encoders(d)}};\ncsoundGetNamedGEN$$module$src$modules$table.toString=()=>"getNamedGEN = async (tableNum) => ?string;";var module$src$modules$table={};module$src$modules$table.csoundGetNamedGEN=csoundGetNamedGEN$$module$src$modules$table;module$src$modules$table.csoundGetTable=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundGetTableArgs=csoundGetTableArgs$$module$src$modules$table;module$src$modules$table.csoundIsNamedGEN=csoundIsNamedGEN$$module$src$modules$table;\nmodule$src$modules$table.csoundTableCopyIn=csoundTableCopyIn$$module$src$modules$table;module$src$modules$table.csoundTableCopyOut=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundTableGet=csoundTableGet$$module$src$modules$table;module$src$modules$table.csoundTableLength=csoundTableLength$$module$src$modules$table;module$src$modules$table.csoundTableSet=csoundTableSet$$module$src$modules$table;function writeFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.writeFile(c,b)}}writeFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";function appendFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.appendFile(c,b)}}appendFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";\nfunction readFile$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readFile(c)}readFile$$module$src$filesystem$worker_fs.toString=()=>"async (path) => ?Uint8Array";function unlink$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.unlink(c)}unlink$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";function readdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readdir(c)}readdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => string[]";\nfunction mkdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.mkdir(c)}mkdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";var module$src$filesystem$worker_fs={};module$src$filesystem$worker_fs.appendFile=appendFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.mkdir=mkdir$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readFile=readFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readdir=readdir$$module$src$filesystem$worker_fs;\nmodule$src$filesystem$worker_fs.unlink=unlink$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.writeFile=writeFile$$module$src$filesystem$worker_fs;const api$$module$src$libcsound={csoundCreate:csoundCreate$$module$src$modules$instantiation,csoundDestroy:csoundDestroy$$module$src$modules$instantiation,csoundGetAPIVersion:csoundGetAPIVersion$$module$src$modules$instantiation,csoundGetVersion:csoundGetVersion$$module$src$modules$instantiation,csoundInitialize:csoundInitialize$$module$src$modules$instantiation,csoundParseOrc:csoundParseOrc$$module$src$modules$performance,csoundCompileTree:csoundCompileTree$$module$src$modules$performance,csoundCompileOrc:csoundCompileOrc$$module$src$modules$performance,\ncsoundEvalCode:csoundEvalCode$$module$src$modules$performance,csoundStart:csoundStart$$module$src$modules$performance,csoundCompileCsd:csoundCompileCsd$$module$src$modules$performance,csoundCompileCsdText:csoundCompileCsdText$$module$src$modules$performance,csoundPerform:csoundPerform$$module$src$modules$performance,csoundPerformKsmps:csoundPerformKsmps$$module$src$modules$performance,csoundPerformBuffer:csoundPerformBuffer$$module$src$modules$performance,csoundStop:csoundStop$$module$src$modules$performance,\ncsoundCleanup:csoundCleanup$$module$src$modules$performance,csoundReset:csoundReset$$module$src$modules$performance,csoundGetSr:csoundGetSr$$module$src$modules$attributes,csoundGetKr:csoundGetKr$$module$src$modules$attributes,csoundGetKsmps:csoundGetKsmps$$module$src$modules$attributes,csoundGetNchnls:csoundGetNchnls$$module$src$modules$attributes,csoundGetNchnlsInput:csoundGetNchnlsInput$$module$src$modules$attributes,csoundGet0dBFS:csoundGet0dBFS$$module$src$modules$attributes,csoundGetA4:csoundGetA4$$module$src$modules$attributes,\ncsoundGetCurrentTimeSamples:csoundGetCurrentTimeSamples$$module$src$modules$attributes,csoundGetSizeOfMYFLT:csoundGetSizeOfMYFLT$$module$src$modules$attributes,csoundSetOption:csoundSetOption$$module$src$modules$attributes,csoundSetParams:csoundSetParams$$module$src$modules$attributes,csoundGetParams:csoundGetParams$$module$src$modules$attributes,csoundGetDebug:csoundGetDebug$$module$src$modules$attributes,csoundSetDebug:csoundSetDebug$$module$src$modules$attributes,csoundGetInputBufferSize:csoundGetInputBufferSize$$module$src$modules$rtaudio,\ncsoundGetOutputBufferSize:csoundGetOutputBufferSize$$module$src$modules$rtaudio,csoundGetInputBuffer:csoundGetInputBuffer$$module$src$modules$rtaudio,csoundGetOutputBuffer:csoundGetOutputBuffer$$module$src$modules$rtaudio,csoundGetSpin:csoundGetSpin$$module$src$modules$rtaudio,csoundGetSpout:csoundGetSpout$$module$src$modules$rtaudio,csoundGetMIDIDevList:csoundGetMIDIDevList$$module$src$modules$rtmidi,csoundSetMidiCallbacks:csoundSetMidiCallbacks$$module$src$modules$rtmidi,csoundGetRtMidiName:csoundGetRtMidiName$$module$src$modules$rtmidi,\ncsoundGetMidiOutFileName:csoundGetMidiOutFileName$$module$src$modules$rtmidi,csoundPushMidiMessage:csoundPushMidiMessage$$module$src$modules$rtmidi,_isRequestingRtMidiInput:_isRequestingRtMidiInput$$module$src$modules$rtmidi,csoundInputMessage:csoundInputMessage$$module$src$modules$control_events,csoundInputMessageAsync:csoundInputMessageAsync$$module$src$modules$control_events,csoundGetControlChannel:csoundGetControlChannel$$module$src$modules$control_events,csoundSetControlChannel:csoundSetControlChannel$$module$src$modules$control_events,\ncsoundGetStringChannel:csoundGetStringChannel$$module$src$modules$control_events,csoundSetStringChannel:csoundSetStringChannel$$module$src$modules$control_events,csoundGetInputName:csoundGetInputName$$module$src$modules$general_io,csoundGetOutputName:csoundGetOutputName$$module$src$modules$general_io,csoundAppendEnv:csoundAppendEnv$$module$src$modules$extra,csoundShouldDaemonize:csoundShouldDaemonize$$module$src$modules$extra,csoundIsScorePending:csoundIsScorePending$$module$src$modules$score_handling,\ncsoundSetScorePending:csoundSetScorePending$$module$src$modules$score_handling,csoundReadScore:csoundReadScore$$module$src$modules$score_handling,csoundGetScoreTime:csoundGetScoreTime$$module$src$modules$score_handling,csoundGetScoreOffsetSeconds:csoundGetScoreOffsetSeconds$$module$src$modules$score_handling,csoundSetScoreOffsetSeconds:csoundSetScoreOffsetSeconds$$module$src$modules$score_handling,csoundRewindScore:csoundRewindScore$$module$src$modules$score_handling,csoundTableLength:csoundTableLength$$module$src$modules$table,\ncsoundTableGet:csoundTableGet$$module$src$modules$table,csoundTableSet:csoundTableSet$$module$src$modules$table,csoundTableCopyIn:csoundTableCopyIn$$module$src$modules$table,csoundTableCopyOut:csoundTableCopyOut$$module$src$modules$table,csoundGetTable:csoundTableCopyOut$$module$src$modules$table,csoundGetTableArgs:csoundGetTableArgs$$module$src$modules$table,csoundIsNamedGEN:csoundIsNamedGEN$$module$src$modules$table,csoundGetNamedGEN:csoundGetNamedGEN$$module$src$modules$table,fs:module$src$filesystem$worker_fs};\nvar $jscompDefaultExport$$module$src$libcsound=function(a){return mergeAll$$module$node_modules$rambda$dist$rambda_mjs([reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,api$$module$src$libcsound[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(dissoc$$module$node_modules$rambda$dist$rambda_mjs("fs")(api$$module$src$libcsound))),reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,\napi$$module$src$libcsound.fs[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(module$src$filesystem$worker_fs))])},module$src$libcsound={};module$src$libcsound.api=api$$module$src$libcsound;module$src$libcsound.default=$jscompDefaultExport$$module$src$libcsound;const dlinit$$module$src$dlinit=(a,b,c,d)=>{if(b.exports.csoundModuleInit){var e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=new WebAssembly.Global({value:"i32",mutable:!0},0);const h=new WebAssembly.Global({value:"i32",mutable:!0},0);let k=c.length;"function"===typeof b.exports.csoundModuleCreate&&(c.grow(1),e.value=k,c.set(k,b.exports.csoundModuleCreate),k+=1);"function"===typeof b.exports.csoundModuleInit&&(c.grow(1),f.value=k,c.set(k,\nb.exports.csoundModuleInit),k+=1);"function"===typeof b.exports.csoundModuleDestroy&&(c.grow(1),g.value=k,c.set(k,b.exports.csoundModuleDestroy),k+=1);"function"===typeof b.exports.csoundModuleErrorCodeToString&&(c.grow(1),h.value=k,c.set(k,b.exports.csoundModuleErrorCodeToString));a.exports.csoundWasiLoadPlugin(d,e,f,g,h)}else b.exports.csound_opcode_init||b.exports.csound_fgen_init?(e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=c.length,\n"function"===typeof b.exports.csound_opcode_init&&(e.value=g,c.grow(1),c.set(g,b.exports.csound_opcode_init),g+=1),"function"===typeof b.exports.csound_fgen_init&&(f.value=g,c.grow(1),c.set(g,b.exports.csound_fgen_init)),a.exports.csoundWasiLoadOpcodeLibrary(d,f,e)):console.error("Plugin doesn\'t export nececcary functions to quality as csound plugin.")};var module$src$dlinit={};module$src$dlinit.dlinit=dlinit$$module$src$dlinit;void 0!==goog.global&&(goog.global={});goog.global.BigInt||(goog.global.BigInt=void 0===BigInt?Number:BigInt);\nconst WASI_ESUCCESS$$module$src$filesystem$constants=0,WASI_E2BIG$$module$src$filesystem$constants=1,WASI_EACCES$$module$src$filesystem$constants=2,WASI_EADDRINUSE$$module$src$filesystem$constants=3,WASI_EADDRNOTAVAIL$$module$src$filesystem$constants=4,WASI_EAFNOSUPPORT$$module$src$filesystem$constants=5,WASI_EAGAIN$$module$src$filesystem$constants=6,WASI_EALREADY$$module$src$filesystem$constants=7,WASI_EBADF$$module$src$filesystem$constants=8,WASI_EBADMSG$$module$src$filesystem$constants=9,WASI_EBUSY$$module$src$filesystem$constants=\n10,WASI_ECANCELED$$module$src$filesystem$constants=11,WASI_ECHILD$$module$src$filesystem$constants=12,WASI_ECONNABORTED$$module$src$filesystem$constants=13,WASI_ECONNREFUSED$$module$src$filesystem$constants=14,WASI_ECONNRESET$$module$src$filesystem$constants=15,WASI_EDEADLK$$module$src$filesystem$constants=16,WASI_EDESTADDRREQ$$module$src$filesystem$constants=17,WASI_EDOM$$module$src$filesystem$constants=18,WASI_EDQUOT$$module$src$filesystem$constants=19,WASI_EEXIST$$module$src$filesystem$constants=\n20,WASI_EFAULT$$module$src$filesystem$constants=21,WASI_EFBIG$$module$src$filesystem$constants=22,WASI_EHOSTUNREACH$$module$src$filesystem$constants=23,WASI_EIDRM$$module$src$filesystem$constants=24,WASI_EILSEQ$$module$src$filesystem$constants=25,WASI_EINPROGRESS$$module$src$filesystem$constants=26,WASI_EINTR$$module$src$filesystem$constants=27,WASI_EINVAL$$module$src$filesystem$constants=28,WASI_EIO$$module$src$filesystem$constants=29,WASI_EISCONN$$module$src$filesystem$constants=30,WASI_EISDIR$$module$src$filesystem$constants=\n31,WASI_ELOOP$$module$src$filesystem$constants=32,WASI_EMFILE$$module$src$filesystem$constants=33,WASI_EMLINK$$module$src$filesystem$constants=34,WASI_EMSGSIZE$$module$src$filesystem$constants=35,WASI_EMULTIHOP$$module$src$filesystem$constants=36,WASI_ENAMETOOLONG$$module$src$filesystem$constants=37,WASI_ENETDOWN$$module$src$filesystem$constants=38,WASI_ENETRESET$$module$src$filesystem$constants=39,WASI_ENETUNREACH$$module$src$filesystem$constants=40,WASI_ENFILE$$module$src$filesystem$constants=41,\nWASI_ENOBUFS$$module$src$filesystem$constants=42,WASI_ENODEV$$module$src$filesystem$constants=43,WASI_ENOENT$$module$src$filesystem$constants=44,WASI_ENOEXEC$$module$src$filesystem$constants=45,WASI_ENOLCK$$module$src$filesystem$constants=46,WASI_ENOLINK$$module$src$filesystem$constants=47,WASI_ENOMEM$$module$src$filesystem$constants=48,WASI_ENOMSG$$module$src$filesystem$constants=49,WASI_ENOPROTOOPT$$module$src$filesystem$constants=50,WASI_ENOSPC$$module$src$filesystem$constants=51,WASI_ENOSYS$$module$src$filesystem$constants=\n52,WASI_ENOTCONN$$module$src$filesystem$constants=53,WASI_ENOTDIR$$module$src$filesystem$constants=54,WASI_ENOTEMPTY$$module$src$filesystem$constants=55,WASI_ENOTRECOVERABLE$$module$src$filesystem$constants=56,WASI_ENOTSOCK$$module$src$filesystem$constants=57,WASI_ENOTSUP$$module$src$filesystem$constants=58,WASI_ENOTTY$$module$src$filesystem$constants=59,WASI_ENXIO$$module$src$filesystem$constants=60,WASI_EOVERFLOW$$module$src$filesystem$constants=61,WASI_EOWNERDEAD$$module$src$filesystem$constants=\n62,WASI_EPERM$$module$src$filesystem$constants=63,WASI_EPIPE$$module$src$filesystem$constants=64,WASI_EPROTO$$module$src$filesystem$constants=65,WASI_EPROTONOSUPPORT$$module$src$filesystem$constants=66,WASI_EPROTOTYPE$$module$src$filesystem$constants=67,WASI_ERANGE$$module$src$filesystem$constants=68,WASI_EROFS$$module$src$filesystem$constants=69,WASI_ESPIPE$$module$src$filesystem$constants=70,WASI_ESRCH$$module$src$filesystem$constants=71,WASI_ESTALE$$module$src$filesystem$constants=72,WASI_ETIMEDOUT$$module$src$filesystem$constants=\n73,WASI_ETXTBSY$$module$src$filesystem$constants=74,WASI_EXDEV$$module$src$filesystem$constants=75,WASI_ENOTCAPABLE$$module$src$filesystem$constants=76,WASI_SIGABRT$$module$src$filesystem$constants=0,WASI_SIGALRM$$module$src$filesystem$constants=1,WASI_SIGBUS$$module$src$filesystem$constants=2,WASI_SIGCHLD$$module$src$filesystem$constants=3,WASI_SIGCONT$$module$src$filesystem$constants=4,WASI_SIGFPE$$module$src$filesystem$constants=5,WASI_SIGHUP$$module$src$filesystem$constants=6,WASI_SIGILL$$module$src$filesystem$constants=\n7,WASI_SIGINT$$module$src$filesystem$constants=8,WASI_SIGKILL$$module$src$filesystem$constants=9,WASI_SIGPIPE$$module$src$filesystem$constants=10,WASI_SIGQUIT$$module$src$filesystem$constants=11,WASI_SIGSEGV$$module$src$filesystem$constants=12,WASI_SIGSTOP$$module$src$filesystem$constants=13,WASI_SIGTERM$$module$src$filesystem$constants=14,WASI_SIGTRAP$$module$src$filesystem$constants=15,WASI_SIGTSTP$$module$src$filesystem$constants=16,WASI_SIGTTIN$$module$src$filesystem$constants=17,WASI_SIGTTOU$$module$src$filesystem$constants=\n18,WASI_SIGURG$$module$src$filesystem$constants=19,WASI_SIGUSR1$$module$src$filesystem$constants=20,WASI_SIGUSR2$$module$src$filesystem$constants=21,WASI_SIGVTALRM$$module$src$filesystem$constants=22,WASI_SIGXCPU$$module$src$filesystem$constants=23,WASI_SIGXFSZ$$module$src$filesystem$constants=24,WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants=0,WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants=1,WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants=2,WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants=\n3,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants=4,WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants=5,WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants=6,WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants=7,WASI_FDFLAG_APPEND$$module$src$filesystem$constants=1,WASI_FDFLAG_DSYNC$$module$src$filesystem$constants=2,WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants=4,WASI_FDFLAG_RSYNC$$module$src$filesystem$constants=8,WASI_FDFLAG_SYNC$$module$src$filesystem$constants=\n16,WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants=goog.global.BigInt(1),WASI_RIGHT_FD_READ$$module$src$filesystem$constants=goog.global.BigInt(2),WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants=goog.global.BigInt(4),WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants=goog.global.BigInt(8),WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants=goog.global.BigInt(16),WASI_RIGHT_FD_TELL$$module$src$filesystem$constants=goog.global.BigInt(32),WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants=\ngoog.global.BigInt(64),WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants=goog.global.BigInt(128),WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants=goog.global.BigInt(256),WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(512),WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants=goog.global.BigInt(1024),WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(2048),WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants=\ngoog.global.BigInt(4096),WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants=goog.global.BigInt(8192),WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants=goog.global.BigInt(16384),WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants=goog.global.BigInt(32768),WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(65536),WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants=goog.global.BigInt(131072),WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants=\ngoog.global.BigInt(262144),WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(524288),WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(1048576),WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants=goog.global.BigInt(2097152),WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(4194304),WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(8388608),WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants=\ngoog.global.BigInt(16777216),WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(33554432),WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants=goog.global.BigInt(67108864),WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants=goog.global.BigInt(134217728),WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants=goog.global.BigInt(268435456),RIGHTS_ALL$$module$src$filesystem$constants=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|\nWASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|\nWASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants=\nWASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|\nWASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|\nWASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|\nWASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants|RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants,RIGHTS_SOCKET_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|\nWASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_SOCKET_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_TTY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,\nRIGHTS_TTY_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),WASI_CLOCK_REALTIME$$module$src$filesystem$constants=0,WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants=1,WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants=2,WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants=3,WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants=0,WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants=1,WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants=\n1,WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants=4,WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants=8,WASI_O_CREAT$$module$src$filesystem$constants=1,WASI_O_DIRECTORY$$module$src$filesystem$constants=2,WASI_O_EXCL$$module$src$filesystem$constants=4,WASI_O_TRUNC$$module$src$filesystem$constants=8,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants=0,WASI_DIRCOOKIE_START$$module$src$filesystem$constants=0,WASI_STDIN_FILENO$$module$src$filesystem$constants=\n0,WASI_STDOUT_FILENO$$module$src$filesystem$constants=1,WASI_STDERR_FILENO$$module$src$filesystem$constants=2,WASI_WHENCE_SET$$module$src$filesystem$constants=0,WASI_WHENCE_CUR$$module$src$filesystem$constants=1,WASI_WHENCE_END$$module$src$filesystem$constants=2;var module$src$filesystem$constants={};module$src$filesystem$constants.RIGHTS_ALL=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_BASE=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_INHERITING=RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.RIGHTS_REGULAR_FILE_BASE=RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_REGULAR_FILE_INHERITING=RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_BASE=RIGHTS_SOCKET_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_TTY_BASE=RIGHTS_TTY_BASE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.RIGHTS_TTY_INHERITING=RIGHTS_TTY_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_MONOTONIC=WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_PROCESS_CPUTIME_ID=WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_REALTIME=WASI_CLOCK_REALTIME$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_CLOCK_THREAD_CPUTIME_ID=WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_DIRCOOKIE_START=WASI_DIRCOOKIE_START$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_E2BIG=WASI_E2BIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EACCES=WASI_EACCES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EADDRINUSE=WASI_EADDRINUSE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EADDRNOTAVAIL=WASI_EADDRNOTAVAIL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAFNOSUPPORT=WASI_EAFNOSUPPORT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAGAIN=WASI_EAGAIN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EALREADY=WASI_EALREADY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBADF=WASI_EBADF$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EBADMSG=WASI_EBADMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBUSY=WASI_EBUSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECANCELED=WASI_ECANCELED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECHILD=WASI_ECHILD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNABORTED=WASI_ECONNABORTED$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ECONNREFUSED=WASI_ECONNREFUSED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNRESET=WASI_ECONNRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDEADLK=WASI_EDEADLK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDESTADDRREQ=WASI_EDESTADDRREQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDOM=WASI_EDOM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EDQUOT=WASI_EDQUOT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EEXIST=WASI_EEXIST$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFAULT=WASI_EFAULT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFBIG=WASI_EFBIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EHOSTUNREACH=WASI_EHOSTUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIDRM=WASI_EIDRM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EILSEQ=WASI_EILSEQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINPROGRESS=WASI_EINPROGRESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINTR=WASI_EINTR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINVAL=WASI_EINVAL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIO=WASI_EIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EISCONN=WASI_EISCONN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EISDIR=WASI_EISDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ELOOP=WASI_ELOOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMFILE=WASI_EMFILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMLINK=WASI_EMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMSGSIZE=WASI_EMSGSIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMULTIHOP=WASI_EMULTIHOP$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENAMETOOLONG=WASI_ENAMETOOLONG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETDOWN=WASI_ENETDOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETRESET=WASI_ENETRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETUNREACH=WASI_ENETUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENFILE=WASI_ENFILE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOBUFS=WASI_ENOBUFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENODEV=WASI_ENODEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOENT=WASI_ENOENT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOEXEC=WASI_ENOEXEC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLCK=WASI_ENOLCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLINK=WASI_ENOLINK$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOMEM=WASI_ENOMEM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOMSG=WASI_ENOMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOPROTOOPT=WASI_ENOPROTOOPT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSPC=WASI_ENOSPC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSYS=WASI_ENOSYS$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOTCAPABLE=WASI_ENOTCAPABLE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTCONN=WASI_ENOTCONN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTDIR=WASI_ENOTDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTEMPTY=WASI_ENOTEMPTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTRECOVERABLE=WASI_ENOTRECOVERABLE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ENOTSOCK=WASI_ENOTSOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTSUP=WASI_ENOTSUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTTY=WASI_ENOTTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENXIO=WASI_ENXIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EOVERFLOW=WASI_EOVERFLOW$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EOWNERDEAD=WASI_EOWNERDEAD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPERM=WASI_EPERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPIPE=WASI_EPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTO=WASI_EPROTO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTONOSUPPORT=WASI_EPROTONOSUPPORT$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EPROTOTYPE=WASI_EPROTOTYPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ERANGE=WASI_ERANGE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EROFS=WASI_EROFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESPIPE=WASI_ESPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESRCH=WASI_ESRCH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESTALE=WASI_ESTALE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_ESUCCESS=WASI_ESUCCESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETIMEDOUT=WASI_ETIMEDOUT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETXTBSY=WASI_ETXTBSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_CLOCK=WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_FD_READ=WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_EVENTTYPE_FD_WRITE=WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EXDEV=WASI_EXDEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_APPEND=WASI_FDFLAG_APPEND$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_DSYNC=WASI_FDFLAG_DSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_NONBLOCK=WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FDFLAG_RSYNC=WASI_FDFLAG_RSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_SYNC=WASI_FDFLAG_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM=WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM_NOW=WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_MTIM=WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FILESTAT_SET_MTIM_NOW=WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_BLOCK_DEVICE=WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_CHARACTER_DEVICE=WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_DIRECTORY=WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FILETYPE_REGULAR_FILE=WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_DGRAM=WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_STREAM=WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SYMBOLIC_LINK=WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_FILETYPE_UNKNOWN=WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_CREAT=WASI_O_CREAT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_DIRECTORY=WASI_O_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_EXCL=WASI_O_EXCL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_TRUNC=WASI_O_TRUNC$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_PREOPENTYPE_DIR=WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ADVISE=WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ALLOCATE=WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_DATASYNC=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FDSTAT_SET_FLAGS=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_GET=WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_SIZE=WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_TIMES=WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_READ=WASI_RIGHT_FD_READ$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_FD_READDIR=WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SEEK=WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SYNC=WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_TELL=WASI_RIGHT_FD_TELL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_WRITE=WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_DIRECTORY=WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_FILE=WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_GET=WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_SIZE=WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_TIMES=WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_SOURCE=WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_TARGET=WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_OPEN=WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_READLINK=WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_REMOVE_DIRECTORY=WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_SOURCE=WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_TARGET=WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_RIGHT_PATH_SYMLINK=WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_UNLINK_FILE=WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_POLL_FD_READWRITE=WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_SOCK_SHUTDOWN=WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGABRT=WASI_SIGABRT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGALRM=WASI_SIGALRM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGBUS=WASI_SIGBUS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCHLD=WASI_SIGCHLD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCONT=WASI_SIGCONT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGFPE=WASI_SIGFPE$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGHUP=WASI_SIGHUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGILL=WASI_SIGILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGINT=WASI_SIGINT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGKILL=WASI_SIGKILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGPIPE=WASI_SIGPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGQUIT=WASI_SIGQUIT$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGSEGV=WASI_SIGSEGV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGSTOP=WASI_SIGSTOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTERM=WASI_SIGTERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTRAP=WASI_SIGTRAP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTSTP=WASI_SIGTSTP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTTIN=WASI_SIGTTIN$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGTTOU=WASI_SIGTTOU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGURG=WASI_SIGURG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR1=WASI_SIGUSR1$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR2=WASI_SIGUSR2$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGVTALRM=WASI_SIGVTALRM$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_SIGXCPU=WASI_SIGXCPU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGXFSZ=WASI_SIGXFSZ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDERR_FILENO=WASI_STDERR_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDIN_FILENO=WASI_STDIN_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDOUT_FILENO=WASI_STDOUT_FILENO$$module$src$filesystem$constants;\nmodule$src$filesystem$constants.WASI_WHENCE_CUR=WASI_WHENCE_CUR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_END=WASI_WHENCE_END$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_SET=WASI_WHENCE_SET$$module$src$filesystem$constants;goog.debug={};function module$contents$goog$debug$Error_DebugError(a,b){if(Error.captureStackTrace)Error.captureStackTrace(this,module$contents$goog$debug$Error_DebugError);else{const c=Error().stack;c&&(this.stack=c)}a&&(this.message=String(a));void 0!==b&&(this.cause=b);this.reportErrorToServer=!0}goog.inherits(module$contents$goog$debug$Error_DebugError,Error);module$contents$goog$debug$Error_DebugError.prototype.name="CustomError";goog.debug.Error=module$contents$goog$debug$Error_DebugError;goog.dom={};goog.dom.NodeType={ELEMENT:1,ATTRIBUTE:2,TEXT:3,CDATA_SECTION:4,ENTITY_REFERENCE:5,ENTITY:6,PROCESSING_INSTRUCTION:7,COMMENT:8,DOCUMENT:9,DOCUMENT_TYPE:10,DOCUMENT_FRAGMENT:11,NOTATION:12};goog.asserts={};goog.asserts.ENABLE_ASSERTS=goog.DEBUG;function module$contents$goog$asserts_AssertionError(a,b){module$contents$goog$debug$Error_DebugError.call(this,module$contents$goog$asserts_subs(a,b));this.messagePattern=a}goog.inherits(module$contents$goog$asserts_AssertionError,module$contents$goog$debug$Error_DebugError);goog.asserts.AssertionError=module$contents$goog$asserts_AssertionError;module$contents$goog$asserts_AssertionError.prototype.name="AssertionError";\ngoog.asserts.DEFAULT_ERROR_HANDLER=function(a){throw a;};let module$contents$goog$asserts_errorHandler_=goog.asserts.DEFAULT_ERROR_HANDLER;function module$contents$goog$asserts_subs(a,b){a=a.split("%s");let c="";const d=a.length-1;for(let e=0;e<d;e++)c+=a[e]+(e<b.length?b[e]:"%s");return c+a[d]}\nfunction module$contents$goog$asserts_doAssertFailure(a,b,c,d){let e="Assertion failed",f;c?(e+=": "+c,f=d):a&&(e+=": "+a,f=b);a=new module$contents$goog$asserts_AssertionError(""+e,f||[]);module$contents$goog$asserts_errorHandler_(a)}goog.asserts.setErrorHandler=function(a){goog.asserts.ENABLE_ASSERTS&&(module$contents$goog$asserts_errorHandler_=a)};\ngoog.asserts.assert=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!a&&module$contents$goog$asserts_doAssertFailure("",null,b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertExists=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&null==a&&module$contents$goog$asserts_doAssertFailure("Expected to exist: %s.",[a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.fail=function(a,b){goog.asserts.ENABLE_ASSERTS&&module$contents$goog$asserts_errorHandler_(new module$contents$goog$asserts_AssertionError("Failure"+(a?": "+a:""),Array.prototype.slice.call(arguments,1)))};goog.asserts.assertNumber=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"number"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected number but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertString=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"string"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected string but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertFunction=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"function"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected function but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertObject=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isObject(a)&&module$contents$goog$asserts_doAssertFailure("Expected object but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertArray=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!Array.isArray(a)&&module$contents$goog$asserts_doAssertFailure("Expected array but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertBoolean=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"boolean"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected boolean but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertElement=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT||module$contents$goog$asserts_doAssertFailure("Expected Element but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};\ngoog.asserts.assertInstanceof=function(a,b,c,d){!goog.asserts.ENABLE_ASSERTS||a instanceof b||module$contents$goog$asserts_doAssertFailure("Expected instanceof %s but got %s.",[module$contents$goog$asserts_getType(b),module$contents$goog$asserts_getType(a)],c,Array.prototype.slice.call(arguments,3));return a};\ngoog.asserts.assertFinite=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||"number"==typeof a&&isFinite(a)||module$contents$goog$asserts_doAssertFailure("Expected %s to be a finite number but it is not.",[a],b,Array.prototype.slice.call(arguments,2));return a};\nfunction module$contents$goog$asserts_getType(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.array={};goog.NATIVE_ARRAY_PROTOTYPES=goog.TRUSTED_SITE;const module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS=2012<goog.FEATURESET_YEAR;goog.array.ASSUME_NATIVE_FUNCTIONS=module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS;function module$contents$goog$array_peek(a){return a[a.length-1]}goog.array.peek=module$contents$goog$array_peek;goog.array.last=module$contents$goog$array_peek;\nconst module$contents$goog$array_indexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.indexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.indexOf(b,c);for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1};goog.array.indexOf=module$contents$goog$array_indexOf;\nconst module$contents$goog$array_lastIndexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.lastIndexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.lastIndexOf.call(a,b,null==c?a.length-1:c)}:function(a,b,c){c=null==c?a.length-1:c;0>c&&(c=Math.max(0,a.length+c));if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.lastIndexOf(b,c);for(;0<=c;c--)if(c in a&&a[c]===b)return c;return-1};\ngoog.array.lastIndexOf=module$contents$goog$array_lastIndexOf;const module$contents$goog$array_forEach=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.forEach)?function(a,b,c){goog.asserts.assert(null!=a.length);Array.prototype.forEach.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)};goog.array.forEach=module$contents$goog$array_forEach;\nfunction module$contents$goog$array_forEachRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;--d)d in e&&b.call(c,e[d],d,a)}goog.array.forEachRight=module$contents$goog$array_forEachRight;\nconst module$contents$goog$array_filter=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.filter)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.filter.call(a,b,c)}:function(a,b,c){const d=a.length,e=[];let f=0;const g="string"===typeof a?a.split(""):a;for(let h=0;h<d;h++)if(h in g){const k=g[h];b.call(c,k,h,a)&&(e[f++]=k)}return e};goog.array.filter=module$contents$goog$array_filter;\nconst module$contents$goog$array_map=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.map)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.map.call(a,b,c)}:function(a,b,c){const d=a.length,e=Array(d),f="string"===typeof a?a.split(""):a;for(let g=0;g<d;g++)g in f&&(e[g]=b.call(c,f[g],g,a));return e};goog.array.map=module$contents$goog$array_map;\nconst module$contents$goog$array_reduce=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduce)?function(a,b,c,d){goog.asserts.assert(null!=a.length);d&&(b=goog.bind(b,d));return Array.prototype.reduce.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEach(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduce=module$contents$goog$array_reduce;\nconst module$contents$goog$array_reduceRight=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduceRight)?function(a,b,c,d){goog.asserts.assert(null!=a.length);goog.asserts.assert(null!=b);d&&(b=goog.bind(b,d));return Array.prototype.reduceRight.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEachRight(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduceRight=module$contents$goog$array_reduceRight;\nconst module$contents$goog$array_some=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.some)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.some.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return!0;return!1};goog.array.some=module$contents$goog$array_some;\nconst module$contents$goog$array_every=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.every)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.every.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&!b.call(c,e[f],f,a))return!1;return!0};goog.array.every=module$contents$goog$array_every;\nfunction module$contents$goog$array_count(a,b,c){let d=0;module$contents$goog$array_forEach(a,function(e,f,g){b.call(c,e,f,g)&&++d},c);return d}goog.array.count=module$contents$goog$array_count;function module$contents$goog$array_find(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.find=module$contents$goog$array_find;\nfunction module$contents$goog$array_findIndex(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return f;return-1}goog.array.findIndex=module$contents$goog$array_findIndex;function module$contents$goog$array_findRight(a,b,c){b=module$contents$goog$array_findIndexRight(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.findRight=module$contents$goog$array_findRight;\nfunction module$contents$goog$array_findIndexRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;d--)if(d in e&&b.call(c,e[d],d,a))return d;return-1}goog.array.findIndexRight=module$contents$goog$array_findIndexRight;function module$contents$goog$array_contains(a,b){return 0<=module$contents$goog$array_indexOf(a,b)}goog.array.contains=module$contents$goog$array_contains;function module$contents$goog$array_isEmpty(a){return 0==a.length}goog.array.isEmpty=module$contents$goog$array_isEmpty;\nfunction module$contents$goog$array_clear(a){if(!Array.isArray(a))for(let b=a.length-1;0<=b;b--)delete a[b];a.length=0}goog.array.clear=module$contents$goog$array_clear;function module$contents$goog$array_insert(a,b){module$contents$goog$array_contains(a,b)||a.push(b)}goog.array.insert=module$contents$goog$array_insert;function module$contents$goog$array_insertAt(a,b,c){module$contents$goog$array_splice(a,c,0,b)}goog.array.insertAt=module$contents$goog$array_insertAt;\nfunction module$contents$goog$array_insertArrayAt(a,b,c){goog.partial(module$contents$goog$array_splice,a,c,0).apply(null,b)}goog.array.insertArrayAt=module$contents$goog$array_insertArrayAt;function module$contents$goog$array_insertBefore(a,b,c){let d;2==arguments.length||0>(d=module$contents$goog$array_indexOf(a,c))?a.push(b):module$contents$goog$array_insertAt(a,b,d)}goog.array.insertBefore=module$contents$goog$array_insertBefore;\nfunction module$contents$goog$array_remove(a,b){b=module$contents$goog$array_indexOf(a,b);let c;(c=0<=b)&&module$contents$goog$array_removeAt(a,b);return c}goog.array.remove=module$contents$goog$array_remove;function module$contents$goog$array_removeLast(a,b){b=module$contents$goog$array_lastIndexOf(a,b);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeLast=module$contents$goog$array_removeLast;\nfunction module$contents$goog$array_removeAt(a,b){goog.asserts.assert(null!=a.length);return 1==Array.prototype.splice.call(a,b,1).length}goog.array.removeAt=module$contents$goog$array_removeAt;function module$contents$goog$array_removeIf(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeIf=module$contents$goog$array_removeIf;\nfunction module$contents$goog$array_removeAllIf(a,b,c){let d=0;module$contents$goog$array_forEachRight(a,function(e,f){b.call(c,e,f,a)&&module$contents$goog$array_removeAt(a,f)&&d++});return d}goog.array.removeAllIf=module$contents$goog$array_removeAllIf;function module$contents$goog$array_concat(a){return Array.prototype.concat.apply([],arguments)}goog.array.concat=module$contents$goog$array_concat;function module$contents$goog$array_join(a){return Array.prototype.concat.apply([],arguments)}\ngoog.array.join=module$contents$goog$array_join;function module$contents$goog$array_toArray(a){const b=a.length;if(0<b){const c=Array(b);for(let d=0;d<b;d++)c[d]=a[d];return c}return[]}const module$contents$goog$array_clone=goog.array.toArray=module$contents$goog$array_toArray;goog.array.clone=module$contents$goog$array_toArray;\nfunction module$contents$goog$array_extend(a,b){for(let c=1;c<arguments.length;c++){const d=arguments[c];if(goog.isArrayLike(d)){const e=a.length||0,f=d.length||0;a.length=e+f;for(let g=0;g<f;g++)a[e+g]=d[g]}else a.push(d)}}goog.array.extend=module$contents$goog$array_extend;function module$contents$goog$array_splice(a,b,c,d){goog.asserts.assert(null!=a.length);return Array.prototype.splice.apply(a,module$contents$goog$array_slice(arguments,1))}goog.array.splice=module$contents$goog$array_splice;\nfunction module$contents$goog$array_slice(a,b,c){goog.asserts.assert(null!=a.length);return 2>=arguments.length?Array.prototype.slice.call(a,b):Array.prototype.slice.call(a,b,c)}goog.array.slice=module$contents$goog$array_slice;\nfunction module$contents$goog$array_removeDuplicates(a,b,c){b=b||a;var d=function(g){return goog.isObject(g)?"o"+goog.getUid(g):(typeof g).charAt(0)+g};c=c||d;let e=d=0;const f={};for(;e<a.length;){const g=a[e++],h=c(g);Object.prototype.hasOwnProperty.call(f,h)||(f[h]=!0,b[d++]=g)}b.length=d}goog.array.removeDuplicates=module$contents$goog$array_removeDuplicates;\nfunction module$contents$goog$array_binarySearch(a,b,c){return module$contents$goog$array_binarySearch_(a,c||module$contents$goog$array_defaultCompare,!1,b)}goog.array.binarySearch=module$contents$goog$array_binarySearch;function module$contents$goog$array_binarySelect(a,b,c){return module$contents$goog$array_binarySearch_(a,b,!0,void 0,c)}goog.array.binarySelect=module$contents$goog$array_binarySelect;\nfunction module$contents$goog$array_binarySearch_(a,b,c,d,e){let f=0,g=a.length,h;for(;f<g;){const k=f+(g-f>>>1);let l;l=c?b.call(e,a[k],k,a):b(d,a[k]);0<l?f=k+1:(g=k,h=!l)}return h?f:-f-1}function module$contents$goog$array_sort(a,b){a.sort(b||module$contents$goog$array_defaultCompare)}goog.array.sort=module$contents$goog$array_sort;\nfunction module$contents$goog$array_stableSort(a,b){const c=Array(a.length);for(let e=0;e<a.length;e++)c[e]={index:e,value:a[e]};const d=b||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(c,function(e,f){return d(e.value,f.value)||e.index-f.index});for(b=0;b<a.length;b++)a[b]=c[b].value}goog.array.stableSort=module$contents$goog$array_stableSort;\nfunction module$contents$goog$array_sortByKey(a,b,c){const d=c||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(a,function(e,f){return d(b(e),b(f))})}goog.array.sortByKey=module$contents$goog$array_sortByKey;function module$contents$goog$array_sortObjectsByKey(a,b,c){module$contents$goog$array_sortByKey(a,function(d){return d[b]},c)}goog.array.sortObjectsByKey=module$contents$goog$array_sortObjectsByKey;\nfunction module$contents$goog$array_isSorted(a,b,c){b=b||module$contents$goog$array_defaultCompare;for(let d=1;d<a.length;d++){const e=b(a[d-1],a[d]);if(0<e||0==e&&c)return!1}return!0}goog.array.isSorted=module$contents$goog$array_isSorted;function module$contents$goog$array_equals(a,b,c){if(!goog.isArrayLike(a)||!goog.isArrayLike(b)||a.length!=b.length)return!1;const d=a.length;c=c||module$contents$goog$array_defaultCompareEquality;for(let e=0;e<d;e++)if(!c(a[e],b[e]))return!1;return!0}\ngoog.array.equals=module$contents$goog$array_equals;function module$contents$goog$array_compare3(a,b,c){c=c||module$contents$goog$array_defaultCompare;const d=Math.min(a.length,b.length);for(let e=0;e<d;e++){const f=c(a[e],b[e]);if(0!=f)return f}return module$contents$goog$array_defaultCompare(a.length,b.length)}goog.array.compare3=module$contents$goog$array_compare3;function module$contents$goog$array_defaultCompare(a,b){return a>b?1:a<b?-1:0}goog.array.defaultCompare=module$contents$goog$array_defaultCompare;\nfunction module$contents$goog$array_inverseDefaultCompare(a,b){return-module$contents$goog$array_defaultCompare(a,b)}goog.array.inverseDefaultCompare=module$contents$goog$array_inverseDefaultCompare;function module$contents$goog$array_defaultCompareEquality(a,b){return a===b}goog.array.defaultCompareEquality=module$contents$goog$array_defaultCompareEquality;\nfunction module$contents$goog$array_binaryInsert(a,b,c){c=module$contents$goog$array_binarySearch(a,b,c);return 0>c?(module$contents$goog$array_insertAt(a,b,-(c+1)),!0):!1}goog.array.binaryInsert=module$contents$goog$array_binaryInsert;function module$contents$goog$array_binaryRemove(a,b,c){b=module$contents$goog$array_binarySearch(a,b,c);return 0<=b?module$contents$goog$array_removeAt(a,b):!1}goog.array.binaryRemove=module$contents$goog$array_binaryRemove;\nfunction module$contents$goog$array_bucket(a,b,c){const d={};for(let e=0;e<a.length;e++){const f=a[e],g=b.call(c,f,e,a);void 0!==g&&(d[g]||(d[g]=[])).push(f)}return d}goog.array.bucket=module$contents$goog$array_bucket;function module$contents$goog$array_bucketToMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d],f=b(e,d,a);if(void 0!==f){let g=c.get(f);g||(g=[],c.set(f,g));g.push(e)}}return c}goog.array.bucketToMap=module$contents$goog$array_bucketToMap;\nfunction module$contents$goog$array_toObject(a,b,c){const d={};module$contents$goog$array_forEach(a,function(e,f){d[b.call(c,e,f,a)]=e});return d}goog.array.toObject=module$contents$goog$array_toObject;function module$contents$goog$array_toMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d];c.set(b(e,d,a),e)}return c}goog.array.toMap=module$contents$goog$array_toMap;\nfunction module$contents$goog$array_range(a,b,c){const d=[];let e=0,f=a;c=c||1;void 0!==b&&(e=a,f=b);if(0>c*(f-e))return[];if(0<c)for(a=e;a<f;a+=c)d.push(a);else for(a=e;a>f;a+=c)d.push(a);return d}goog.array.range=module$contents$goog$array_range;function module$contents$goog$array_repeat(a,b){const c=[];for(let d=0;d<b;d++)c[d]=a;return c}goog.array.repeat=module$contents$goog$array_repeat;\nfunction module$contents$goog$array_flatten(a){const b=[];for(let d=0;d<arguments.length;d++){const e=arguments[d];if(Array.isArray(e))for(let f=0;f<e.length;f+=8192){var c=module$contents$goog$array_slice(e,f,f+8192);c=module$contents$goog$array_flatten.apply(null,c);for(let g=0;g<c.length;g++)b.push(c[g])}else b.push(e)}return b}goog.array.flatten=module$contents$goog$array_flatten;\nfunction module$contents$goog$array_rotate(a,b){goog.asserts.assert(null!=a.length);a.length&&(b%=a.length,0<b?Array.prototype.unshift.apply(a,a.splice(-b,b)):0>b&&Array.prototype.push.apply(a,a.splice(0,-b)));return a}goog.array.rotate=module$contents$goog$array_rotate;function module$contents$goog$array_moveItem(a,b,c){goog.asserts.assert(0<=b&&b<a.length);goog.asserts.assert(0<=c&&c<a.length);b=Array.prototype.splice.call(a,b,1);Array.prototype.splice.call(a,c,0,b[0])}goog.array.moveItem=module$contents$goog$array_moveItem;\nfunction module$contents$goog$array_zip(a){if(!arguments.length)return[];const b=[];let c=arguments[0].length;for(var d=1;d<arguments.length;d++)arguments[d].length<c&&(c=arguments[d].length);for(d=0;d<c;d++){const e=[];for(let f=0;f<arguments.length;f++)e.push(arguments[f][d]);b.push(e)}return b}goog.array.zip=module$contents$goog$array_zip;function module$contents$goog$array_shuffle(a,b){b=b||Math.random;for(let c=a.length-1;0<c;c--){const d=Math.floor(b()*(c+1)),e=a[c];a[c]=a[d];a[d]=e}}\ngoog.array.shuffle=module$contents$goog$array_shuffle;function module$contents$goog$array_copyByIndex(a,b){const c=[];module$contents$goog$array_forEach(b,function(d){c.push(a[d])});return c}goog.array.copyByIndex=module$contents$goog$array_copyByIndex;function module$contents$goog$array_concatMap(a,b,c){return module$contents$goog$array_concat.apply([],module$contents$goog$array_map(a,b,c))}goog.array.concatMap=module$contents$goog$array_concatMap;goog.dom.asserts={};goog.dom.asserts.assertIsLocation=function(a){if(goog.asserts.ENABLE_ASSERTS){var b=goog.dom.asserts.getWindow_(a);b&&(!a||!(a instanceof b.Location)&&a instanceof b.Element)&&goog.asserts.fail("Argument is not a Location (or a non-Element mock); got: %s",goog.dom.asserts.debugStringForType_(a))}return a};\ngoog.dom.asserts.assertIsElementType_=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=goog.dom.asserts.getWindow_(a);c&&"undefined"!=typeof c[b]&&(a&&(a instanceof c[b]||!(a instanceof c.Location||a instanceof c.Element))||goog.asserts.fail("Argument is not a %s (or a non-Element, non-Location mock); got: %s",b,goog.dom.asserts.debugStringForType_(a)))}return a};goog.dom.asserts.assertIsHTMLAnchorElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAnchorElement")};\ngoog.dom.asserts.assertIsHTMLButtonElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLButtonElement")};goog.dom.asserts.assertIsHTMLLinkElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLLinkElement")};goog.dom.asserts.assertIsHTMLImageElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLImageElement")};goog.dom.asserts.assertIsHTMLAudioElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAudioElement")};\ngoog.dom.asserts.assertIsHTMLVideoElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLVideoElement")};goog.dom.asserts.assertIsHTMLInputElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLInputElement")};goog.dom.asserts.assertIsHTMLTextAreaElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLTextAreaElement")};goog.dom.asserts.assertIsHTMLCanvasElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLCanvasElement")};\ngoog.dom.asserts.assertIsHTMLEmbedElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLEmbedElement")};goog.dom.asserts.assertIsHTMLFormElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFormElement")};goog.dom.asserts.assertIsHTMLFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFrameElement")};goog.dom.asserts.assertIsHTMLIFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLIFrameElement")};\ngoog.dom.asserts.assertIsHTMLObjectElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLObjectElement")};goog.dom.asserts.assertIsHTMLScriptElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLScriptElement")};\ngoog.dom.asserts.debugStringForType_=function(a){if(goog.isObject(a))try{return a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a)}catch(b){return"<object could not be stringified>"}else return void 0===a?"undefined":null===a?"null":typeof a};goog.dom.asserts.getWindow_=function(a){try{var b=a&&a.ownerDocument,c=b&&(b.defaultView||b.parentWindow);c=c||goog.global;if(c.Element&&c.Location)return c}catch(d){}return null};goog.functions={};goog.functions.constant=function(a){return function(){return a}};goog.functions.FALSE=function(){return!1};goog.functions.TRUE=function(){return!0};goog.functions.NULL=function(){return null};goog.functions.UNDEFINED=function(){};goog.functions.EMPTY=goog.functions.UNDEFINED;goog.functions.identity=function(a,b){return a};goog.functions.error=function(a){return function(){throw Error(a);}};goog.functions.fail=function(a){return function(){throw a;}};\ngoog.functions.lock=function(a,b){b=b||0;return function(){return a.apply(this,Array.prototype.slice.call(arguments,0,b))}};goog.functions.nth=function(a){return function(){return arguments[a]}};goog.functions.partialRight=function(a,b){const c=Array.prototype.slice.call(arguments,1);return function(){let d=this;d===goog.global&&(d=void 0);const e=Array.prototype.slice.call(arguments);e.push.apply(e,c);return a.apply(d,e)}};\ngoog.functions.withReturnValue=function(a,b){return goog.functions.sequence(a,goog.functions.constant(b))};goog.functions.equalTo=function(a,b){return function(c){return b?a==c:a===c}};goog.functions.compose=function(a,b){const c=arguments,d=c.length;return function(){let e;d&&(e=c[d-1].apply(this,arguments));for(let f=d-2;0<=f;f--)e=c[f].call(this,e);return e}};\ngoog.functions.sequence=function(a){const b=arguments,c=b.length;return function(){let d;for(let e=0;e<c;e++)d=b[e].apply(this,arguments);return d}};goog.functions.and=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(!b[d].apply(this,arguments))return!1;return!0}};goog.functions.or=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(b[d].apply(this,arguments))return!0;return!1}};\ngoog.functions.not=function(a){return function(){return!a.apply(this,arguments)}};goog.functions.create=function(a,b){var c=function(){};c.prototype=a.prototype;c=new c;a.apply(c,Array.prototype.slice.call(arguments,1));return c};goog.functions.CACHE_RETURN_VALUE=!0;goog.functions.cacheReturnValue=function(a){let b=!1,c;return function(){if(!goog.functions.CACHE_RETURN_VALUE)return a();b||(c=a(),b=!0);return c}};goog.functions.once=function(a){let b=a;return function(){if(b){const c=b;b=null;c()}}};\ngoog.functions.debounce=function(a,b,c){let d=0;return function(e){goog.global.clearTimeout(d);const f=arguments;d=goog.global.setTimeout(function(){a.apply(c,f)},b)}};goog.functions.throttle=function(a,b,c){let d=0,e=!1,f=[];const g=function(){d=0;e&&(e=!1,h())},h=function(){d=goog.global.setTimeout(g,b);let k=f;f=[];a.apply(c,k)};return function(k){f=arguments;d?e=!0:h()}};\ngoog.functions.rateLimit=function(a,b,c){let d=0;const e=function(){d=0};return function(f){d||(d=goog.global.setTimeout(e,b),a.apply(c,arguments))}};goog.functions.isFunction=a=>"function"===typeof a;goog.string={};goog.string.TypedString=function(){};goog.string.Const=function(a,b){this.stringConstValueWithSecurityContract__googStringSecurityPrivate_=a===goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_&&b||"";this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_=goog.string.Const.TYPE_MARKER_};goog.string.Const.prototype.implementsGoogStringTypedString=!0;goog.string.Const.prototype.getTypedStringValue=function(){return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_};\ngoog.DEBUG&&(goog.string.Const.prototype.toString=function(){return"Const{"+this.stringConstValueWithSecurityContract__googStringSecurityPrivate_+"}"});goog.string.Const.unwrap=function(a){if(a instanceof goog.string.Const&&a.constructor===goog.string.Const&&a.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_===goog.string.Const.TYPE_MARKER_)return a.stringConstValueWithSecurityContract__googStringSecurityPrivate_;goog.asserts.fail("expected object of type Const, got \'"+a+"\'");return"type_error:Const"};\ngoog.string.Const.from=function(a){return new goog.string.Const(goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_,a)};goog.string.Const.TYPE_MARKER_={};goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_={};goog.string.Const.EMPTY=goog.string.Const.from("");goog.html={};goog.html.trustedtypes={};goog.html.trustedtypes.POLICY_NAME=goog.TRUSTED_TYPES_POLICY_NAME?goog.TRUSTED_TYPES_POLICY_NAME+"#html":"";goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse=function(){if(!goog.html.trustedtypes.POLICY_NAME)return null;void 0===goog.html.trustedtypes.cachedPolicy_&&(goog.html.trustedtypes.cachedPolicy_=goog.createTrustedTypesPolicy(goog.html.trustedtypes.POLICY_NAME));return goog.html.trustedtypes.cachedPolicy_};const module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeScript_SafeScript{constructor(a,b){this.privateDoNotAccessOrElseSafeScriptWrappedValue_=b===module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static fromConstant(a){a=goog.string.Const.unwrap(a);return 0===a.length?module$contents$goog$html$SafeScript_SafeScript.EMPTY:module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(a)}static fromJson(a){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(module$contents$goog$html$SafeScript_SafeScript.stringify_(a))}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(a).toString()}static unwrapTrustedScript(a){if(a instanceof\nmodule$contents$goog$html$SafeScript_SafeScript&&a.constructor===module$contents$goog$html$SafeScript_SafeScript)return a.privateDoNotAccessOrElseSafeScriptWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeScript, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:SafeScript"}static stringify_(a){return JSON.stringify(a).replace(/</g,"\\\\x3c")}static createSafeScriptSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScript(a):\na;return new module$contents$goog$html$SafeScript_SafeScript(a,module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE)}}module$contents$goog$html$SafeScript_SafeScript.EMPTY=function(){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("")}();goog.html.SafeScript=module$contents$goog$html$SafeScript_SafeScript;goog.fs={};goog.fs.url={};goog.fs.url.createObjectUrl=function(a){return goog.fs.url.getUrlObject_().createObjectURL(a)};goog.fs.url.revokeObjectUrl=function(a){goog.fs.url.getUrlObject_().revokeObjectURL(a)};goog.fs.url.UrlObject_=function(){};goog.fs.url.UrlObject_.prototype.createObjectURL=function(a){};goog.fs.url.UrlObject_.prototype.revokeObjectURL=function(a){};\ngoog.fs.url.getUrlObject_=function(){const a=goog.fs.url.findUrlObject_();if(null!=a)return a;throw Error("This browser doesn\'t seem to support blob URLs");};goog.fs.url.findUrlObject_=function(){return void 0!==goog.global.URL&&void 0!==goog.global.URL.createObjectURL?goog.global.URL:void 0!==goog.global.createObjectURL?goog.global:null};goog.fs.url.browserSupportsObjectUrls=function(){return null!=goog.fs.url.findUrlObject_()};goog.fs.blob={};goog.fs.blob.getBlob=function(a){var b=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==b){b=new b;for(let c=0;c<arguments.length;c++)b.append(arguments[c]);return b.getBlob()}return goog.fs.blob.getBlobWithProperties(Array.prototype.slice.call(arguments))};\ngoog.fs.blob.getBlobWithProperties=function(a,b,c){var d=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==d){d=new d;for(let e=0;e<a.length;e++)d.append(a[e],c);return d.getBlob(b)}if(void 0!==goog.global.Blob)return d={},b&&(d.type=b),c&&(d.endings=c),new Blob(a,d);throw Error("This browser doesn\'t seem to support creating Blobs");};goog.html.TrustedResourceUrl=class{constructor(a,b){this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_=b===goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_+""}};goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString=!0;goog.html.TrustedResourceUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_.toString()};\ngoog.html.TrustedResourceUrl.prototype.cloneWithParams=function(a,b){var c=goog.html.TrustedResourceUrl.unwrap(this);c=goog.html.TrustedResourceUrl.URL_PARAM_PARSER_.exec(c);var d=c[3]||"";return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(c[1]+goog.html.TrustedResourceUrl.stringifyParams_("?",c[2]||"",a)+goog.html.TrustedResourceUrl.stringifyParams_("#",d,b))};goog.html.TrustedResourceUrl.unwrap=function(a){return goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(a).toString()};\ngoog.html.TrustedResourceUrl.unwrapTrustedScriptURL=function(a){if(a instanceof goog.html.TrustedResourceUrl&&a.constructor===goog.html.TrustedResourceUrl)return a.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;goog.asserts.fail("expected object of type TrustedResourceUrl, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:TrustedResourceUrl"};\ngoog.html.TrustedResourceUrl.format=function(a,b){var c=goog.string.Const.unwrap(a);if(!goog.html.TrustedResourceUrl.BASE_URL_.test(c))throw Error("Invalid TrustedResourceUrl format: "+c);a=c.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_,function(d,e){if(!Object.prototype.hasOwnProperty.call(b,e))throw Error(\'Found marker, "\'+e+\'", in format string, "\'+c+\'", but no valid label mapping found in args: \'+JSON.stringify(b));d=b[e];return d instanceof goog.string.Const?goog.string.Const.unwrap(d):\nencodeURIComponent(String(d))});return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.FORMAT_MARKER_=/%{(\\w+)}/g;goog.html.TrustedResourceUrl.BASE_URL_=RegExp("^((https:)?//[0-9a-z.:[\\\\]-]+/|/[^/\\\\\\\\]|[^:/\\\\\\\\%]+/|[^:/\\\\\\\\%]*[?#]|about:blank#)","i");goog.html.TrustedResourceUrl.URL_PARAM_PARSER_=/^([^?#]*)(\\?[^#]*)?(#[\\s\\S]*)?/;\ngoog.html.TrustedResourceUrl.formatWithParams=function(a,b,c,d){return goog.html.TrustedResourceUrl.format(a,b).cloneWithParams(c,d)};goog.html.TrustedResourceUrl.fromConstant=function(a){return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};goog.html.TrustedResourceUrl.fromConstants=function(a){for(var b="",c=0;c<a.length;c++)b+=goog.string.Const.unwrap(a[c]);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.TrustedResourceUrl.fromSafeScript=function(a){a=goog.fs.blob.getBlobWithProperties([module$contents$goog$html$SafeScript_SafeScript.unwrap(a)],"text/javascript");a=goog.fs.url.createObjectUrl(a);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};\ngoog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse=function(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScriptURL(a):a;return new goog.html.TrustedResourceUrl(a,goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};\ngoog.html.TrustedResourceUrl.stringifyParams_=function(a,b,c){if(null==c)return b;if("string"===typeof c)return c?a+encodeURIComponent(c):"";for(var d in c)if(Object.prototype.hasOwnProperty.call(c,d)){var e=c[d];e=Array.isArray(e)?e:[e];for(var f=0;f<e.length;f++){var g=e[f];null!=g&&(b||(b=a),b+=(b.length>a.length?"&":"")+encodeURIComponent(d)+"="+encodeURIComponent(String(g)))}}return b};goog.string.internal={};goog.string.internal.startsWith=function(a,b){return 0==a.lastIndexOf(b,0)};goog.string.internal.endsWith=function(a,b){const c=a.length-b.length;return 0<=c&&a.indexOf(b,c)==c};goog.string.internal.caseInsensitiveStartsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(0,b.length))};goog.string.internal.caseInsensitiveEndsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(a.length-b.length))};\ngoog.string.internal.caseInsensitiveEquals=function(a,b){return a.toLowerCase()==b.toLowerCase()};goog.string.internal.isEmptyOrWhitespace=function(a){return/^[\\s\\xa0]*$/.test(a)};goog.string.internal.trim=goog.TRUSTED_SITE&&String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(a)[1]};goog.string.internal.caseInsensitiveCompare=function(a,b){a=String(a).toLowerCase();b=String(b).toLowerCase();return a<b?-1:a==b?0:1};\ngoog.string.internal.newLineToBr=function(a,b){return a.replace(/(\\r\\n|\\r|\\n)/g,b?"<br />":"<br>")};\ngoog.string.internal.htmlEscape=function(a,b){if(b)a=a.replace(goog.string.internal.AMP_RE_,"&amp;").replace(goog.string.internal.LT_RE_,"&lt;").replace(goog.string.internal.GT_RE_,"&gt;").replace(goog.string.internal.QUOT_RE_,"&quot;").replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;").replace(goog.string.internal.NULL_RE_,"&#0;");else{if(!goog.string.internal.ALL_RE_.test(a))return a;-1!=a.indexOf("&")&&(a=a.replace(goog.string.internal.AMP_RE_,"&amp;"));-1!=a.indexOf("<")&&(a=a.replace(goog.string.internal.LT_RE_,\n"&lt;"));-1!=a.indexOf(">")&&(a=a.replace(goog.string.internal.GT_RE_,"&gt;"));-1!=a.indexOf(\'"\')&&(a=a.replace(goog.string.internal.QUOT_RE_,"&quot;"));-1!=a.indexOf("\'")&&(a=a.replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;"));-1!=a.indexOf("\\x00")&&(a=a.replace(goog.string.internal.NULL_RE_,"&#0;"))}return a};goog.string.internal.AMP_RE_=/&/g;goog.string.internal.LT_RE_=/</g;goog.string.internal.GT_RE_=/>/g;goog.string.internal.QUOT_RE_=/"/g;goog.string.internal.SINGLE_QUOTE_RE_=/\'/g;\ngoog.string.internal.NULL_RE_=/\\x00/g;goog.string.internal.ALL_RE_=/[\\x00&<>"\']/;goog.string.internal.whitespaceEscape=function(a,b){return goog.string.internal.newLineToBr(a.replace(/  /g," &#160;"),b)};goog.string.internal.contains=function(a,b){return-1!=a.indexOf(b)};goog.string.internal.caseInsensitiveContains=function(a,b){return goog.string.internal.contains(a.toLowerCase(),b.toLowerCase())};\ngoog.string.internal.compareVersions=function(a,b){var c=0;a=goog.string.internal.trim(String(a)).split(".");b=goog.string.internal.trim(String(b)).split(".");const d=Math.max(a.length,b.length);for(let g=0;0==c&&g<d;g++){var e=a[g]||"",f=b[g]||"";do{e=/(\\d*)(\\D*)(.*)/.exec(e)||["","","",""];f=/(\\d*)(\\D*)(.*)/.exec(f)||["","","",""];if(0==e[0].length&&0==f[0].length)break;c=0==e[1].length?0:parseInt(e[1],10);const h=0==f[1].length?0:parseInt(f[1],10);c=goog.string.internal.compareElements_(c,h)||\ngoog.string.internal.compareElements_(0==e[2].length,0==f[2].length)||goog.string.internal.compareElements_(e[2],f[2]);e=e[3];f=f[3]}while(0==c)}return c};goog.string.internal.compareElements_=function(a,b){return a<b?-1:a>b?1:0};goog.html.SafeUrl=class{constructor(a,b){this.privateDoNotAccessOrElseSafeUrlWrappedValue_=b===goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()}};goog.html.SafeUrl.INNOCUOUS_STRING="about:invalid#zClosurez";goog.html.SafeUrl.prototype.implementsGoogStringTypedString=!0;goog.html.SafeUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()};\ngoog.html.SafeUrl.unwrap=function(a){if(a instanceof goog.html.SafeUrl&&a.constructor===goog.html.SafeUrl)return a.privateDoNotAccessOrElseSafeUrlWrappedValue_;goog.asserts.fail("expected object of type SafeUrl, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:SafeUrl"};goog.html.SafeUrl.fromConstant=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};\ngoog.html.SAFE_MIME_TYPE_PATTERN_=RegExp(\'^(?:audio/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-matroska|x-wav|wav|webm)|font/\\\\w+|image/(?:bmp|gif|jpeg|jpg|png|tiff|webp|x-icon|heic|heif)|video/(?:mpeg|mp4|ogg|webm|quicktime|x-matroska))(?:;\\\\w+=(?:\\\\w+|"[\\\\w;,= ]+"))*$\',"i");goog.html.SafeUrl.isSafeMimeType=function(a){return goog.html.SAFE_MIME_TYPE_PATTERN_.test(a)};\ngoog.html.SafeUrl.fromBlob=function(a){a=goog.html.SafeUrl.isSafeMimeType(a.type)?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.revokeObjectUrl=function(a){a=a.getTypedStringValue();a!==goog.html.SafeUrl.INNOCUOUS_STRING&&goog.fs.url.revokeObjectUrl(a)};\ngoog.html.SafeUrl.fromMediaSource=function(a){goog.asserts.assert("MediaSource"in goog.global,"No support for MediaSource");a=a instanceof MediaSource?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.DATA_URL_PATTERN_=/^data:(.*);base64,[a-z0-9+\\/]+=*$/i;\ngoog.html.SafeUrl.tryFromDataUrl=function(a){a=String(a);a=a.replace(/(%0A|%0D)/g,"");return a.match(goog.html.DATA_URL_PATTERN_)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):null};goog.html.SafeUrl.fromDataUrl=function(a){return goog.html.SafeUrl.tryFromDataUrl(a)||goog.html.SafeUrl.INNOCUOUS_URL};goog.html.SafeUrl.fromTelUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"tel:")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SIP_URL_PATTERN_=RegExp("^sip[s]?:[+a-z0-9_.!$%&\'*\\\\/=^`{|}~-]+@([a-z0-9-]+\\\\.)+[a-z0-9]{2,63}$","i");goog.html.SafeUrl.fromSipUrl=function(a){goog.html.SIP_URL_PATTERN_.test(decodeURIComponent(a))||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromFacebookMessengerUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"fb-messenger://share")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.fromWhatsAppUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"whatsapp://send")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromSmsUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"sms:")&&goog.html.SafeUrl.isSmsUrlBodyValid_(a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.isSmsUrlBodyValid_=function(a){var b=a.indexOf("#");0<b&&(a=a.substring(0,b));b=a.match(/[?&]body=/gi);if(!b)return!0;if(1<b.length)return!1;a=a.match(/[?&]body=([^&]*)/)[1];if(!a)return!0;try{decodeURIComponent(a)}catch(c){return!1}return/^(?:[a-z0-9\\-_.~]|%[0-9a-f]{2})+$/i.test(a)};goog.html.SafeUrl.fromSshUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"ssh://")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.sanitizeChromeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^chrome-extension:\\/\\/([^\\/]+)\\//,a,b)};goog.html.SafeUrl.sanitizeFirefoxExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^moz-extension:\\/\\/([^\\/]+)\\//,a,b)};goog.html.SafeUrl.sanitizeEdgeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^ms-browser-extension:\\/\\/([^\\/]+)\\//,a,b)};\ngoog.html.SafeUrl.sanitizeExtensionUrl_=function(a,b,c){(a=a.exec(b))?(a=a[1],-1==(c instanceof goog.string.Const?[goog.string.Const.unwrap(c)]:c.map(function(d){return goog.string.Const.unwrap(d)})).indexOf(a)&&(b=goog.html.SafeUrl.INNOCUOUS_STRING)):b=goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};goog.html.SafeUrl.fromTrustedResourceUrl=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.TrustedResourceUrl.unwrap(a))};\ngoog.html.SAFE_URL_PATTERN_=/^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;goog.html.SafeUrl.SAFE_URL_PATTERN=goog.html.SAFE_URL_PATTERN_;goog.html.SafeUrl.trySanitize=function(a){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return goog.html.SAFE_URL_PATTERN_.test(a)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):goog.html.SafeUrl.tryFromDataUrl(a)};\ngoog.html.SafeUrl.sanitize=function(a){return goog.html.SafeUrl.trySanitize(a)||goog.html.SafeUrl.INNOCUOUS_URL};\ngoog.html.SafeUrl.sanitizeAssertUnchanged=function(a,b){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);if(b&&/^data:/i.test(a)&&(b=goog.html.SafeUrl.fromDataUrl(a),b.getTypedStringValue()==a))return b;goog.asserts.assert(goog.html.SAFE_URL_PATTERN_.test(a),"%s does not match the safe URL pattern",a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};\ngoog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse=function(a){return new goog.html.SafeUrl(a,goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};goog.html.SafeUrl.INNOCUOUS_URL=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.SafeUrl.INNOCUOUS_STRING);goog.html.SafeUrl.ABOUT_BLANK=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse("about:blank");const module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeStyle_SafeStyle{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleWrappedValue_=b===module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyle_SafeStyle.EMPTY;(0,goog.asserts.assert)((0,goog.string.internal.endsWith)(a,";"),`Last character of style string is not \';\': ${a}`);(0,goog.asserts.assert)((0,goog.string.internal.contains)(a,\n":"),"Style string must contain at least one \':\', to specify a \\"name: value\\" pair: "+a);return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_}toString(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_.toString()}static unwrap(a){if(a instanceof module$contents$goog$html$SafeStyle_SafeStyle&&a.constructor===module$contents$goog$html$SafeStyle_SafeStyle)return a.privateDoNotAccessOrElseSafeStyleWrappedValue_;\n(0,goog.asserts.fail)(`expected object of type SafeStyle, got \'${a}`+"\' of type "+goog.typeOf(a));return"type_error:SafeStyle"}static createSafeStyleSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyle_SafeStyle(a,module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE)}static create(a){let b="";for(let c in a)if(Object.prototype.hasOwnProperty.call(a,c)){if(!/^[-_a-zA-Z0-9]+$/.test(c))throw Error(`Name allows only [-_a-zA-Z0-9], got: ${c}`);let d=a[c];null!=d&&\n(d=Array.isArray(d)?d.map(module$contents$goog$html$SafeStyle_sanitizePropertyValue).join(" "):module$contents$goog$html$SafeStyle_sanitizePropertyValue(d),b+=`${c}:${d};`)}return b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(d)};Array.prototype.forEach.call(arguments,c);\nreturn b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}}module$contents$goog$html$SafeStyle_SafeStyle.EMPTY=module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse("");module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING="zClosurez";\nfunction module$contents$goog$html$SafeStyle_sanitizePropertyValue(a){if(a instanceof goog.html.SafeUrl)return\'url("\'+goog.html.SafeUrl.unwrap(a).replace(/</g,"%3c").replace(/[\\\\"]/g,"\\\\$&")+\'")\';a=a instanceof goog.string.Const?goog.string.Const.unwrap(a):module$contents$goog$html$SafeStyle_sanitizePropertyValueString(String(a));if(/[{;}]/.test(a))throw new module$contents$goog$asserts_AssertionError("Value does not allow [{;}], got: %s.",[a]);return a}\nfunction module$contents$goog$html$SafeStyle_sanitizePropertyValueString(a){const b=a.replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_URL_RE,"url");if(module$contents$goog$html$SafeStyle_VALUE_RE.test(b)){if(module$contents$goog$html$SafeStyle_COMMENT_RE.test(a))return(0,goog.asserts.fail)(`String value disallows comments, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;\nif(!module$contents$goog$html$SafeStyle_hasBalancedQuotes(a))return(0,goog.asserts.fail)(`String value requires balanced quotes, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;if(!module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a))return(0,goog.asserts.fail)("String value requires balanced square brackets and one identifier per pair of brackets, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING}else return(0,goog.asserts.fail)(`String value allows only ${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}`+\n" and simple functions, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;return module$contents$goog$html$SafeStyle_sanitizeUrl(a)}function module$contents$goog$html$SafeStyle_hasBalancedQuotes(a){let b=!0,c=!0;for(let d=0;d<a.length;d++){const e=a.charAt(d);"\'"==e&&c?b=!b:\'"\'==e&&b&&(c=!c)}return b&&c}\nfunction module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a){let b=!0;const c=/^[-_a-zA-Z0-9]$/;for(let d=0;d<a.length;d++){const e=a.charAt(d);if("]"==e){if(b)return!1;b=!0}else if("["==e){if(!b)return!1;b=!1}else if(!b&&!c.test(e))return!1}return b}\nconst module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS="[-,.\\"\'%_!#/ a-zA-Z0-9\\\\[\\\\]]",module$contents$goog$html$SafeStyle_VALUE_RE=new RegExp(`^${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}+\\$`),module$contents$goog$html$SafeStyle_URL_RE=RegExp("\\\\b(url\\\\([ \\t\\n]*)(\'[ -&(-\\\\[\\\\]-~]*\'|\\"[ !#-\\\\[\\\\]-~]*\\"|[!#-&*-\\\\[\\\\]-~]*)([ \\t\\n]*\\\\))","g"),module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS="calc cubic-bezier fit-content hsl hsla linear-gradient matrix minmax radial-gradient repeat rgb rgba (rotate|scale|translate)(X|Y|Z|3d)? steps var".split(" "),\nmodule$contents$goog$html$SafeStyle_FUNCTIONS_RE=new RegExp("\\\\b("+module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS.join("|")+")\\\\([-+*/0-9a-zA-Z.%#\\\\[\\\\], ]+\\\\)","g"),module$contents$goog$html$SafeStyle_COMMENT_RE=/\\/\\*/;function module$contents$goog$html$SafeStyle_sanitizeUrl(a){return a.replace(module$contents$goog$html$SafeStyle_URL_RE,(b,c,d,e)=>{let f="";d=d.replace(/^([\'"])(.*)\\1$/,(g,h,k)=>{f=h;return k});b=goog.html.SafeUrl.sanitize(d).getTypedStringValue();return c+f+b+f+e})}\ngoog.html.SafeStyle=module$contents$goog$html$SafeStyle_SafeStyle;goog.object={};function module$contents$goog$object_forEach(a,b,c){for(const d in a)b.call(c,a[d],d,a)}function module$contents$goog$object_filter(a,b,c){const d={};for(const e in a)b.call(c,a[e],e,a)&&(d[e]=a[e]);return d}function module$contents$goog$object_map(a,b,c){const d={};for(const e in a)d[e]=b.call(c,a[e],e,a);return d}function module$contents$goog$object_some(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return!0;return!1}\nfunction module$contents$goog$object_every(a,b,c){for(const d in a)if(!b.call(c,a[d],d,a))return!1;return!0}function module$contents$goog$object_getCount(a){let b=0;for(const c in a)b++;return b}function module$contents$goog$object_getAnyKey(a){for(const b in a)return b}function module$contents$goog$object_getAnyValue(a){for(const b in a)return a[b]}function module$contents$goog$object_contains(a,b){return module$contents$goog$object_containsValue(a,b)}\nfunction module$contents$goog$object_getValues(a){const b=[];let c=0;for(const d in a)b[c++]=a[d];return b}function module$contents$goog$object_getKeys(a){const b=[];let c=0;for(const d in a)b[c++]=d;return b}function module$contents$goog$object_getValueByKeys(a,b){var c=goog.isArrayLike(b);const d=c?b:arguments;for(c=c?0:1;c<d.length;c++){if(null==a)return;a=a[d[c]]}return a}function module$contents$goog$object_containsKey(a,b){return null!==a&&b in a}\nfunction module$contents$goog$object_containsValue(a,b){for(const c in a)if(a[c]==b)return!0;return!1}function module$contents$goog$object_findKey(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return d}function module$contents$goog$object_findValue(a,b,c){return(b=module$contents$goog$object_findKey(a,b,c))&&a[b]}function module$contents$goog$object_isEmpty(a){for(const b in a)return!1;return!0}function module$contents$goog$object_clear(a){for(const b in a)delete a[b]}\nfunction module$contents$goog$object_remove(a,b){let c;(c=b in a)&&delete a[b];return c}function module$contents$goog$object_add(a,b,c){if(null!==a&&b in a)throw Error(`The object already contains the key "${b}"`);module$contents$goog$object_set(a,b,c)}function module$contents$goog$object_get(a,b,c){return null!==a&&b in a?a[b]:c}function module$contents$goog$object_set(a,b,c){a[b]=c}function module$contents$goog$object_setIfUndefined(a,b,c){return b in a?a[b]:a[b]=c}\nfunction module$contents$goog$object_setWithReturnValueIfNotSet(a,b,c){if(b in a)return a[b];c=c();return a[b]=c}function module$contents$goog$object_equals(a,b){for(const c in a)if(!(c in b)||a[c]!==b[c])return!1;for(const c in b)if(!(c in a))return!1;return!0}function module$contents$goog$object_clone(a){const b={};for(const c in a)b[c]=a[c];return b}\nfunction module$contents$goog$object_unsafeClone(a){if(!a||"object"!==typeof a)return a;if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);if(a instanceof Date)return new Date(a.getTime());const b=Array.isArray(a)?[]:"function"!==typeof ArrayBuffer||"function"!==typeof ArrayBuffer.isView||!ArrayBuffer.isView(a)||a instanceof DataView?{}:new a.constructor(a.length);for(const c in a)b[c]=\nmodule$contents$goog$object_unsafeClone(a[c]);return b}function module$contents$goog$object_transpose(a){const b={};for(const c in a)b[a[c]]=c;return b}const module$contents$goog$object_PROTOTYPE_FIELDS="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");\nfunction module$contents$goog$object_extend(a,b){let c,d;for(let e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(let f=0;f<module$contents$goog$object_PROTOTYPE_FIELDS.length;f++)c=module$contents$goog$object_PROTOTYPE_FIELDS[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}}\nfunction module$contents$goog$object_create(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_create.apply(null,arguments[0]);if(b%2)throw Error("Uneven number of arguments");const c={};for(let d=0;d<b;d+=2)c[arguments[d]]=arguments[d+1];return c}\nfunction module$contents$goog$object_createSet(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_createSet.apply(null,arguments[0]);const c={};for(let d=0;d<b;d++)c[arguments[d]]=!0;return c}function module$contents$goog$object_createImmutableView(a){let b=a;Object.isFrozen&&!Object.isFrozen(a)&&(b=Object.create(a),Object.freeze(b));return b}function module$contents$goog$object_isImmutableView(a){return!!Object.isFrozen&&Object.isFrozen(a)}\nfunction module$contents$goog$object_getAllPropertyNames(a,b,c){if(!a)return[];if(!Object.getOwnPropertyNames||!Object.getPrototypeOf)return module$contents$goog$object_getKeys(a);const d={};for(;a&&(a!==Object.prototype||b)&&(a!==Function.prototype||c);){const e=Object.getOwnPropertyNames(a);for(let f=0;f<e.length;f++)d[e[f]]=!0;a=Object.getPrototypeOf(a)}return module$contents$goog$object_getKeys(d)}\nfunction module$contents$goog$object_getSuperClass(a){return(a=Object.getPrototypeOf(a.prototype))&&a.constructor}goog.object.add=module$contents$goog$object_add;goog.object.clear=module$contents$goog$object_clear;goog.object.clone=module$contents$goog$object_clone;goog.object.contains=module$contents$goog$object_contains;goog.object.containsKey=module$contents$goog$object_containsKey;goog.object.containsValue=module$contents$goog$object_containsValue;goog.object.create=module$contents$goog$object_create;\ngoog.object.createImmutableView=module$contents$goog$object_createImmutableView;goog.object.createSet=module$contents$goog$object_createSet;goog.object.equals=module$contents$goog$object_equals;goog.object.every=module$contents$goog$object_every;goog.object.extend=module$contents$goog$object_extend;goog.object.filter=module$contents$goog$object_filter;goog.object.findKey=module$contents$goog$object_findKey;goog.object.findValue=module$contents$goog$object_findValue;goog.object.forEach=module$contents$goog$object_forEach;\ngoog.object.get=module$contents$goog$object_get;goog.object.getAllPropertyNames=module$contents$goog$object_getAllPropertyNames;goog.object.getAnyKey=module$contents$goog$object_getAnyKey;goog.object.getAnyValue=module$contents$goog$object_getAnyValue;goog.object.getCount=module$contents$goog$object_getCount;goog.object.getKeys=module$contents$goog$object_getKeys;goog.object.getSuperClass=module$contents$goog$object_getSuperClass;goog.object.getValueByKeys=module$contents$goog$object_getValueByKeys;\ngoog.object.getValues=module$contents$goog$object_getValues;goog.object.isEmpty=module$contents$goog$object_isEmpty;goog.object.isImmutableView=module$contents$goog$object_isImmutableView;goog.object.map=module$contents$goog$object_map;goog.object.remove=module$contents$goog$object_remove;goog.object.set=module$contents$goog$object_set;goog.object.setIfUndefined=module$contents$goog$object_setIfUndefined;goog.object.setWithReturnValueIfNotSet=module$contents$goog$object_setWithReturnValueIfNotSet;\ngoog.object.some=module$contents$goog$object_some;goog.object.transpose=module$contents$goog$object_transpose;goog.object.unsafeClone=module$contents$goog$object_unsafeClone;const module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeStyleSheet_SafeStyleSheet{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_=b===module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_.toString()}static createRule(a,b){if((0,goog.string.internal.contains)(a,"<"))throw Error(`Selector does not allow \'<\', got: ${a}`);const c=a.replace(/(\'|")((?!\\1)[^\\r\\n\\f\\\\]|\\\\[\\s\\S])*\\1/g,\n"");if(!/^[-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|]+$/.test(c))throw Error("Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\\\]()=^$|] and strings, got: "+a);if(!module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.hasBalancedBrackets_(c))throw Error("() and [] in selector must be balanced, got: "+a);b instanceof module$contents$goog$html$SafeStyle_SafeStyle||(b=module$contents$goog$html$SafeStyle_SafeStyle.create(b));a=`${a}{`+module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b).replace(/</g,"\\\\3C ")+"}";\nreturn module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}static hasBalancedBrackets_(a){const b={"(":")","[":"]"},c=[];for(let d=0;d<a.length;d++){const e=a[d];if(b[e])c.push(b[e]);else if(module$contents$goog$object_contains(b,e)&&c.pop()!=e)return!1}return 0==c.length}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(d)};Array.prototype.forEach.call(arguments,\nc);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY;(0,goog.asserts.assert)(!(0,goog.string.internal.contains)(a,"<"),`Forbidden \'<\' character in style sheet string: ${a}`);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_}static unwrap(a){if(a instanceof\nmodule$contents$goog$html$SafeStyleSheet_SafeStyleSheet&&a.constructor===module$contents$goog$html$SafeStyleSheet_SafeStyleSheet)return a.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeStyleSheet, got \'"+a+"\' of type "+goog.typeOf(a));return"type_error:SafeStyleSheet"}static createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyleSheet_SafeStyleSheet(a,module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE)}}\nmodule$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse("");goog.html.SafeStyleSheet=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet;goog.dom.HtmlElement=function(){};goog.dom.TagName=class{static cast(a,b){return a}constructor(){}toString(){}};goog.dom.TagName.A="A";goog.dom.TagName.ABBR="ABBR";goog.dom.TagName.ACRONYM="ACRONYM";goog.dom.TagName.ADDRESS="ADDRESS";goog.dom.TagName.APPLET="APPLET";goog.dom.TagName.AREA="AREA";goog.dom.TagName.ARTICLE="ARTICLE";goog.dom.TagName.ASIDE="ASIDE";goog.dom.TagName.AUDIO="AUDIO";goog.dom.TagName.B="B";goog.dom.TagName.BASE="BASE";goog.dom.TagName.BASEFONT="BASEFONT";goog.dom.TagName.BDI="BDI";goog.dom.TagName.BDO="BDO";\ngoog.dom.TagName.BIG="BIG";goog.dom.TagName.BLOCKQUOTE="BLOCKQUOTE";goog.dom.TagName.BODY="BODY";goog.dom.TagName.BR="BR";goog.dom.TagName.BUTTON="BUTTON";goog.dom.TagName.CANVAS="CANVAS";goog.dom.TagName.CAPTION="CAPTION";goog.dom.TagName.CENTER="CENTER";goog.dom.TagName.CITE="CITE";goog.dom.TagName.CODE="CODE";goog.dom.TagName.COL="COL";goog.dom.TagName.COLGROUP="COLGROUP";goog.dom.TagName.COMMAND="COMMAND";goog.dom.TagName.DATA="DATA";goog.dom.TagName.DATALIST="DATALIST";goog.dom.TagName.DD="DD";\ngoog.dom.TagName.DEL="DEL";goog.dom.TagName.DETAILS="DETAILS";goog.dom.TagName.DFN="DFN";goog.dom.TagName.DIALOG="DIALOG";goog.dom.TagName.DIR="DIR";goog.dom.TagName.DIV="DIV";goog.dom.TagName.DL="DL";goog.dom.TagName.DT="DT";goog.dom.TagName.EM="EM";goog.dom.TagName.EMBED="EMBED";goog.dom.TagName.FIELDSET="FIELDSET";goog.dom.TagName.FIGCAPTION="FIGCAPTION";goog.dom.TagName.FIGURE="FIGURE";goog.dom.TagName.FONT="FONT";goog.dom.TagName.FOOTER="FOOTER";goog.dom.TagName.FORM="FORM";\ngoog.dom.TagName.FRAME="FRAME";goog.dom.TagName.FRAMESET="FRAMESET";goog.dom.TagName.H1="H1";goog.dom.TagName.H2="H2";goog.dom.TagName.H3="H3";goog.dom.TagName.H4="H4";goog.dom.TagName.H5="H5";goog.dom.TagName.H6="H6";goog.dom.TagName.HEAD="HEAD";goog.dom.TagName.HEADER="HEADER";goog.dom.TagName.HGROUP="HGROUP";goog.dom.TagName.HR="HR";goog.dom.TagName.HTML="HTML";goog.dom.TagName.I="I";goog.dom.TagName.IFRAME="IFRAME";goog.dom.TagName.IMG="IMG";goog.dom.TagName.INPUT="INPUT";\ngoog.dom.TagName.INS="INS";goog.dom.TagName.ISINDEX="ISINDEX";goog.dom.TagName.KBD="KBD";goog.dom.TagName.KEYGEN="KEYGEN";goog.dom.TagName.LABEL="LABEL";goog.dom.TagName.LEGEND="LEGEND";goog.dom.TagName.LI="LI";goog.dom.TagName.LINK="LINK";goog.dom.TagName.MAIN="MAIN";goog.dom.TagName.MAP="MAP";goog.dom.TagName.MARK="MARK";goog.dom.TagName.MATH="MATH";goog.dom.TagName.MENU="MENU";goog.dom.TagName.MENUITEM="MENUITEM";goog.dom.TagName.META="META";goog.dom.TagName.METER="METER";\ngoog.dom.TagName.NAV="NAV";goog.dom.TagName.NOFRAMES="NOFRAMES";goog.dom.TagName.NOSCRIPT="NOSCRIPT";goog.dom.TagName.OBJECT="OBJECT";goog.dom.TagName.OL="OL";goog.dom.TagName.OPTGROUP="OPTGROUP";goog.dom.TagName.OPTION="OPTION";goog.dom.TagName.OUTPUT="OUTPUT";goog.dom.TagName.P="P";goog.dom.TagName.PARAM="PARAM";goog.dom.TagName.PICTURE="PICTURE";goog.dom.TagName.PRE="PRE";goog.dom.TagName.PROGRESS="PROGRESS";goog.dom.TagName.Q="Q";goog.dom.TagName.RP="RP";goog.dom.TagName.RT="RT";\ngoog.dom.TagName.RTC="RTC";goog.dom.TagName.RUBY="RUBY";goog.dom.TagName.S="S";goog.dom.TagName.SAMP="SAMP";goog.dom.TagName.SCRIPT="SCRIPT";goog.dom.TagName.SECTION="SECTION";goog.dom.TagName.SELECT="SELECT";goog.dom.TagName.SMALL="SMALL";goog.dom.TagName.SOURCE="SOURCE";goog.dom.TagName.SPAN="SPAN";goog.dom.TagName.STRIKE="STRIKE";goog.dom.TagName.STRONG="STRONG";goog.dom.TagName.STYLE="STYLE";goog.dom.TagName.SUB="SUB";goog.dom.TagName.SUMMARY="SUMMARY";goog.dom.TagName.SUP="SUP";\ngoog.dom.TagName.SVG="SVG";goog.dom.TagName.TABLE="TABLE";goog.dom.TagName.TBODY="TBODY";goog.dom.TagName.TD="TD";goog.dom.TagName.TEMPLATE="TEMPLATE";goog.dom.TagName.TEXTAREA="TEXTAREA";goog.dom.TagName.TFOOT="TFOOT";goog.dom.TagName.TH="TH";goog.dom.TagName.THEAD="THEAD";goog.dom.TagName.TIME="TIME";goog.dom.TagName.TITLE="TITLE";goog.dom.TagName.TR="TR";goog.dom.TagName.TRACK="TRACK";goog.dom.TagName.TT="TT";goog.dom.TagName.U="U";goog.dom.TagName.UL="UL";goog.dom.TagName.VAR="VAR";\ngoog.dom.TagName.VIDEO="VIDEO";goog.dom.TagName.WBR="WBR";goog.labs={};goog.labs.userAgent={};const module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE="",module$contents$goog$labs$userAgent_USE_CLIENT_HINTS=!1;let module$contents$goog$labs$userAgent_forceClientHintsInTests=!1;goog.labs.userAgent.setUseClientHintsForTesting=a=>{module$contents$goog$labs$userAgent_forceClientHintsInTests=a};\nconst module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride=module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE?!!goog.getObjectByName(module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE):!1;goog.labs.userAgent.useClientHints=()=>module$contents$goog$labs$userAgent_USE_CLIENT_HINTS||module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride||module$contents$goog$labs$userAgent_forceClientHintsInTests;goog.labs.userAgent.util={};const module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT=!1;function module$contents$goog$labs$userAgent$util_getNativeUserAgentString(){var a=module$contents$goog$labs$userAgent$util_getNavigator();return a&&(a=a.userAgent)?a:""}function module$contents$goog$labs$userAgent$util_getNativeUserAgentData(){const a=module$contents$goog$labs$userAgent$util_getNavigator();return a?a.userAgentData||null:null}\nfunction module$contents$goog$labs$userAgent$util_getNavigator(){return goog.global.navigator}let module$contents$goog$labs$userAgent$util_userAgentInternal=null,module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData();\nfunction module$contents$goog$labs$userAgent$util_setUserAgent(a){module$contents$goog$labs$userAgent$util_userAgentInternal="string"===typeof a?a:module$contents$goog$labs$userAgent$util_getNativeUserAgentString()}function module$contents$goog$labs$userAgent$util_getUserAgent(){return null==module$contents$goog$labs$userAgent$util_userAgentInternal?module$contents$goog$labs$userAgent$util_getNativeUserAgentString():module$contents$goog$labs$userAgent$util_userAgentInternal}\nfunction module$contents$goog$labs$userAgent$util_setUserAgentData(a){module$contents$goog$labs$userAgent$util_userAgentDataInternal=a}function module$contents$goog$labs$userAgent$util_resetUserAgentData(){module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData()}function module$contents$goog$labs$userAgent$util_getUserAgentData(){return module$contents$goog$labs$userAgent$util_userAgentDataInternal}\nfunction module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(a){if(!(0,goog.labs.userAgent.useClientHints)())return!1;const b=module$contents$goog$labs$userAgent$util_getUserAgentData();return b?b.brands.some(({brand:c})=>c&&(0,goog.string.internal.contains)(c,a)):!1}function module$contents$goog$labs$userAgent$util_matchUserAgent(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.contains)(b,a)}\nfunction module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.caseInsensitiveContains)(b,a)}function module$contents$goog$labs$userAgent$util_extractVersionTuples(a){const b=RegExp("([A-Z][\\\\w ]+)/([^\\\\s]+)\\\\s*(?:\\\\((.*?)\\\\))?","g"),c=[];let d;for(;d=b.exec(a);)c.push([d[1],d[2],d[3]||void 0]);return c}goog.labs.userAgent.util.ASSUME_CLIENT_HINTS_SUPPORT=module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT;\ngoog.labs.userAgent.util.extractVersionTuples=module$contents$goog$labs$userAgent$util_extractVersionTuples;goog.labs.userAgent.util.getNativeUserAgentString=module$contents$goog$labs$userAgent$util_getNativeUserAgentString;goog.labs.userAgent.util.getUserAgent=module$contents$goog$labs$userAgent$util_getUserAgent;goog.labs.userAgent.util.getUserAgentData=module$contents$goog$labs$userAgent$util_getUserAgentData;goog.labs.userAgent.util.matchUserAgent=module$contents$goog$labs$userAgent$util_matchUserAgent;\ngoog.labs.userAgent.util.matchUserAgentDataBrand=module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand;goog.labs.userAgent.util.matchUserAgentIgnoreCase=module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase;goog.labs.userAgent.util.resetUserAgentData=module$contents$goog$labs$userAgent$util_resetUserAgentData;goog.labs.userAgent.util.setUserAgent=module$contents$goog$labs$userAgent$util_setUserAgent;goog.labs.userAgent.util.setUserAgentData=module$contents$goog$labs$userAgent$util_setUserAgentData;var module$exports$goog$labs$userAgent$highEntropy$highEntropyValue={AsyncValue:class{getIfLoaded(){}load(){}},HighEntropyValue:class{constructor(a){this.key_=a;this.promise_=this.value_=void 0;this.pending_=!1}getIfLoaded(){if(module$contents$goog$labs$userAgent$util_getUserAgentData())return this.value_}async load(){const a=module$contents$goog$labs$userAgent$util_getUserAgentData();if(a)return this.promise_||(this.pending_=!0,this.promise_=(async()=>{try{return this.value_=(await a.getHighEntropyValues([this.key_]))[this.key_]}finally{this.pending_=\n!1}})()),await this.promise_}resetForTesting(){if(this.pending_)throw Error("Unsafe call to resetForTesting");this.value_=this.promise_=void 0;this.pending_=!1}},Version:class{constructor(a){this.versionString_=a}toVersionStringForLogging(){return this.versionString_}isAtLeast(a){return 0<=(0,goog.string.internal.compareVersions)(this.versionString_,a)}}};var module$exports$goog$labs$userAgent$highEntropy$highEntropyData={};module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("fullVersionList");module$exports$goog$labs$userAgent$highEntropy$highEntropyData.platformVersion=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("platformVersion");goog.labs.userAgent.browser={};const module$contents$goog$labs$userAgent$browser_Brand={ANDROID_BROWSER:"Android Browser",CHROMIUM:"Chromium",EDGE:"Microsoft Edge",FIREFOX:"Firefox",IE:"Internet Explorer",OPERA:"Opera",SAFARI:"Safari",SILK:"Silk"};goog.labs.userAgent.browser.Brand=module$contents$goog$labs$userAgent$browser_Brand;\nfunction module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(a=!1){if(module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT)return!0;if(!a&&!(0,goog.labs.userAgent.useClientHints)())return!1;a=module$contents$goog$labs$userAgent$util_getUserAgentData();return!!a&&0<a.brands.length}\nfunction module$contents$goog$labs$userAgent$browser_hasFullVersionList(){return module$contents$goog$labs$userAgent$browser_isAtLeast(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM,98)}function module$contents$goog$labs$userAgent$browser_matchOpera(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Opera")}\nfunction module$contents$goog$labs$userAgent$browser_matchIE(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Trident")||module$contents$goog$labs$userAgent$util_matchUserAgent("MSIE")}function module$contents$goog$labs$userAgent$browser_matchEdgeHtml(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Edge")}\nfunction module$contents$goog$labs$userAgent$browser_matchEdgeChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.EDGE):module$contents$goog$labs$userAgent$util_matchUserAgent("Edg/")}\nfunction module$contents$goog$labs$userAgent$browser_matchOperaChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.OPERA):module$contents$goog$labs$userAgent$util_matchUserAgent("OPR")}\nfunction module$contents$goog$labs$userAgent$browser_matchFirefox(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Firefox")||module$contents$goog$labs$userAgent$util_matchUserAgent("FxiOS")}\nfunction module$contents$goog$labs$userAgent$browser_matchSafari(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Safari")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchCoast()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_matchEdgeChromium()||module$contents$goog$labs$userAgent$browser_matchOperaChromium()||\nmodule$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_isSilk()||module$contents$goog$labs$userAgent$util_matchUserAgent("Android"))}function module$contents$goog$labs$userAgent$browser_matchCoast(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Coast")}\nfunction module$contents$goog$labs$userAgent$browser_matchIosWebview(){return(module$contents$goog$labs$userAgent$util_matchUserAgent("iPad")||module$contents$goog$labs$userAgent$util_matchUserAgent("iPhone"))&&!module$contents$goog$labs$userAgent$browser_matchSafari()&&!module$contents$goog$labs$userAgent$browser_matchChrome()&&!module$contents$goog$labs$userAgent$browser_matchCoast()&&!module$contents$goog$labs$userAgent$browser_matchFirefox()&&module$contents$goog$labs$userAgent$util_matchUserAgent("AppleWebKit")}\nfunction module$contents$goog$labs$userAgent$browser_matchChrome(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM):(module$contents$goog$labs$userAgent$util_matchUserAgent("Chrome")||module$contents$goog$labs$userAgent$util_matchUserAgent("CriOS"))&&!module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_isSilk()}\nfunction module$contents$goog$labs$userAgent$browser_matchAndroidBrowser(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Android")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_isSilk())}const module$contents$goog$labs$userAgent$browser_isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;\ngoog.labs.userAgent.browser.isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;const module$contents$goog$labs$userAgent$browser_isIE=module$contents$goog$labs$userAgent$browser_matchIE;goog.labs.userAgent.browser.isIE=module$contents$goog$labs$userAgent$browser_matchIE;const module$contents$goog$labs$userAgent$browser_isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;goog.labs.userAgent.browser.isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;\nconst module$contents$goog$labs$userAgent$browser_isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;goog.labs.userAgent.browser.isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;const module$contents$goog$labs$userAgent$browser_isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;goog.labs.userAgent.browser.isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;\nconst module$contents$goog$labs$userAgent$browser_isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;goog.labs.userAgent.browser.isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;const module$contents$goog$labs$userAgent$browser_isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;goog.labs.userAgent.browser.isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;const module$contents$goog$labs$userAgent$browser_isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;\ngoog.labs.userAgent.browser.isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;const module$contents$goog$labs$userAgent$browser_isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;goog.labs.userAgent.browser.isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;const module$contents$goog$labs$userAgent$browser_isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;goog.labs.userAgent.browser.isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;\nconst module$contents$goog$labs$userAgent$browser_isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;goog.labs.userAgent.browser.isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;function module$contents$goog$labs$userAgent$browser_isSilk(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Silk")}goog.labs.userAgent.browser.isSilk=module$contents$goog$labs$userAgent$browser_isSilk;\nfunction module$contents$goog$labs$userAgent$browser_createVersionMap(a){const b={};a.forEach(c=>{b[c[0]]=c[1]});return c=>b[c.find(d=>d in b)]||""}\nfunction module$contents$goog$labs$userAgent$browser_getVersion(){var a=module$contents$goog$labs$userAgent$util_getUserAgent();if(module$contents$goog$labs$userAgent$browser_matchIE())return module$contents$goog$labs$userAgent$browser_getIEVersion(a);a=module$contents$goog$labs$userAgent$util_extractVersionTuples(a);const b=module$contents$goog$labs$userAgent$browser_createVersionMap(a);return module$contents$goog$labs$userAgent$browser_matchOpera()?b(["Version","Opera"]):module$contents$goog$labs$userAgent$browser_matchEdgeHtml()?\nb(["Edge"]):module$contents$goog$labs$userAgent$browser_matchEdgeChromium()?b(["Edg"]):module$contents$goog$labs$userAgent$browser_isSilk()?b(["Silk"]):module$contents$goog$labs$userAgent$browser_matchChrome()?b(["Chrome","CriOS","HeadlessChrome"]):(a=a[2])&&a[1]||""}goog.labs.userAgent.browser.getVersion=module$contents$goog$labs$userAgent$browser_getVersion;\nfunction module$contents$goog$labs$userAgent$browser_isVersionOrHigher(a){return 0<=(0,goog.string.internal.compareVersions)(module$contents$goog$labs$userAgent$browser_getVersion(),a)}goog.labs.userAgent.browser.isVersionOrHigher=module$contents$goog$labs$userAgent$browser_isVersionOrHigher;\nfunction module$contents$goog$labs$userAgent$browser_getIEVersion(a){var b=/rv: *([\\d\\.]*)/.exec(a);if(b&&b[1])return b[1];b="";const c=/MSIE +([\\d\\.]+)/.exec(a);if(c&&c[1])if(a=/Trident\\/(\\d.\\d)/.exec(a),"7.0"==c[1])if(a&&a[1])switch(a[1]){case "4.0":b="8.0";break;case "5.0":b="9.0";break;case "6.0":b="10.0";break;case "7.0":b="11.0"}else b="7.0";else b=c[1];return b}\nfunction module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a){var b=module$contents$goog$labs$userAgent$util_getUserAgent();if(a===module$contents$goog$labs$userAgent$browser_Brand.IE)return module$contents$goog$labs$userAgent$browser_matchIE()?module$contents$goog$labs$userAgent$browser_getIEVersion(b):"";b=module$contents$goog$labs$userAgent$util_extractVersionTuples(b);const c=module$contents$goog$labs$userAgent$browser_createVersionMap(b);switch(a){case module$contents$goog$labs$userAgent$browser_Brand.OPERA:if(module$contents$goog$labs$userAgent$browser_matchOpera())return c(["Version",\n"Opera"]);if(module$contents$goog$labs$userAgent$browser_matchOperaChromium())return c(["OPR"]);break;case module$contents$goog$labs$userAgent$browser_Brand.EDGE:if(module$contents$goog$labs$userAgent$browser_matchEdgeHtml())return c(["Edge"]);if(module$contents$goog$labs$userAgent$browser_matchEdgeChromium())return c(["Edg"]);break;case module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM:if(module$contents$goog$labs$userAgent$browser_matchChrome())return c(["Chrome","CriOS","HeadlessChrome"])}return a===\nmodule$contents$goog$labs$userAgent$browser_Brand.FIREFOX&&module$contents$goog$labs$userAgent$browser_matchFirefox()||a===module$contents$goog$labs$userAgent$browser_Brand.SAFARI&&module$contents$goog$labs$userAgent$browser_matchSafari()||a===module$contents$goog$labs$userAgent$browser_Brand.ANDROID_BROWSER&&module$contents$goog$labs$userAgent$browser_matchAndroidBrowser()||a===module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_isSilk()?(a=b[2])&&\na[1]||"":""}\nfunction module$contents$goog$labs$userAgent$browser_versionOf_(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()&&a!==module$contents$goog$labs$userAgent$browser_Brand.SILK){var b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);if(!b||!b.version)return NaN;b=b.version.split(".")}else{b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a);if(""===b)return NaN;b=b.split(".")}return 0===b.length?NaN:Number(b[0])}\nfunction module$contents$goog$labs$userAgent$browser_isAtLeast(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)>=b}goog.labs.userAgent.browser.isAtLeast=module$contents$goog$labs$userAgent$browser_isAtLeast;\nfunction module$contents$goog$labs$userAgent$browser_isAtMost(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)<=b}goog.labs.userAgent.browser.isAtMost=module$contents$goog$labs$userAgent$browser_isAtMost;\nclass module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion{constructor(a,b,c){this.brand_=a;this.version_=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(c);this.useUach_=b}getIfLoaded(){if(this.useUach_){var a=module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.getIfLoaded();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}if(module$contents$goog$labs$userAgent$browser_preUachHasLoaded)return this.version_}async load(){if(this.useUach_){var a=\nawait module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}else await 0;module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0;return this.version_}}let module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;\nasync function module$contents$goog$labs$userAgent$browser_loadFullVersions(){module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)&&await module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0}goog.labs.userAgent.browser.loadFullVersions=module$contents$goog$labs$userAgent$browser_loadFullVersions;\ngoog.labs.userAgent.browser.resetForTesting=()=>{module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.resetForTesting()};\nfunction module$contents$goog$labs$userAgent$browser_fullVersionOf(a){let b="";module$contents$goog$labs$userAgent$browser_hasFullVersionList()||(b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a));const c=a!==module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0);if(c){if(!module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:d})=>d===a))return}else if(""===b)return;return new module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion(a,\nc,b)}goog.labs.userAgent.browser.fullVersionOf=module$contents$goog$labs$userAgent$browser_fullVersionOf;\nfunction module$contents$goog$labs$userAgent$browser_getVersionStringForLogging(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)){var b=module$contents$goog$labs$userAgent$browser_fullVersionOf(a);if(b){if(b=b.getIfLoaded())return b.toVersionStringForLogging();b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);(0,goog.asserts.assertExists)(b);return b.version}return""}return module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a)}\ngoog.labs.userAgent.browser.getVersionStringForLogging=module$contents$goog$labs$userAgent$browser_getVersionStringForLogging;goog.dom.tags={};goog.dom.tags.VOID_TAGS_={area:!0,base:!0,br:!0,col:!0,command:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};goog.dom.tags.isVoidTag=function(a){return!0===goog.dom.tags.VOID_TAGS_[a]};const module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE={};\nclass module$contents$goog$html$SafeHtml_SafeHtml{constructor(a,b){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_=b===module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}toString(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(a).toString()}static unwrapTrustedHTML(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml&&\na.constructor===module$contents$goog$html$SafeHtml_SafeHtml)return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_;goog.asserts.fail(`expected object of type SafeHtml, got \'${a}\' of type `+goog.typeOf(a));return"type_error:SafeHtml"}static htmlEscape(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.htmlEscape(a))}static htmlEscapePreservingNewlines(a){if(a instanceof\nmodule$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.newLineToBr(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static htmlEscapePreservingNewlinesAndSpaces(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.whitespaceEscape(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static comment(a){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("\\x3c!--"+\ngoog.string.internal.htmlEscape(a)+"--\\x3e")}static create(a,b,c){module$contents$goog$html$SafeHtml_SafeHtml.verifyTagName(String(a));return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(String(a),b,c)}static verifyTagName(a){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Invalid tag name <${a}>.`:"");if(a.toUpperCase()in module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n`Tag name <${a}> is not allowed for SafeHtml.`:"");}static createIframe(a,b,c,d){a&&goog.html.TrustedResourceUrl.unwrap(a);const e={};e.src=a||null;e.srcdoc=b&&module$contents$goog$html$SafeHtml_SafeHtml.unwrap(b);a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{sandbox:""},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static createSandboxIframe(a,b,c,d){if(!module$contents$goog$html$SafeHtml_SafeHtml.canUseSandboxIframe())throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n"The browser does not support sandboxed iframes.":"");const e={};e.src=a?goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a)):null;e.srcdoc=b||null;e.sandbox="";a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static canUseSandboxIframe(){return goog.global.HTMLIFrameElement&&"sandbox"in goog.global.HTMLIFrameElement.prototype}static createScriptSrc(a,b){goog.html.TrustedResourceUrl.unwrap(a);\na=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({src:a},{},b);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",a)}static createScript(a,b){for(var c in b)if(Object.prototype.hasOwnProperty.call(b,c)){var d=c.toLowerCase();if("language"==d||"src"==d||"text"==d)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot set "${d}" attribute`:"");}c="";a=module$contents$goog$array_concat(a);for(d=0;d<\na.length;d++)c+=module$contents$goog$html$SafeScript_SafeScript.unwrap(a[d]);a=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",b,a)}static createStyle(a,b){b=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({type:"text/css"},{},b);let c="";a=module$contents$goog$array_concat(a);for(let d=0;d<a.length;d++)c+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(a[d]);\na=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("style",b,a)}static createMetaRefresh(a,b){a=goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a));(module$contents$goog$labs$userAgent$browser_matchIE()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml())&&goog.string.internal.contains(a,";")&&(a="\'"+a.replace(/\'/g,"%27")+"\'");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("meta",\n{"http-equiv":"refresh",content:(b||0)+"; url="+a})}static join(a,b){a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);const c=[],d=e=>{Array.isArray(e)?e.forEach(d):(e=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(e),c.push(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(e)))};b.forEach(d);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c.join(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static concat(a){return module$contents$goog$html$SafeHtml_SafeHtml.join(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY,\nArray.prototype.slice.call(arguments))}static createSafeHtmlSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createHTML(a):a;return new module$contents$goog$html$SafeHtml_SafeHtml(a,module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE)}static createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(a,b,c){b=`<${a}`+module$contents$goog$html$SafeHtml_SafeHtml.stringifyAttributes(a,b);null==c?c=[]:Array.isArray(c)||(c=[c]);goog.dom.tags.isVoidTag(a.toLowerCase())?\n(goog.asserts.assert(!c.length,`Void tag <${a}> does not allow content.`),b+=">"):(c=module$contents$goog$html$SafeHtml_SafeHtml.concat(c),b+=">"+module$contents$goog$html$SafeHtml_SafeHtml.unwrap(c)+"</"+a+">");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)}static stringifyAttributes(a,b){let c="";if(b)for(let d in b)if(Object.prototype.hasOwnProperty.call(b,d)){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(d))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n`Invalid attribute name "${d}".`:"");const e=b[d];null!=e&&(c+=" "+module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,d,e))}return c}static combineAttributes(a,b,c){const d={};for(var e in a)Object.prototype.hasOwnProperty.call(a,e)&&(goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=a[e]);for(const f in b)Object.prototype.hasOwnProperty.call(b,f)&&(goog.asserts.assert(f.toLowerCase()==f,"Must be lower case"),d[f]=b[f]);if(c)for(const f in c)if(Object.prototype.hasOwnProperty.call(c,\nf)){e=f.toLowerCase();if(e in a)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot override "${e}" attribute, got "`+f+\'" with value "\'+c[f]+\'"\':"");e in b&&delete d[e];d[f]=c[f]}return d}}module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES=goog.DEBUG;module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE=!0;module$contents$goog$html$SafeHtml_SafeHtml.from=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape;\nconst module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG=/^[a-zA-Z0-9-]+$/,module$contents$goog$html$SafeHtml_URL_ATTRIBUTES={action:!0,cite:!0,data:!0,formaction:!0,href:!0,manifest:!0,poster:!0,src:!0},module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES={[goog.dom.TagName.APPLET]:!0,[goog.dom.TagName.BASE]:!0,[goog.dom.TagName.EMBED]:!0,[goog.dom.TagName.IFRAME]:!0,[goog.dom.TagName.LINK]:!0,[goog.dom.TagName.MATH]:!0,[goog.dom.TagName.META]:!0,[goog.dom.TagName.OBJECT]:!0,[goog.dom.TagName.SCRIPT]:!0,\n[goog.dom.TagName.STYLE]:!0,[goog.dom.TagName.SVG]:!0,[goog.dom.TagName.TEMPLATE]:!0};\nfunction module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,b,c){if(c instanceof goog.string.Const)c=goog.string.Const.unwrap(c);else if("style"==b.toLowerCase())if(module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE)c=module$contents$goog$html$SafeHtml_getStyleValue(c);else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\'Attribute "style" not supported.\':"");else{if(/^on/i.test(b))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\n`Attribute "${b}`+\'" requires goog.string.Const value, "\'+c+\'" given.\':"");if(b.toLowerCase()in module$contents$goog$html$SafeHtml_URL_ATTRIBUTES)if(c instanceof goog.html.TrustedResourceUrl)c=goog.html.TrustedResourceUrl.unwrap(c);else if(c instanceof goog.html.SafeUrl)c=goog.html.SafeUrl.unwrap(c);else if("string"===typeof c)c=goog.html.SafeUrl.sanitize(c).getTypedStringValue();else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Attribute "${b}" on tag "${a}`+\'" requires goog.html.SafeUrl, goog.string.Const, or string, value "\'+\nc+\'" given.\':"");}c.implementsGoogStringTypedString&&(c=c.getTypedStringValue());goog.asserts.assert("string"===typeof c||"number"===typeof c,"String or number value expected, got "+typeof c+" with value: "+c);return`${b}="`+goog.string.internal.htmlEscape(String(c))+\'"\'}\nfunction module$contents$goog$html$SafeHtml_getStyleValue(a){if(!goog.isObject(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?\'The "style" attribute requires goog.html.SafeStyle or map of style properties, \'+typeof a+" given: "+a:"");a instanceof module$contents$goog$html$SafeStyle_SafeStyle||(a=module$contents$goog$html$SafeStyle_SafeStyle.create(a));return module$contents$goog$html$SafeStyle_SafeStyle.unwrap(a)}\nmodule$contents$goog$html$SafeHtml_SafeHtml.DOCTYPE_HTML=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<!DOCTYPE html>")}();module$contents$goog$html$SafeHtml_SafeHtml.EMPTY=new module$contents$goog$html$SafeHtml_SafeHtml(goog.global.trustedTypes&&goog.global.trustedTypes.emptyHTML||"",module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE);module$contents$goog$html$SafeHtml_SafeHtml.BR=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<br>")}();\ngoog.html.SafeHtml=module$contents$goog$html$SafeHtml_SafeHtml;goog.html.uncheckedconversions={};goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};\ngoog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.dom.safe={};goog.dom.safe.InsertAdjacentHtmlPosition={AFTERBEGIN:"afterbegin",AFTEREND:"afterend",BEFOREBEGIN:"beforebegin",BEFOREEND:"beforeend"};goog.dom.safe.insertAdjacentHtml=function(a,b,c){a.insertAdjacentHTML(b,module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(c))};goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_={MATH:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};\ngoog.dom.safe.isInnerHtmlCleanupRecursive_=goog.functions.cacheReturnValue(function(){if(goog.DEBUG&&"undefined"===typeof document)return!1;var a=document.createElement("div"),b=document.createElement("div");b.appendChild(document.createElement("div"));a.appendChild(b);if(goog.DEBUG&&!a.firstChild)return!1;b=a.firstChild.firstChild;a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY);return!b.parentElement});\ngoog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse=function(a,b){if(goog.dom.safe.isInnerHtmlCleanupRecursive_())for(;a.lastChild;)a.removeChild(a.lastChild);a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};\ngoog.dom.safe.setInnerHtml=function(a,b){if(goog.asserts.ENABLE_ASSERTS&&a.tagName){var c=a.tagName.toUpperCase();if(goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[c])throw Error("goog.dom.safe.setInnerHtml cannot be used to set content of "+a.tagName+".");}goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse(a,b)};\ngoog.dom.safe.setInnerHtmlFromConstant=function(a,b){goog.dom.safe.setInnerHtml(a,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Constant HTML to be immediatelly used."),goog.string.Const.unwrap(b)))};goog.dom.safe.setOuterHtml=function(a,b){a.outerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};\ngoog.dom.safe.setFormElementAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLFormElement(a).action=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setButtonFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLButtonElement(a).formAction=goog.html.SafeUrl.unwrap(b)};\ngoog.dom.safe.setInputFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLInputElement(a).formAction=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setStyle=function(a,b){a.style.cssText=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b)};goog.dom.safe.documentWrite=function(a,b){a.write(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};\ngoog.dom.safe.setAnchorHref=function(a,b){goog.dom.asserts.assertIsHTMLAnchorElement(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setAudioSrc=function(a,b){goog.dom.asserts.assertIsHTMLAudioElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:audio\\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};\ngoog.dom.safe.setVideoSrc=function(a,b){goog.dom.asserts.assertIsHTMLVideoElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:video\\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setEmbedSrc=function(a,b){goog.dom.asserts.assertIsHTMLEmbedElement(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setFrameSrc=function(a,b){goog.dom.asserts.assertIsHTMLFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};\ngoog.dom.safe.setIframeSrc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrcdoc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.srcdoc=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};\ngoog.dom.safe.setLinkHrefAndRel=function(a,b,c){goog.dom.asserts.assertIsHTMLLinkElement(a);a.rel=c;goog.string.internal.caseInsensitiveContains(c,"stylesheet")?(goog.asserts.assert(b instanceof goog.html.TrustedResourceUrl,\'URL must be TrustedResourceUrl because "rel" contains "stylesheet"\'),a.href=goog.html.TrustedResourceUrl.unwrap(b),(b=goog.dom.safe.getStyleNonce(a.ownerDocument&&a.ownerDocument.defaultView))&&a.setAttribute("nonce",b)):a.href=b instanceof goog.html.TrustedResourceUrl?goog.html.TrustedResourceUrl.unwrap(b):\nb instanceof goog.html.SafeUrl?goog.html.SafeUrl.unwrap(b):goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitizeAssertUnchanged(b))};goog.dom.safe.setObjectData=function(a,b){goog.dom.asserts.assertIsHTMLObjectElement(a);a.data=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setScriptSrc=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};\ngoog.dom.safe.setScriptContent=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.textContent=module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(b)};goog.dom.safe.setNonceForScriptElement_=function(a){const b=goog.dom.safe.getScriptNonce(a.ownerDocument&&a.ownerDocument.defaultView);b&&a.setAttribute("nonce",b)};\ngoog.dom.safe.setLocationHref=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.assignLocation=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.assign(goog.html.SafeUrl.unwrap(b))};\ngoog.dom.safe.replaceLocation=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.replace(goog.html.SafeUrl.unwrap(b))};goog.dom.safe.openInWindow=function(a,b,c,d){a=a instanceof goog.html.SafeUrl?a:goog.html.SafeUrl.sanitizeAssertUnchanged(a);b=b||goog.global;c=c instanceof goog.string.Const?goog.string.Const.unwrap(c):c||"";return void 0!==d?b.open(goog.html.SafeUrl.unwrap(a),c,d):b.open(goog.html.SafeUrl.unwrap(a),c)};\ngoog.dom.safe.parseFromStringHtml=function(a,b){return goog.dom.safe.parseFromString(a,b,"text/html")};goog.dom.safe.parseFromString=function(a,b,c){return a.parseFromString(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b),c)};\ngoog.dom.safe.createImageFromBlob=function(a){if(!/^image\\/.*/g.test(a.type))throw Error("goog.dom.safe.createImageFromBlob only accepts MIME type image/.*.");var b=goog.global.URL.createObjectURL(a);a=new goog.global.Image;a.onload=function(){goog.global.URL.revokeObjectURL(b)};a.src=b;return a};goog.dom.safe.createContextualFragment=function(a,b){return a.createContextualFragment(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};\ngoog.dom.safe.getScriptNonce=function(a){return goog.dom.safe.getNonce_("script[nonce]",a)};goog.dom.safe.getStyleNonce=function(a){return goog.dom.safe.getNonce_(\'style[nonce],link[rel="stylesheet"][nonce]\',a)};goog.dom.safe.NONCE_PATTERN_=/^[\\w+/_-]+[=]{0,2}$/;goog.dom.safe.getNonce_=function(a,b){b=(b||goog.global).document;return b.querySelector?(a=b.querySelector(a))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.dom.safe.NONCE_PATTERN_.test(a)?a:"":""};goog.string.DETECT_DOUBLE_ESCAPING=!1;goog.string.FORCE_NON_DOM_HTML_UNESCAPING=!1;goog.string.Unicode={NBSP:"\\u00a0",ZERO_WIDTH_SPACE:"\\u200b"};goog.string.startsWith=goog.string.internal.startsWith;goog.string.endsWith=goog.string.internal.endsWith;goog.string.caseInsensitiveStartsWith=goog.string.internal.caseInsensitiveStartsWith;goog.string.caseInsensitiveEndsWith=goog.string.internal.caseInsensitiveEndsWith;goog.string.caseInsensitiveEquals=goog.string.internal.caseInsensitiveEquals;\ngoog.string.subs=function(a,b){const c=a.split("%s");let d="";const e=Array.prototype.slice.call(arguments,1);for(;e.length&&1<c.length;)d+=c.shift()+e.shift();return d+c.join("%s")};goog.string.collapseWhitespace=function(a){return a.replace(/[\\s\\xa0]+/g," ").replace(/^\\s+|\\s+$/g,"")};goog.string.isEmptyOrWhitespace=goog.string.internal.isEmptyOrWhitespace;goog.string.isEmptyString=function(a){return 0==a.length};goog.string.isEmpty=goog.string.isEmptyOrWhitespace;\ngoog.string.isEmptyOrWhitespaceSafe=function(a){return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(a))};goog.string.isEmptySafe=goog.string.isEmptyOrWhitespaceSafe;goog.string.isBreakingWhitespace=function(a){return!/[^\\t\\n\\r ]/.test(a)};goog.string.isAlpha=function(a){return!/[^a-zA-Z]/.test(a)};goog.string.isNumeric=function(a){return!/[^0-9]/.test(a)};goog.string.isAlphaNumeric=function(a){return!/[^a-zA-Z0-9]/.test(a)};goog.string.isSpace=function(a){return" "==a};\ngoog.string.isUnicodeChar=function(a){return 1==a.length&&" "<=a&&"~">=a||"\\u0080"<=a&&"\\ufffd">=a};goog.string.stripNewlines=function(a){return a.replace(/(\\r\\n|\\r|\\n)+/g," ")};goog.string.canonicalizeNewlines=function(a){return a.replace(/(\\r\\n|\\r|\\n)/g,"\\n")};goog.string.normalizeWhitespace=function(a){return a.replace(/\\xa0|\\s/g," ")};goog.string.normalizeSpaces=function(a){return a.replace(/\\xa0|[ \\t]+/g," ")};\ngoog.string.collapseBreakingSpaces=function(a){return a.replace(/[\\t\\r\\n ]+/g," ").replace(/^[\\t\\r\\n ]+|[\\t\\r\\n ]+$/g,"")};goog.string.trim=goog.string.internal.trim;goog.string.trimLeft=function(a){return a.replace(/^[\\s\\xa0]+/,"")};goog.string.trimRight=function(a){return a.replace(/[\\s\\xa0]+$/,"")};goog.string.caseInsensitiveCompare=goog.string.internal.caseInsensitiveCompare;\ngoog.string.numberAwareCompare_=function(a,b,c){if(a==b)return 0;if(!a)return-1;if(!b)return 1;const d=a.toLowerCase().match(c),e=b.toLowerCase().match(c),f=Math.min(d.length,e.length);for(let g=0;g<f;g++){c=d[g];const h=e[g];if(c!=h)return a=parseInt(c,10),!isNaN(a)&&(b=parseInt(h,10),!isNaN(b)&&a-b)?a-b:c<h?-1:1}return d.length!=e.length?d.length-e.length:a<b?-1:1};goog.string.intAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\\d+|\\D+/g)};\ngoog.string.floatAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\\d+|\\.\\d+|\\D+/g)};goog.string.numerateCompare=goog.string.floatAwareCompare;goog.string.urlEncode=function(a){return encodeURIComponent(String(a))};goog.string.urlDecode=function(a){return decodeURIComponent(a.replace(/\\+/g," "))};goog.string.newLineToBr=goog.string.internal.newLineToBr;\ngoog.string.htmlEscape=function(a,b){a=goog.string.internal.htmlEscape(a,b);goog.string.DETECT_DOUBLE_ESCAPING&&(a=a.replace(goog.string.E_RE_,"&#101;"));return a};goog.string.E_RE_=/e/g;goog.string.unescapeEntities=function(a){return goog.string.contains(a,"&")?!goog.string.FORCE_NON_DOM_HTML_UNESCAPING&&"document"in goog.global?goog.string.unescapeEntitiesUsingDom_(a):goog.string.unescapePureXmlEntities_(a):a};\ngoog.string.unescapeEntitiesWithDocument=function(a,b){return goog.string.contains(a,"&")?goog.string.unescapeEntitiesUsingDom_(a,b):a};\ngoog.string.unescapeEntitiesUsingDom_=function(a,b){const c={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":\'"\'};let d;d=b?b.createElement("div"):goog.global.document.createElement("div");return a.replace(goog.string.HTML_ENTITY_PATTERN_,function(e,f){let g=c[e];if(g)return g;"#"==f.charAt(0)&&(f=Number("0"+f.slice(1)),isNaN(f)||(g=String.fromCharCode(f)));g||(goog.dom.safe.setInnerHtml(d,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Single HTML entity."),\ne+" ")),g=d.firstChild.nodeValue.slice(0,-1));return c[e]=g})};goog.string.unescapePureXmlEntities_=function(a){return a.replace(/&([^;]+);/g,function(b,c){switch(c){case "amp":return"&";case "lt":return"<";case "gt":return">";case "quot":return\'"\';default:return"#"!=c.charAt(0)||(c=Number("0"+c.slice(1)),isNaN(c))?b:String.fromCharCode(c)}})};goog.string.HTML_ENTITY_PATTERN_=/&([^;\\s<&]+);?/g;goog.string.whitespaceEscape=function(a,b){return goog.string.newLineToBr(a.replace(/  /g," &#160;"),b)};\ngoog.string.preserveSpaces=function(a){return a.replace(/(^|[\\n ]) /g,"$1"+goog.string.Unicode.NBSP)};goog.string.stripQuotes=function(a,b){const c=b.length;for(let d=0;d<c;d++){const e=1==c?b:b.charAt(d);if(a.charAt(0)==e&&a.charAt(a.length-1)==e)return a.substring(1,a.length-1)}return a};goog.string.truncate=function(a,b,c){c&&(a=goog.string.unescapeEntities(a));a.length>b&&(a=a.substring(0,b-3)+"...");c&&(a=goog.string.htmlEscape(a));return a};\ngoog.string.truncateMiddle=function(a,b,c,d){c&&(a=goog.string.unescapeEntities(a));if(d&&a.length>b){d>b&&(d=b);var e=a.length-d;a=a.substring(0,b-d)+"..."+a.substring(e)}else a.length>b&&(d=Math.floor(b/2),e=a.length-d,a=a.substring(0,d+b%2)+"..."+a.substring(e));c&&(a=goog.string.htmlEscape(a));return a};goog.string.specialEscapeChars_={"\\x00":"\\\\0","\\b":"\\\\b","\\f":"\\\\f","\\n":"\\\\n","\\r":"\\\\r","\\t":"\\\\t","\\v":"\\\\x0B",\'"\':\'\\\\"\',"\\\\":"\\\\\\\\","<":"\\\\u003C"};goog.string.jsEscapeCache_={"\'":"\\\\\'"};\ngoog.string.quote=function(a){a=String(a);const b=[\'"\'];for(let c=0;c<a.length;c++){const d=a.charAt(c),e=d.charCodeAt(0);b[c+1]=goog.string.specialEscapeChars_[d]||(31<e&&127>e?d:goog.string.escapeChar(d))}b.push(\'"\');return b.join("")};goog.string.escapeString=function(a){const b=[];for(let c=0;c<a.length;c++)b[c]=goog.string.escapeChar(a.charAt(c));return b.join("")};\ngoog.string.escapeChar=function(a){if(a in goog.string.jsEscapeCache_)return goog.string.jsEscapeCache_[a];if(a in goog.string.specialEscapeChars_)return goog.string.jsEscapeCache_[a]=goog.string.specialEscapeChars_[a];let b;const c=a.charCodeAt(0);if(31<c&&127>c)b=a;else{if(256>c){if(b="\\\\x",16>c||256<c)b+="0"}else b="\\\\u",4096>c&&(b+="0");b+=c.toString(16).toUpperCase()}return goog.string.jsEscapeCache_[a]=b};goog.string.contains=goog.string.internal.contains;\ngoog.string.caseInsensitiveContains=goog.string.internal.caseInsensitiveContains;goog.string.countOf=function(a,b){return a&&b?a.split(b).length-1:0};goog.string.removeAt=function(a,b,c){let d=a;0<=b&&b<a.length&&0<c&&(d=a.slice(0,b)+a.slice(b+c));return d};goog.string.remove=function(a,b){return a.replace(b,"")};goog.string.removeAll=function(a,b){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,"")};\ngoog.string.replaceAll=function(a,b,c){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,c.replace(/\\$/g,"$$$$"))};goog.string.regExpEscape=function(a){return String(a).replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g,"\\\\$1").replace(/\\x08/g,"\\\\x08")};goog.string.repeat=String.prototype.repeat?function(a,b){return a.repeat(b)}:function(a,b){return Array(b+1).join(a)};\ngoog.string.padNumber=function(a,b,c){if(!Number.isFinite(a))return String(a);a=void 0!==c?a.toFixed(c):String(a);c=a.indexOf(".");-1===c&&(c=a.length);const d="-"===a[0]?"-":"";d&&(a=a.substring(1));return d+goog.string.repeat("0",Math.max(0,b-c))+a};goog.string.makeSafe=function(a){return null==a?"":String(a)};goog.string.getRandomString=function(){return Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^goog.now()).toString(36)};\ngoog.string.compareVersions=goog.string.internal.compareVersions;goog.string.hashCode=function(a){let b=0;for(let c=0;c<a.length;++c)b=31*b+a.charCodeAt(c)>>>0;return b};goog.string.uniqueStringCounter_=2147483648*Math.random()|0;goog.string.createUniqueString=function(){return"goog_"+goog.string.uniqueStringCounter_++};goog.string.toNumber=function(a){const b=Number(a);return 0==b&&goog.string.isEmptyOrWhitespace(a)?NaN:b};goog.string.isLowerCamelCase=function(a){return/^[a-z]+([A-Z][a-z]*)*$/.test(a)};\ngoog.string.isUpperCamelCase=function(a){return/^([A-Z][a-z]*)+$/.test(a)};goog.string.toCamelCase=function(a){return String(a).replace(/\\-([a-z])/g,function(b,c){return c.toUpperCase()})};goog.string.toSelectorCase=function(a){return String(a).replace(/([A-Z])/g,"-$1").toLowerCase()};goog.string.toTitleCase=function(a,b){b="string"===typeof b?goog.string.regExpEscape(b):"\\\\s";return a.replace(new RegExp("(^"+(b?"|["+b+"]+":"")+")([a-z])","g"),function(c,d,e){return d+e.toUpperCase()})};\ngoog.string.capitalize=function(a){return String(a.charAt(0)).toUpperCase()+String(a.slice(1)).toLowerCase()};goog.string.parseInt=function(a){isFinite(a)&&(a=String(a));return"string"===typeof a?/^\\s*-?0x/i.test(a)?parseInt(a,16):parseInt(a,10):NaN};goog.string.splitLimit=function(a,b,c){a=a.split(b);const d=[];for(;0<c&&a.length;)d.push(a.shift()),c--;a.length&&d.push(a.join(b));return d};\ngoog.string.lastComponent=function(a,b){if(b)"string"==typeof b&&(b=[b]);else return a;let c=-1;for(let d=0;d<b.length;d++){if(""==b[d])continue;const e=a.lastIndexOf(b[d]);e>c&&(c=e)}return-1==c?a:a.slice(c+1)};\ngoog.string.editDistance=function(a,b){const c=[],d=[];if(a==b)return 0;if(!a.length||!b.length)return Math.max(a.length,b.length);for(var e=0;e<b.length+1;e++)c[e]=e;for(e=0;e<a.length;e++){d[0]=e+1;for(var f=0;f<b.length;f++)d[f+1]=Math.min(d[f]+1,c[f+1]+1,c[f]+Number(a[e]!=b[f]));for(f=0;f<c.length;f++)c[f]=d[f]}return d[b.length]};goog.string.path={};goog.string.path.baseName=function(a){const b=a.lastIndexOf("/")+1;return a.slice(b)};goog.string.path.basename=goog.string.path.baseName;goog.string.path.dirname=function(a){const b=a.lastIndexOf("/")+1;a=a.slice(0,b);/^\\/+$/.test(a)||(a=a.replace(/\\/+$/,""));return a};goog.string.path.extension=function(a){a=goog.string.path.baseName(a).replace(/\\.+/g,".");const b=a.lastIndexOf(".");return 0>=b?"":a.slice(b+1)};\ngoog.string.path.join=function(a){let b=arguments[0];for(let c=1;c<arguments.length;c++){const d=arguments[c];b=goog.string.startsWith(d,"/")?d:""==b||goog.string.endsWith(b,"/")?b+d:b+("/"+d)}return b};\ngoog.string.path.normalizePath=function(a){if(""==a)return".";let b="";goog.string.startsWith(a,"/")&&(b="/",goog.string.startsWith(a,"//")&&!goog.string.startsWith(a,"///")&&(b="//"));a=a.split("/");const c=[];for(let d=0;d<a.length;d++){const e=a[d];""!=e&&"."!=e&&(".."!=e||!b&&!c.length||".."==module$contents$goog$array_peek(c)?c.push(e):c.pop())}return b+c.join("/")||"."};goog.string.path.split=function(a){const b=goog.string.path.dirname(a);a=goog.string.path.baseName(a);return[b,a]};const DEBUG_WASI$$module$src$filesystem$wasi=!1;function assertLeadingSlash$$module$src$filesystem$wasi(a){return/^\\//g.test(a)?a:`/${a}`}function removeLeadingSlash$$module$src$filesystem$wasi(a){return a.replace(/^\\//g,"")}function shouldOpenReader$$module$src$filesystem$wasi(a){return(a&(WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants))!==goog.global.BigInt(0)}\nfunction performanceNowPoly$$module$src$filesystem$wasi(){if("undefined"===typeof performance||"undefined"===typeof performance.now){const a=Date.now();return Date.now()-a}return performance.now()}function concatUint8Arrays$$module$src$filesystem$wasi(a){var b=a.reduce((d,e)=>d+e.length,0);if(0!==a.length){b=new Uint8Array(b);var c=0;for(const d of a)b.set(d,c),c+=d.length;return b}}\nconst WASI$$module$src$filesystem$wasi=function({}){this.fd=Array.from({length:4});this.fd[0]={fd:0,path:"/dev/stdin",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[1]={fd:1,path:"/dev/stdout",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[2]={fd:2,path:"/dev/stderr",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[3]={fd:3,path:"/",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.getMemory=this.getMemory.bind(this);this.CPUTIME_START=0};\nWASI$$module$src$filesystem$wasi.prototype.start=function(a){this.CPUTIME_START=performanceNowPoly$$module$src$filesystem$wasi();a.exports._start()};WASI$$module$src$filesystem$wasi.prototype.getImports=function(a){const b={};a=WebAssembly.Module.imports(a);for(const c of a)"function"===c.kind&&c.module.startsWith("wasi_")&&("object"!==typeof b[c.module]&&(b[c.module]={}),b[c.module][c.name]=this[c.name].bind(this));return b};\nWASI$$module$src$filesystem$wasi.prototype.setMemory=function(a){this.memory=a};WASI$$module$src$filesystem$wasi.prototype.getMemory=function(){this.view&&this.view.buffer&&this.view.buffer.byteLength||(this.view=new DataView(this.memory.buffer));return this.view};WASI$$module$src$filesystem$wasi.prototype.msToNs=function(a){const b=Math.trunc(a);a=goog.global.BigInt(Math.round(1E6*(a-b)));return goog.global.BigInt(b)*goog.global.BigInt(1E6)+a};\nWASI$$module$src$filesystem$wasi.prototype.now=function(a){switch(a){case WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi());case WASI_CLOCK_REALTIME$$module$src$filesystem$constants:return this.msToNs(Date.now());case WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants:case WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi()-this.CPUTIME_START);\ndefault:return 0}};WASI$$module$src$filesystem$wasi.prototype.args_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,module$src$filesystem$constants);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.args_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.clock_res_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.clock_time_get=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("clock_time_get",a,b,c,arguments);const d=this.getMemory(),e=this.now(a);d.setBigUint64(c,goog.global.BigInt(e),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.environ_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.environ_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_advise=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_advise",a,b,c,d,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_allocate=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_allocate",a,b,c,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_close=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_close",a,arguments);this.fd[a]&&(this.fd[a].open=!1);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_datasync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_datasync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_fdstat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_get",a,b,arguments);const c=this.getMemory();c.setUint8(b+4,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);c.setUint16(b+2,0,!0);c.setUint16(b+4,0,!0);c.setBigUint64(b+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants),!0);c.setBigUint64(b+8+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants),\n!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_flags=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_flags",a,b,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_rights=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_rights",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_filestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_get",a,b,arguments);let c=0;this.fd[a]&&(c=this.fd[a].buffers.reduce(function(e,f){return e+(null==f?void 0:f.byteLength)?null==f?void 0:f.byteLength:0},0));const d=this.getMemory();d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setUint8(b,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);b+=8;d.setBigUint64(b,\ngoog.global.BigInt(1),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(c),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);d.setBigUint64(b+8,this.msToNs(this.CPUTIME_START),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_size=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_size",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_times=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_times",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_pread=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_pread",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_prestat_dir_name=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_dir_name",a,b,c,this.fd[a]);if(!this.fd[a]&&!this.fd[a-1])return WASI_EBADF$$module$src$filesystem$constants;({path:c}=this.fd[a]);a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);(new Uint8Array(a.buffer)).set(c,b);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_prestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_get",a,b,this.fd[a]);if(!this.fd[a])return WASI_EBADF$$module$src$filesystem$constants;var {path:c}=this.fd[a];a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);a.setUint8(b,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants);a.setUint32(b+4,c.byteLength,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_pwrite=function(a,b,c,d,e){console.log("fd_pwrite",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_read=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_read",a,b,c,d,arguments);const e=this.fd[a]&&this.fd[a].buffers;var f=e.reduce((m,p)=>m+p.length,0);const g=this.getMemory();if(e&&0!==e.length){var h=Number(this.fd[a].seekPos),k=0,l=!1;if(h>=f)return k=g.getUint32(b,!0),g.setUint8(k,"\\x00"),g.setUint32(d,0,!0),WASI_ESUCCESS$$module$src$filesystem$constants;for(f=0;f<c;f++){var n=b+8*f;const m=g.getUint32(n,!0);n=g.getUint32(n+\n4,!0);l||(k+=n,Array.from({length:n},(p,q)=>q).reduce((p,q)=>{if(l)return p;const [B,r]=p;let v=p=0,D=!1,y=0,u;if(0===q)for(;!D;)u=e[p]?e[p].byteLength:0,y<=h&&u+y>h?(D=!0,v=h-y):(y+=u,p+=1);else p=B,v=r;e[p]?(g.setUint8(m+q,e[p][v]),v+1>=e[p].byteLength?(p=B+1,v=0):v+=1):(g.setUint8(m+q,"\\x00"),h+=q,l=!0);return[p,v]},[0,0]),l||(h+=n))}this.fd[a].seekPos=goog.global.BigInt(h);g.setUint32(d,k,!0);return WASI_ESUCCESS$$module$src$filesystem$constants}console.error("Reading non existent file",a,this.fd[a])};\nWASI$$module$src$filesystem$wasi.prototype.fd_readdir=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_readdir",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_renumber=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_renumber",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_seek=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_seek",a,b,c,d,arguments);const e=this.getMemory();switch(c){case WASI_WHENCE_CUR$$module$src$filesystem$constants:var f;this.fd[a].seekPos=(null!=(f=this.fd[a].seekPos)?f:goog.global.BigInt(0))+goog.global.BigInt(b);break;case WASI_WHENCE_END$$module$src$filesystem$constants:f=(this.fd[a].buffers||[]).reduce((g,h)=>g+h.length,0);this.fd[a].seekPos=BigInt(f)+BigInt(b);break;\ncase WASI_WHENCE_SET$$module$src$filesystem$constants:this.fd[a].seekPos=BigInt(b)}e.setBigUint64(d,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_sync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_sync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_tell=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_tell",a,b,arguments);const c=this.getMemory();this.fd[a].seekPos||(this.fd[a].seekPos=goog.global.BigInt(0));c.setBigUint64(b,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.fd_write=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_write",{fd:a,iovs:b,iovsLength:c,nwritten:d});const e=this.getMemory();this.fd[a].buffers=this.fd[a].buffers||[];this.fd[a].buffers=0<this.fd[a].buffers.length?[concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)]:this.fd[a].buffers;let f=0;for(let k=0;k<c;k++){var g=b+8*k,h=e.getUint32(g,!0);g=e.getUint32(g+4,!0);f+=g;h=new Uint8Array(e.buffer,h,g);if(this.fd[a].buffers[0]&&\nthis.fd[a].seekPos<this.fd[a].buffers[0].length){const l=Number(this.fd[a].seekPos);h.slice(0,g).forEach((n,m)=>{this.fd[a].buffers[0][l+m]=n})}else this.fd[a].buffers.push(h.slice(0,g))}this.fd[a].seekPos+=goog.global.BigInt(f);e.setUint32(d,f,!0);[1,2].includes(a)&&console.log(decoder$$module$src$utils$text_encoders.decode(concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)));return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_create_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_create_directory",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_filestat_get=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_get",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_filestat_set_times=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_set_times",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_link=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_link",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_open=function(a,b,c,d,e,f,g,h,k){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_open",a,b,c,d,e,f,g,h,k,arguments);const l=this.getMemory();var n=(this.fd[a]||{path:"/"}).path,m=new Uint8Array(l.buffer,c,d);m=decoder$$module$src$utils$text_encoders.decode(m);const p=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(goog.string.path.join(3===a?"":n,m)));DEBUG_WASI$$module$src$filesystem$wasi&&console.log(";; opening path",\np,"withREader",shouldOpenReader$$module$src$filesystem$wasi(f));if(p.startsWith("/..")||"/._"===p||"/.AppleDouble"===p)return WASI_EBADF$$module$src$filesystem$constants;(n=Object.values(this.fd).find(q=>q.path===p&&Array.isArray(q.buffers)))?m=n.fd:(m=this.fd.length,this.fd[m]={fd:m});this.fd[m]={...this.fd[m],path:p,type:"file",seekPos:goog.global.BigInt(0),buffers:n?this.fd[m].buffers:[],open:!0};shouldOpenReader$$module$src$filesystem$wasi(f)&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("should open a read handle for",\np);l.setUint32(k,m,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_readlink=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_readlink",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_remove_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_remove_directory",a,b,c);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_rename=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_rename",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_symlink=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_symlink",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.path_unlink_file=function(a,b,c){3<a&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_unlink_file",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.poll_oneoff=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("poll_oneoff",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.proc_exit=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_exit",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.proc_raise=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_raise",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.random_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("random_get",a,b);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sched_yield=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sched_yield",arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.sock_recv=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_recv",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sock_send=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_send",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};\nWASI$$module$src$filesystem$wasi.prototype.sock_shutdown=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_shutdown",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.findBuffers=function(a){const b=Object.values(this.fd).find(({path:c})=>c===a);return[b&&b.buffers,b.fd]};\nWASI$$module$src$filesystem$wasi.prototype.readdir=function(a){const b=(assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a))+"/").replace("//","/"),c=[];Object.values(this.fd).forEach(({path:d})=>!/\\//g.test(d.replace(b,""))&&c.push(d));return c.map(d=>removeLeadingSlash$$module$src$filesystem$wasi(d.replace(b,""))).filter(d=>!!d)};\nWASI$$module$src$filesystem$wasi.prototype.writeFile=function(a,b){const c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));a=Object.keys(this.fd).length;const d=Object.values(this.fd).find(({path:e})=>e===c);this.fd[a]={fd:a,path:c,seekPos:goog.global.BigInt(0),buffers:[b]};d&&delete this.fd[d]};\nWASI$$module$src$filesystem$wasi.prototype.appendFile=function(a,b){var c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));[c]=this.findBuffers(c);c?c.push(b):console.error(`Can\'t append to non-existing file ${a}`)};\nWASI$$module$src$filesystem$wasi.prototype.readFile=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),[c,d]=this.findBuffers(b);this.fd[d]&&this.fd[d].open&&console.warn(`readFile: file ${a} hasn\'t been closed yet!`);if(c)return concatUint8Arrays$$module$src$filesystem$wasi(c)};\nWASI$$module$src$filesystem$wasi.prototype.readStdOut=function(){const a=Object.values(this.fd[0]);return concatUint8Arrays$$module$src$filesystem$wasi(a&&a.buffers||[])};WASI$$module$src$filesystem$wasi.prototype.unlink=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));(a=Object.values(this.fd).find(({path:c})=>c===b))?delete this.fd[a]:console.error(`While trying to unlink ${b}, path not found`)};\nWASI$$module$src$filesystem$wasi.prototype.mkdir=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),c=[];Object.values(this.fd).forEach(({path:d})=>d.startsWith(b)&&c.push(d));0<c.length?console.warn(`mkdir: path ${a} already exists`):(a=Object.keys(this.fd).length,this.fd[a]={fd:a,path:b})};var module$src$filesystem$wasi={};module$src$filesystem$wasi.WASI=WASI$$module$src$filesystem$wasi;function clearArray$$module$src$utils$clear_array(a){for(;0<a.length;)a.pop()}var module$src$utils$clear_array={};module$src$utils$clear_array.clearArray=clearArray$$module$src$utils$clear_array;var module$node_modules$lines_logger$lib$index={default:{}};module$node_modules$lines_logger$lib$index.default.__esModule=!0;module$node_modules$lines_logger$lib$index.default.LoggerFactory=module$node_modules$lines_logger$lib$index.default.logLevels=void 0;module$node_modules$lines_logger$lib$index.default.logLevels={log_raise_error:1,log_with_warnings:2,trace:3,debug:4,info:5,warn:6,error:7,disable:8};\nvar LoggerFactory$$module$node_modules$lines_logger$lib$index=function(){function a(b,c){if(void 0===b&&(b="log_with_warnings"),void 0===c&&(c=null),this.logLevel=b,!module$node_modules$lines_logger$lib$index.default.logLevels[b])throw Error("Invalid log level "+b+" allowed: "+JSON.stringify(module$node_modules$lines_logger$lib$index.default.logLevels));this.mockConsole=c||console}return a.prototype.dummy=function(){},a.prototype.setLogWarnings=function(b){this.logLevel=b},a.prototype.getLogWarnings=\nfunction(){return this.logLevel},a.prototype.getSingleLoggerColor=function(b,c,d){return this.getSingleLoggerStyle(b,this.getColorStyle(c),d)},a.prototype.getSingleLogger=function(b,c){var d=this.getRandomColor(b);return this.getSingleLoggerStyle(b,this.getColorStyle(d),c)},a.prototype.getSingleLoggerStyle=function(b,c,d,e){var f=this;return void 0===e&&(e="log_with_warnings"),function(){for(var g=[],h=0;h<arguments.length;h++)g[h]=arguments[h];if(module$node_modules$lines_logger$lib$index.default.logLevels[f.logLevel]>\nmodule$node_modules$lines_logger$lib$index.default.logLevels[e])return f.dummy;g=Array.prototype.slice.call(g);h=g.shift().split("{}");for(var k=[f.mockConsole,"%c"+b,c],l=0;l<h.length;l++)k.push(h[l]),void 0!==g[l]&&k.push(g[l]);if(h.length-1!==g.length)if("log_with_warnings"===f.logLevel)f.mockConsole.error("MissMatch amount of arguments");else if("log_raise_error"===f.logLevel)throw Error("MissMatch amount of arguments");return Function.prototype.bind.apply(d,k)}},a.prototype.getLoggerColor=function(b,\nc){return this.getLoggerStyle(b,this.getColorStyle(c))},a.prototype.getColorStyle=function(b){return"color: white; background-color: "+b+"; padding: 2px 6px; border-radius: 2px; font-size: 10px"},a.getHash=function(b,c){void 0===c&&(c=0);var d=3735928559^c;c^=1103547991;for(var e=0,f;e<b.length;e++)f=b.charCodeAt(e),d=Math.imul(d^f,2654435761),c=Math.imul(c^f,1597334677);return d=Math.imul(d^d>>>16,2246822507)^Math.imul(c^c>>>13,3266489909),4294967296*(2097151&(Math.imul(c^c>>>16,2246822507)^Math.imul(d^\nd>>>13,3266489909)))+(d>>>0)},a.prototype.getRandomColor=function(b){void 0===b&&(b="");b=a.getHash(b);for(var c="#",d=0;3>d;d++)c+=("00"+(8+(b>>7*d&127)).toString(16)).substr(-2);return c},a.prototype.getLogger=function(b){return this.getLoggerColor(b,this.getRandomColor(b))},a.prototype.getLoggerStyle=function(b,c){return{trace:this.getSingleLoggerStyle(b,c,this.mockConsole.trace,"trace"),debug:this.getSingleLoggerStyle(b,c,this.mockConsole.debug,"debug"),log:this.getSingleLoggerStyle(b,c,this.mockConsole.log,\n"info"),warn:this.getSingleLoggerStyle(b,c,this.mockConsole.warn,"warn"),error:this.getSingleLoggerStyle(b,c,this.mockConsole.error,"error")}},a}();module$node_modules$lines_logger$lib$index.default.LoggerFactory=LoggerFactory$$module$node_modules$lines_logger$lib$index;let logWorkletMain$$module$src$logger,logWorkletWorker$$module$src$logger,logSABMain$$module$src$logger,logSABWorker$$module$src$logger,logVANMain$$module$src$logger,logVANWorker$$module$src$logger,logOldSpnMain$$module$src$logger,logOldSpnWorker$$module$src$logger,logIndex$$module$src$logger,logSPNMainSingle$$module$src$logger,logSinglethreadWorkletMain$$module$src$logger,logSinglethreadWorkletWorker$$module$src$logger,logCommonUtils$$module$src$logger,logWasmModule$$module$src$logger,logMidiRequest$$module$src$logger;\nconst isProd$$module$src$logger=1;logWorkletMain$$module$src$logger=a=>b=>{};logWorkletWorker$$module$src$logger=a=>b=>{};logSABMain$$module$src$logger=a=>b=>{};logSABWorker$$module$src$logger=a=>b=>{};logVANMain$$module$src$logger=a=>b=>{};logVANWorker$$module$src$logger=a=>b=>{};logOldSpnMain$$module$src$logger=a=>b=>{};logOldSpnWorker$$module$src$logger=a=>b=>{};logIndex$$module$src$logger=a=>b=>{};logSPNMainSingle$$module$src$logger=a=>b=>{};\nlogSinglethreadWorkletMain$$module$src$logger=a=>b=>{};logSinglethreadWorkletWorker$$module$src$logger=a=>b=>{};logCommonUtils$$module$src$logger=a=>b=>{};logWasmModule$$module$src$logger=a=>b=>{};logMidiRequest$$module$src$logger=a=>b=>{};var $jscompDefaultExport$$module$src$logger=a=>b=>{},module$src$logger={};module$src$logger.default=$jscompDefaultExport$$module$src$logger;module$src$logger.logCommonUtils=logCommonUtils$$module$src$logger;module$src$logger.logIndex=logIndex$$module$src$logger;\nmodule$src$logger.logMidiRequest=logMidiRequest$$module$src$logger;module$src$logger.logOldSpnMain=logOldSpnMain$$module$src$logger;module$src$logger.logOldSpnWorker=logOldSpnWorker$$module$src$logger;module$src$logger.logSABMain=logSABMain$$module$src$logger;module$src$logger.logSABWorker=logSABWorker$$module$src$logger;module$src$logger.logSPNMainSingle=logSPNMainSingle$$module$src$logger;module$src$logger.logSinglethreadWorkletMain=logSinglethreadWorkletMain$$module$src$logger;\nmodule$src$logger.logSinglethreadWorkletWorker=logSinglethreadWorkletWorker$$module$src$logger;module$src$logger.logVANMain=logVANMain$$module$src$logger;module$src$logger.logVANWorker=logVANWorker$$module$src$logger;module$src$logger.logWasmModule=logWasmModule$$module$src$logger;module$src$logger.logWorkletMain=logWorkletMain$$module$src$logger;module$src$logger.logWorkletWorker=logWorkletWorker$$module$src$logger;const CompressionMethod$$module$src$zlib$zlib={DEFLATE:8,RESERVED:15};var module$src$zlib$zlib={};module$src$zlib$zlib.CompressionMethod=CompressionMethod$$module$src$zlib$zlib;/*\n zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */\nfunction Huffman$$module$src$zlib$huffman(a){const b=a.length;let c=0,d=Number.POSITIVE_INFINITY,e,f,g,h;let k,l;for(k=0;k<b;++k)a[k]>c&&(c=a[k]),a[k]<d&&(d=a[k]);const n=1<<c,m=new Uint32Array(n);e=1;f=0;for(g=2;e<=c;){for(k=0;k<b;++k)if(a[k]===e){h=0;var p=f;for(l=0;l<e;++l)h=h<<1|p&1,p>>=1;p=e<<16|k;for(l=h;l<n;l+=g)m[l]=p;++f}++e;f<<=1;g<<=1}return[m,c,d]}var module$src$zlib$huffman={};module$src$zlib$huffman.Huffman=Huffman$$module$src$zlib$huffman;const ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate=32768;\nfunction RawInflate$$module$src$zlib$rawinflate(a,b){this.blocks=[];this.bufferSize=ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate;this.bitsbuflen=this.bitsbuf=this.ip=this.totalpos=0;this.input=new Uint8Array(a);this.bfinal=!1;this.bufferType=RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE;this.resize=!1;if(b||!(b={}))b.index&&(this.ip=b.index),b.bufferSize&&(this.bufferSize=b.bufferSize),b.bufferType&&(this.bufferType=b.bufferType),b.resize&&(this.resize=b.resize);switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.op=\nRawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;this.output=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength+this.bufferSize+RawInflate$$module$src$zlib$rawinflate.MaxCopyLength);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.op=0;this.output=new Uint8Array(this.bufferSize);break;default:throw Error("invalid inflate mode");}}RawInflate$$module$src$zlib$rawinflate.BufferType={BLOCK:0,ADAPTIVE:1};\nRawInflate$$module$src$zlib$rawinflate.prototype.decompress=function(){for(;!this.bfinal;)this.parseBlock();switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:return this.concatBufferBlock();case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:return this.concatBufferDynamic();default:throw Error("invalid inflate mode");}};RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength=32768;RawInflate$$module$src$zlib$rawinflate.MaxCopyLength=258;\nRawInflate$$module$src$zlib$rawinflate.Order=function(a){return new Uint16Array(a)}([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]);RawInflate$$module$src$zlib$rawinflate.LengthCodeTable=function(a){return new Uint16Array(a)}([3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258]);RawInflate$$module$src$zlib$rawinflate.LengthExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0]);\nRawInflate$$module$src$zlib$rawinflate.DistCodeTable=function(a){return new Uint16Array(a)}([1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577]);RawInflate$$module$src$zlib$rawinflate.DistExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]);\nRawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable=function(a){return a}(function(){const a=new Uint8Array(288);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=143>=b?8:255>=b?9:279>=b?7:8;return Huffman$$module$src$zlib$huffman(a)}());RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable=function(a){return a}(function(){const a=new Uint8Array(30);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=5;return Huffman$$module$src$zlib$huffman(a)}());\nRawInflate$$module$src$zlib$rawinflate.prototype.parseBlock=function(){let a=this.readBits(3);a&1&&(this.bfinal=!0);a>>>=1;switch(a){case 0:this.parseUncompressedBlock();break;case 1:this.parseFixedHuffmanBlock();break;case 2:this.parseDynamicHuffmanBlock();break;default:throw Error("unknown BTYPE: "+a);}};\nRawInflate$$module$src$zlib$rawinflate.prototype.readBits=function(a){let b=this.bitsbuf,c=this.bitsbuflen;const d=this.input;let e=this.ip;if(e+(a-c+7>>3)>=d.length)throw Error("input buffer is broken");for(;c<a;)b|=d[e++]<<c,c+=8;this.bitsbuf=b>>>a;this.bitsbuflen=c-a;this.ip=e;return b&(1<<a)-1};\nRawInflate$$module$src$zlib$rawinflate.prototype.readCodeByTable=function(a){let b=this.bitsbuf,c=this.bitsbuflen;var d=this.input;let e=this.ip;var f=d.length;const g=a[0];for(a=a[1];c<a&&!(e>=f);)b|=d[e++]<<c,c+=8;d=g[b&(1<<a)-1];f=d>>>16;if(f>c)throw Error("invalid code length: "+f);this.bitsbuf=b>>f;this.bitsbuflen=c-f;this.ip=e;return d&65535};\nRawInflate$$module$src$zlib$rawinflate.prototype.parseUncompressedBlock=function(){const a=this.input;let b=this.ip,c=this.output,d=this.op;var e=a.length;let f;const g=c.length;this.bitsbuflen=this.bitsbuf=0;if(b+1>=e)throw Error("invalid uncompressed block header: LEN");f=a[b++]|a[b++]<<8;if(b+1>=e)throw Error("invalid uncompressed block header: NLEN");e=a[b++]|a[b++]<<8;if(f===~e)throw Error("invalid uncompressed block header: length verify");if(b+f>a.length)throw Error("input buffer is broken");\nswitch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:for(;d+f>c.length;)e=g-d,f-=e,c.set(a.subarray(b,b+e),d),d+=e,b+=e,this.op=d,c=this.expandBufferBlock(),d=this.op;break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:for(;d+f>c.length;)c=this.expandBufferAdaptive({fixRatio:2});break;default:throw Error("invalid inflate mode");}c.set(a.subarray(b,b+f),d);this.ip=b+f;this.op=d+f;this.output=c};\nRawInflate$$module$src$zlib$rawinflate.prototype.parseFixedHuffmanBlock=function(){switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);\nbreak;default:throw Error("invalid inflate mode");}};\nRawInflate$$module$src$zlib$rawinflate.prototype.parseDynamicHuffmanBlock=function(){var a=this.readBits(5)+257,b=this.readBits(5)+1,c=this.readBits(4)+4,d=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.Order.length);let e;for(e=0;e<c;++e)d[RawInflate$$module$src$zlib$rawinflate.Order[e]]=this.readBits(3);d=Huffman$$module$src$zlib$huffman(d);c=new Uint8Array(a+b);e=0;for(b=a+b;e<b;){var f=this.readCodeByTable(d);switch(f){case 16:for(f=3+this.readBits(2);f--;)c[e++]=g;break;case 17:for(f=\n3+this.readBits(3);f--;)c[e++]=0;var g=0;break;case 18:for(f=11+this.readBits(7);f--;)c[e++]=0;g=0;break;default:g=c[e++]=f}}g=Huffman$$module$src$zlib$huffman(c.subarray(0,a));a=Huffman$$module$src$zlib$huffman(c.subarray(a));switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(g,a);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(g,a);break;default:throw Error("invalid inflate mode");}};\nRawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanBlock=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;const e=c.length-RawInflate$$module$src$zlib$rawinflate.MaxCopyLength;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,l=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,n=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,m=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=\ne&&(this.op=d,c=this.expandBufferBlock(),d=this.op),c[d++]=f;else for(f-=257,h=k[f],0<l[f]&&(h+=this.readBits(l[f])),f=this.readCodeByTable(b),g=n[f],0<m[f]&&(g+=this.readBits(m[f])),d>=e&&(this.op=d,c=this.expandBufferBlock(),d=this.op);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};\nRawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanAdaptive=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;let e=c.length;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,l=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,n=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,m=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=e&&(c=this.expandBufferAdaptive(),e=c.length),c[d++]=\nf;else for(f-=257,h=k[f],0<l[f]&&(h+=this.readBits(l[f])),f=this.readCodeByTable(b),g=n[f],0<m[f]&&(g+=this.readBits(m[f])),d+h>e&&(c=this.expandBufferAdaptive(),e=c.length);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};\nRawInflate$$module$src$zlib$rawinflate.prototype.expandBufferBlock=function(a){a=new Uint8Array(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength);const b=this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,c=this.output;a.set(c.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,a.length));this.blocks.push(a);this.totalpos+=a.length;c.set(c.subarray(b,b+RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));this.op=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;\nreturn c};RawInflate$$module$src$zlib$rawinflate.prototype.expandBufferAdaptive=function(a){let b=Math.trunc(this.input.length/this.ip+1);const c=this.input,d=this.output;a&&("number"===typeof a.fixRatio&&(b=a.fixRatio),"number"===typeof a.addRatio&&(b+=a.addRatio));2>b?(a=(c.length-this.ip)/this.currentLitlenTable[2],a=Math.trunc(a/2*258),a=a<d.length?d.length+a:d.length<<1):a=d.length*b;a=new Uint8Array(a);a.set(d);return this.output=a};\nRawInflate$$module$src$zlib$rawinflate.prototype.concatBufferBlock=function(){let a=0;const b=this.output,c=this.blocks;let d;const e=new Uint8Array(this.totalpos+(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));let f,g,h,k;if(0===c.length)return this.output.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,this.op);f=0;for(g=c.length;f<g;++f)for(d=c[f],h=0,k=d.length;h<k;++h)e[a++]=d[h];f=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;for(g=this.op;f<\ng;++f)e[a++]=b[f];this.blocks=[];return this.buffer=e};RawInflate$$module$src$zlib$rawinflate.prototype.concatBufferDynamic=function(){let a;const b=this.op;this.resize?(a=new Uint8Array(b),a.set(this.output.subarray(0,b))):a=this.output.subarray(0,b);return this.buffer=a};var module$src$zlib$rawinflate={};module$src$zlib$rawinflate.RawInflate=RawInflate$$module$src$zlib$rawinflate;function Util$$module$src$zlib$util(){}Util$$module$src$zlib$util.stringToByteArray=function(a){a=[...a];let b,c;b=0;for(c=a.length;b<c;b++)a[b]=(a[b].charPointAt(0)&255)>>>0;return new Uint8Array([a])};var module$src$zlib$util={};module$src$zlib$util.Util=Util$$module$src$zlib$util;function Adler32$$module$src$zlib$adler32(a){"string"===typeof a&&(a=Util$$module$src$zlib$util.stringToByteArray(a));return Adler32$$module$src$zlib$adler32.update(1,a)}Adler32$$module$src$zlib$adler32.update=function(a,b){let c=a&65535;a=a>>>16&65535;let d=b.length,e,f=0;for(;0<d;){e=d>Adler32$$module$src$zlib$adler32.OptimizationParameter?Adler32$$module$src$zlib$adler32.OptimizationParameter:d;d-=e;do c+=b[f++],a+=c;while(--e);c%=65521;a%=65521}return(a<<16|c)>>>0};\nAdler32$$module$src$zlib$adler32.OptimizationParameter=1024;var module$src$zlib$adler32={};module$src$zlib$adler32.Adler32=Adler32$$module$src$zlib$adler32;function Inflate$$module$src$zlib$inflate(a,b){this.input=a;this.ip=0;if(b||!(b={}))b.index&&(this.ip=b.index),b.verify&&(this.verify=b.verify);const c=a[this.ip++],d=a[this.ip++];switch(c&15){case CompressionMethod$$module$src$zlib$zlib.DEFLATE:this.method=CompressionMethod$$module$src$zlib$zlib.DEFLATE;break;default:throw Error("unsupported compression method");}if(0!==((c<<8)+d)%31)throw Error("invalid fcheck flag:"+((c<<8)+d)%31);if(d&32)throw Error("fdict flag is not supported");this.rawinflate=\nnew RawInflate$$module$src$zlib$rawinflate(a,{index:this.ip,bufferSize:b.bufferSize,bufferType:b.bufferType,resize:b.resize})}Inflate$$module$src$zlib$inflate.BufferType=RawInflate$$module$src$zlib$rawinflate.BufferType;\nInflate$$module$src$zlib$inflate.prototype.decompress=function(){var a=this.input;const b=this.rawinflate.decompress();this.ip=this.rawinflate.ip;if(this.verify&&(a=(a[this.ip++]<<24|a[this.ip++]<<16|a[this.ip++]<<8|a[this.ip++])>>>0,a!==Adler32$$module$src$zlib$adler32(b)))throw Error("invalid adler-32 checksum");return b};var module$src$zlib$inflate={};module$src$zlib$inflate.Inflate=Inflate$$module$src$zlib$inflate;const PAGE_SIZE$$module$src$module=65536,PAGES_PER_MB$$module$src$module=16,csoundWasiJsMessageCallback$$module$src$module=({memory:a,messagePort:b,streamBuffer:c})=>function(d,e,f,g){if(a){d=new Uint8Array(a.buffer,g,f);d=uint2String$$module$src$utils$text_encoders(d);var h=/\\n$/g.test(d);e=/^\\n/g.test(d);var k=d.split("\\n").filter(n=>0<n.length),l=[];if(0===k.length&&h||e)l.push(c.join("")),clearArray$$module$src$utils$clear_array(c);k.forEach((n,m)=>{m+1===k.length?h?0===m?(l.push(c.join("")+n),\nclearArray$$module$src$utils$clear_array(c)):l.push(n):c.push(n):0===m?(l.push(c.join("")+n),clearArray$$module$src$utils$clear_array(c)):l.push(n)});l.forEach(n=>{n.replace(/(\\r\\n|\\n|\\r)/gm,"")&&b.post({log:n})})}},assertPluginExports$$module$src$module=a=>{if(a&&"object"===typeof a&&"object"===typeof a.exports){if(a.exports.__wasm_call_ctors){if(a.exports.csoundModuleCreate||a.exports.csound_opcode_init||a.exports.csound_fgen_init)return!0;console.error(a.exports,"A csound plugin turns out to be neither a plugin, opcode or module.\\nPerhaps csdl.h or module.h wasn\'t imported correctly?");\nreturn!1}console.error("A csound plugin didn\'t export __wasm_call_ctors.\\nPlease re-run wasm-ld with either --export-all or include --export=__wasm_call_ctors");return!1}console.error("Error instantiating a csound plugin, instance and/or export is missing!");return!1},getBinaryHeaderData$$module$src$module=a=>{function b(){let l=0,n=1;for(;;){const m=a[c++];l+=(m&127)*n;n*=128;if(!(m&128))break}return l}1836278016!==(new Uint32Array((new Uint8Array(a.subarray(0,24))).buffer))[0]&&console.error("Wasm magic number is missing!");\nif(0!==a[8])return logWasmModule$$module$src$logger("Dylink section wasn\'t found in wasm binary, assuming static wasm."),"static";let c=9;const d=b();c++;(0,goog.asserts.assert)(a[c]==="d".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="y".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="l".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="i".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="n".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="k".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]===\n".".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="0".codePointAt(0));c+=3;const e=b(),f=b(),g=b(),h=b(),k=b();return{sectionSize:d,memorySize:e,memoryAlign:f,neededDynlibsCount:k,tableSize:g,tableAlign:h}},loadStaticWasm$$module$src$module=async({wasmBytes:a,wasi:b,messagePort:c})=>{const d=await WebAssembly.compile(a);a=new WebAssembly.Memory({initial:16384});const e=b.getImports(d);e.env=e.env||{};e.env.csoundLoadModules=()=>0;e.env.memory=a;e.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:e.env.memory,\nstreamBuffer:[],messagePort:c});c=await WebAssembly.instantiate(d,e);b.setMemory(a);b.start(c);c.exports.__wasi_js_csoundSetMessageStringCallback();return[c,b]};\nvar $jscompDefaultExport$$module$src$module=async function({wasmDataURI:a,withPlugins:b=[],messagePort:c}){var d={};const e=new WASI$$module$src$filesystem$wasi({preopens:{"/":"/"}});a=new Uint8Array(a);a=(new Inflate$$module$src$zlib$inflate(a)).decompress();var f=getBinaryHeaderData$$module$src$module(a);if("static"===f)return await loadStaticWasm$$module$src$module({messagePort:c,wasmBytes:a,wasmFs:d,wasi:e});const {memorySize:g,memoryAlign:h,tableSize:k}=f;b=await b.reduce(async(u,z)=>{u=await u;\nlet C,A;try{C=new Uint8Array(z),A=getBinaryHeaderData$$module$src$module(C)}catch(G){console.error("Error in plugin",G)}A&&u.push({headerData:A,wasmPluginBytes:C});return u},[]);var l=128*PAGES_PER_MB$$module$src$module;d=Math.ceil((g+h)/PAGE_SIZE$$module$src$module);f=Math.ceil(b.reduce((u,{headerData:z})=>"static"===z?0:u+(z.memorySize+h),0)/PAGE_SIZE$$module$src$module);f=d+f+l;const n=new WebAssembly.Memory({initial:f,maximum:1024*PAGES_PER_MB$$module$src$module}),m=new WebAssembly.Table({initial:k+\n1,element:"anyfunc"});e.setMemory(n);const p=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);f=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);l=new WebAssembly.Global({value:"i32",mutable:!1},l);const q=new WebAssembly.Global({value:"i32",mutable:!1},1),B=new WebAssembly.Global({value:"i32",mutable:!0},0);a=await WebAssembly.compile(a);const r=e.getImports(a);let v=[],D=d;r.env=r.env||{};r.env.memory=n;r.env.__indirect_function_table=\nm;r.env.__stack_pointer=p;r.env.__memory_base=l;r.env.__table_base=q;r.env.csoundLoadModules=u=>{v.forEach(z=>{void 0===y?console.error("csound-wasm internal: timing problem detected!"):dlinit$$module$src$dlinit(y,z,m,u)});return 0};r.env._ZTH5errno=function(){};r.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:n,messagePort:c,streamBuffer:[]});r.env.printDebugCallback=(u,z)=>{u=new Uint8Array(n.buffer,u,z);u=uint2String$$module$src$utils$text_encoders(u);console.log(u)};\nr["GOT.mem"]=r["GOT.mem"]||{};r["GOT.mem"].__heap_base=f;r["GOT.func"]=r["GOT.func"]||{};const y=await WebAssembly.instantiate(a,r);c=Object.assign({},y.exports);a={};a.exports=Object.assign(c,{memory:n});v=await b.reduce(async(u,{headerData:z,wasmPluginBytes:C})=>{u=await u;try{const {memorySize:A,memoryAlign:G,tableSize:F}=z,I=await WebAssembly.compile(C),t=e.getImports(I),E=new WebAssembly.Global({value:"i32",mutable:!1},D*PAGE_SIZE$$module$src$module);m.grow(F);t.env=Object.assign({},t.env);t.env.memory=\nn;t.env.__indirect_function_table=m;t.env.__memory_base=E;t.env.__stack_pointer=p;t.env.__table_base=q;t.env.csoundLoadModules=B;delete t.env.csoundWasiJsMessageCallback;D+=Math.ceil((A+G)/PAGE_SIZE$$module$src$module);const x=await WebAssembly.instantiate(I,t);assertPluginExports$$module$src$module(x)&&(x.exports.__wasm_call_ctors(),u.push(x))}catch(A){console.error("Error while compiling csound-plugin",A)}return u},[]);e.start(a);a.exports.__wasi_js_csoundSetMessageStringCallback();return[a,e]},\nmodule$src$module={};module$src$module.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module;module$src$module.default=$jscompDefaultExport$$module$src$module;const handleCsoundStart$$module$src$workers$common_utils=(a,b,c,d,e)=>f=>{const {csound:g}=f,h=1===b.csoundShouldDaemonize(g);h&&(b.csoundSetOption(g,"--daemon"),b.csoundSetOption(g,"-odac"));const k=b.csoundStart(g),l=b.csoundGetOutputName(g)||"test.wav";logCommonUtils$$module$src$logger(`handleCsoundStart: actual csoundStart result ${k}, outputName: ${l}`)();0!==k&&a.post(`error: csoundStart failed while trying to render ${l},`+" look out for errors in options and syntax");setTimeout(()=>{const n=\nb._isRequestingRtMidiInput(g);if(h||n||l.includes("dac"))d(f);else if(a.broadcastPlayState("renderStarted"),e)e(f);else for(;0===b.csoundPerformKsmps(g););},0);return k},instantiateAudioPacket$$module$src$workers$common_utils=(a,b)=>{const c=[];for(let d=0;d<a;d++)c.push(new Float64Array(b));return c},renderFunction$$module$src$workers$common_utils=({libraryCsound:a,workerMessagePort:b})=>async({csound:c})=>{const d=a.csoundGetKr(c);let e=0,f=0;for(;("renderStarted"===b.vanillaWorkerState||"renderStarted"===\nb.workerState)&&0===e;)e=a.csoundPerformKsmps(c),f+=1,"function"===typeof setTimeout&&0===e&&0===f%(2*d)&&await new Promise(g=>setTimeout(g,0));b.broadcastPlayState("renderEnded")};var module$src$workers$common_utils={};module$src$workers$common_utils.handleCsoundStart=handleCsoundStart$$module$src$workers$common_utils;module$src$workers$common_utils.instantiateAudioPacket=instantiateAudioPacket$$module$src$workers$common_utils;module$src$workers$common_utils.renderFunction=renderFunction$$module$src$workers$common_utils;const DEFAULT_BUFFER_LEN$$module$src$constants=128,MAX_CHANNELS$$module$src$constants=32,RING_BUFFER_SIZE$$module$src$constants=16384,MIDI_BUFFER_SIZE$$module$src$constants=1024,MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants=3,CALLBACK_DATA_BUFFER_SIZE$$module$src$constants=16384,initialSharedState$$module$src$constants=[0,4096,0,0,0,0,-1,-1,-1,-1,0,DEFAULT_BUFFER_LEN$$module$src$constants,0,0,0,0,0,0,0,0],AUDIO_STATE$$module$src$constants={CSOUND_LOCK:0,FRAMES_REQUESTED:1,IS_PERFORMING:2,IS_RENDERING:3,\nIS_PAUSED:4,STOP:5,SAMPLE_RATE:6,KSMPS:7,NCHNLS:8,NCHNLS_I:9,IS_REQUESTING_MIC:10,BUFFER_LEN:11,OUTPUT_READ_INDEX:12,OUTPUT_WRITE_INDEX:13,AVAIL_IN_BUFS:14,AVAIL_OUT_BUFS:15,IS_REQUESTING_RTMIDI:16,RTMIDI_INDEX:17,AVAIL_RTMIDI_EVENTS:18,HAS_PENDING_CALLBACKS:19},DATA_TYPE$$module$src$constants={NUMBER:0,STRING:1,FLOAT_32:2,FLOAT_64:3};var module$src$constants={};module$src$constants.AUDIO_STATE=AUDIO_STATE$$module$src$constants;module$src$constants.CALLBACK_DATA_BUFFER_SIZE=CALLBACK_DATA_BUFFER_SIZE$$module$src$constants;\nmodule$src$constants.DATA_TYPE=DATA_TYPE$$module$src$constants;module$src$constants.DEFAULT_BUFFER_LEN=DEFAULT_BUFFER_LEN$$module$src$constants;module$src$constants.MAX_CHANNELS=MAX_CHANNELS$$module$src$constants;module$src$constants.MIDI_BUFFER_PAYLOAD_SIZE=MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants;module$src$constants.MIDI_BUFFER_SIZE=MIDI_BUFFER_SIZE$$module$src$constants;module$src$constants.RING_BUFFER_SIZE=RING_BUFFER_SIZE$$module$src$constants;module$src$constants.initialSharedState=initialSharedState$$module$src$constants;let combined$$module$src$workers$sab_worker,pollPromise$$module$src$workers$sab_worker,unlockPromise$$module$src$workers$sab_worker;\nconst callUncloned$$module$src$workers$sab_worker=async(a,b)=>(a=combined$$module$src$workers$sab_worker.get(a))&&a.apply({},b||[]),sabCreateRealtimeAudioThread$$module$src$workers$sab_worker=({libraryCsound:a,callbacksRequest:b,releaseStop:c,releasePause:d,releaseResumed:e,wasm:f,workerMessagePort:g})=>async({audioStateBuffer:h,audioStreamIn:k,audioStreamOut:l,midiBuffer:n,csound:m})=>{const p=new Int32Array(h);initialSharedState$$module$src$constants.forEach((H,K)=>{Atomics.store(p,K,H)});h=a._isRequestingRtMidiInput(m);\nvar q=0===Atomics.load(p,AUDIO_STATE$$module$src$constants.NCHNLS_I)&&a.csoundGetInputName(m).includes("adc"),B=Atomics.load(p,AUDIO_STATE$$module$src$constants.NCHNLS),r=Atomics.load(p,AUDIO_STATE$$module$src$constants.NCHNLS_I),v=Atomics.load(p,AUDIO_STATE$$module$src$constants.SAMPLE_RATE);-1<B&&a.csoundSetOption(m,`--nchnls=${B}`);-1<r&&a.csoundSetOption(m,`--nchnls_i=${r}`);-1<v&&a.csoundSetOption(m,`--sr=${v}`);const D=a.csoundGetNchnls(m),y=r||q?a.csoundGetNchnlsInput(m):0,u=Atomics.load(p,\nAUDIO_STATE$$module$src$constants.SAMPLE_RATE)||a.csoundGetSr(m);Atomics.store(p,AUDIO_STATE$$module$src$constants.NCHNLS,D);Atomics.store(p,AUDIO_STATE$$module$src$constants.NCHNLS_I,y);Atomics.store(p,AUDIO_STATE$$module$src$constants.IS_REQUESTING_MIC,q?1:0);Atomics.store(p,AUDIO_STATE$$module$src$constants.SAMPLE_RATE,a.csoundGetSr(m));Atomics.store(p,AUDIO_STATE$$module$src$constants.IS_REQUESTING_RTMIDI,h);q=a.csoundGetKsmps(m);Atomics.store(p,AUDIO_STATE$$module$src$constants.KSMPS,q);const z=\na.csoundGet0dBFS(m);B=[];r=[];for(v=0;v<D;++v)B.push(new Float64Array(l,RING_BUFFER_SIZE$$module$src$constants*v,RING_BUFFER_SIZE$$module$src$constants));for(l=0;l<y;++l)r.push(new Float64Array(k,RING_BUFFER_SIZE$$module$src$constants*l,RING_BUFFER_SIZE$$module$src$constants));g.broadcastPlayState("realtimePerformanceStarted");Atomics.store(p,AUDIO_STATE$$module$src$constants.IS_PERFORMING,1);logSABWorker$$module$src$logger("Atomic.wait started (thread is now locked)\\n")();k=!0;let C=0,A=0,G=0,F=\n0,I;l=(H=!1)=>1===Atomics.load(p,AUDIO_STATE$$module$src$constants.STOP)||1!==Atomics.load(p,AUDIO_STATE$$module$src$constants.IS_PERFORMING)||0!==C||H?(0===C&&(logSABWorker$$module$src$logger("calling csoundStop and one performKsmps to trigger endof logs")(),a.csoundStop(m),a.csoundPerformKsmps(m)),logSABWorker$$module$src$logger("triggering realtimePerformanceEnded event")(),g.broadcastPlayState("realtimePerformanceEnded"),logSABWorker$$module$src$logger("End of realtimePerformance loop!")(),c(),\n!0):!1;for(v=!0;!v||(I=Atomics.wait(p,AUDIO_STATE$$module$src$constants.CSOUND_LOCK,1,1E4));){if("timed-out"===I){l(!0);break}k&&(k=!1,await new Promise(w=>{unlockPromise$$module$src$workers$sab_worker=w;g.broadcastSabUnlocked()}),logSABWorker$$module$src$logger("Atomic.wait unlocked, performance started")());1===Atomics.load(p,AUDIO_STATE$$module$src$constants.IS_PAUSED)&&(await new Promise(w=>setTimeout(w,0)),d(),await new Promise(w=>setTimeout(w,0)),Atomics.wait(p,AUDIO_STATE$$module$src$constants.IS_PAUSED,\n0),await new Promise(w=>setTimeout(w,0)),e(),await new Promise(w=>setTimeout(w,0)));if(l())break;if(h){var t=Atomics.load(p,AUDIO_STATE$$module$src$constants.AVAIL_RTMIDI_EVENTS);if(0<t){var E=Atomics.load(p,AUDIO_STATE$$module$src$constants.RTMIDI_INDEX),x=E;for(let w=0;w<t;w++){x=(E+MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants*w)%MIDI_BUFFER_SIZE$$module$src$constants;const J=Atomics.load(n,x),L=Atomics.load(n,x+1),M=Atomics.load(n,x+2);a.csoundPushMidiMessage(m,J,L,M)}Atomics.store(p,AUDIO_STATE$$module$src$constants.RTMIDI_INDEX,\n(x+1)%MIDI_BUFFER_SIZE$$module$src$constants);Atomics.sub(p,AUDIO_STATE$$module$src$constants.AVAIL_RTMIDI_EVENTS,t)}}const H=Atomics.load(p,AUDIO_STATE$$module$src$constants.BUFFER_LEN);t=Atomics.load(p,AUDIO_STATE$$module$src$constants.AVAIL_IN_BUFS)>=H;E=a.csoundGetSpin(m);x=a.csoundGetSpout(m);const K=t&&new Float64Array(f.wasi.memory.buffer,E,q*y),N=new Float64Array(f.wasi.memory.buffer,x,q*D);E=Atomics.load(p,AUDIO_STATE$$module$src$constants.FRAMES_REQUESTED);for(x=0;x<E;x++){if(0===A)if(0===\nC)C=a.csoundPerformKsmps(m),!v&&Atomics.add(p,AUDIO_STATE$$module$src$constants.AVAIL_OUT_BUFS,q),v=!1;else if(0!==C){Atomics.store(p,AUDIO_STATE$$module$src$constants.IS_PERFORMING,0);l(!0);return}B.forEach((w,J)=>{w[F]=(N[A*D+J]||0)/z});t&&(r.forEach((w,J)=>{K[A*y+J]=(w[G]||0)*z}),G=t&&(G+1)%RING_BUFFER_SIZE$$module$src$constants);F=(F+1)%RING_BUFFER_SIZE$$module$src$constants;A=(A+1)%q}t&&Atomics.sub(p,AUDIO_STATE$$module$src$constants.AVAIL_IN_BUFS,E);1===Atomics.compareExchange(p,AUDIO_STATE$$module$src$constants.HAS_PENDING_CALLBACKS,\n1,0)&&await new Promise(w=>{pollPromise$$module$src$workers$sab_worker=w;b()});if(l())break;t=Atomics.load(p,AUDIO_STATE$$module$src$constants.OUTPUT_READ_INDEX);t=Math.max(2048-(F<t?F+RING_BUFFER_SIZE$$module$src$constants-t:F-t),0);Atomics.store(p,AUDIO_STATE$$module$src$constants.FRAMES_REQUESTED,t);0===t&&await new Promise(w=>setTimeout(w,H/u*1E3))}},initMessagePort$$module$src$workers$sab_worker=({port:a})=>{const b=new $jscompDefaultExport$$module$src$utils$message_port_state;b.post=c=>a.postMessage({log:c});\nb.broadcastPlayState=c=>a.postMessage({playStateChange:c});b.broadcastSabUnlocked=()=>a.postMessage({sabWorker:"unlocked"});b.ready=!0;return b},initCallbackReplyPort$$module$src$workers$sab_worker=({port:a})=>{a.addEventListener("message",b=>{if(b.data&&b.data.unlock)b=unlockPromise$$module$src$workers$sab_worker,unlockPromise$$module$src$workers$sab_worker=void 0,b&&b();else{b=b.data;var c=b.reduce((d,{id:e,argumentz:f,apiKey:g})=>{try{const h=combined$$module$src$workers$sab_worker.get(g),k=h&&\nh.apply({},f||[]);d.push({id:e,answer:k})}catch(h){throw Error(h);}return d},[]);a.postMessage(c);c=pollPromise$$module$src$workers$sab_worker;pollPromise$$module$src$workers$sab_worker=void 0;c&&c(b)}});a.start()},renderFunction$$module$src$workers$sab_worker=({libraryCsound:a,callbacksRequest:b,releaseStop:c,releasePause:d,releaseResumed:e,workerMessagePort:f})=>async({audioStateBuffer:g,csound:h})=>{g=new Int32Array(g);Atomics.store(g,AUDIO_STATE$$module$src$constants.IS_RENDERING,1);for(f.broadcastSabUnlocked();1!==\nAtomics.load(g,AUDIO_STATE$$module$src$constants.STOP)&&0===a.csoundPerformKsmps(h);)1===Atomics.load(g,AUDIO_STATE$$module$src$constants.IS_PAUSED)&&(d(),Atomics.wait(g,AUDIO_STATE$$module$src$constants.IS_PAUSED,0),e()),1===Atomics.compareExchange(g,AUDIO_STATE$$module$src$constants.HAS_PENDING_CALLBACKS,1,0)&&await new Promise(k=>{pollPromise$$module$src$workers$sab_worker=k;b()});Atomics.store(g,AUDIO_STATE$$module$src$constants.IS_RENDERING,0);f.broadcastPlayState("renderEnded");c()},initialize$$module$src$workers$sab_worker=\nasync({wasmDataURI:a,withPlugins:b=[],messagePort:c,callbackPort:d})=>{logSABWorker$$module$src$logger("initializing SABWorker and WASM")();const e=initMessagePort$$module$src$workers$sab_worker({port:c}),f=()=>d.postMessage("poll"),g=()=>d.postMessage("releaseStop"),h=()=>d.postMessage("releasePause"),k=()=>d.postMessage("releaseResumed");initCallbackReplyPort$$module$src$workers$sab_worker({port:d});const [l,n]=await $jscompDefaultExport$$module$src$module({wasmDataURI:a,withPlugins:b,messagePort:e});\nl.wasi=n;const m=$jscompDefaultExport$$module$src$libcsound(l);a=pipe$$module$node_modules$rambda$dist$rambda_mjs(assoc$$module$node_modules$rambda$dist$rambda_mjs("csoundStart",(p,q)=>handleCsoundStart$$module$src$workers$common_utils(e,m,n,sabCreateRealtimeAudioThread$$module$src$workers$sab_worker({libraryCsound:m,callbacksRequest:f,wasm:l,workerMessagePort:e,releaseStop:g,releasePause:h,releaseResumed:k}),renderFunction$$module$src$workers$sab_worker({libraryCsound:m,callbacksRequest:f,workerMessagePort:e,\nwasi:n,releaseStop:g,releasePause:h,releaseResumed:k}))(q)),assoc$$module$node_modules$rambda$dist$rambda_mjs("wasm",l))(m);combined$$module$src$workers$sab_worker=new Map(Object.entries(a));m.csoundInitialize(0);return m.csoundCreate()},sabWorker$$module$src$workers$sab_worker={initialize:initialize$$module$src$workers$sab_worker,callUncloned:callUncloned$$module$src$workers$sab_worker};\nexpose$$module$node_modules$comlink$dist$esm$comlink_mjs({initialize:sabWorker$$module$src$workers$sab_worker.initialize,callUncloned:sabWorker$$module$src$workers$sab_worker.callUncloned});var module$src$workers$sab_worker={};module$src$workers$sab_worker.sabWorker=sabWorker$$module$src$workers$sab_worker;}).call(this);\n//# sourceMappingURL=__compiled.sab.worker.js.map\n'])),
+module$dist$__compiled_sab_worker_inline={};module$dist$__compiled_sab_worker_inline.default=$jscompDefaultExport$$module$dist$__compiled_sab_worker_inline;class SharedArrayBufferMainThread$$module$src$mains$sab_main{constructor({audioContext:a,audioWorker:b,audioContextIsProvided:c,inputChannelCount:d,outputChannelCount:e}){this.hasSharedArrayBuffer=!0;this.ipcMessagePorts=new IPCMessagePorts$$module$src$mains$messages_main;this.eventPromises=new EventPromises$$module$src$utils$event_promises;this.publicEvents=new PublicEventAPI$$module$src$events(this);b.ipcMessagePorts=this.ipcMessagePorts;this.audioContextIsProvided=c;this.audioWorker=b;this.audioWorker.onPlayStateChange=
+this.audioWorker.onPlayStateChange.bind(b);this.currentPlayState=this.csoundInstance=void 0;this.currentDerivedPlayState="stop";this.exportApi={};this.callbackId=0;this.callbackBuffer={};this.audioStateBuffer=new SharedArrayBuffer(initialSharedState$$module$src$constants.length*Int32Array.BYTES_PER_ELEMENT);this.audioStatePointer=new Int32Array(this.audioStateBuffer);c&&Atomics.store(this.audioStatePointer,AUDIO_STATE$$module$src$constants.SAMPLE_RATE,a.sampleRate);d&&Atomics.store(this.audioStatePointer,
+AUDIO_STATE$$module$src$constants.NCHNLS_I,d);e&&Atomics.store(this.audioStatePointer,AUDIO_STATE$$module$src$constants.NCHNLS,e);this.audioStreamIn=new SharedArrayBuffer(MAX_CHANNELS$$module$src$constants*RING_BUFFER_SIZE$$module$src$constants*Float64Array.BYTES_PER_ELEMENT);this.audioStreamOut=new SharedArrayBuffer(MAX_CHANNELS$$module$src$constants*RING_BUFFER_SIZE$$module$src$constants*Float64Array.BYTES_PER_ELEMENT);this.midiBufferSAB=new SharedArrayBuffer(MIDI_BUFFER_SIZE$$module$src$constants*
+MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants*Int32Array.BYTES_PER_ELEMENT);this.midiBuffer=new Int32Array(this.midiBufferSAB);this.onPlayStateChange=this.onPlayStateChange.bind(this);this.prepareRealtimePerformance=this.prepareRealtimePerformance.bind(this);logSABMain$$module$src$logger("SharedArrayBufferMainThread got constructed")()}async terminateInstance(){this.csoundWorker&&(this.csoundWorker.terminate(),delete this.csoundWorker);this.audioWorker&&this.audioWorker.terminateInstance&&(await this.audioWorker.terminateInstance(),
+delete this.audioWorker.terminateInstance);this.proxyPort&&(this.proxyPort[releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs](),delete this.proxyPort);this.publicEvents&&this.publicEvents.terminateInstance();Object.keys(this.exportApi).forEach(a=>delete this.exportApi[a]);Object.keys(this).forEach(a=>delete this[a])}get api(){return this.exportApi}handleMidiInput({data:[a,b,c]}){var d=Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.AVAIL_RTMIDI_EVENTS);const e=Atomics.load(this.audioStatePointer,
+AUDIO_STATE$$module$src$constants.RTMIDI_INDEX);d=(d*MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants+e)%MIDI_BUFFER_SIZE$$module$src$constants;Atomics.store(this.midiBuffer,d,a);Atomics.store(this.midiBuffer,d+1,b);Atomics.store(this.midiBuffer,d+2,c);Atomics.add(this.audioStatePointer,AUDIO_STATE$$module$src$constants.AVAIL_RTMIDI_EVENTS,1)}async csoundPause(){if(this.eventPromises.isWaiting("pause"))return-1;this.eventPromises.createPausePromise();Atomics.store(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_PAUSED,
+1);await this.eventPromises.waitForPause();this.onPlayStateChange("realtimePerformancePaused");return 0}async csoundResume(){1===Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_PAUSED)&&1!==Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.STOP)&&1===Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_PERFORMING)&&(Atomics.store(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_PAUSED,0),Atomics.notify(this.audioStatePointer,
+AUDIO_STATE$$module$src$constants.IS_PAUSED),this.onPlayStateChange("realtimePerformanceResumed"))}async onPlayStateChange(a){if(void 0===this)console.log("Failed to announce playstatechange",a);else if(this.currentPlayState=a,this.publicEvents&&a){switch(a){case "realtimePerformanceStarted":logSABMain$$module$src$logger("event: realtimePerformanceStarted received, proceeding to call prepareRealtimePerformance")();try{await this.prepareRealtimePerformance()}catch(b){console.error(b)}break;case "realtimePerformanceEnded":this.eventPromises.createStopPromise();
+Object.values(this.callbackBuffer).forEach(({argumentz:b,apiKey:c,resolveCallback:d})=>this.proxyPort.callUncloned(c,b).then(d));this.callbackBuffer={};logSABMain$$module$src$logger("event: realtimePerformanceEnded received, beginning cleanup")();initialSharedState$$module$src$constants.forEach((b,c)=>{Atomics.store(this.audioStatePointer,c,b)});break;case "renderStarted":this.publicEvents.triggerRenderStarted(this);this.eventPromises.releaseStartPromise();break;case "renderEnded":logSABMain$$module$src$logger("event: renderEnded received, beginning cleanup")(),
+this.publicEvents.triggerRenderEnded(this),this.eventPromises&&this.eventPromises.releaseStopPromise()}try{await this.audioWorker.onPlayStateChange(a)}catch(b){console.error(b)}}}async prepareRealtimePerformance(){logSABMain$$module$src$logger("prepareRealtimePerformance")();const a=Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.NCHNLS),b=Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.NCHNLS_I);this.audioWorker.isRequestingInput=Atomics.load(this.audioStatePointer,
+AUDIO_STATE$$module$src$constants.IS_REQUESTING_MIC);this.audioWorker.isRequestingMidi=Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_REQUESTING_RTMIDI);const c=Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.KSMPS),d=Atomics.load(this.audioStatePointer,AUDIO_STATE$$module$src$constants.SAMPLE_RATE);this.audioWorker.ksmps=c;this.audioWorker.sampleRate=d;this.audioWorker.inputCount=b;this.audioWorker.outputsCount=a}async initialize({wasmDataURI:a,withPlugins:b}){b&&
+!isEmpty$$module$node_modules$rambda$dist$rambda_mjs(b)&&(b=await fetchPlugins$$module$src$utils(b));logSABMain$$module$src$logger("initialization: instantiate the SABWorker Thread")();const c=new Worker($jscompDefaultExport$$module$dist$__compiled_sab_worker_inline());this.csoundWorker=c;const d=this.audioStateBuffer,e=this.audioStatePointer,f=this.audioStreamIn,g=this.audioStreamOut,h=this.midiBuffer;logSABMain$$module$src$logger("providing the audioWorker a pointer to SABMain's instance")();this.audioWorker.csoundWorkerMain=
+this;logSABMain$$module$src$logger("adding message eventListeners for mainMessagePort and mainMessagePortAudio")();this.ipcMessagePorts.mainMessagePort.addEventListener("message",messageEventHandler$$module$src$mains$messages_main(this));this.ipcMessagePorts.mainMessagePort.start();this.ipcMessagePorts.mainMessagePortAudio.addEventListener("message",messageEventHandler$$module$src$mains$messages_main(this));this.ipcMessagePorts.mainMessagePortAudio.start();logSABMain$$module$src$logger("(postMessage) making a message channel from SABMain to SABWorker via workerMessagePort")();
+this.ipcMessagePorts.sabMainCallbackReply.addEventListener("message",m=>{switch(m.data){case "poll":this.ipcMessagePorts&&this.ipcMessagePorts.sabMainCallbackReply.postMessage(Object.keys(this.callbackBuffer).map(l=>({id:l,apiKey:this.callbackBuffer[l].apiKey,argumentz:this.callbackBuffer[l].argumentz})));break;case "releaseStop":this.onPlayStateChange("renderStarted"===this.currentPlayState?"renderEnded":"realtimePerformanceEnded");this.publicEvents&&this.publicEvents.triggerRealtimePerformanceEnded(this);
+this.eventPromises&&this.eventPromises.releaseStopPromise();break;case "releasePause":this.publicEvents.triggerRealtimePerformancePaused(this);this.eventPromises.releasePausePromise();break;case "releaseResumed":this.publicEvents.triggerRealtimePerformanceResumed(this);this.eventPromises.releaseResumePromise();break;default:m.data.forEach(({id:l,answer:p})=>{this.callbackBuffer[l].resolveCallback(p);delete this.callbackBuffer[l]})}});this.ipcMessagePorts.sabMainCallbackReply.start();const k=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(c);
+a=a();this.proxyPort=k;const n=await k.initialize(transfer$$module$node_modules$comlink$dist$esm$comlink_mjs({wasmDataURI:a,wasmTransformerDataURI:this.wasmTransformerDataURI,messagePort:this.ipcMessagePorts.workerMessagePort,callbackPort:this.ipcMessagePorts.sabWorkerCallbackReply,withPlugins:b},[a,this.ipcMessagePorts.workerMessagePort,this.ipcMessagePorts.sabWorkerCallbackReply]));this.csoundInstance=n;this.ipcMessagePorts.mainMessagePort.start();this.ipcMessagePorts.mainMessagePortAudio.start();
+logSABMain$$module$src$logger("A proxy port from SABMain to SABWorker established")();this.exportApi.pause=this.csoundPause.bind(this);this.exportApi.resume=this.csoundResume.bind(this);this.exportApi.terminateInstance=this.terminateInstance.bind(this);this.exportApi.enableAudioInput=()=>console.warn("enableAudioInput was ignored: please use -iadc option before calling start with useWorker=true");this.exportApi.getNode=async()=>{const m=this.audioWorker.audioWorkletNode;return m?m:await new Promise(l=>
+{this.exportApi.once("onAudioNodeCreated",l)})};this.exportApi.getAudioContext=async()=>this.audioWorker.audioContext;this.exportApi=this.publicEvents.decorateAPI(this.exportApi);this.exportApi.addListener("message",console.log);for(const m of Object.keys(api$$module$src$libcsound)){const l=makeProxyCallback$$module$src$utils(k,n,m,this.currentPlayState),p=api$$module$src$libcsound[m];switch(m){case "csoundCreate":break;case "csoundStart":b=async function(){if(!n||"number"!==typeof n)return console.error("starting csound failed because csound instance wasn't created"),
+-1;if(this.eventPromises.isWaiting("start"))return-1;this.eventPromises.createStartPromise();const q=await l({audioStateBuffer:d,audioStreamIn:f,audioStreamOut:g,midiBuffer:h,csound:n});await this.eventPromises.waitForStart();this.ipcMessagePorts&&this.ipcMessagePorts.sabMainCallbackReply.postMessage({unlock:!0});return q};b.toString=()=>p.toString();this.exportApi.start=b.bind(this);break;case "csoundStop":b=async()=>{logSABMain$$module$src$logger(["Checking if it's safe to call stop:",stopableStates$$module$src$utils.has(this.currentPlayState),
+"currentPlayState is",this.currentPlayState].join("\n"))();return this.eventPromises.isWaiting("stop")?(logSABMain$$module$src$logger("already waiting to stop, doing nothing")(),-1):stopableStates$$module$src$utils.has(this.currentPlayState)?(logSABMain$$module$src$logger("Marking SAB's state to STOP")(),this.eventPromises.createStopPromise(),Atomics.store(this.audioStatePointer,AUDIO_STATE$$module$src$constants.STOP,1),logSABMain$$module$src$logger("Marking that performance is not running anymore (stops the audio too)")(),
+Atomics.store(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_PERFORMING,0),"realtimePerformancePaused"===this.currentPlayState&&(Atomics.store(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_PAUSED,0),Atomics.notify(this.audioStatePointer,AUDIO_STATE$$module$src$constants.IS_PAUSED)),"renderStarted"!==this.currentPlayState&&!Atomics.compareExchange(this.audioStatePointer,AUDIO_STATE$$module$src$constants.CSOUND_LOCK,0,1)&&Atomics.notify(this.audioStatePointer,AUDIO_STATE$$module$src$constants.CSOUND_LOCK),
+await this.eventPromises.waitForStop(),0):-1};this.exportApi.stop=b.bind(this);b.toString=()=>p.toString();break;case "csoundReset":b=async()=>{if(this.currentPlayState){if(this.eventPromises.isWaiting("reset"))return-1;stopableStates$$module$src$utils.has(this.currentPlayState)&&await this.exportApi.stop();this.ipcMessagePorts.restartAudioWorkerPorts();this.audioContextIsProvided||(await this.audioWorker.terminateInstance(),delete this.audioWorker.audioContext);return await l([])}};this.exportApi.reset=
+b.bind(this);b.toString=()=>p.toString();break;case "csoundPushMidiMessage":b=async(q=0,u=0,t=0)=>{this.handleMidiInput({data:[q,u,t]})};this.exportApi.midiMessage=b.bind(this);b.toString=()=>p.toString();break;case "fs":this.exportApi.fs={};Object.keys(p).forEach(q=>{const u=makeProxyCallback$$module$src$utils(k,n,q,this.currentPlayState);u.toString=()=>p[q].toString();this.exportApi.fs[q]=u});break;default:b=async(...q)=>{if("realtimePerformanceStarted"===this.currentPlayState||"renderStarted"===
+this.currentPlayState||this.eventPromises.isWaitingToStart()){const u=this.callbackId;this.callbackId+=1;const t=new Promise((x,r)=>{const y=setTimeout(()=>r(Error(`Worker timed out so ${csoundApiRename$$module$src$utils(m)}() wasn't called!`)),1E4);this.callbackBuffer[u]={resolveCallback:v=>{clearTimeout(y);x(v)},apiKey:m,argumentz:[n,...q]}});Atomics.compareExchange(e,AUDIO_STATE$$module$src$constants.HAS_PENDING_CALLBACKS,0,1);return await t}return await l.apply(void 0,q)},b.toString=()=>p.toString(),
+this.exportApi[csoundApiRename$$module$src$utils(m)]=b}}logSABMain$$module$src$logger("PUBLIC API Generated and stored")()}}var $jscompDefaultExport$$module$src$mains$sab_main=SharedArrayBufferMainThread$$module$src$mains$sab_main,module$src$mains$sab_main={};module$src$mains$sab_main.default=$jscompDefaultExport$$module$src$mains$sab_main;async function requestMidi$$module$src$utils$request_midi({onMidiMessage:a}){logMidiRequest$$module$src$logger("requesting for web-midi connection")();if(navigator&&navigator.requestMIDIAccess)try{const b=await navigator.requestMIDIAccess();if(b.inputs){const c=b.inputs.values();for(let d=c.next();d&&!d.done;d=c.next())logMidiRequest$$module$src$logger(`Connecting midi-input: ${d.value.name||"unkown"}`)(),d.value.onmidimessage=a}else logMidiRequest$$module$src$logger("no midi-device detected")()}catch(b){logMidiRequest$$module$src$logger("error while connecting web-midi: "+
+b)()}else logMidiRequest$$module$src$logger("no web-midi support found, midi-input will not work!")()}var module$src$utils$request_midi={};module$src$utils$request_midi.requestMidi=requestMidi$$module$src$utils$request_midi;var $jscompDefaultExport$$module$dist$__compiled_worklet_worker_inline=()=>"data:application/javascript;base64,let self = AudioWorkletGlobalScope;
/*

 Copyright The Closure Library Authors.
 SPDX-License-Identifier: Apache-2.0
*/
var $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this||self;goog.exportPath_=function(a,b,c,d){a=a.split(".");d=d||goog.global;a[0]in d||"undefined"==typeof d.execScript||d.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)if(a.length||void 0===b)d=d[e]&&d[e]!==Object.prototype[e]?d[e]:d[e]={};else if(!c&&goog.isObject(b)&&goog.isObject(d[e]))for(var f in b)b.hasOwnProperty(f)&&(d[e][f]=b[f]);else d[e]=b};
goog.define=function(a,b){if(!COMPILED){var c=goog.global.CLOSURE_UNCOMPILED_DEFINES,d=goog.global.CLOSURE_DEFINES;c&&void 0===c.nodeType&&Object.prototype.hasOwnProperty.call(c,a)?b=c[a]:d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)&&(b=d[a])}return b};goog.FEATURESET_YEAR=2020;goog.DEBUG=!0;goog.LOCALE="en";goog.getLocale=function(){return goog.LOCALE};goog.TRUSTED_SITE=!0;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;
goog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b,c){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var d=a;(d=d.substring(0,d.lastIndexOf(".")))&&!goog.getObjectByName(d);)goog.implicitNamespaces_[d]=!0}goog.exportPath_(a,b,c)};goog.NONCE_PATTERN_=/^[\w+/_-]+[=]{0,2}$/;
goog.getScriptNonce_=function(a){a=(a||goog.global).document;return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module=function(a){if("string"!==typeof a||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");
goog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;
goog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG};goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1};
goog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0};
goog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error('Module with namespace "'+a+'" already exists.');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error('Module with namespace "'+
a+'" has been loaded incorrectly.');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){};COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&null!=goog.getObjectByName(a)},goog.implicitNamespaces_={"goog.module":!0});
goog.getObjectByName=function(a,b){a=a.split(".");b=b||goog.global;for(var c=0;c<a.length;c++)if(b=b[a[c]],null==b)return null;return b};goog.addDependency=function(a,b,c,d){!COMPILED&&goog.DEPENDENCIES_ENABLED&&goog.debugLoader_.addDependency(a,b,c,d)};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};
goog.require=function(a){if(!COMPILED){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_.requested(a);if(goog.isProvided_(a)){if(goog.isInModuleLoader_())return goog.module.getInternal_(a)}else if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{goog.debugLoader_.load_(a)}finally{goog.moduleLoaderState_=b}}return null}};goog.requireType=function(a){return{}};goog.basePath="";goog.abstractMethod=function(){throw Error("unimplemented abstract method");};
goog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";goog.ASSUME_ES_MODULES_TRANSPILED=!1;goog.TRUSTED_TYPES_POLICY_NAME="goog";
goog.hasBadLetScoping=null;
goog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:"",declareLegacyNamespace:!1,type:goog.ModuleType.GOOG};var c={},d=c;if("function"===typeof a)d=a.call(void 0,d);else if("string"===typeof a)d=goog.loadModuleFromSource_.call(void 0,d,a);else throw Error("Invalid module definition");var e=goog.moduleLoaderState_.moduleName;if("string"===typeof e&&e)goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(e,d,c!==d):goog.SEAL_MODULE_EXPORTS&&
Object.seal&&"object"==typeof d&&null!=d&&Object.seal(d),goog.loadedModules_[e]={exports:d,type:goog.ModuleType.GOOG,moduleId:goog.moduleLoaderState_.moduleName};else throw Error('Invalid module name "'+e+'"');}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a,b){eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(b));return a};goog.normalizePath_=function(a){a=a.split("/");for(var b=0;b<a.length;)"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++;return a.join("/")};
goog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC)return goog.global.CLOSURE_LOAD_FILE_SYNC(a);try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};goog.typeOf=function(a){var b=typeof a;return"object"!=b?b:a?Array.isArray(a)?"array":b:"null"};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};
goog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear};goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return Object.prototype.hasOwnProperty.call(a,goog.UID_PROPERTY_)&&a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return!!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute"in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};
goog.UID_PROPERTY_="closure_uid_"+(1E9*Math.random()>>>0);goog.uidCounter_=0;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};
goog.bindJs_=function(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var e=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(e,d);return a.apply(b,e)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};
goog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var d=c.slice();d.push.apply(d,arguments);return a.apply(this,d)}};goog.now=function(){return Date.now()};goog.globalEval=function(a){(0,eval)(a)};
goog.getCssName=function(a,b){if("."==String(a).charAt(0))throw Error('className passed in goog.getCssName must not start with ".". You passed: '+a);var c=function(e){return goog.cssNameMapping_[e]||e},d=function(e){e=e.split("-");for(var f=[],g=0;g<e.length;g++)f.push(c(e[g]));return f.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(e){return e};a=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(a):a};
goog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.GetMsgOptions=function(){};
goog.getMsg=function(a,b,c){c&&c.html&&(a=a.replace(/</g,"&lt;"));c&&c.unescapeHtmlEntities&&(a=a.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&apos;/g,"'").replace(/&quot;/g,'"').replace(/&amp;/g,"&"));b&&(a=a.replace(/\{\$([^}]+)}/g,function(d,e){return null!=b&&e in b?b[e]:d}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,!0,c)};goog.exportProperty=function(a,b,c){a[b]=c};
goog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(d,e,f){for(var g=Array(arguments.length-2),h=2;h<arguments.length;h++)g[h-2]=arguments[h];return b.prototype[e].apply(d,g)}};goog.scope=function(a){if(goog.isInModuleLoader_())throw Error("goog.scope is not supported within a module.");a.call(goog.global)};COMPILED||(goog.global.COMPILED=COMPILED);
goog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).");});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;
goog.defineClass.createSealingConstructor_=function(a,b){return goog.defineClass.SEAL_CLASS_INSTANCES?function(){var c=a.apply(this,arguments)||this;c[goog.UID_PROPERTY_]=c[goog.UID_PROPERTY_];return c}:a};goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
goog.defineClass.applyProperties_=function(a,b){for(var c in b)Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c]);for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++)c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])};goog.identity_=function(a){return a};
goog.createTrustedTypesPolicy=function(a){var b=null,c=goog.global.trustedTypes;if(!c||!c.createPolicy)return b;try{b=c.createPolicy(a,{createHTML:goog.identity_,createScript:goog.identity_,createScriptURL:goog.identity_})}catch(d){goog.logToConsole_(d.message)}return b};
!COMPILED&&goog.DEPENDENCIES_ENABLED&&(goog.isEdge_=function(){return!!(goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"").match(/Edge\/(\d+)(\.\d)*/i)},goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write"in a},goog.isDocumentLoading_=function(){var a=goog.global.document;return a.attachEvent?"complete"!=a.readyState:"loading"==a.readyState},goog.findBasePath_=function(){if(void 0!=goog.global.CLOSURE_BASE_PATH&&"string"===typeof goog.global.CLOSURE_BASE_PATH)goog.basePath=
goog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.slice(d-7,d)){goog.basePath=c.slice(0,d-7);break}}}},goog.findBasePath_(),goog.protectScriptTag_=function(a){return a.replace(/<\/(SCRIPT)/ig,"\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_={};this.idToPath_={};this.written_={};this.loadingDeps_=
[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory;this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){b=[];for(var e=0;e<a.length;e++){var f=this.getPathFromDeps_(a[e]);if(!f)throw Error("Unregonized namespace: "+a[e]);b.push(this.dependencies_[f])}f=goog.require;var g=0;for(e=0;e<a.length;e++)f(a[e]),b[e].onLoad(function(){++g==a.length&&c()})}else c()},
goog.DebugLoader_.prototype.loadClosureDeps=function(){this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath+"deps.js"),"deps.js",[],[],{}));this.loadDeps_()},goog.DebugLoader_.prototype.requested=function(a,b){(a=this.getPathFromDeps_(a))&&(b||this.areDepsLoaded_(this.dependencies_[a].requires))&&(b=this.deferredCallbacks_[a])&&(delete this.deferredCallbacks_[a],b())},goog.DebugLoader_.prototype.setDependencyFactory=function(a){this.factory_=a},goog.DebugLoader_.prototype.load_=
function(a){if(this.getPathFromDeps_(a)){var b=this,c=[],d=function(e){var f=b.getPathFromDeps_(e);if(!f)throw Error("Bad dependency path or symbol: "+e);if(!b.written_[f]){b.written_[f]=!0;e=b.dependencies_[f];for(f=0;f<e.requires.length;f++)goog.isProvided_(e.requires[f])||d(e.requires[f]);c.push(e)}};d(a);a=!!this.depsToLoad_.length;this.depsToLoad_=this.depsToLoad_.concat(c);this.paused_||a||this.loadDeps_()}else goog.logToConsole_("goog.require could not find: "+a)},goog.DebugLoader_.prototype.loadDeps_=
function(){for(var a=this,b=this.paused_;this.depsToLoad_.length&&!b;)(function(){var c=!1,d=a.depsToLoad_.shift(),e=!1;a.loading_(d);var f={pause:function(){if(c)throw Error("Cannot call pause after the call to load.");b=!0},resume:function(){c?a.resume_():b=!1},loaded:function(){if(e)throw Error("Double call to loaded.");e=!0;a.loaded_(d)},pending:function(){for(var g=[],h=0;h<a.loadingDeps_.length;h++)g.push(a.loadingDeps_[h]);return g},setModuleState:function(g){goog.moduleLoaderState_={type:g,
moduleName:"",declareLegacyNamespace:!1}},registerEs6ModuleExports:function(g,h,l){l&&(goog.loadedModules_[l]={exports:h,type:goog.ModuleType.ES6,moduleId:l||""})},registerGoogModuleExports:function(g,h){goog.loadedModules_[g]={exports:h,type:goog.ModuleType.GOOG,moduleId:g}},clearModuleState:function(){goog.moduleLoaderState_=null},defer:function(g){if(c)throw Error("Cannot register with defer after the call to load.");a.defer_(d,g)},areDepsLoaded:function(){return a.areDepsLoaded_(d.requires)}};
try{d.load(f)}finally{c=!0}})();b&&this.pause_()},goog.DebugLoader_.prototype.pause_=function(){this.paused_=!0},goog.DebugLoader_.prototype.resume_=function(){this.paused_&&(this.paused_=!1,this.loadDeps_())},goog.DebugLoader_.prototype.loading_=function(a){this.loadingDeps_.push(a)},goog.DebugLoader_.prototype.loaded_=function(a){for(var b=0;b<this.loadingDeps_.length;b++)if(this.loadingDeps_[b]==a){this.loadingDeps_.splice(b,1);break}for(b=0;b<this.deferredQueue_.length;b++)if(this.deferredQueue_[b]==
a.path){this.deferredQueue_.splice(b,1);break}if(this.loadingDeps_.length==this.deferredQueue_.length&&!this.depsToLoad_.length)for(;this.deferredQueue_.length;)this.requested(this.deferredQueue_.shift(),!0);a.loaded()},goog.DebugLoader_.prototype.areDepsLoaded_=function(a){for(var b=0;b<a.length;b++){var c=this.getPathFromDeps_(a[b]);if(!c||!(c in this.deferredCallbacks_||goog.isProvided_(a[b])))return!1}return!0},goog.DebugLoader_.prototype.getPathFromDeps_=function(a){return a in this.idToPath_?
this.idToPath_[a]:a in this.dependencies_?a:null},goog.DebugLoader_.prototype.defer_=function(a,b){this.deferredCallbacks_[a.path]=b;this.deferredQueue_.push(a.path)},goog.LoadController=function(){},goog.LoadController.prototype.pause=function(){},goog.LoadController.prototype.resume=function(){},goog.LoadController.prototype.loaded=function(){},goog.LoadController.prototype.pending=function(){},goog.LoadController.prototype.registerEs6ModuleExports=function(a,b,c){},goog.LoadController.prototype.setModuleState=
function(a){},goog.LoadController.prototype.clearModuleState=function(){},goog.LoadController.prototype.defer=function(a){},goog.LoadController.prototype.areDepsLoaded=function(){},goog.Dependency=function(a,b,c,d,e){this.path=a;this.relativePath=b;this.provides=c;this.requires=d;this.loadFlags=e;this.loaded_=!1;this.loadCallbacks_=[]},goog.Dependency.prototype.getPathName=function(){var a=this.path,b=a.indexOf("://");0<=b&&(a=a.substring(b+3),b=a.indexOf("/"),0<=b&&(a=a.substring(b+1)));return a},
goog.Dependency.prototype.onLoad=function(a){this.loaded_?a():this.loadCallbacks_.push(a)},goog.Dependency.prototype.loaded=function(){this.loaded_=!0;var a=this.loadCallbacks_;this.loadCallbacks_=[];for(var b=0;b<a.length;b++)a[b]()},goog.Dependency.defer_=!1,goog.Dependency.callbackMap_={},goog.Dependency.registerCallback_=function(a){var b=Math.random().toString(32);goog.Dependency.callbackMap_[b]=a;return b},goog.Dependency.unregisterCallback_=function(a){delete goog.Dependency.callbackMap_[a]},
goog.Dependency.callback_=function(a,b){if(a in goog.Dependency.callbackMap_){for(var c=goog.Dependency.callbackMap_[a],d=[],e=1;e<arguments.length;e++)d.push(arguments[e]);c.apply(void 0,d)}else throw Error("Callback key "+a+" does not exist (was base.js loaded more than once?).");},goog.Dependency.prototype.load=function(a){if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var b=goog.global.document;if("complete"==
b.readyState&&!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING){if(/\bdeps.js$/.test(this.path)){a.loaded();return}throw Error('Cannot write "'+this.path+'" after document load');}var c=goog.getScriptNonce_();if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&goog.isDocumentLoading_()){var d=function(h){h.readyState&&"complete"!=h.readyState?h.onload=d:(goog.Dependency.unregisterCallback_(e),a.loaded())};var e=goog.Dependency.registerCallback_(d);c=c?' nonce="'+c+'"':"";var f='<script src="'+this.path+'"'+
c+(goog.Dependency.defer_?" defer":"")+' id="script-'+e+'">\x3c/script>';f+="<script"+c+">";f=goog.Dependency.defer_?f+("document.getElementById('script-"+e+"').onload = function() {\n  goog.Dependency.callback_('"+e+"', this);\n};\n"):f+("goog.Dependency.callback_('"+e+"', document.getElementById('script-"+e+"'));");f+="\x3c/script>";b.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(f):f)}else{var g=b.createElement("script");g.defer=goog.Dependency.defer_;g.async=!1;c&&(g.nonce=
c);g.onload=function(){g.onload=null;a.loaded()};g.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path):this.path;b.head.appendChild(g)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."),a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,
b,c,d,e)},goog.inherits(goog.Es6ModuleDependency,goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(k,m){var n="",p=goog.getScriptNonce_();p&&(n=' nonce="'+p+'"');k=m?'<script type="module" crossorigin'+n+">"+m+"\x3c/script>":'<script type="module" crossorigin src="'+k+'"'+n+">\x3c/script>";d.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(k):k)}function c(k,m){var n=d.createElement("script");n.defer=!0;n.async=!1;n.type="module";n.setAttribute("crossorigin",
!0);var p=goog.getScriptNonce_();p&&(n.nonce=p);m?n.text=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScript(m):m:n.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(k):k;d.head.appendChild(n)}if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var d=goog.global.document,e=this;if(goog.isDocumentLoading_()){var f=b;goog.Dependency.defer_=!0}else f=c;var g=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(g);
a.setModuleState(goog.ModuleType.ES6)});f(void 0,'goog.Dependency.callback_("'+g+'")');f(this.path,void 0);var h=goog.Dependency.registerCallback_(function(k){goog.Dependency.unregisterCallback_(h);a.registerEs6ModuleExports(e.path,k,goog.moduleLoaderState_.moduleName)});f(void 0,'import * as m from "'+this.path+'"; goog.Dependency.callback_("'+h+'", m)');var l=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(l);a.clearModuleState();a.loaded()});f(void 0,'goog.Dependency.callback_("'+
l+'")')}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),a.pause()},goog.TransformedDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e);this.contents_=null;this.lazyFetch_=!goog.inHtmlDocument_()||!("noModule"in goog.global.document.createElement("script"))},goog.inherits(goog.TransformedDependency,goog.Dependency),goog.TransformedDependency.prototype.load=function(a){function b(){e.contents_=goog.loadFileSync_(e.path);e.contents_&&(e.contents_=
e.transform(e.contents_),e.contents_&&(e.contents_+="\n//# sourceURL="+e.path))}function c(){e.lazyFetch_&&b();if(e.contents_){f&&a.setModuleState(goog.ModuleType.ES6);try{var k=e.contents_;e.contents_=null;goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(k));if(f)var m=goog.moduleLoaderState_.moduleName}finally{f&&a.clearModuleState()}f&&goog.global.$jscomp.require.ensure([e.getPathName()],function(){a.registerEs6ModuleExports(e.path,goog.global.$jscomp.require(e.getPathName()),m)});a.loaded()}}
function d(){var k=goog.global.document,m=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(m);c()}),n=goog.getScriptNonce_();n="<script"+(n?' nonce="'+n+'"':"")+">"+goog.protectScriptTag_('goog.Dependency.callback_("'+m+'");')+"\x3c/script>";k.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(n):n)}var e=this;if(goog.global.CLOSURE_IMPORT_SCRIPT)b(),this.contents_&&goog.global.CLOSURE_IMPORT_SCRIPT("",this.contents_)?(this.contents_=null,a.loaded()):
a.pause();else{var f=this.loadFlags.module==goog.ModuleType.ES6;this.lazyFetch_||b();var g=1<a.pending().length;if(goog.Dependency.defer_&&(g||goog.isDocumentLoading_()))a.defer(function(){c()});else{var h=goog.global.document;g=goog.inHtmlDocument_()&&("ActiveXObject"in goog.global||goog.isEdge_());if(f&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()&&!g){goog.Dependency.defer_=!0;a.pause();var l=h.onreadystatechange;h.onreadystatechange=function(){"interactive"==h.readyState&&(h.onreadystatechange=
l,c(),a.resume());"function"===typeof l&&l.apply(void 0,arguments)}}else goog.inHtmlDocument_()&&goog.isDocumentLoading_()?d():c()}}},goog.TransformedDependency.prototype.transform=function(a){},goog.PreTranspiledEs6ModuleDependency=function(a,b,c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.PreTranspiledEs6ModuleDependency,goog.TransformedDependency),goog.PreTranspiledEs6ModuleDependency.prototype.transform=function(a){return a},goog.GoogModuleDependency=function(a,b,
c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.GoogModuleDependency,goog.TransformedDependency),goog.GoogModuleDependency.prototype.transform=function(a){return goog.LOAD_MODULE_USING_EVAL&&void 0!==goog.global.JSON?"goog.loadModule("+goog.global.JSON.stringify(a+"\n//# sourceURL="+this.path+"\n")+");":'goog.loadModule(function(exports) {"use strict";'+a+"\n;return exports});\n//# sourceURL="+this.path+"\n"},goog.DebugLoader_.prototype.addDependency=function(a,b,c,d){b=
b||[];a=a.replace(/\\/g,"/");var e=goog.normalizePath_(goog.basePath+a);d&&"boolean"!==typeof d||(d=d?{module:goog.ModuleType.GOOG}:{});c=this.factory_.createDependency(e,a,b,c,d);this.dependencies_[e]=c;for(c=0;c<b.length;c++)this.idToPath_[b[c]]=e;this.idToPath_[a]=e},goog.DependencyFactory=function(){},goog.DependencyFactory.prototype.createDependency=function(a,b,c,d,e){return e.module==goog.ModuleType.GOOG?new goog.GoogModuleDependency(a,b,c,d,e):e.module==goog.ModuleType.ES6?goog.ASSUME_ES_MODULES_TRANSPILED?
new goog.PreTranspiledEs6ModuleDependency(a,b,c,d,e):new goog.Es6ModuleDependency(a,b,c,d,e):new goog.Dependency(a,b,c,d,e)},goog.debugLoader_=new goog.DebugLoader_,goog.loadClosureDeps=function(){goog.debugLoader_.loadClosureDeps()},goog.setDependencyFactory=function(a){goog.debugLoader_.setDependencyFactory(a)},goog.TRUSTED_TYPES_POLICY_=goog.TRUSTED_TYPES_POLICY_NAME?goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME+"#base"):null,goog.global.CLOSURE_NO_DEPS||goog.debugLoader_.loadClosureDeps(),
goog.bootstrap=function(a,b){goog.debugLoader_.bootstrap(a,b)});if(!COMPILED){var isChrome87=!1;try{isChrome87=eval(goog.global.trustedTypes.emptyScript)!==goog.global.trustedTypes.emptyScript}catch(a){}goog.CLOSURE_EVAL_PREFILTER_=goog.global.trustedTypes&&isChrome87&&goog.createTrustedTypesPolicy("goog#base#devonly#eval")||{createScript:goog.identity_}};const proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.proxy"),createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.endpoint"),releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.releaseProxy"),throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.thrown"),isObject$$module$node_modules$comlink$dist$esm$comlink_mjs=a=>"object"===typeof a&&null!==a||"function"===typeof a,proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs=
{canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs],serialize(a){const {port1:b,port2:c}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b);return[c,[c]]},deserialize(a){a.start();return wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a)}},throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs={canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&
throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs in a,serialize({value:a}){return[a instanceof Error?{isError:!0,value:{message:a.message,name:a.name,stack:a.stack}}:{isError:!1,value:a},[]]},deserialize(a){if(a.isError)throw Object.assign(Error(a.value.message),a.value);throw a.value;}},transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs=new Map([["proxy",proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs],["throw",throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs]]);
function expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self){b.addEventListener("message",function e(d){if(d&&d.data){var {id:f,type:g,path:h}=Object.assign({path:[]},d.data),l=(d.data.argumentList||[]).map(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);try{const m=h.slice(0,-1).reduce((p,q)=>p[q],a),n=h.reduce((p,q)=>p[q],a);switch(g){case "GET":var k=n;break;case "SET":m[h.slice(-1)[0]]=fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(d.data.value);
k=!0;break;case "APPLY":k=n.apply(m,l);break;case "CONSTRUCT":const p=new n(...l);k=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(p);break;case "ENDPOINT":const {port1:q,port2:r}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,r);k=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(q,[q]);break;case "RELEASE":k=void 0;break;default:return}}catch(m){k={value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0}}Promise.resolve(k).catch(m=>
({value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0})).then(m=>{const [n,p]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(m);b.postMessage(Object.assign(Object.assign({},n),{id:f}),p);"RELEASE"===g&&(b.removeEventListener("message",e),closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(b))})}});b.start&&b.start()}function isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return"MessagePort"===a.constructor.name}
function closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a){isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a.close()}function wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[],b)}function throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(a){if(a)throw Error("Proxy has been released and is not useable");}
function createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=[],c=function(){}){let d=!1;const e=new Proxy(c,{get(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);if(g===releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs)return()=>requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"RELEASE",path:b.map(h=>h.toString())}).then(()=>{closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a);d=!0});if("then"===
g){if(0===b.length)return{then:()=>e};f=requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"GET",path:b.map(h=>h.toString())}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return f.then.bind(f)}return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[...b,g])},set(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [l,k]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
{type:"SET",path:[...b,g].map(m=>m.toString()),value:l},k).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},apply(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);f=b[b.length-1];if(f===createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs)return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"ENDPOINT"}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);if("bind"===f)return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
b.slice(0,-1));const [l,k]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"APPLY",path:b.map(m=>m.toString()),argumentList:l},k).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},construct(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [h,l]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(g);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
{type:"CONSTRUCT",path:b.map(k=>k.toString()),argumentList:h},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)}});return e}function myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Array.prototype.concat.apply([],a)}
function processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(a){a=a.map(toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return[a.map(b=>b[0]),myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a.map(b=>b[1]))]}const transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs=new WeakMap;function transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.set(a,b);return a}
function proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Object.assign(a,{[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:!0})}function windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self,c="*"){return{postMessage:(d,e)=>a.postMessage(d,c,e),addEventListener:b.addEventListener.bind(b),removeEventListener:b.removeEventListener.bind(b)}}
function toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){for(const [b,c]of transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs)if(c.canHandle(a)){const [d,e]=c.serialize(a);return[{type:"HANDLER",name:b,value:d},e]}return[{type:"RAW",value:a},transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a)||[]]}
function fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){switch(a.type){case "HANDLER":return transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a.name).deserialize(a.value);case "RAW":return a.value}}
function requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b,c){return new Promise(d=>{const e=generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs();a.addEventListener("message",function h(g){g.data&&g.data.id&&g.data.id===e&&(a.removeEventListener("message",h),d(g.data))});a.start&&a.start();a.postMessage(Object.assign({id:e},b),c)})}
function generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs(){return Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}var module$node_modules$comlink$dist$esm$comlink_mjs={};module$node_modules$comlink$dist$esm$comlink_mjs.createEndpoint=createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.expose=expose$$module$node_modules$comlink$dist$esm$comlink_mjs;
module$node_modules$comlink$dist$esm$comlink_mjs.proxy=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.proxyMarker=proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.releaseProxy=releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.transfer=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs;
module$node_modules$comlink$dist$esm$comlink_mjs.transferHandlers=transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.windowEndpoint=windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.wrap=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs;function MessagePortState$$module$src$utils$message_port_state(){}MessagePortState$$module$src$utils$message_port_state.prototype.ready=!1;MessagePortState$$module$src$utils$message_port_state.prototype.port=void 0;MessagePortState$$module$src$utils$message_port_state.prototype.post=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.broadcastPlayState=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.workerState=void 0;
MessagePortState$$module$src$utils$message_port_state.prototype.vanillaWorkerState=void 0;var $jscompDefaultExport$$module$src$utils$message_port_state=MessagePortState$$module$src$utils$message_port_state,module$src$utils$message_port_state={};module$src$utils$message_port_state.MessagePortState=MessagePortState$$module$src$utils$message_port_state;module$src$utils$message_port_state.default=$jscompDefaultExport$$module$src$utils$message_port_state;const DEFAULT_BUFFER_LEN$$module$src$constants=128,MAX_CHANNELS$$module$src$constants=32,RING_BUFFER_SIZE$$module$src$constants=16384,MIDI_BUFFER_SIZE$$module$src$constants=1024,MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants=3,CALLBACK_DATA_BUFFER_SIZE$$module$src$constants=16384,initialSharedState$$module$src$constants=[0,4096,0,0,0,0,-1,-1,-1,-1,0,DEFAULT_BUFFER_LEN$$module$src$constants,0,0,0,0,0,0,0,0],AUDIO_STATE$$module$src$constants={CSOUND_LOCK:0,FRAMES_REQUESTED:1,IS_PERFORMING:2,IS_RENDERING:3,
IS_PAUSED:4,STOP:5,SAMPLE_RATE:6,KSMPS:7,NCHNLS:8,NCHNLS_I:9,IS_REQUESTING_MIC:10,BUFFER_LEN:11,OUTPUT_READ_INDEX:12,OUTPUT_WRITE_INDEX:13,AVAIL_IN_BUFS:14,AVAIL_OUT_BUFS:15,IS_REQUESTING_RTMIDI:16,RTMIDI_INDEX:17,AVAIL_RTMIDI_EVENTS:18,HAS_PENDING_CALLBACKS:19},DATA_TYPE$$module$src$constants={NUMBER:0,STRING:1,FLOAT_32:2,FLOAT_64:3};var module$src$constants={};module$src$constants.AUDIO_STATE=AUDIO_STATE$$module$src$constants;module$src$constants.CALLBACK_DATA_BUFFER_SIZE=CALLBACK_DATA_BUFFER_SIZE$$module$src$constants;
module$src$constants.DATA_TYPE=DATA_TYPE$$module$src$constants;module$src$constants.DEFAULT_BUFFER_LEN=DEFAULT_BUFFER_LEN$$module$src$constants;module$src$constants.MAX_CHANNELS=MAX_CHANNELS$$module$src$constants;module$src$constants.MIDI_BUFFER_PAYLOAD_SIZE=MIDI_BUFFER_PAYLOAD_SIZE$$module$src$constants;module$src$constants.MIDI_BUFFER_SIZE=MIDI_BUFFER_SIZE$$module$src$constants;module$src$constants.RING_BUFFER_SIZE=RING_BUFFER_SIZE$$module$src$constants;module$src$constants.initialSharedState=initialSharedState$$module$src$constants;var module$node_modules$lines_logger$lib$index={default:{}};module$node_modules$lines_logger$lib$index.default.__esModule=!0;module$node_modules$lines_logger$lib$index.default.LoggerFactory=module$node_modules$lines_logger$lib$index.default.logLevels=void 0;module$node_modules$lines_logger$lib$index.default.logLevels={log_raise_error:1,log_with_warnings:2,trace:3,debug:4,info:5,warn:6,error:7,disable:8};
var LoggerFactory$$module$node_modules$lines_logger$lib$index=function(){function a(b,c){if(void 0===b&&(b="log_with_warnings"),void 0===c&&(c=null),this.logLevel=b,!module$node_modules$lines_logger$lib$index.default.logLevels[b])throw Error("Invalid log level "+b+" allowed: "+JSON.stringify(module$node_modules$lines_logger$lib$index.default.logLevels));this.mockConsole=c||console}return a.prototype.dummy=function(){},a.prototype.setLogWarnings=function(b){this.logLevel=b},a.prototype.getLogWarnings=
function(){return this.logLevel},a.prototype.getSingleLoggerColor=function(b,c,d){return this.getSingleLoggerStyle(b,this.getColorStyle(c),d)},a.prototype.getSingleLogger=function(b,c){var d=this.getRandomColor(b);return this.getSingleLoggerStyle(b,this.getColorStyle(d),c)},a.prototype.getSingleLoggerStyle=function(b,c,d,e){var f=this;return void 0===e&&(e="log_with_warnings"),function(){for(var g=[],h=0;h<arguments.length;h++)g[h]=arguments[h];if(module$node_modules$lines_logger$lib$index.default.logLevels[f.logLevel]>
module$node_modules$lines_logger$lib$index.default.logLevels[e])return f.dummy;g=Array.prototype.slice.call(g);h=g.shift().split("{}");for(var l=[f.mockConsole,"%c"+b,c],k=0;k<h.length;k++)l.push(h[k]),void 0!==g[k]&&l.push(g[k]);if(h.length-1!==g.length)if("log_with_warnings"===f.logLevel)f.mockConsole.error("MissMatch amount of arguments");else if("log_raise_error"===f.logLevel)throw Error("MissMatch amount of arguments");return Function.prototype.bind.apply(d,l)}},a.prototype.getLoggerColor=function(b,
c){return this.getLoggerStyle(b,this.getColorStyle(c))},a.prototype.getColorStyle=function(b){return"color: white; background-color: "+b+"; padding: 2px 6px; border-radius: 2px; font-size: 10px"},a.getHash=function(b,c){void 0===c&&(c=0);var d=3735928559^c;c^=1103547991;for(var e=0,f;e<b.length;e++)f=b.charCodeAt(e),d=Math.imul(d^f,2654435761),c=Math.imul(c^f,1597334677);return d=Math.imul(d^d>>>16,2246822507)^Math.imul(c^c>>>13,3266489909),4294967296*(2097151&(Math.imul(c^c>>>16,2246822507)^Math.imul(d^
d>>>13,3266489909)))+(d>>>0)},a.prototype.getRandomColor=function(b){void 0===b&&(b="");b=a.getHash(b);for(var c="#",d=0;3>d;d++)c+=("00"+(8+(b>>7*d&127)).toString(16)).substr(-2);return c},a.prototype.getLogger=function(b){return this.getLoggerColor(b,this.getRandomColor(b))},a.prototype.getLoggerStyle=function(b,c){return{trace:this.getSingleLoggerStyle(b,c,this.mockConsole.trace,"trace"),debug:this.getSingleLoggerStyle(b,c,this.mockConsole.debug,"debug"),log:this.getSingleLoggerStyle(b,c,this.mockConsole.log,
"info"),warn:this.getSingleLoggerStyle(b,c,this.mockConsole.warn,"warn"),error:this.getSingleLoggerStyle(b,c,this.mockConsole.error,"error")}},a}();module$node_modules$lines_logger$lib$index.default.LoggerFactory=LoggerFactory$$module$node_modules$lines_logger$lib$index;let logWorkletMain$$module$src$logger,logWorkletWorker$$module$src$logger,logSABMain$$module$src$logger,logSABWorker$$module$src$logger,logVANMain$$module$src$logger,logVANWorker$$module$src$logger,logOldSpnMain$$module$src$logger,logOldSpnWorker$$module$src$logger,logIndex$$module$src$logger,logSPNMainSingle$$module$src$logger,logSinglethreadWorkletMain$$module$src$logger,logSinglethreadWorkletWorker$$module$src$logger,logCommonUtils$$module$src$logger,logWasmModule$$module$src$logger,logMidiRequest$$module$src$logger;
const isProd$$module$src$logger=1;logWorkletMain$$module$src$logger=a=>b=>{};logWorkletWorker$$module$src$logger=a=>b=>{};logSABMain$$module$src$logger=a=>b=>{};logSABWorker$$module$src$logger=a=>b=>{};logVANMain$$module$src$logger=a=>b=>{};logVANWorker$$module$src$logger=a=>b=>{};logOldSpnMain$$module$src$logger=a=>b=>{};logOldSpnWorker$$module$src$logger=a=>b=>{};logIndex$$module$src$logger=a=>b=>{};logSPNMainSingle$$module$src$logger=a=>b=>{};
logSinglethreadWorkletMain$$module$src$logger=a=>b=>{};logSinglethreadWorkletWorker$$module$src$logger=a=>b=>{};logCommonUtils$$module$src$logger=a=>b=>{};logWasmModule$$module$src$logger=a=>b=>{};logMidiRequest$$module$src$logger=a=>b=>{};var $jscompDefaultExport$$module$src$logger=a=>b=>{},module$src$logger={};module$src$logger.default=$jscompDefaultExport$$module$src$logger;module$src$logger.logCommonUtils=logCommonUtils$$module$src$logger;module$src$logger.logIndex=logIndex$$module$src$logger;
module$src$logger.logMidiRequest=logMidiRequest$$module$src$logger;module$src$logger.logOldSpnMain=logOldSpnMain$$module$src$logger;module$src$logger.logOldSpnWorker=logOldSpnWorker$$module$src$logger;module$src$logger.logSABMain=logSABMain$$module$src$logger;module$src$logger.logSABWorker=logSABWorker$$module$src$logger;module$src$logger.logSPNMainSingle=logSPNMainSingle$$module$src$logger;module$src$logger.logSinglethreadWorkletMain=logSinglethreadWorkletMain$$module$src$logger;
module$src$logger.logSinglethreadWorkletWorker=logSinglethreadWorkletWorker$$module$src$logger;module$src$logger.logVANMain=logVANMain$$module$src$logger;module$src$logger.logVANWorker=logVANWorker$$module$src$logger;module$src$logger.logWasmModule=logWasmModule$$module$src$logger;module$src$logger.logWorkletMain=logWorkletMain$$module$src$logger;module$src$logger.logWorkletWorker=logWorkletWorker$$module$src$logger;const handleCsoundStart$$module$src$workers$common_utils=(a,b,c,d,e)=>f=>{const {csound:g}=f,h=1===b.csoundShouldDaemonize(g);h&&(b.csoundSetOption(g,"--daemon"),b.csoundSetOption(g,"-odac"));const l=b.csoundStart(g),k=b.csoundGetOutputName(g)||"test.wav";logCommonUtils$$module$src$logger(`handleCsoundStart: actual csoundStart result ${l}, outputName: ${k}`)();0!==l&&a.post(`error: csoundStart failed while trying to render ${k},`+" look out for errors in options and syntax");setTimeout(()=>{const m=
b._isRequestingRtMidiInput(g);if(h||m||k.includes("dac"))d(f);else if(a.broadcastPlayState("renderStarted"),e)e(f);else for(;0===b.csoundPerformKsmps(g););},0);return l},instantiateAudioPacket$$module$src$workers$common_utils=(a,b)=>{const c=[];for(let d=0;d<a;d++)c.push(new Float64Array(b));return c},renderFunction$$module$src$workers$common_utils=({libraryCsound:a,workerMessagePort:b})=>async({csound:c})=>{const d=a.csoundGetKr(c);let e=0,f=0;for(;("renderStarted"===b.vanillaWorkerState||"renderStarted"===
b.workerState)&&0===e;)e=a.csoundPerformKsmps(c),f+=1,"function"===typeof setTimeout&&0===e&&0===f%(2*d)&&await new Promise(g=>setTimeout(g,0));b.broadcastPlayState("renderEnded")};var module$src$workers$common_utils={};module$src$workers$common_utils.handleCsoundStart=handleCsoundStart$$module$src$workers$common_utils;module$src$workers$common_utils.instantiateAudioPacket=instantiateAudioPacket$$module$src$workers$common_utils;module$src$workers$common_utils.renderFunction=renderFunction$$module$src$workers$common_utils;const VANILLA_INPUT_WRITE_BUFFER_LEN$$module$src$workers$worklet_worker=2048,activeNodes$$module$src$workers$worklet_worker=new Map;
function processSharedArrayBuffer$$module$src$workers$worklet_worker(a,b){var c=1===Atomics.load(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.IS_PERFORMING),d=1===Atomics.load(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.IS_PAUSED);const e=1===Atomics.load(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.STOP);this.startPromiz&&(this.startPromiz(),delete this.startPromiz);if(!this.sharedArrayBuffer||d||!c||e)return this.isPerformingLastTime=c,this.notifiedOnce=this.firstBufferReady=
!1,(b[0]||[]).forEach(g=>g.fill(0)),!0;this.isPerformingLastTime=c;a=a&&a[0];b=b&&b[0];c=b[0].length;this.bufferLength!==c&&(this.bufferLength=c,Atomics.store(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.BUFFER_LEN,c));d=a&&0<a.length?(this.inputWriteIndex+c)%RING_BUFFER_SIZE$$module$src$constants:0;const f=b&&0<b.length?(this.outputReadIndex+c)%RING_BUFFER_SIZE$$module$src$constants:0;if(Atomics.load(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.AVAIL_OUT_BUFS)>=c)this.bufferUnderrunCount&&
(this.bufferUnderrunCount=0),b.forEach((g,h)=>{g.set(this.sabOutputChannels[h].subarray(this.outputReadIndex,f<this.outputReadIndex?RING_BUFFER_SIZE$$module$src$constants:f))}),a&&a[0]&&0<a[0].length&&(a.forEach((g,h)=>{this.sabInputChannels[h].set(g,this.inputWriteIndex)}),this.inputWriteIndex=d,Atomics.add(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.AVAIL_IN_BUFS,a[0].length)),this.outputReadIndex=f,Atomics.sub(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.AVAIL_OUT_BUFS,
c),Atomics.store(this.sharedArrayBuffer,AUDIO_STATE$$module$src$constants.OUTPUT_READ_INDEX,this.outputReadIndex);else{if(4098<this.outputReadIndex)console.log("buffer underrun");else return!0;this.bufferUnderrunCount+=1;if(100===this.bufferUnderrunCount)return this.workerMessagePort.post("FATAL: 100 buffers failed in a row"),this.workerMessagePort.broadcastPlayState("realtimePerformanceEnded"),!1}return!0}
function processVanillaBuffers$$module$src$workers$worklet_worker(a,b){if(!this.vanillaInitialized)return this.audioFramePort.requestFrames({readIndex:0,numFrames:8192}),this.pendingFrames+=8192,this.vanillaInitialized=!0,this.startPromiz&&(this.startPromiz(),delete this.startPromiz),!0;if(!this.vanillaFirstTransferDone)return(b&&b[0]||[]).forEach(f=>f.fill(0)),!0;a=a&&a[0];const c=(b=b&&b[0])?b[0].length:0,d=b&&0<b.length?(this.vanillaOutputReadIndex+b[0].length)%RING_BUFFER_SIZE$$module$src$constants:
0,e=a&&0<a.length?(this.vanillaInputReadIndex+a[0].length)%RING_BUFFER_SIZE$$module$src$constants:0;if(c&&this.vanillaAvailableFrames>=c){b.forEach((f,g)=>{f.set(this.vanillaOutputChannels[g].subarray(this.vanillaOutputReadIndex,d<this.vanillaOutputReadIndex?RING_BUFFER_SIZE$$module$src$constants:d))});if(a&&0<a.length&&(a.forEach((f,g)=>{this.vanillaInputChannels[g].set(f,this.vanillaInputReadIndex)}),0===e%VANILLA_INPUT_WRITE_BUFFER_LEN$$module$src$workers$worklet_worker)){const f=[],g=(0===e?RING_BUFFER_SIZE$$module$src$constants:
e)-VANILLA_INPUT_WRITE_BUFFER_LEN$$module$src$workers$worklet_worker,h=0===e?RING_BUFFER_SIZE$$module$src$constants:e;this.vanillaInputChannels.forEach(l=>{f.push(l.subarray(g,h))});this.audioInputPort.transferInputFrames(f)}this.vanillaOutputReadIndex=d;this.vanillaInputReadIndex=e;this.vanillaAvailableFrames-=c;this.bufferUnderrunCount=0}else if(1<this.bufferUnderrunCount&&12>this.bufferUnderrunCount&&(this.workerMessagePort.post("Buffer underrun"),this.bufferUnderrunCount+=1),100===this.bufferUnderrunCount)return this.workerMessagePort.post("FATAL: 100 buffers failed in a row"),
this.workerMessagePort.broadcastPlayState("realtimePerformanceEnded"),!1;a=2048-this.vanillaAvailableFrames;0<a&&(this.audioFramePort.requestFrames({readIndex:(this.vanillaAvailableFrames+d+this.pendingFrames)%RING_BUFFER_SIZE$$module$src$constants,numFrames:a}),this.pendingFrames+=a);return!0}
class CsoundWorkletProcessor$$module$src$workers$worklet_worker extends AudioWorkletProcessor{constructor({processorOptions:{contextUid:a,inputsCount:b,outputsCount:c,ksmps:d,maybeSharedArrayBuffer:e,maybeSharedArrayBufferAudioIn:f,maybeSharedArrayBufferAudioOut:g}}){super();activeNodes$$module$src$workers$worklet_worker.set(`${a}Node`,this);this.messagePortsReady=!1;this.currentPlayState=void 0;this.pause=this.pause.bind(this);this.resume=this.resume.bind(this);this.isPaused=!1;this.ksmps=d;this.inputsCount=
b;this.outputsCount=c;this.bufferUnderrunCount=this.outputReadIndex=this.inputWriteIndex=0;this.isPerformingLastTime=!1;this.preProcessCount=0;if(e){this.sharedArrayBuffer=e;this.audioStreamIn=f;this.audioStreamOut=g;this.sabOutputChannels=[];this.sabInputChannels=[];for(a=0;a<b;++a)this.sabInputChannels.push(new Float64Array(this.audioStreamIn,RING_BUFFER_SIZE$$module$src$constants*a,RING_BUFFER_SIZE$$module$src$constants));for(b=0;b<c;++b)this.sabOutputChannels.push(new Float64Array(this.audioStreamOut,
RING_BUFFER_SIZE$$module$src$constants*b,RING_BUFFER_SIZE$$module$src$constants));this.actualProcess=processSharedArrayBuffer$$module$src$workers$worklet_worker.bind(this)}else this.vanillaOutputChannels=[],this.vanillaInputChannels=[],this.pendingFrames=this.vanillaAvailableFrames=this.vanillaInputReadIndex=this.vanillaOutputReadIndex=0,this.vanillaFirstTransferDone=this.vanillaInitialized=!1,this.minBufferSize=4096,this.vanillaInputChannels=instantiateAudioPacket$$module$src$workers$common_utils(b,
RING_BUFFER_SIZE$$module$src$constants),this.vanillaOutputChannels=instantiateAudioPacket$$module$src$workers$common_utils(c,RING_BUFFER_SIZE$$module$src$constants),this.actualProcess=processVanillaBuffers$$module$src$workers$worklet_worker.bind(this),this.updateVanillaFrames=this.updateVanillaFrames.bind(this);expose$$module$node_modules$comlink$dist$esm$comlink_mjs({initialize:initialize$$module$src$workers$worklet_worker,pause:this.pause,resume:this.resume},this.port);logWorkletWorker$$module$src$logger("Worker thread was constructed")()}initCallbacks({workerMessagePort:a,
audioInputPort:b,audioFramePort:c,startPromiz:d}){logWorkletWorker$$module$src$logger("initCallbacks in worker")();a&&(this.workerMessagePort=a);b&&(this.audioInputPort=b);c&&(this.audioFramePort=c);this.messagePortsReady=!0;this.startPromiz=d}updateVanillaFrames({audioPacket:a,numFrames:b,readIndex:c}){this.pendingFrames-=b;if(a){for(let d=0;d<this.outputsCount;++d){let e=!1,f;(c+b)%RING_BUFFER_SIZE$$module$src$constants<c&&(e=!0,f=RING_BUFFER_SIZE$$module$src$constants-c);e?(this.vanillaOutputChannels[d].set(a[d].subarray(0,
f),c),this.vanillaOutputChannels[d].set(a[d].subarray(f),0)):this.vanillaOutputChannels[d].set(a[d],c)}this.vanillaAvailableFrames+=b;this.vanillaFirstTransferDone||(this.vanillaFirstTransferDone=!0)}}pause(){this.isPaused=!0;this.workerMessagePort.broadcastPlayState("realtimePerformancePaused")}resume(){this.isPaused=!1;this.workerMessagePort.broadcastPlayState("realtimePerformanceResumed")}process(a,b){return this.isPaused||!this.messagePortsReady?!0:this.actualProcess(a,b)}}
function initMessagePort$$module$src$workers$worklet_worker({port:a}){logWorkletWorker$$module$src$logger("initMessagePort in worker")();const b=new $jscompDefaultExport$$module$src$utils$message_port_state;b.post=c=>a.postMessage({log:c});b.broadcastPlayState=c=>a.postMessage({playStateChange:c});b.ready=!0;return b}
function initRequestPort$$module$src$workers$worklet_worker({requestPort:a,audioNode:b}){logWorkletWorker$$module$src$logger("initRequestPort in worker")();a.addEventListener("message",c=>{const {audioPacket:d,readIndex:e,numFrames:f}=c.data;b.updateVanillaFrames({audioPacket:d,numFrames:f,readIndex:e})});a.start();return{requestFrames:c=>a.postMessage(c),ready:!0}}
function initAudioInputPort$$module$src$workers$worklet_worker({inputPort:a}){logWorkletWorker$$module$src$logger("initAudioInputPort in worker")();return{ready:!1,transferInputFrames:b=>a.postMessage(b)}}
const initialize$$module$src$workers$worklet_worker=async({contextUid:a,inputPort:b,messagePort:c,requestPort:d})=>{a=activeNodes$$module$src$workers$worklet_worker.get(`${a}Node`);c=initMessagePort$$module$src$workers$worklet_worker({port:c});b=initAudioInputPort$$module$src$workers$worklet_worker({inputPort:b});d=initRequestPort$$module$src$workers$worklet_worker({requestPort:d,audioNode:a});let e;const f=new Promise(g=>{e=g});a.initCallbacks({workerMessagePort:c,audioInputPort:b,audioFramePort:d,
startPromiz:e});await f};registerProcessor("csound-worklet-processor",CsoundWorkletProcessor$$module$src$workers$worklet_worker);var module$src$workers$worklet_worker={};
//# sourceMappingURL=__compiled.worklet.worker.js.map
",
+module$dist$__compiled_worklet_worker_inline={};module$dist$__compiled_worklet_worker_inline.default=$jscompDefaultExport$$module$dist$__compiled_worklet_worker_inline;let UID$$module$src$mains$worklet_main=0;
+class AudioWorkletMainThread$$module$src$mains$worklet_main{constructor({audioContext:a,audioContextIsProvided:b,autoConnect:c}){this.autoConnect=c;this.audioContextIsProvided=b;this.ipcMessagePorts=void 0;this.audioContext=a;this.softwareBufferSize=this.hardwareBufferSize=this.outputsCount=this.inputsCount=this.sampleRate=this.ksmps=this.workletProxy=this.csoundWorkerMain=this.currentPlayState=this.audioWorkletNode=void 0;this.initialize=this.initialize.bind(this);this.onPlayStateChange=this.onPlayStateChange.bind(this);
+this.terminateInstance=this.terminateInstance.bind(this);this.createWorkletNode=this.createWorkletNode.bind(this);logWorkletMain$$module$src$logger("AudioWorkletMainThread was constructed")()}async terminateInstance(){this.audioWorkletNode&&(this.audioWorkletNode.disconnect(),delete this.audioWorkletNode);if(this.audioContext){if("closed"!==this.audioContext.state)try{await this.audioContext.close()}catch{}delete this.audioContext}this.workletProxy&&(this.workletProxy[releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs](),
+delete this.workletProxy)}createWorkletNode(a,b,c){a=new AudioWorkletNode(a,"csound-worklet-processor",{inputChannelCount:b?[b]:0,outputChannelCount:[this.outputsCount||2],processorOptions:{contextUid:c,isRequestingInput:this.isRequestingInput,inputsCount:b,outputsCount:this.outputsCount,ksmps:this.ksmps,maybeSharedArrayBuffer:this.csoundWorkerMain.hasSharedArrayBuffer&&this.csoundWorkerMain.audioStatePointer,maybeSharedArrayBufferAudioIn:this.csoundWorkerMain.hasSharedArrayBuffer&&this.csoundWorkerMain.audioStreamIn,
+maybeSharedArrayBufferAudioOut:this.csoundWorkerMain.hasSharedArrayBuffer&&this.csoundWorkerMain.audioStreamOut}});this.csoundWorkerMain.publicEvents.triggerOnAudioNodeCreated(a);return a}async onPlayStateChange(a){this.currentPlayState=a;switch(a){case "realtimePerformanceStarted":logWorkletMain$$module$src$logger("event received: realtimePerformanceStarted")();await this.initialize();this.csoundWorkerMain&&this.csoundWorkerMain.eventPromises&&(this.csoundWorkerMain.publicEvents&&this.csoundWorkerMain.publicEvents.triggerRealtimePerformanceStarted(this),
+this.csoundWorkerMain.eventPromises&&await this.csoundWorkerMain.eventPromises.releaseStartPromise());break;case "realtimePerformanceEnded":logWorkletMain$$module$src$logger("event received: realtimePerformanceEnded"+!this.csoundWorkerMain.hasSharedArrayBuffer?" cleaning up ports":"")();if(!this.audioContextIsProvided&&this.autoConnect&&this.audioContext&&"closed"!==this.audioContext.state)try{await this.audioContext.close()}catch{}this.autoConnect&&this.audioWorkletNode&&(this.audioWorkletNode.disconnect(),
+delete this.audioWorkletNode);this.workletProxy&&(this.workletProxy[releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs](),delete this.workletProxy);this.workletWorkerUrl&&(window.URL||window.webkitURL).revokeObjectURL(this.workletWorkerUrl);this.audioWorkletNode&&delete this.audioWorkletNode;this.softwareBufferSize=this.hardwareBufferSize=this.outputsCount=this.inputsCount=this.sampleRate=this.currentPlayState=void 0;break;case "realtimePerformancePaused":this.csoundWorkerMain&&this.csoundWorkerMain.eventPromises&&
+(this.csoundWorkerMain.publicEvents&&this.csoundWorkerMain.publicEvents.triggerRealtimePerformancePaused(this),await this.csoundWorkerMain.eventPromises.releasePausePromise());break;case "realtimePerformanceResumed":this.csoundWorkerMain&&this.csoundWorkerMain.eventPromises&&(this.csoundWorkerMain.publicEvents&&this.csoundWorkerMain.publicEvents.triggerRealtimePerformanceResumed(this),await this.csoundWorkerMain.eventPromises.releaseResumePromise())}}async initialize(){this.audioContext||(this.audioContextIsProvided&&
+console.error("fatal: the provided AudioContext was undefined"),this.audioContext=new (WebkitAudioContext$$module$src$utils())({sampleRate:this.sampleRate}));"closed"===this.audioContext.state&&(this.audioContextIsProvided&&console.error("fatal: the provided AudioContext was closed, falling back new AudioContext"),this.audioContext=new (WebkitAudioContext$$module$src$utils())({sampleRate:this.sampleRate}));this.sampleRate!==this.audioContext.sampleRate&&(this.audioContext=new (WebkitAudioContext$$module$src$utils())({sampleRate:this.sampleRate}),
+this.audioContextIsProvided&&console.error("Internal error: sample rate was ignored from provided audioContext"));this.workletWorkerUrl=$jscompDefaultExport$$module$dist$__compiled_worklet_worker_inline();try{await this.audioContext.audioWorklet.addModule(this.workletWorkerUrl)}catch(c){console.error("Error calling audioWorklet.addModule",c)}logWorkletMain$$module$src$logger("WorkletWorker module added")();if(this.csoundWorkerMain){var a=`audioWorklet${UID$$module$src$mains$worklet_main}`;UID$$module$src$mains$worklet_main+=
+1;this.isRequestingMidi&&(logWorkletMain$$module$src$logger("requesting for web-midi connection"),requestMidi$$module$src$utils$request_midi({onMidiMessage:this.csoundWorkerMain.handleMidiInput.bind(this.csoundWorkerMain)}));if(this.isRequestingInput){let c;var b=new Promise(f=>{c=f});const d=void 0===navigator.mediaDevices?navigator.getUserMedia||navigator.webkitGetUserMedia||navigator.mozGetUserMedia:navigator.mediaDevices.getUserMedia,e=f=>{if(f){f=this.audioContext.createMediaStreamSource(f);
+this.inputsCount=f.channelCount;const g=this.createWorkletNode(this.audioContext,f.channelCount,a);this.audioWorkletNode=g;this.autoConnect&&f.connect(g).connect(this.audioContext.destination)}else this.inputsCount=0,this.audioWorkletNode=this.createWorkletNode(this.audioContext,0,a),this.autoConnect&&this.audioWorkletNode.connect(this.audioContext.destination);c&&c()};logWorkletMain$$module$src$logger("requesting microphone access")();void 0===navigator.mediaDevices?d.call(navigator,{audio:{optional:[{echoCancellation:!1,
+sampleSize:32}]}},e,console.error):d.call(navigator.mediaDevices,{audio:{echoCancellation:!1,sampleSize:32}}).then(e).catch(console.error)}else this.audioWorkletNode=this.createWorkletNode(this.audioContext,0,a),logWorkletMain$$module$src$logger("connecting Node to AudioContext destination")(),this.autoConnect&&this.audioWorkletNode.connect(this.audioContext.destination);b&&await b;this.workletProxy=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(this.audioWorkletNode.port);this.ipcMessagePorts.mainMessagePortAudio.addEventListener("message",
+messageEventHandler$$module$src$mains$messages_main(this));this.ipcMessagePorts.mainMessagePortAudio.start();await this.workletProxy.initialize(transfer$$module$node_modules$comlink$dist$esm$comlink_mjs({contextUid:a,messagePort:this.ipcMessagePorts.workerMessagePortAudio,requestPort:this.ipcMessagePorts.audioWorkerFrameRequestPort,inputPort:this.ipcMessagePorts.audioWorkerAudioInputPort},[this.ipcMessagePorts.workerMessagePortAudio,this.ipcMessagePorts.audioWorkerFrameRequestPort,this.ipcMessagePorts.audioWorkerAudioInputPort]));
+logWorkletMain$$module$src$logger("initialization finished in main")()}else console.error("fatal: worker not reachable from worklet-main thread")}}var $jscompDefaultExport$$module$src$mains$worklet_main=AudioWorkletMainThread$$module$src$mains$worklet_main,module$src$mains$worklet_main={};module$src$mains$worklet_main.default=$jscompDefaultExport$$module$src$mains$worklet_main;const requestMicrophoneNode$$module$src$mains$io_utils=a=>{const b=void 0===navigator.mediaDevices?navigator.getUserMedia||navigator.webkitGetUserMedia||navigator.mozGetUserMedia:navigator.mediaDevices.getUserMedia;console.log("requesting microphone access");void 0===navigator.mediaDevices?b.call(navigator,{audio:{optional:[{echoCancellation:!1,sampleSize:32}]}},a,console.error):b.call(navigator.mediaDevices,{audio:{echoCancellation:!1,sampleSize:32}}).then(a).catch(console.error)};
+async function enableAudioInput$$module$src$mains$io_utils(){console.log("enabling audio input");requestMicrophoneNode$$module$src$mains$io_utils(async a=>{if(a){a=(await this.getAudioContext()).createMediaStreamSource(a);this.inputsCount=a.channelCount;const b=await this.getNode();a.connect(b)}})}var module$src$mains$io_utils={};module$src$mains$io_utils.enableAudioInput=enableAudioInput$$module$src$mains$io_utils;module$src$mains$io_utils.requestMicrophoneNode=requestMicrophoneNode$$module$src$mains$io_utils;var $jscompDefaultExport$$module$dist$__compiled_old_spn_worker_inline=()=>(window.URL||window.webkitURL).createObjectURL(new Blob(['(function(){/*\n\n Copyright The Closure Library Authors.\n SPDX-License-Identifier: Apache-2.0\n*/\nvar $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this||self;goog.exportPath_=function(a,b,c,d){a=a.split(".");d=d||goog.global;a[0]in d||"undefined"==typeof d.execScript||d.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)if(a.length||void 0===b)d=d[e]&&d[e]!==Object.prototype[e]?d[e]:d[e]={};else if(!c&&goog.isObject(b)&&goog.isObject(d[e]))for(var f in b)b.hasOwnProperty(f)&&(d[e][f]=b[f]);else d[e]=b};\ngoog.define=function(a,b){if(!COMPILED){var c=goog.global.CLOSURE_UNCOMPILED_DEFINES,d=goog.global.CLOSURE_DEFINES;c&&void 0===c.nodeType&&Object.prototype.hasOwnProperty.call(c,a)?b=c[a]:d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)&&(b=d[a])}return b};goog.FEATURESET_YEAR=2020;goog.DEBUG=!0;goog.LOCALE="en";goog.getLocale=function(){return goog.LOCALE};goog.TRUSTED_SITE=!0;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;\ngoog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error(\'Namespace "\'+a+\'" already declared.\');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b,c){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var d=a;(d=d.substring(0,d.lastIndexOf(".")))&&!goog.getObjectByName(d);)goog.implicitNamespaces_[d]=!0}goog.exportPath_(a,b,c)};goog.NONCE_PATTERN_=/^[\\w+/_-]+[=]{0,2}$/;\ngoog.getScriptNonce_=function(a){a=(a||goog.global).document;return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;\ngoog.module=function(a){if("string"!==typeof a||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You\'re likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");\ngoog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error(\'Namespace "\'+a+\'" already declared.\');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;\ngoog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG};goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1};\ngoog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0};\ngoog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error(\'Module with namespace "\'+a+\'" already exists.\');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error(\'Module with namespace "\'+\na+\'" has been loaded incorrectly.\');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){};COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&null!=goog.getObjectByName(a)},goog.implicitNamespaces_={"goog.module":!0});\ngoog.getObjectByName=function(a,b){a=a.split(".");b=b||goog.global;for(var c=0;c<a.length;c++)if(b=b[a[c]],null==b)return null;return b};goog.addDependency=function(a,b,c,d){!COMPILED&&goog.DEPENDENCIES_ENABLED&&goog.debugLoader_.addDependency(a,b,c,d)};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};\ngoog.require=function(a){if(!COMPILED){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_.requested(a);if(goog.isProvided_(a)){if(goog.isInModuleLoader_())return goog.module.getInternal_(a)}else if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{goog.debugLoader_.load_(a)}finally{goog.moduleLoaderState_=b}}return null}};goog.requireType=function(a){return{}};goog.basePath="";goog.abstractMethod=function(){throw Error("unimplemented abstract method");};\ngoog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";goog.ASSUME_ES_MODULES_TRANSPILED=!1;goog.TRUSTED_TYPES_POLICY_NAME="goog";\ngoog.hasBadLetScoping=null;\ngoog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:"",declareLegacyNamespace:!1,type:goog.ModuleType.GOOG};var c={},d=c;if("function"===typeof a)d=a.call(void 0,d);else if("string"===typeof a)d=goog.loadModuleFromSource_.call(void 0,d,a);else throw Error("Invalid module definition");var e=goog.moduleLoaderState_.moduleName;if("string"===typeof e&&e)goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(e,d,c!==d):goog.SEAL_MODULE_EXPORTS&&\nObject.seal&&"object"==typeof d&&null!=d&&Object.seal(d),goog.loadedModules_[e]={exports:d,type:goog.ModuleType.GOOG,moduleId:goog.moduleLoaderState_.moduleName};else throw Error(\'Invalid module name "\'+e+\'"\');}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a,b){eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(b));return a};goog.normalizePath_=function(a){a=a.split("/");for(var b=0;b<a.length;)"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++;return a.join("/")};\ngoog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC)return goog.global.CLOSURE_LOAD_FILE_SYNC(a);try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};goog.typeOf=function(a){var b=typeof a;return"object"!=b?b:a?Array.isArray(a)?"array":b:"null"};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};\ngoog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear};goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return Object.prototype.hasOwnProperty.call(a,goog.UID_PROPERTY_)&&a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return!!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute"in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};\ngoog.UID_PROPERTY_="closure_uid_"+(1E9*Math.random()>>>0);goog.uidCounter_=0;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};\ngoog.bindJs_=function(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var e=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(e,d);return a.apply(b,e)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};\ngoog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var d=c.slice();d.push.apply(d,arguments);return a.apply(this,d)}};goog.now=function(){return Date.now()};goog.globalEval=function(a){(0,eval)(a)};\ngoog.getCssName=function(a,b){if("."==String(a).charAt(0))throw Error(\'className passed in goog.getCssName must not start with ".". You passed: \'+a);var c=function(e){return goog.cssNameMapping_[e]||e},d=function(e){e=e.split("-");for(var f=[],g=0;g<e.length;g++)f.push(c(e[g]));return f.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(e){return e};a=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(a):a};\ngoog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.GetMsgOptions=function(){};\ngoog.getMsg=function(a,b,c){c&&c.html&&(a=a.replace(/</g,"&lt;"));c&&c.unescapeHtmlEntities&&(a=a.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&apos;/g,"\'").replace(/&quot;/g,\'"\').replace(/&amp;/g,"&"));b&&(a=a.replace(/\\{\\$([^}]+)}/g,function(d,e){return null!=b&&e in b?b[e]:d}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,!0,c)};goog.exportProperty=function(a,b,c){a[b]=c};\ngoog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(d,e,f){for(var g=Array(arguments.length-2),h=2;h<arguments.length;h++)g[h-2]=arguments[h];return b.prototype[e].apply(d,g)}};goog.scope=function(a){if(goog.isInModuleLoader_())throw Error("goog.scope is not supported within a module.");a.call(goog.global)};COMPILED||(goog.global.COMPILED=COMPILED);\ngoog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).");});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;\ngoog.defineClass.createSealingConstructor_=function(a,b){return goog.defineClass.SEAL_CLASS_INSTANCES?function(){var c=a.apply(this,arguments)||this;c[goog.UID_PROPERTY_]=c[goog.UID_PROPERTY_];return c}:a};goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");\ngoog.defineClass.applyProperties_=function(a,b){for(var c in b)Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c]);for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++)c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])};goog.identity_=function(a){return a};\ngoog.createTrustedTypesPolicy=function(a){var b=null,c=goog.global.trustedTypes;if(!c||!c.createPolicy)return b;try{b=c.createPolicy(a,{createHTML:goog.identity_,createScript:goog.identity_,createScriptURL:goog.identity_})}catch(d){goog.logToConsole_(d.message)}return b};\n!COMPILED&&goog.DEPENDENCIES_ENABLED&&(goog.isEdge_=function(){return!!(goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"").match(/Edge\\/(\\d+)(\\.\\d)*/i)},goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write"in a},goog.isDocumentLoading_=function(){var a=goog.global.document;return a.attachEvent?"complete"!=a.readyState:"loading"==a.readyState},goog.findBasePath_=function(){if(void 0!=goog.global.CLOSURE_BASE_PATH&&"string"===typeof goog.global.CLOSURE_BASE_PATH)goog.basePath=\ngoog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.slice(d-7,d)){goog.basePath=c.slice(0,d-7);break}}}},goog.findBasePath_(),goog.protectScriptTag_=function(a){return a.replace(/<\\/(SCRIPT)/ig,"\\\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_={};this.idToPath_={};this.written_={};this.loadingDeps_=\n[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory;this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){b=[];for(var e=0;e<a.length;e++){var f=this.getPathFromDeps_(a[e]);if(!f)throw Error("Unregonized namespace: "+a[e]);b.push(this.dependencies_[f])}f=goog.require;var g=0;for(e=0;e<a.length;e++)f(a[e]),b[e].onLoad(function(){++g==a.length&&c()})}else c()},\ngoog.DebugLoader_.prototype.loadClosureDeps=function(){this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath+"deps.js"),"deps.js",[],[],{}));this.loadDeps_()},goog.DebugLoader_.prototype.requested=function(a,b){(a=this.getPathFromDeps_(a))&&(b||this.areDepsLoaded_(this.dependencies_[a].requires))&&(b=this.deferredCallbacks_[a])&&(delete this.deferredCallbacks_[a],b())},goog.DebugLoader_.prototype.setDependencyFactory=function(a){this.factory_=a},goog.DebugLoader_.prototype.load_=\nfunction(a){if(this.getPathFromDeps_(a)){var b=this,c=[],d=function(e){var f=b.getPathFromDeps_(e);if(!f)throw Error("Bad dependency path or symbol: "+e);if(!b.written_[f]){b.written_[f]=!0;e=b.dependencies_[f];for(f=0;f<e.requires.length;f++)goog.isProvided_(e.requires[f])||d(e.requires[f]);c.push(e)}};d(a);a=!!this.depsToLoad_.length;this.depsToLoad_=this.depsToLoad_.concat(c);this.paused_||a||this.loadDeps_()}else goog.logToConsole_("goog.require could not find: "+a)},goog.DebugLoader_.prototype.loadDeps_=\nfunction(){for(var a=this,b=this.paused_;this.depsToLoad_.length&&!b;)(function(){var c=!1,d=a.depsToLoad_.shift(),e=!1;a.loading_(d);var f={pause:function(){if(c)throw Error("Cannot call pause after the call to load.");b=!0},resume:function(){c?a.resume_():b=!1},loaded:function(){if(e)throw Error("Double call to loaded.");e=!0;a.loaded_(d)},pending:function(){for(var g=[],h=0;h<a.loadingDeps_.length;h++)g.push(a.loadingDeps_[h]);return g},setModuleState:function(g){goog.moduleLoaderState_={type:g,\nmoduleName:"",declareLegacyNamespace:!1}},registerEs6ModuleExports:function(g,h,k){k&&(goog.loadedModules_[k]={exports:h,type:goog.ModuleType.ES6,moduleId:k||""})},registerGoogModuleExports:function(g,h){goog.loadedModules_[g]={exports:h,type:goog.ModuleType.GOOG,moduleId:g}},clearModuleState:function(){goog.moduleLoaderState_=null},defer:function(g){if(c)throw Error("Cannot register with defer after the call to load.");a.defer_(d,g)},areDepsLoaded:function(){return a.areDepsLoaded_(d.requires)}};\ntry{d.load(f)}finally{c=!0}})();b&&this.pause_()},goog.DebugLoader_.prototype.pause_=function(){this.paused_=!0},goog.DebugLoader_.prototype.resume_=function(){this.paused_&&(this.paused_=!1,this.loadDeps_())},goog.DebugLoader_.prototype.loading_=function(a){this.loadingDeps_.push(a)},goog.DebugLoader_.prototype.loaded_=function(a){for(var b=0;b<this.loadingDeps_.length;b++)if(this.loadingDeps_[b]==a){this.loadingDeps_.splice(b,1);break}for(b=0;b<this.deferredQueue_.length;b++)if(this.deferredQueue_[b]==\na.path){this.deferredQueue_.splice(b,1);break}if(this.loadingDeps_.length==this.deferredQueue_.length&&!this.depsToLoad_.length)for(;this.deferredQueue_.length;)this.requested(this.deferredQueue_.shift(),!0);a.loaded()},goog.DebugLoader_.prototype.areDepsLoaded_=function(a){for(var b=0;b<a.length;b++){var c=this.getPathFromDeps_(a[b]);if(!c||!(c in this.deferredCallbacks_||goog.isProvided_(a[b])))return!1}return!0},goog.DebugLoader_.prototype.getPathFromDeps_=function(a){return a in this.idToPath_?\nthis.idToPath_[a]:a in this.dependencies_?a:null},goog.DebugLoader_.prototype.defer_=function(a,b){this.deferredCallbacks_[a.path]=b;this.deferredQueue_.push(a.path)},goog.LoadController=function(){},goog.LoadController.prototype.pause=function(){},goog.LoadController.prototype.resume=function(){},goog.LoadController.prototype.loaded=function(){},goog.LoadController.prototype.pending=function(){},goog.LoadController.prototype.registerEs6ModuleExports=function(a,b,c){},goog.LoadController.prototype.setModuleState=\nfunction(a){},goog.LoadController.prototype.clearModuleState=function(){},goog.LoadController.prototype.defer=function(a){},goog.LoadController.prototype.areDepsLoaded=function(){},goog.Dependency=function(a,b,c,d,e){this.path=a;this.relativePath=b;this.provides=c;this.requires=d;this.loadFlags=e;this.loaded_=!1;this.loadCallbacks_=[]},goog.Dependency.prototype.getPathName=function(){var a=this.path,b=a.indexOf("://");0<=b&&(a=a.substring(b+3),b=a.indexOf("/"),0<=b&&(a=a.substring(b+1)));return a},\ngoog.Dependency.prototype.onLoad=function(a){this.loaded_?a():this.loadCallbacks_.push(a)},goog.Dependency.prototype.loaded=function(){this.loaded_=!0;var a=this.loadCallbacks_;this.loadCallbacks_=[];for(var b=0;b<a.length;b++)a[b]()},goog.Dependency.defer_=!1,goog.Dependency.callbackMap_={},goog.Dependency.registerCallback_=function(a){var b=Math.random().toString(32);goog.Dependency.callbackMap_[b]=a;return b},goog.Dependency.unregisterCallback_=function(a){delete goog.Dependency.callbackMap_[a]},\ngoog.Dependency.callback_=function(a,b){if(a in goog.Dependency.callbackMap_){for(var c=goog.Dependency.callbackMap_[a],d=[],e=1;e<arguments.length;e++)d.push(arguments[e]);c.apply(void 0,d)}else throw Error("Callback key "+a+" does not exist (was base.js loaded more than once?).");},goog.Dependency.prototype.load=function(a){if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var b=goog.global.document;if("complete"==\nb.readyState&&!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING){if(/\\bdeps.js$/.test(this.path)){a.loaded();return}throw Error(\'Cannot write "\'+this.path+\'" after document load\');}var c=goog.getScriptNonce_();if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&goog.isDocumentLoading_()){var d=function(h){h.readyState&&"complete"!=h.readyState?h.onload=d:(goog.Dependency.unregisterCallback_(e),a.loaded())};var e=goog.Dependency.registerCallback_(d);c=c?\' nonce="\'+c+\'"\':"";var f=\'<script src="\'+this.path+\'"\'+\nc+(goog.Dependency.defer_?" defer":"")+\' id="script-\'+e+\'">\\x3c/script>\';f+="<script"+c+">";f=goog.Dependency.defer_?f+("document.getElementById(\'script-"+e+"\').onload = function() {\\n  goog.Dependency.callback_(\'"+e+"\', this);\\n};\\n"):f+("goog.Dependency.callback_(\'"+e+"\', document.getElementById(\'script-"+e+"\'));");f+="\\x3c/script>";b.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(f):f)}else{var g=b.createElement("script");g.defer=goog.Dependency.defer_;g.async=!1;c&&(g.nonce=\nc);g.onload=function(){g.onload=null;a.loaded()};g.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path):this.path;b.head.appendChild(g)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."),a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,\nb,c,d,e)},goog.inherits(goog.Es6ModuleDependency,goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(l,m){var n="",p=goog.getScriptNonce_();p&&(n=\' nonce="\'+p+\'"\');l=m?\'<script type="module" crossorigin\'+n+">"+m+"\\x3c/script>":\'<script type="module" crossorigin src="\'+l+\'"\'+n+">\\x3c/script>";d.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(l):l)}function c(l,m){var n=d.createElement("script");n.defer=!0;n.async=!1;n.type="module";n.setAttribute("crossorigin",\n!0);var p=goog.getScriptNonce_();p&&(n.nonce=p);m?n.text=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScript(m):m:n.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(l):l;d.head.appendChild(n)}if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var d=goog.global.document,e=this;if(goog.isDocumentLoading_()){var f=b;goog.Dependency.defer_=!0}else f=c;var g=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(g);\na.setModuleState(goog.ModuleType.ES6)});f(void 0,\'goog.Dependency.callback_("\'+g+\'")\');f(this.path,void 0);var h=goog.Dependency.registerCallback_(function(l){goog.Dependency.unregisterCallback_(h);a.registerEs6ModuleExports(e.path,l,goog.moduleLoaderState_.moduleName)});f(void 0,\'import * as m from "\'+this.path+\'"; goog.Dependency.callback_("\'+h+\'", m)\');var k=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(k);a.clearModuleState();a.loaded()});f(void 0,\'goog.Dependency.callback_("\'+\nk+\'")\')}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),a.pause()},goog.TransformedDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e);this.contents_=null;this.lazyFetch_=!goog.inHtmlDocument_()||!("noModule"in goog.global.document.createElement("script"))},goog.inherits(goog.TransformedDependency,goog.Dependency),goog.TransformedDependency.prototype.load=function(a){function b(){e.contents_=goog.loadFileSync_(e.path);e.contents_&&(e.contents_=\ne.transform(e.contents_),e.contents_&&(e.contents_+="\\n//# sourceURL="+e.path))}function c(){e.lazyFetch_&&b();if(e.contents_){f&&a.setModuleState(goog.ModuleType.ES6);try{var l=e.contents_;e.contents_=null;goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(l));if(f)var m=goog.moduleLoaderState_.moduleName}finally{f&&a.clearModuleState()}f&&goog.global.$jscomp.require.ensure([e.getPathName()],function(){a.registerEs6ModuleExports(e.path,goog.global.$jscomp.require(e.getPathName()),m)});a.loaded()}}\nfunction d(){var l=goog.global.document,m=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(m);c()}),n=goog.getScriptNonce_();n="<script"+(n?\' nonce="\'+n+\'"\':"")+">"+goog.protectScriptTag_(\'goog.Dependency.callback_("\'+m+\'");\')+"\\x3c/script>";l.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(n):n)}var e=this;if(goog.global.CLOSURE_IMPORT_SCRIPT)b(),this.contents_&&goog.global.CLOSURE_IMPORT_SCRIPT("",this.contents_)?(this.contents_=null,a.loaded()):\na.pause();else{var f=this.loadFlags.module==goog.ModuleType.ES6;this.lazyFetch_||b();var g=1<a.pending().length;if(goog.Dependency.defer_&&(g||goog.isDocumentLoading_()))a.defer(function(){c()});else{var h=goog.global.document;g=goog.inHtmlDocument_()&&("ActiveXObject"in goog.global||goog.isEdge_());if(f&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()&&!g){goog.Dependency.defer_=!0;a.pause();var k=h.onreadystatechange;h.onreadystatechange=function(){"interactive"==h.readyState&&(h.onreadystatechange=\nk,c(),a.resume());"function"===typeof k&&k.apply(void 0,arguments)}}else goog.inHtmlDocument_()&&goog.isDocumentLoading_()?d():c()}}},goog.TransformedDependency.prototype.transform=function(a){},goog.PreTranspiledEs6ModuleDependency=function(a,b,c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.PreTranspiledEs6ModuleDependency,goog.TransformedDependency),goog.PreTranspiledEs6ModuleDependency.prototype.transform=function(a){return a},goog.GoogModuleDependency=function(a,b,\nc,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.GoogModuleDependency,goog.TransformedDependency),goog.GoogModuleDependency.prototype.transform=function(a){return goog.LOAD_MODULE_USING_EVAL&&void 0!==goog.global.JSON?"goog.loadModule("+goog.global.JSON.stringify(a+"\\n//# sourceURL="+this.path+"\\n")+");":\'goog.loadModule(function(exports) {"use strict";\'+a+"\\n;return exports});\\n//# sourceURL="+this.path+"\\n"},goog.DebugLoader_.prototype.addDependency=function(a,b,c,d){b=\nb||[];a=a.replace(/\\\\/g,"/");var e=goog.normalizePath_(goog.basePath+a);d&&"boolean"!==typeof d||(d=d?{module:goog.ModuleType.GOOG}:{});c=this.factory_.createDependency(e,a,b,c,d);this.dependencies_[e]=c;for(c=0;c<b.length;c++)this.idToPath_[b[c]]=e;this.idToPath_[a]=e},goog.DependencyFactory=function(){},goog.DependencyFactory.prototype.createDependency=function(a,b,c,d,e){return e.module==goog.ModuleType.GOOG?new goog.GoogModuleDependency(a,b,c,d,e):e.module==goog.ModuleType.ES6?goog.ASSUME_ES_MODULES_TRANSPILED?\nnew goog.PreTranspiledEs6ModuleDependency(a,b,c,d,e):new goog.Es6ModuleDependency(a,b,c,d,e):new goog.Dependency(a,b,c,d,e)},goog.debugLoader_=new goog.DebugLoader_,goog.loadClosureDeps=function(){goog.debugLoader_.loadClosureDeps()},goog.setDependencyFactory=function(a){goog.debugLoader_.setDependencyFactory(a)},goog.TRUSTED_TYPES_POLICY_=goog.TRUSTED_TYPES_POLICY_NAME?goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME+"#base"):null,goog.global.CLOSURE_NO_DEPS||goog.debugLoader_.loadClosureDeps(),\ngoog.bootstrap=function(a,b){goog.debugLoader_.bootstrap(a,b)});if(!COMPILED){var isChrome87=!1;try{isChrome87=eval(goog.global.trustedTypes.emptyScript)!==goog.global.trustedTypes.emptyScript}catch(a){}goog.CLOSURE_EVAL_PREFILTER_=goog.global.trustedTypes&&isChrome87&&goog.createTrustedTypesPolicy("goog#base#devonly#eval")||{createScript:goog.identity_}};const proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.proxy"),createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.endpoint"),releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.releaseProxy"),throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.thrown"),isObject$$module$node_modules$comlink$dist$esm$comlink_mjs=a=>"object"===typeof a&&null!==a||"function"===typeof a,proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs=\n{canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs],serialize(a){const {port1:b,port2:c}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b);return[c,[c]]},deserialize(a){a.start();return wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a)}},throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs={canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&\nthrowMarker$$module$node_modules$comlink$dist$esm$comlink_mjs in a,serialize({value:a}){return[a instanceof Error?{isError:!0,value:{message:a.message,name:a.name,stack:a.stack}}:{isError:!1,value:a},[]]},deserialize(a){if(a.isError)throw Object.assign(Error(a.value.message),a.value);throw a.value;}},transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs=new Map([["proxy",proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs],["throw",throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs]]);\nfunction expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self){b.addEventListener("message",function e(d){if(d&&d.data){var {id:f,type:g,path:h}=Object.assign({path:[]},d.data),k=(d.data.argumentList||[]).map(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);try{const m=h.slice(0,-1).reduce((p,q)=>p[q],a),n=h.reduce((p,q)=>p[q],a);switch(g){case "GET":var l=n;break;case "SET":m[h.slice(-1)[0]]=fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(d.data.value);\nl=!0;break;case "APPLY":l=n.apply(m,k);break;case "CONSTRUCT":const p=new n(...k);l=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(p);break;case "ENDPOINT":const {port1:q,port2:r}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,r);l=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(q,[q]);break;case "RELEASE":l=void 0;break;default:return}}catch(m){l={value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0}}Promise.resolve(l).catch(m=>\n({value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0})).then(m=>{const [n,p]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(m);b.postMessage(Object.assign(Object.assign({},n),{id:f}),p);"RELEASE"===g&&(b.removeEventListener("message",e),closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(b))})}});b.start&&b.start()}function isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return"MessagePort"===a.constructor.name}\nfunction closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a){isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a.close()}function wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[],b)}function throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(a){if(a)throw Error("Proxy has been released and is not useable");}\nfunction createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=[],c=function(){}){let d=!1;const e=new Proxy(c,{get(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);if(g===releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs)return()=>requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"RELEASE",path:b.map(h=>h.toString())}).then(()=>{closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a);d=!0});if("then"===\ng){if(0===b.length)return{then:()=>e};f=requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"GET",path:b.map(h=>h.toString())}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return f.then.bind(f)}return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[...b,g])},set(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [k,l]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\n{type:"SET",path:[...b,g].map(m=>m.toString()),value:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},apply(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);f=b[b.length-1];if(f===createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs)return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"ENDPOINT"}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);if("bind"===f)return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\nb.slice(0,-1));const [k,l]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"APPLY",path:b.map(m=>m.toString()),argumentList:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},construct(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [h,k]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(g);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,\n{type:"CONSTRUCT",path:b.map(l=>l.toString()),argumentList:h},k).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)}});return e}function myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Array.prototype.concat.apply([],a)}\nfunction processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(a){a=a.map(toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return[a.map(b=>b[0]),myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a.map(b=>b[1]))]}const transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs=new WeakMap;function transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.set(a,b);return a}\nfunction proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Object.assign(a,{[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:!0})}function windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self,c="*"){return{postMessage:(d,e)=>a.postMessage(d,c,e),addEventListener:b.addEventListener.bind(b),removeEventListener:b.removeEventListener.bind(b)}}\nfunction toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){for(const [b,c]of transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs)if(c.canHandle(a)){const [d,e]=c.serialize(a);return[{type:"HANDLER",name:b,value:d},e]}return[{type:"RAW",value:a},transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a)||[]]}\nfunction fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){switch(a.type){case "HANDLER":return transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a.name).deserialize(a.value);case "RAW":return a.value}}\nfunction requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b,c){return new Promise(d=>{const e=generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs();a.addEventListener("message",function h(g){g.data&&g.data.id&&g.data.id===e&&(a.removeEventListener("message",h),d(g.data))});a.start&&a.start();a.postMessage(Object.assign({id:e},b),c)})}\nfunction generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs(){return Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}var module$node_modules$comlink$dist$esm$comlink_mjs={};module$node_modules$comlink$dist$esm$comlink_mjs.createEndpoint=createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.expose=expose$$module$node_modules$comlink$dist$esm$comlink_mjs;\nmodule$node_modules$comlink$dist$esm$comlink_mjs.proxy=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.proxyMarker=proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.releaseProxy=releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.transfer=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs;\nmodule$node_modules$comlink$dist$esm$comlink_mjs.transferHandlers=transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.windowEndpoint=windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.wrap=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs;var module$node_modules$lines_logger$lib$index={default:{}};module$node_modules$lines_logger$lib$index.default.__esModule=!0;module$node_modules$lines_logger$lib$index.default.LoggerFactory=module$node_modules$lines_logger$lib$index.default.logLevels=void 0;module$node_modules$lines_logger$lib$index.default.logLevels={log_raise_error:1,log_with_warnings:2,trace:3,debug:4,info:5,warn:6,error:7,disable:8};\nvar LoggerFactory$$module$node_modules$lines_logger$lib$index=function(){function a(b,c){if(void 0===b&&(b="log_with_warnings"),void 0===c&&(c=null),this.logLevel=b,!module$node_modules$lines_logger$lib$index.default.logLevels[b])throw Error("Invalid log level "+b+" allowed: "+JSON.stringify(module$node_modules$lines_logger$lib$index.default.logLevels));this.mockConsole=c||console}return a.prototype.dummy=function(){},a.prototype.setLogWarnings=function(b){this.logLevel=b},a.prototype.getLogWarnings=\nfunction(){return this.logLevel},a.prototype.getSingleLoggerColor=function(b,c,d){return this.getSingleLoggerStyle(b,this.getColorStyle(c),d)},a.prototype.getSingleLogger=function(b,c){var d=this.getRandomColor(b);return this.getSingleLoggerStyle(b,this.getColorStyle(d),c)},a.prototype.getSingleLoggerStyle=function(b,c,d,e){var f=this;return void 0===e&&(e="log_with_warnings"),function(){for(var g=[],h=0;h<arguments.length;h++)g[h]=arguments[h];if(module$node_modules$lines_logger$lib$index.default.logLevels[f.logLevel]>\nmodule$node_modules$lines_logger$lib$index.default.logLevels[e])return f.dummy;g=Array.prototype.slice.call(g);h=g.shift().split("{}");for(var k=[f.mockConsole,"%c"+b,c],l=0;l<h.length;l++)k.push(h[l]),void 0!==g[l]&&k.push(g[l]);if(h.length-1!==g.length)if("log_with_warnings"===f.logLevel)f.mockConsole.error("MissMatch amount of arguments");else if("log_raise_error"===f.logLevel)throw Error("MissMatch amount of arguments");return Function.prototype.bind.apply(d,k)}},a.prototype.getLoggerColor=function(b,\nc){return this.getLoggerStyle(b,this.getColorStyle(c))},a.prototype.getColorStyle=function(b){return"color: white; background-color: "+b+"; padding: 2px 6px; border-radius: 2px; font-size: 10px"},a.getHash=function(b,c){void 0===c&&(c=0);var d=3735928559^c;c^=1103547991;for(var e=0,f;e<b.length;e++)f=b.charCodeAt(e),d=Math.imul(d^f,2654435761),c=Math.imul(c^f,1597334677);return d=Math.imul(d^d>>>16,2246822507)^Math.imul(c^c>>>13,3266489909),4294967296*(2097151&(Math.imul(c^c>>>16,2246822507)^Math.imul(d^\nd>>>13,3266489909)))+(d>>>0)},a.prototype.getRandomColor=function(b){void 0===b&&(b="");b=a.getHash(b);for(var c="#",d=0;3>d;d++)c+=("00"+(8+(b>>7*d&127)).toString(16)).substr(-2);return c},a.prototype.getLogger=function(b){return this.getLoggerColor(b,this.getRandomColor(b))},a.prototype.getLoggerStyle=function(b,c){return{trace:this.getSingleLoggerStyle(b,c,this.mockConsole.trace,"trace"),debug:this.getSingleLoggerStyle(b,c,this.mockConsole.debug,"debug"),log:this.getSingleLoggerStyle(b,c,this.mockConsole.log,\n"info"),warn:this.getSingleLoggerStyle(b,c,this.mockConsole.warn,"warn"),error:this.getSingleLoggerStyle(b,c,this.mockConsole.error,"error")}},a}();module$node_modules$lines_logger$lib$index.default.LoggerFactory=LoggerFactory$$module$node_modules$lines_logger$lib$index;let logWorkletMain$$module$src$logger,logWorkletWorker$$module$src$logger,logSABMain$$module$src$logger,logSABWorker$$module$src$logger,logVANMain$$module$src$logger,logVANWorker$$module$src$logger,logOldSpnMain$$module$src$logger,logOldSpnWorker$$module$src$logger,logIndex$$module$src$logger,logSPNMainSingle$$module$src$logger,logSinglethreadWorkletMain$$module$src$logger,logSinglethreadWorkletWorker$$module$src$logger,logCommonUtils$$module$src$logger,logWasmModule$$module$src$logger,logMidiRequest$$module$src$logger;\nconst isProd$$module$src$logger=1;logWorkletMain$$module$src$logger=a=>b=>{};logWorkletWorker$$module$src$logger=a=>b=>{};logSABMain$$module$src$logger=a=>b=>{};logSABWorker$$module$src$logger=a=>b=>{};logVANMain$$module$src$logger=a=>b=>{};logVANWorker$$module$src$logger=a=>b=>{};logOldSpnMain$$module$src$logger=a=>b=>{};logOldSpnWorker$$module$src$logger=a=>b=>{};logIndex$$module$src$logger=a=>b=>{};logSPNMainSingle$$module$src$logger=a=>b=>{};\nlogSinglethreadWorkletMain$$module$src$logger=a=>b=>{};logSinglethreadWorkletWorker$$module$src$logger=a=>b=>{};logCommonUtils$$module$src$logger=a=>b=>{};logWasmModule$$module$src$logger=a=>b=>{};logMidiRequest$$module$src$logger=a=>b=>{};var $jscompDefaultExport$$module$src$logger=a=>b=>{},module$src$logger={};module$src$logger.default=$jscompDefaultExport$$module$src$logger;module$src$logger.logCommonUtils=logCommonUtils$$module$src$logger;module$src$logger.logIndex=logIndex$$module$src$logger;\nmodule$src$logger.logMidiRequest=logMidiRequest$$module$src$logger;module$src$logger.logOldSpnMain=logOldSpnMain$$module$src$logger;module$src$logger.logOldSpnWorker=logOldSpnWorker$$module$src$logger;module$src$logger.logSABMain=logSABMain$$module$src$logger;module$src$logger.logSABWorker=logSABWorker$$module$src$logger;module$src$logger.logSPNMainSingle=logSPNMainSingle$$module$src$logger;module$src$logger.logSinglethreadWorkletMain=logSinglethreadWorkletMain$$module$src$logger;\nmodule$src$logger.logSinglethreadWorkletWorker=logSinglethreadWorkletWorker$$module$src$logger;module$src$logger.logVANMain=logVANMain$$module$src$logger;module$src$logger.logVANWorker=logVANWorker$$module$src$logger;module$src$logger.logWasmModule=logWasmModule$$module$src$logger;module$src$logger.logWorkletMain=logWorkletMain$$module$src$logger;module$src$logger.logWorkletWorker=logWorkletWorker$$module$src$logger;const handleCsoundStart$$module$src$workers$common_utils=(a,b,c,d,e)=>f=>{const {csound:g}=f,h=1===b.csoundShouldDaemonize(g);h&&(b.csoundSetOption(g,"--daemon"),b.csoundSetOption(g,"-odac"));const k=b.csoundStart(g),l=b.csoundGetOutputName(g)||"test.wav";logCommonUtils$$module$src$logger(`handleCsoundStart: actual csoundStart result ${k}, outputName: ${l}`)();0!==k&&a.post(`error: csoundStart failed while trying to render ${l},`+" look out for errors in options and syntax");setTimeout(()=>{const m=\nb._isRequestingRtMidiInput(g);if(h||m||l.includes("dac"))d(f);else if(a.broadcastPlayState("renderStarted"),e)e(f);else for(;0===b.csoundPerformKsmps(g););},0);return k},instantiateAudioPacket$$module$src$workers$common_utils=(a,b)=>{const c=[];for(let d=0;d<a;d++)c.push(new Float64Array(b));return c},renderFunction$$module$src$workers$common_utils=({libraryCsound:a,workerMessagePort:b})=>async({csound:c})=>{const d=a.csoundGetKr(c);let e=0,f=0;for(;("renderStarted"===b.vanillaWorkerState||"renderStarted"===\nb.workerState)&&0===e;)e=a.csoundPerformKsmps(c),f+=1,"function"===typeof setTimeout&&0===e&&0===f%(2*d)&&await new Promise(g=>setTimeout(g,0));b.broadcastPlayState("renderEnded")};var module$src$workers$common_utils={};module$src$workers$common_utils.handleCsoundStart=handleCsoundStart$$module$src$workers$common_utils;module$src$workers$common_utils.instantiateAudioPacket=instantiateAudioPacket$$module$src$workers$common_utils;module$src$workers$common_utils.renderFunction=renderFunction$$module$src$workers$common_utils;function MessagePortState$$module$src$utils$message_port_state(){}MessagePortState$$module$src$utils$message_port_state.prototype.ready=!1;MessagePortState$$module$src$utils$message_port_state.prototype.port=void 0;MessagePortState$$module$src$utils$message_port_state.prototype.post=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.broadcastPlayState=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.workerState=void 0;\nMessagePortState$$module$src$utils$message_port_state.prototype.vanillaWorkerState=void 0;var $jscompDefaultExport$$module$src$utils$message_port_state=MessagePortState$$module$src$utils$message_port_state,module$src$utils$message_port_state={};module$src$utils$message_port_state.MessagePortState=MessagePortState$$module$src$utils$message_port_state;module$src$utils$message_port_state.default=$jscompDefaultExport$$module$src$utils$message_port_state;const WebkitAudioContext$$module$src$utils$new_audio_context=()=>{if(void 0!==window.webkitAudioContext)return window.webkitAudioContext;if(void 0!==window.AudioContext)return window.AudioContext},newAudioContext$$module$src$utils$new_audio_context=()=>{const a=WebkitAudioContext$$module$src$utils$new_audio_context();if(a)return new a};var module$src$utils$new_audio_context={};module$src$utils$new_audio_context.WebkitAudioContext=WebkitAudioContext$$module$src$utils$new_audio_context;\nmodule$src$utils$new_audio_context.newAudioContext=newAudioContext$$module$src$utils$new_audio_context;function add$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>add$$module$node_modules$rambda$dist$rambda_mjs(a,c):Number(a)+Number(b)}const cloneList$$module$node_modules$rambda$dist$rambda_mjs=a=>Array.prototype.slice.call(a);function curry$$module$node_modules$rambda$dist$rambda_mjs(a,b=[]){return(...c)=>{c=[...b,...c];return c.length>=a.length?a(...c):curry$$module$node_modules$rambda$dist$rambda_mjs(a,c)}}\nfunction adjustFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d=0>a?c.length+a:a;if(a>=c.length||0>d)return c;a=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);a[d]=b(a[d]);return a}const adjust$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(adjustFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction all$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>all$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(!a(b[c]))return!1;return!0}function allPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(!a[c](...b))return!1;c++}return!0}}function always$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>a}\nfunction and$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>and$$module$node_modules$rambda$dist$rambda_mjs(a,c):a&&b}function any$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>any$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=0;for(;c<b.length;){if(a(b[c],c))return!0;c++}return!1}\nfunction anyPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(a[c](...b))return!0;c++}return!1}}function append$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>append$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.split("").concat(a);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);c.push(a);return c}\nfunction apply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>apply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.apply(this,b)}const {isArray:isArray$$module$node_modules$rambda$dist$rambda_mjs}=Array;\nfunction __findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a,b=0){for(const c in a)!1!==a.hasOwnProperty(c)&&"constructor"!==c&&("object"===typeof a[c]&&(b=Math.max(b,__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a[c]))),"function"===typeof a[c]&&(b=Math.max(b,a[c].length)));return b}\nfunction __filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(){const a=[];let b=0;const c=arguments.length;for(;b<c&&"undefined"!==typeof arguments[b];)a[b]=arguments[b],b++;return a}\nfunction __applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){var d=b-c.length;if(1===d)return f=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f));if(2===d)return(f,g)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g));if(3===d)return(f,g,h)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,\nb,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h));if(4===d)return(f,g,h,k)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h,k));if(4<d)return(...f)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,...f));if(isArray$$module$node_modules$rambda$dist$rambda_mjs(a)){var e=[];d=0;const f=a.length;\nfor(;d<f;d++){if("object"===typeof a[d]||isArray$$module$node_modules$rambda$dist$rambda_mjs(a[d]))e[d]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[d],b,c);"function"===typeof a[d]&&(e[d]=a[d](...c))}return e}d={};for(e in a)!1!==a.hasOwnProperty(e)&&"constructor"!==e&&("object"===typeof a[e]?d[e]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[e],b,c):"function"===typeof a[e]&&(d[e]=a[e](...c)));return d}\nfunction applySpec$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a);return 0===c?()=>({}):__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,c,b)}function assocFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return Object.assign({},c,{[a]:b})}const assoc$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction _isInteger$$module$node_modules$rambda$dist$rambda_mjs(a){return a<<0===a}const isInteger$$module$node_modules$rambda$dist$rambda_mjs=Number.isInteger||_isInteger$$module$node_modules$rambda$dist$rambda_mjs;\nfunction assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d="string"===typeof a?a.split(".").map(e=>isInteger$$module$node_modules$rambda$dist$rambda_mjs(Number(e))?Number(e):e):a;if(0===d.length)return b;a=d[0];if(1<d.length){const e="object"===typeof c&&null!==c&&c.hasOwnProperty(a)?c[a]:isInteger$$module$node_modules$rambda$dist$rambda_mjs(d[1])?[]:{};b=assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(d,1),b,e)}return isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)&&\nisArray$$module$node_modules$rambda$dist$rambda_mjs(c)?(c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c),c[a]=b,c):assoc$$module$node_modules$rambda$dist$rambda_mjs(a,b,c)}const assocPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocPathFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction _curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return function(){var d=0;let e=0;const f=b.length,g=arguments.length,h=Array(f+g);for(;d<f;)h[d]=b[d],d++;for(;e<g;)h[f+e]=arguments[e],e++;d=a-h.length;return h.length>=a?c.apply(this,h):_arity$1$$module$node_modules$rambda$dist$rambda_mjs(d,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,h,c))}}\nfunction _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};\ncase 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,m){return b.apply(this,arguments)};default:return function(c,d,e,f,g,h,k,l,m,n){return b.apply(this,arguments)}}}\nfunction curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>curryN$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(10<a)throw Error("First argument to _arity must be a non-negative integer no greater than ten");return _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,[],b))}\nfunction bind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>bind$$module$node_modules$rambda$dist$rambda_mjs(a,c):curryN$$module$node_modules$rambda$dist$rambda_mjs(a.length,(...c)=>a.apply(b,c))}function both$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>both$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>a(...c)&&b(...c)}\nfunction chain$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>chain$$module$node_modules$rambda$dist$rambda_mjs(a,c):[].concat(...b.map(a))}function clampFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(a>b)throw Error("min must not be greater than max in clamp(min, max, value)");if(c>=a&&c<=b)return c;if(c>b)return b;if(c<a)return a}const clamp$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(clampFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction clone$$module$node_modules$rambda$dist$rambda_mjs(a){const b=isArray$$module$node_modules$rambda$dist$rambda_mjs(a)?Array(a.length):{};if(a&&a.getTime)return new Date(a.getTime());for(const c in a){const d=a[c];b[c]="object"===typeof d&&null!==d?d.getTime?new Date(d.getTime()):clone$$module$node_modules$rambda$dist$rambda_mjs(d):d}return b}function complement$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>!a(...b)}\nclass ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs{constructor(a){this.value=a}}function reduceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(c))throw new TypeError("reduce: list must be array or iterable");let d=0;const e=c.length;for(;d<e;){b=a(b,c[d],d,c);if(b instanceof ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs)return b.value;d++}return b}\nconst reduce$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(reduceFn$$module$node_modules$rambda$dist$rambda_mjs),reduceStopper$$module$node_modules$rambda$dist$rambda_mjs=a=>new ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs(a);\nfunction _arity$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};\ncase 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,m){return b.apply(this,arguments)};case 10:return function(c,d,e,f,g,h,k,l,m,n){return b.apply(this,arguments)};default:throw Error("First argument to _arity must be a non-negative integer no greater than ten");}}\nfunction _pipe$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(){return b.call(this,a.apply(this,arguments))}}\nfunction pipe$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("pipe requires at least one argument");return _arity$$module$node_modules$rambda$dist$rambda_mjs(arguments[0].length,reduceFn$$module$node_modules$rambda$dist$rambda_mjs(_pipe$$module$node_modules$rambda$dist$rambda_mjs,arguments[0],Array.prototype.slice.call(arguments,1,Infinity)))}\nfunction compose$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("compose requires at least one argument");return pipe$$module$node_modules$rambda$dist$rambda_mjs.apply(this,Array.prototype.slice.call(arguments,0).reverse())}function concat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>concat$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof a?`${a}${b}`:[...a,...b]}\nfunction cond$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>{let c=!1,d;a.forEach(([e,f])=>{!c&&e(b)&&(c=!0,d=f(b))});return d}}const {keys:keys$1$$module$node_modules$rambda$dist$rambda_mjs}=Object;function mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=Array(b.length);for(;d<b.length;)e[d]=c?a(b[d],d):a(b[d]),d++;return e}\nfunction mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,g);let c=0;const d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b),e=d.length,f={};for(;c<e;){const g=d[c];f[g]=a(b[g],g,b);c++}return f}const mapObjIndexed$$module$node_modules$rambda$dist$rambda_mjs=mapObject$$module$node_modules$rambda$dist$rambda_mjs;\nfunction map$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>map$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error(INCORRECT_ITERABLE_INPUT);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction max$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>max$$module$node_modules$rambda$dist$rambda_mjs(a,c):b>a?b:a}\nfunction converge$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>converge$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=reduce$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>max$$module$node_modules$rambda$dist$rambda_mjs(d,e.length),0,b);return curryN$$module$node_modules$rambda$dist$rambda_mjs(c,function(){return a.apply(this,map$$module$node_modules$rambda$dist$rambda_mjs(d=>d.apply(this,arguments),b))})}\nfunction count$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>count$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?b.filter(c=>a(c)).length:0}function countBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>countBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};b.forEach(d=>{d=a(d);c[d]?c[d]++:c[d]=1});return c}\nconst dec$$module$node_modules$rambda$dist$rambda_mjs=a=>a-1;function isFalsy$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a||!0===Number.isNaN(a)}function defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c):isFalsy$$module$node_modules$rambda$dist$rambda_mjs(b)?a:b}\nfunction type$$module$node_modules$rambda$dist$rambda_mjs(a){if(null===a)return"Null";if(void 0===a)return"Undefined";if(Number.isNaN(a))return"NaN";a=Object.prototype.toString.call(a).slice(8,-1);return"AsyncFunction"===a?"Promise":a}\nfunction _lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property \'indexOf\' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.lastIndexOf(a);({length:c}=b);let d=-1;for(;-1<--c&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}\nfunction _indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property \'indexOf\' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.indexOf(a);let d=c=-1;const {length:e}=b;for(;++c<e&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}\nfunction _arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a){const b=[];let c;for(;!(c=a.next()).done;)b.push(c.value);return b}function _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(a.size!==b.size)return!1;a=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a.values());const c=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(b.values());return 0===a.filter(d=>-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,c)).length}\nfunction parseError$$module$node_modules$rambda$dist$rambda_mjs(a){const b=a.__proto__.toString();return["Error","TypeError"].includes(b)?[b,a.message]:[]}function parseDate$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toDateString?[!0,a.getTime()]:[!1]}function parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a){return a.constructor!==RegExp?[!1]:[!0,a.toString()]}\nfunction equals$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>equals$$module$node_modules$rambda$dist$rambda_mjs(a,f);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(c!==type$$module$node_modules$rambda$dist$rambda_mjs(b))return!1;if("Function"===c)return void 0===a.name?!1:a.name===b.name;if(["NaN","Undefined","Null"].includes(c))return!0;if("Number"===c)return Object.is(-0,a)!==Object.is(-0,b)?!1:a.toString()===b.toString();if(["String","Boolean"].includes(c))return a.toString()===\nb.toString();if("Array"===c){c=Array.from(a);const f=Array.from(b);if(c.toString()!==f.toString())return!1;let g=!0;c.forEach((h,k)=>{g&&(h===f[k]||equals$$module$node_modules$rambda$dist$rambda_mjs(h,f[k])||(g=!1))});return g}var d=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a),e=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseDate$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseDate$$module$node_modules$rambda$dist$rambda_mjs(b);\nif(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseError$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseError$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[0]===e[0]&&d[1]===e[1]:!1;if("Set"===c)return _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b);if("Object"===c){c=Object.keys(a);if(c.length!==Object.keys(b).length)return!1;let f=!0;c.forEach(g=>{if(f){const h=a[g];g=b[g];h===g||equals$$module$node_modules$rambda$dist$rambda_mjs(h,g)||(f=!1)}});\nreturn f}return!1}function includes$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>includes$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof b)return b.includes(a);if(!b)throw new TypeError(`Cannot read property \\\'indexOf\\\' of ${b}`);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b):!1}\nclass _Set$$module$node_modules$rambda$dist$rambda_mjs{constructor(){this.set=new Set;this.items={}}checkUniqueness(a){var b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Null","Undefined","NaN"].includes(b)?b in this.items?!1:this.items[b]=!0:["Object","Array"].includes(b)?b in this.items?-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,this.items[b])?(this.items[b].push(a),!0):!1:(this.items[b]=[a],!0):(b=this.set.size,this.set.add(a),this.set.size!==b)}}\nfunction uniq$$module$node_modules$rambda$dist$rambda_mjs(a){const b=new _Set$$module$node_modules$rambda$dist$rambda_mjs,c=[];a.forEach(d=>{b.checkUniqueness(d)&&c.push(d)});return c}function difference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>difference$$module$node_modules$rambda$dist$rambda_mjs(a,c):uniq$$module$node_modules$rambda$dist$rambda_mjs(a).filter(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(null===b||void 0===b)return{};const c={};for(const d in b)c[d]=b[d];delete c[a];return c}function divide$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>divide$$module$node_modules$rambda$dist$rambda_mjs(a,c):a/b}\nfunction drop$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>drop$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.slice(0<a?a:0)}function dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,c):0<a?b.slice(0,-a):b.slice()}\nfunction dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(0===b.length)return b;const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if("function"!==typeof a)throw Error(`\'predicate\' is from wrong type ${typeof a}`);if(!c&&"string"!==typeof b)throw Error(`\'iterable\' is from wrong type ${typeof b}`);let d=!1;const e=[];let f=b.length;for(;0<f;)f--,d||!1!==a(b[f])?d&&e.push(b[f]):\n(d=!0,e.push(b[f]));return c?e.reverse():e.reverse().join("")}function dropRepeats$$module$node_modules$rambda$dist$rambda_mjs(a){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`${a} is not a list`);const b=[];a.reduce((c,d)=>{equals$$module$node_modules$rambda$dist$rambda_mjs(c,d)||b.push(d);return d},void 0);return b}\nfunction dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`${b} is not a list`);const c=[];b.reduce((d,e)=>{if(void 0===d)return c.push(e),e;a(d,e)||c.push(e);return e},void 0);return c}\nfunction dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!1;const e=[];let f=-1;for(;f++<b.length-1;)d?e.push(b[f]):a(b[f])||(d||(d=!0),e.push(b[f]));return c?e:e.join("")}\nfunction either$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>either$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>!(!a(...c)&&!b(...c))}\nfunction endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);if("string"===typeof b)return b.endsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;const c=b.length-a.length;let d=!0;return a.filter((e,f)=>{if(!d)return!1;(e=equals$$module$node_modules$rambda$dist$rambda_mjs(e,b[f+c]))||(d=!1);return e}).length===a.length}\nfunction prop$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>prop$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(b)return b[a]}function eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a,b),prop$$module$node_modules$rambda$dist$rambda_mjs(a,c))}const eqProps$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapArray$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c,b,!0)}\nfunction evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapObject$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>{if("Object"===type$$module$node_modules$rambda$dist$rambda_mjs(c)){const e=type$$module$node_modules$rambda$dist$rambda_mjs(a[d]);return"Function"===e?a[d](c):"Object"===e?evolve$$module$node_modules$rambda$dist$rambda_mjs(a[d],c):c}return"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c},b)}\nfunction evolve$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>evolve$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=type$$module$node_modules$rambda$dist$rambda_mjs(a),d=type$$module$node_modules$rambda$dist$rambda_mjs(b);if(d!==c)throw Error("iterableType !== rulesType");if(!["Object","Array"].includes(c))throw Error(`\'iterable\' and \'rules\' are from wrong type ${c}`);return"Object"===d?evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b):evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,\nb)}function F$$module$node_modules$rambda$dist$rambda_mjs(){return!1}function filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(const d in b)a(b[d],d,b)&&(c[d]=b[d]);return c}function filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=b.length,f=[];for(;d<e;)(c?a(b[d],d):a(b[d]))&&f.push(b[d]),d++;return f}\nfunction filter$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>filter$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error("Incorrect iterable input");return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,!1):filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction find$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>find$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=0;const d=b.length;for(;c<d;){const e=b[c];if(a(e))return e;c++}}function findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;let d=-1;for(;++d<c;)if(a(b[d]))return d;return-1}\nfunction findLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLast$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return b[c]}function findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return c;return-1}\nfunction flatten$$module$node_modules$rambda$dist$rambda_mjs(a,b){b=void 0===b?[]:b;for(let c=0;c<a.length;c++)isArray$$module$node_modules$rambda$dist$rambda_mjs(a[c])?flatten$$module$node_modules$rambda$dist$rambda_mjs(a[c],b):b.push(a[c]);return b}\nfunction flipFn$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{if(1===b.length)return c=>a(c,b[0]);if(2===b.length)return a(b[1],b[0]);if(3===b.length)return a(b[1],b[0],b[2]);if(4===b.length)return a(b[1],b[0],b[2],b[3]);throw Error("R.flip doesn\'t work with arity > 4");}}function flip$$module$node_modules$rambda$dist$rambda_mjs(a){return flipFn$$module$node_modules$rambda$dist$rambda_mjs(a)}\nfunction forEach$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>forEach$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(void 0!==b){if(isArray$$module$node_modules$rambda$dist$rambda_mjs(b))for(var c=0,d=b.length;c<d;)a(b[c]),c++;else{c=0;d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b);const e=d.length;for(;c<e;){const f=d[c];a(b[f],f,b);c++}}return b}}\nfunction fromPairs$$module$node_modules$rambda$dist$rambda_mjs(a){const b={};a.forEach(([c,d])=>b[c]=d);return b}function groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};for(let d=0;d<b.length;d++){const e=b[d],f=a(e);c[f]||(c[f]=[]);c[f].push(e)}return c}\nfunction groupWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw new TypeError("list.reduce is not a function");const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);if(1===b.length)return[c];const d=[];let e=[];c.reduce((f,g,h)=>{if(0===h)return g;const k=a(f,g),l=0===e.length;h=h===b.length-1;if(k)return l&&e.push(f),e.push(g),h&&d.push(e),g;if(l)return d.push([f]),h&&d.push([g]),g;d.push(e);h&&d.push([g]);e=[];return g},\nvoid 0);return d}function has$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>has$$module$node_modules$rambda$dist$rambda_mjs(a,c):b?b.hasOwnProperty(a):!1}function createPath$$module$node_modules$rambda$dist$rambda_mjs(a,b="."){return"string"===typeof a?a.split(b):a}\nfunction path$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>path$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=b,d=0,e=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);d<e.length;){if(null===c||void 0===c||null===c[e[d]])return;c=c[e[d]];d++}return c}}\nfunction hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,c):void 0!==path$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function head$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[0]||"":a[0]}function _objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b}const objectIs$$module$node_modules$rambda$dist$rambda_mjs=Object.is||_objectIs$$module$node_modules$rambda$dist$rambda_mjs;\nfunction identical$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>identical$$module$node_modules$rambda$dist$rambda_mjs(a,c):objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function identity$$module$node_modules$rambda$dist$rambda_mjs(a){return a}function ifElseFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return(...d)=>!0===("boolean"===typeof a?a:a(...d))?b(...d):c(...d)}\nconst ifElse$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(ifElseFn$$module$node_modules$rambda$dist$rambda_mjs),inc$$module$node_modules$rambda$dist$rambda_mjs=a=>a+1;function indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(let d=0;d<b.length;d++){const e=b[d];c[path$$module$node_modules$rambda$dist$rambda_mjs(a,e)]=e}return c}\nfunction indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof a)return indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b);const c={};for(let d=0;d<b.length;d++){const e=b[d];c[a(e)]=e}return c}\nfunction indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=-1,{length:e}=a;c=c>e?e:c;0>c&&(c+=e);e=b>c?0:c-b>>>0;b>>>=0;for(c=Array(e);++d<e;)c[d]=a[d+b];return c}\nfunction init$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.slice(0,-1):a.length?baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,0,-1):[]}function intersection$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>intersection$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b)}\nfunction intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,f);let c=-1;const d=b.length,e=[];for(;++c<d;)c===d-1?e.push(b[c]):e.push(b[c],a);return e}function is$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>is$$module$node_modules$rambda$dist$rambda_mjs(a,c):null!=b&&b.constructor===a||b instanceof a}\nfunction isEmpty$$module$node_modules$rambda$dist$rambda_mjs(a){const b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Undefined","NaN","Number","Null"].includes(b)?!1:a?"Object"===b?0===Object.keys(a).length:"Array"===b?0===a.length:!1:!0}function isNil$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a}\nfunction join$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>join$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.join(a)}function juxt$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>a.map(c=>c(...b))}function keys$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.keys(a)}function last$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[a.length-1]||"":a[a.length-1]}\nfunction lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function length$$module$node_modules$rambda$dist$rambda_mjs(a){return isArray$$module$node_modules$rambda$dist$rambda_mjs(a)||"string"===typeof a?a.length:NaN}\nfunction lens$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(c){return function(d){return c(a(d)).map(e=>b(e,d))}}}function nth$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>nth$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=0>a?b.length+a:a;return"[object String]"===Object.prototype.toString.call(b)?b.charAt(c):b[c]}\nfunction updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);return-1===a?c.fill(b,a):c.fill(b,a,a+1)}const update$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(updateFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction lensIndex$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(nth$$module$node_modules$rambda$dist$rambda_mjs(a),update$$module$node_modules$rambda$dist$rambda_mjs(a))}function lensPath$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a),assocPath$$module$node_modules$rambda$dist$rambda_mjs(a))}\nfunction lensProp$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a),assoc$$module$node_modules$rambda$dist$rambda_mjs(a))}function match$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>match$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=b.match(a);return null===c?[]:c}\nfunction mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,c):!isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)||!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||1>b?NaN:(a%b+b)%b}function maxByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)>a(b)?c:b}const maxBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(maxByFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction sum$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>b+c,0)}function mean$$module$node_modules$rambda$dist$rambda_mjs(a){return sum$$module$node_modules$rambda$dist$rambda_mjs(a)/a.length}function median$$module$node_modules$rambda$dist$rambda_mjs(a){var b=a.length;if(0===b)return NaN;const c=2-b%2;b=(b-c)/2;return mean$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,0).sort((d,e)=>d===e?0:d<e?-1:1).slice(b,b+c))}\nfunction mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,c):Object.assign({},a||{},b||{})}function mergeAll$$module$node_modules$rambda$dist$rambda_mjs(a){let b={};map$$module$node_modules$rambda$dist$rambda_mjs(c=>{b=mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,c)},a);return b}\nfunction mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=clone$$module$node_modules$rambda$dist$rambda_mjs(a);Object.keys(b).forEach(d=>{"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(b[d])?"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?c[d]=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a[d],b[d]):c[d]=b[d]:c[d]=b[d]});return c}\nfunction mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,c):mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,a)}function mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d={};Object.keys(b).forEach(e=>{d[e]=void 0===c[e]?b[e]:a(b[e],c[e])});Object.keys(c).forEach(e=>{void 0===d[e]&&(d[e]=void 0===b[e]?c[e]:a(b[e],c[e]))});return d}\nconst mergeWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs);function min$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>min$$module$node_modules$rambda$dist$rambda_mjs(a,c):b<a?b:a}function minByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)<a(b)?c:b}const minBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(minByFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction ownKeys$$module$node_modules$rambda$dist$rambda_mjs(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(e){return Object.getOwnPropertyDescriptor(a,e).enumerable}));c.push.apply(c,d)}return c}\nfunction _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(a){for(var b=1;b<arguments.length;b++){var c=null!=arguments[b]?arguments[b]:{};b%2?ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c),!0).forEach(function(d){_defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,d,c[d])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(c)):ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c)).forEach(function(d){Object.defineProperty(a,\nd,Object.getOwnPropertyDescriptor(c,d))})}return a}function _defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c;return a}function isIterable$$module$node_modules$rambda$dist$rambda_mjs(a){return Array.isArray(a)||"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a)}\nfunction modifyFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return isIterable$$module$node_modules$rambda$dist$rambda_mjs(c)&&void 0!==c[a]?isArray$$module$node_modules$rambda$dist$rambda_mjs(c)?updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b(c[a]),c):_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a]:b(c[a])}):c}const modify$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){a=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);if(1===a.length)return _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a[0]]:b(c[a[0]])});if(void 0===path$$module$node_modules$rambda$dist$rambda_mjs(a,c))return c;b=modifyPath$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,1),b,c[a[0]]);return b===c[a[0]]?c:assoc$$module$node_modules$rambda$dist$rambda_mjs(a[0],\nb,c)}const modifyPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs);function modulo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>modulo$$module$node_modules$rambda$dist$rambda_mjs(a,c):a%b}\nfunction moveFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(0>a||0>b)throw Error("Rambda.move does not support negative indexes");if(a>c.length-1||b>c.length-1)return c;const d=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);d[a]=c[b];d[b]=c[a];return d}const move$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(moveFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction multiply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>multiply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a*b}function negate$$module$node_modules$rambda$dist$rambda_mjs(a){return-a}function none$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>none$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(a(b[c]))return!1;return!0}\nfunction not$$module$node_modules$rambda$dist$rambda_mjs(a){return!a}function objOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>objOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):{[a]:b}}function of$$module$node_modules$rambda$dist$rambda_mjs(a){return[a]}\nfunction omit$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>omit$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(null!==b&&void 0!==b){var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={};for(const e in b)c.includes(e)||(d[e]=b[e]);return d}}\nfunction on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,d){return 3===arguments.length?e=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,e):2===arguments.length?(e,f)=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,e,f):a(b(c),b(d))}function onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b){let c;return function(){a&&(c=a.apply(b||this,arguments),a=null);return c}}\nfunction once$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length){const c=onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b);return curry$$module$node_modules$rambda$dist$rambda_mjs(c)}return onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function or$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>or$$module$node_modules$rambda$dist$rambda_mjs(a,c):a||b}const Identity$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(a))});\nfunction overFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(d=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(d)))(c).x}const over$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(overFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction partial$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=a.length;return(...d)=>b.length+d.length>=c?a(...b,...d):partial$$module$node_modules$rambda$dist$rambda_mjs(a,...[...b,...d])}function partialObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return c=>a(mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={},d={};Object.entries(b).forEach(([e,f])=>{a(f,e)?c[e]=f:d[e]=f});return[c,d]}function partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){const d=[],e=[];let f=-1;for(;f++<b.length-1;)(c?a(b[f],f):a(b[f]))?d.push(b[f]):e.push(b[f]);return[d,e]}\nfunction partition$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>partition$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}\nfunction pathEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a,c),b)}const pathEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathEqFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction pathOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,path$$module$node_modules$rambda$dist$rambda_mjs(b,c))}const pathOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathOrFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction paths$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>paths$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.map(c=>path$$module$node_modules$rambda$dist$rambda_mjs(c,b))}\nfunction pick$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pick$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)c[e]in b&&(d[c[e]]=b[c[e]]),e++;return d}}\nfunction pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)d[c[e]]=c[e]in b?b[c[e]]:void 0,e++;return d}}\nfunction pluck$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>pluck$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=[];map$$module$node_modules$rambda$dist$rambda_mjs(d=>{void 0!==d[a]&&c.push(d[a])},b);return c}function prepend$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>prepend$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof b?[a].concat(b.split("")):[a].concat(b)}\nconst product$$module$node_modules$rambda$dist$rambda_mjs=reduce$$module$node_modules$rambda$dist$rambda_mjs(multiply$$module$node_modules$rambda$dist$rambda_mjs,1);function propEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?equals$$module$node_modules$rambda$dist$rambda_mjs(b,prop$$module$node_modules$rambda$dist$rambda_mjs(a,c)):!1}const propEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propEqFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction propIsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return is$$module$node_modules$rambda$dist$rambda_mjs(a,c[b])}const propIs$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propIsFn$$module$node_modules$rambda$dist$rambda_mjs);function propOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c[b]):a}const propOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propOrFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction props$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>props$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error("propsToPick is not a list");return mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>b[c],a)}function propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(prop$$module$node_modules$rambda$dist$rambda_mjs(b,c))}\nconst propSatisfies$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction range$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>range$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(Number.isNaN(Number(a))||Number.isNaN(Number(b)))throw new TypeError("Both arguments to range must be numbers");if(b<a)return[];const c=b-a,d=Array(c);for(let e=0;e<c;e++)d[e]=a+e;return d}\nfunction reject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>reject$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!a(c),b)}function repeat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>repeat$$module$node_modules$rambda$dist$rambda_mjs(a,c):Array(b).fill(a)}function replaceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.replace(a,b)}\nconst replace$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(replaceFn$$module$node_modules$rambda$dist$rambda_mjs);function reverse$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.split("").reverse().join(""):a.slice().reverse()}function setFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return over$$module$node_modules$rambda$dist$rambda_mjs(a,always$$module$node_modules$rambda$dist$rambda_mjs(b),c)}\nconst set$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(setFn$$module$node_modules$rambda$dist$rambda_mjs);function sliceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.slice(a,b)}const slice$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(sliceFn$$module$node_modules$rambda$dist$rambda_mjs);\nfunction sort$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sort$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort(a)}function sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort((c,d)=>{c=a(c);d=a(d);return c===d?0:c<d?-1:1})}\nfunction split$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>split$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.split(a)}function maybe$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b=a&&"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(b)?b():b;c=a||"Function"!==type$$module$node_modules$rambda$dist$rambda_mjs(c)?c:c();return a?b:c}\nfunction take$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>take$$module$node_modules$rambda$dist$rambda_mjs(a,c):0>a?b.slice():"string"===typeof b?b.slice(0,a):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,0,a)}\nfunction splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!b)throw new TypeError(`Cannot read property \'slice\' of ${b}`);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b)&&"string"!==typeof b)return[[],[]];const c=maybe$$module$node_modules$rambda$dist$rambda_mjs(0>a,0>b.length+a?0:b.length+a,a);return[take$$module$node_modules$rambda$dist$rambda_mjs(c,b),drop$$module$node_modules$rambda$dist$rambda_mjs(c,\nb)]}function splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(1>a)throw Error("First argument to splitEvery must be a positive integer");const c=[];let d=0;for(;d<b.length;)c.push(b.slice(d,d+=a));return c}\nfunction splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(!b)throw new TypeError(`Cannot read property \'length\' of ${b}`);const c=[],d=[];let e=!1,f=-1;for(;f++<b.length-1;)e?d.push(b[f]):a(b[f])?(d.push(b[f]),e=!0):c.push(b[f]);return[c,d]}\nfunction startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.startsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;let c=!0;return a.filter((d,e)=>{if(!c)return!1;(d=equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]))||(c=!1);return d}).length===a.length}\nfunction subtract$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>subtract$$module$node_modules$rambda$dist$rambda_mjs(a,c):a-b}\nfunction symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,c):concat$$module$node_modules$rambda$dist$rambda_mjs(filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b),a),filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b))}\nfunction T$$module$node_modules$rambda$dist$rambda_mjs(){return!0}function tail$$module$node_modules$rambda$dist$rambda_mjs(a){return drop$$module$node_modules$rambda$dist$rambda_mjs(1,a)}\nfunction takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;if(0>a)return b.slice();let d=a>c?c:a;return"string"===typeof b?b.slice(c-d):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,c-d,c)}\nfunction takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(0===b.length)return b;let c=!1;const d=[];let e=b.length;for(;!c||0===e;)e--,!1===a(b[e])?c=!0:c||d.push(b[e]);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?d.reverse():d.reverse().join("")}\nfunction takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!0;const e=[];let f=-1;for(;f++<b.length-1;)a(b[f])?d&&e.push(b[f]):d&&(d=!1);return c?e:e.join("")}\nfunction tap$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>tap$$module$node_modules$rambda$dist$rambda_mjs(a,c);a(b);return b}function test$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>test$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof a)throw new TypeError(`\\u2018test\\u2019 requires a value of type RegExp as its first argument; received "${a}"`);return-1!==b.search(a)}\nfunction times$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>times$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||0>b)throw new RangeError("n must be an integer");return map$$module$node_modules$rambda$dist$rambda_mjs(a,range$$module$node_modules$rambda$dist$rambda_mjs(0,b))}function toLower$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toLowerCase()}\nfunction toPairs$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.entries(a)}function toString$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toString()}function toUpper$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toUpperCase()}function transpose$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>{c.forEach((d,e)=>isArray$$module$node_modules$rambda$dist$rambda_mjs(b[e])?b[e].push(d):b.push([d]));return b},[])}\nfunction trim$$module$node_modules$rambda$dist$rambda_mjs(a){return a.trim()}const isFunction$$module$node_modules$rambda$dist$rambda_mjs=a=>["Promise","Function"].includes(type$$module$node_modules$rambda$dist$rambda_mjs(a));\nfunction tryCatch$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isFunction$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`R.tryCatch | fn \'${a}\'`);const c=isFunction$$module$node_modules$rambda$dist$rambda_mjs(b);return(...d)=>{try{return a(...d)}catch(e){return c?b(e,...d):b}}}function unapply$$module$node_modules$rambda$dist$rambda_mjs(a){return function(...b){return a.call(this,b)}}\nfunction union$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>union$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(a);b.forEach(d=>{includes$$module$node_modules$rambda$dist$rambda_mjs(d,a)||c.push(d)});return c}\nfunction uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=new Set;return b.filter(d=>{if(c.has(a(d)))return!1;c.add(a(d));return!0})}function includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=!1,e=-1;for(;++e<c.length&&!d;)a(b,c[e])&&(d=!0);return d}\nfunction uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=-1;const d=[];for(;++c<b.length;){const e=b[c];includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,e,d)||d.push(e)}return d}function unless$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unless$$module$node_modules$rambda$dist$rambda_mjs(a,c):c=>a(c)?c:b(c)}\nfunction unwind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unwind$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b[a])?mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},b),{},{[a]:c}),b[a]):[b]}\nfunction values$$module$node_modules$rambda$dist$rambda_mjs(a){return"Object"!==type$$module$node_modules$rambda$dist$rambda_mjs(a)?[]:Object.values(a)}const Const$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Const$$module$node_modules$rambda$dist$rambda_mjs(a)});function view$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>view$$module$node_modules$rambda$dist$rambda_mjs(a,c):a(Const$$module$node_modules$rambda$dist$rambda_mjs)(b).x}\nfunction whenFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)?b(c):c}const when$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(whenFn$$module$node_modules$rambda$dist$rambda_mjs);function where$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return d=>where$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=!0;for(const d in a){if(!c)continue;const e=a[d](b[d]);c&&!1===e&&(c=!1)}return c}\nfunction whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return c=>whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(const c in a)if(a[c](b[c]))return!0;return!1}\nfunction whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=filter$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]),a);return Object.keys(c).length===Object.keys(a).length}\nfunction without$$module$node_modules$rambda$dist$rambda_mjs(a,b){return void 0===b?c=>without$$module$node_modules$rambda$dist$rambda_mjs(a,c):reduce$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,a)?c:c.concat(d),[],b)}function xor$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>xor$$module$node_modules$rambda$dist$rambda_mjs(a,c):!!a&&!b||!!b&&!a}\nfunction zip$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>zip$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=[],d=Math.min(a.length,b.length);for(let e=0;e<d;e++)c[e]=[a[e],b[e]];return c}function zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,c):take$$module$node_modules$rambda$dist$rambda_mjs(b.length,a).reduce((c,d,e)=>{c[d]=b[e];return c},{})}\nfunction zipWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return take$$module$node_modules$rambda$dist$rambda_mjs(b.length>c.length?c.length:b.length,b).map((d,e)=>a(d,c[e]))}const zipWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(zipWithFn$$module$node_modules$rambda$dist$rambda_mjs);var module$node_modules$rambda$dist$rambda_mjs={};module$node_modules$rambda$dist$rambda_mjs.F=F$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.T=T$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.__findHighestArity=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._arity=_arity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._indexOf=_indexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._lastIndexOf=_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs._pipe=_pipe$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.add=add$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.adjust=adjust$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.all=all$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.allPass=allPass$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.always=always$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.and=and$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.any=any$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.anyPass=anyPass$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.append=append$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.apply=apply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.applySpec=applySpec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assoc=assoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assocPath=assocPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.bind=bind$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.both=both$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.chain=chain$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clamp=clamp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clone=clone$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.complement=complement$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.compose=compose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.concat=concat$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.cond=cond$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.converge=converge$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.count=count$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.countBy=countBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curry=curry$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curryN=curryN$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dec=dec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.defaultTo=defaultTo$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.difference=difference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dissoc=dissoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.divide=divide$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.drop=drop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropLast=dropLast$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.dropLastWhile=dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeats=dropRepeats$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeatsWith=dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropWhile=dropWhile$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.either=either$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.endsWith=endsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.eqProps=eqProps$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.equals=equals$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolve=evolve$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.evolveArray=evolveArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolveObject=evolveObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filter=filter$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterArray=filterArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterObject=filterObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.find=find$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findIndex=findIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLast=findLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLastIndex=findLastIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.flatten=flatten$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.flip=flip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.forEach=forEach$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.fromPairs=fromPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupBy=groupBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupWith=groupWith$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.has=has$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.hasPath=hasPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.head=head$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identical=identical$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identity=identity$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.ifElse=ifElse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.inc=inc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.includes=includes$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexBy=indexBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexOf=indexOf$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.init=init$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersection=intersection$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersperse=intersperse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.is=is$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.isEmpty=isEmpty$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.isNil=isNil$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.join=join$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.juxt=juxt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.keys=keys$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.last=last$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.lastIndexOf=lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.length=length$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lens=lens$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensIndex=lensIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensPath=lensPath$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.lensProp=lensProp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.map=map$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapArray=mapArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObjIndexed=mapObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObject=mapObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.match=match$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mathMod=mathMod$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.max=max$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxBy=maxBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxByFn=maxByFn$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.mean=mean$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.median=median$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.merge=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeAll=mergeAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeDeepRight=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.mergeLeft=mergeLeft$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeRight=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeWith=mergeWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.min=min$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.minBy=minBy$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.minByFn=minByFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modify=modify$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPath=modifyPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPathFn=modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modulo=modulo$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.move=move$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.multiply=multiply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.negate=negate$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.none=none$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.not=not$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.nth=nth$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.objOf=objOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.of=of$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.omit=omit$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.on=on$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.once=once$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.or=or$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.over=over$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partial=partial$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partialObject=partialObject$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.partition=partition$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionArray=partitionArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionObject=partitionObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.path=path$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pathEq=pathEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.pathOr=pathOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.paths=paths$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pick=pick$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pickAll=pickAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pipe=pipe$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.pluck=pluck$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prepend=prepend$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.product=product$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prop=prop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propEq=propEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.propIs=propIs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propOr=propOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propSatisfies=propSatisfies$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.props=props$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.range=range$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.reduce=reduce$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceFn=reduceFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceStopper=reduceStopper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reject=reject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.repeat=repeat$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.replace=replace$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reverse=reverse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.set=set$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.slice=slice$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sort=sort$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.sortBy=sortBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.split=split$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitAt=splitAt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitEvery=splitEvery$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitWhen=splitWhen$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.startsWith=startsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.subtract=subtract$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sum=sum$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.symmetricDifference=symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tail=tail$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.take=take$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLast=takeLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLastWhile=takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeWhile=takeWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tap=tap$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.test=test$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.times=times$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toLower=toLower$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toPairs=toPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toString=toString$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.toUpper=toUpper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.transpose=transpose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.trim=trim$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tryCatch=tryCatch$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.type=type$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.unapply=unapply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.union=union$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniq=uniq$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqBy=uniqBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqWith=uniqWith$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.unless=unless$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.unwind=unwind$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.update=update$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.updateFn=updateFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.values=values$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.view=view$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.when=when$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.where=where$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereAny=whereAny$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereEq=whereEq$$module$node_modules$rambda$dist$rambda_mjs;\nmodule$node_modules$rambda$dist$rambda_mjs.without=without$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.xor=xor$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zip=zip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipObj=zipObj$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipWith=zipWith$$module$node_modules$rambda$dist$rambda_mjs;let startPromize$$module$src$workers$old_spn_worker;\nconst getAudioContext$$module$src$workers$old_spn_worker=a=>window[a]||window.parent[`__csound_wasm_iframe_parent_${a}`]||newAudioContext$$module$src$utils$new_audio_context(),closeAndDeleteContext$$module$src$workers$old_spn_worker=async a=>{const b=window[a],c=window.parent[`__csound_wasm_iframe_parent_${a}`];if(b){if("closed"!==b.state)try{await b.close()}catch(d){}delete window[a]}if(c){if(b!==c&&"closed"!==c.state)try{await c.close()}catch(d){}delete window.parent[`__csound_wasm_iframe_parent_${a}`]}},getAudioNode$$module$src$workers$old_spn_worker=\na=>window[a+"Node"]||window.parent[`__csound_wasm_iframe_parent_${a}Node`],setAudioNode$$module$src$workers$old_spn_worker=(a,b)=>{window[a]?window[`${a}Node`]=b:window.parent[`__csound_wasm_iframe_parent_${a}Node`]=b},disconnectAudioNode$$module$src$workers$old_spn_worker=a=>{(a=getAudioNode$$module$src$workers$old_spn_worker(a))&&a.disconnect()},deleteAudioNode$$module$src$workers$old_spn_worker=a=>{window[a+"Node"]&&delete window[a+"Node"];window.parent[`__csound_wasm_iframe_parent_${a}Node`]&&\ndelete window.parent[`__csound_wasm_iframe_parent_${a}Node`]},PERIODS$$module$src$workers$old_spn_worker=4,spnInstances$$module$src$workers$old_spn_worker=new Map;\nclass CsoundScriptNodeProcessor$$module$src$workers$old_spn_worker{constructor({audioContext:a,contextUid:b,hardwareBufferSize:c,softwareBufferSize:d,inputsCount:e,outputsCount:f,sampleRate:g,audioContextIsProvided:h,autoConnect:k}){this.autoConnect=k;this.audioContextIsProvided=h;this.hardwareBufferSize=c;this.softwareBufferSize=d;this.inputsCount=e;this.outputsCount=f;this.sampleRate=g;this.vanillaOutputChannels=[];this.vanillaInputChannels=[];this.pendingFrames=this.vanillaAvailableFrames=this.vanillaInputReadIndex=\nthis.vanillaOutputReadIndex=0;this.vanillaFirstTransferDone=this.vanillaInitialized=!1;this.vanillaInputChannels=instantiateAudioPacket$$module$src$workers$common_utils(e,c);this.vanillaOutputChannels=instantiateAudioPacket$$module$src$workers$common_utils(f,c);this.audioContext=a;this.contextUid=b;this.scriptNode=this.audioContext.createScriptProcessor(this.softwareBufferSize,e,f);this.process=this.process.bind(this);a=this.process.bind(this);this.scriptNode.onaudioprocess=a;this.autoConnect?setAudioNode$$module$src$workers$old_spn_worker(b,\nthis.scriptNode.connect(this.audioContext.destination)):setAudioNode$$module$src$workers$old_spn_worker(b,this.scriptNode.context.destination);this.updateVanillaFrames=this.updateVanillaFrames.bind(this);this.initCallbacks=this.initCallbacks.bind(this)}async initCallbacks({workerMessagePort:a,transferInputFrames:b,requestPort:c}){this.workerMessagePort=a;this.transferInputFrames=b;this.requestPort=c;if("suspended"===this.audioContext.state){for(a=0;100>a;)if(await new Promise(d=>setTimeout(d,100)),\n"suspended"===this.audioContext.state)a+=1;else return;this.workerMessagePort.broadcastPlayState("realtimePerformancePaused")}}updateVanillaFrames({audioPacket:a,numFrames:b,readIndex:c}){this.pendingFrames-=b;if(a){for(let d=0;d<this.outputsCount;++d){let e=!1,f=b;(c+b)%this.hardwareBufferSize<c&&(e=!0,f=this.hardwareBufferSize-c);this.vanillaOutputChannels[d].set(a[d].subarray(0,f),c);e&&this.vanillaOutputChannels[d].set(a[d].subarray(f))}this.vanillaAvailableFrames+=b}this.vanillaFirstTransferDone||\n(this.vanillaFirstTransferDone=!0,startPromize$$module$src$workers$old_spn_worker&&startPromize$$module$src$workers$old_spn_worker())}process({inputBuffer:a,outputBuffer:b}){if("realtimePerformanceEnded"===this.workerMessagePort.vanillaWorkerState)return setPlayState$$module$src$workers$old_spn_worker({contextUid:this.contextUid,newPlayState:"realtimePerformanceEnded"}),!0;if(!this.vanillaInitialized){var c=this.softwareBufferSize*PERIODS$$module$src$workers$old_spn_worker;this.requestPort.postMessage({readIndex:0,\nnumFrames:c});this.pendingFrames+=c;return this.vanillaInitialized=!0}if(!this.vanillaFirstTransferDone)return!0;c=range$$module$node_modules$rambda$dist$rambda_mjs(0,this.inputsCount).map(h=>a.getChannelData(h));const d=range$$module$node_modules$rambda$dist$rambda_mjs(0,this.outputsCount).map(h=>b.getChannelData(h));var e=0<c.length;const f=(this.vanillaOutputReadIndex+d[0].length)%this.hardwareBufferSize,g=e?(this.vanillaInputReadIndex+c[0].length)%this.hardwareBufferSize:0;if("realtimePerformanceStarted"!==\nthis.workerMessagePort.vanillaWorkerState&&"realtimePerformanceResumed"!==this.workerMessagePort.vanillaWorkerState)return d.forEach(h=>{h.fill(0)}),!0;if(this.vanillaAvailableFrames>=d[0].length){d.forEach((h,k)=>{h.set(this.vanillaOutputChannels[k].subarray(this.vanillaOutputReadIndex,f<this.vanillaOutputReadIndex?this.hardwareBufferSize:f))});if(0<this.inputsCount&&e&&0<c[0].length&&(e=this.softwareBufferSize*PERIODS$$module$src$workers$old_spn_worker,c.forEach((h,k)=>{this.vanillaInputChannels[k].set(h,\nthis.vanillaInputReadIndex)}),0===g%e)){const h=[],k=(0===g?this.hardwareBufferSize:g)-e,l=0===g?this.hardwareBufferSize:g;this.vanillaInputChannels.forEach(m=>{h.push(m.subarray(k,l))});this.transferInputFrames(h)}this.vanillaOutputReadIndex=f;this.vanillaInputReadIndex=g;this.vanillaAvailableFrames-=d[0].length;this.bufferUnderrunCount=0}else 1<this.bufferUnderrunCount&&12>this.bufferUnderrunCount&&(this.workerMessagePort.post("Buffer underrun"),this.bufferUnderrunCount+=1),100===this.bufferUnderrunCount&&\n(this.workerMessagePort.post("FATAL: 100 buffers failed in a row"),this.workerMessagePort.broadcastPlayState("realtimePerformanceEnded"));this.vanillaAvailableFrames<this.softwareBufferSize*PERIODS$$module$src$workers$old_spn_worker&&this.pendingFrames<this.softwareBufferSize*PERIODS$$module$src$workers$old_spn_worker&&(this.requestPort.postMessage({readIndex:(this.vanillaAvailableFrames+f+this.pendingFrames)%this.hardwareBufferSize,numFrames:this.softwareBufferSize*PERIODS$$module$src$workers$old_spn_worker}),\nthis.pendingFrames+=this.softwareBufferSize*PERIODS$$module$src$workers$old_spn_worker);return!0}}\nconst initAudioInputPort$$module$src$workers$old_spn_worker=({audioInputPort:a})=>b=>a.postMessage(b),initMessagePort$$module$src$workers$old_spn_worker=({port:a})=>{const b=new $jscompDefaultExport$$module$src$utils$message_port_state;b.post=c=>a.postMessage({log:c});b.broadcastPlayState=c=>{"realtimePerformanceStarted"===b.vanillaWorkerState&&"realtimePerformanceStarted"===c||a.postMessage({playStateChange:c})};b.ready=!0;return b},initRequestPort$$module$src$workers$old_spn_worker=({requestPort:a,\nspnClassInstance:b})=>{a.addEventListener("message",c=>{const {audioPacket:d,readIndex:e,numFrames:f}=c.data;b.updateVanillaFrames({audioPacket:d,numFrames:f,readIndex:e})});a.start();return a},setPlayState$$module$src$workers$old_spn_worker=async({contextUid:a,newPlayState:b})=>{const c=spnInstances$$module$src$workers$old_spn_worker.get(a);c&&("resume"===b?("suspended"===c.audioContext.state&&c.audioContext.resume(),"running"===c.audioContext.state&&c.workerMessagePort.broadcastPlayState("realtimePerformanceResumed")):\nc.workerMessagePort&&("realtimePerformanceEnded"===b&&"realtimePerformanceEnded"!==c.workerMessagePort.vanillaWorkerState?(c.workerMessagePort.broadcastPlayState("realtimePerformanceEnded"),c.autoConnect&&disconnectAudioNode$$module$src$workers$old_spn_worker(a),deleteAudioNode$$module$src$workers$old_spn_worker(a),spnInstances$$module$src$workers$old_spn_worker.delete(a),c.autoConnect&&!c.audioContextIsProvided&&closeAndDeleteContext$$module$src$workers$old_spn_worker(a)):"realtimePerformanceResumed"===\nb&&"suspended"===c.audioContext.state&&c.audioContext.resume(),c.workerMessagePort.vanillaWorkerState=b))},initialize$$module$src$workers$old_spn_worker=async({contextUid:a,hardwareBufferSize:b,softwareBufferSize:c,inputsCount:d,outputsCount:e,sampleRate:f,audioInputPort:g,messagePort:h,requestPort:k,audioContextIsProvided:l,autoConnect:m,initialPlayState:n})=>{logOldSpnWorker$$module$src$logger("initializing old-spn worker in iframe")();startPromize$$module$src$workers$old_spn_worker=void 0;const p=\ngetAudioContext$$module$src$workers$old_spn_worker(a);b=new CsoundScriptNodeProcessor$$module$src$workers$old_spn_worker({audioContext:p,contextUid:a,hardwareBufferSize:b,softwareBufferSize:c,inputsCount:d,outputsCount:e,sampleRate:f,audioContextIsProvided:l,autoConnect:m});h=initMessagePort$$module$src$workers$old_spn_worker({port:h});g=initAudioInputPort$$module$src$workers$old_spn_worker({audioInputPort:g,spnClassInstance:b});initRequestPort$$module$src$workers$old_spn_worker({requestPort:k,spnClassInstance:b});\nb.initCallbacks({workerMessagePort:h,transferInputFrames:g,requestPort:k});spnInstances$$module$src$workers$old_spn_worker.set(a,b);if("realtimePerformanceStarted"===n)return await new Promise((q,r)=>{startPromize$$module$src$workers$old_spn_worker=q;setTimeout(()=>{if("function"===typeof startPromize$$module$src$workers$old_spn_worker)return r(Error("a call to start() timed out")),startPromize$$module$src$workers$old_spn_worker=void 0,-1},6E5)})};\nexpose$$module$node_modules$comlink$dist$esm$comlink_mjs({initialize:initialize$$module$src$workers$old_spn_worker,setPlayState:setPlayState$$module$src$workers$old_spn_worker},windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(window.parent));var module$src$workers$old_spn_worker={};}).call(this);\n//# sourceMappingURL=__compiled.old-spn.worker.js.map\n'])),
+module$dist$__compiled_old_spn_worker_inline={};module$dist$__compiled_old_spn_worker_inline.default=$jscompDefaultExport$$module$dist$__compiled_old_spn_worker_inline;let spnWorker$$module$src$mains$old_spn_main,proxyPort$$module$src$mains$old_spn_main,UID$$module$src$mains$old_spn_main=0;
+class ScriptProcessorNodeMainThread$$module$src$mains$old_spn_main{constructor({audioContext:a,audioContextIsProvided:b,autoConnect:c}){this.autoConnect=c;this.audioContextIsProvided=b;this.audioContext=a;this.softwareBufferSize=this.hardwareBufferSize=this.outputsCount=this.inputsCount=this.sampleRate=this.csoundWorkerMain=this.currentPlayState=void 0;this.scriptProcessorNode=!0;logOldSpnMain$$module$src$logger("ScriptProcessorNodeMainThread was constructed")()}async terminateInstance(){window[`__csound_wasm_iframe_parent_${this.contextUid}Node`]&&
+(window[`__csound_wasm_iframe_parent_${this.contextUid}Node`].disconnect(),delete window[`__csound_wasm_iframe_parent_${this.contextUid}Node`]);if(this.audioContext){if("closed"!==this.audioContext.state)try{await this.audioContext.close()}catch(a){}delete this.audioContext}proxyPort$$module$src$mains$old_spn_main&&(proxyPort$$module$src$mains$old_spn_main[releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs](),proxyPort$$module$src$mains$old_spn_main=void 0);this.iFrameElement&&this.iFrameElement.remove();
+spnWorker$$module$src$mains$old_spn_main=void 0;UID$$module$src$mains$old_spn_main=0}async onPlayStateChange(a){if(this.currentPlayState!==a){switch(a){case "realtimePerformanceStarted":logOldSpnMain$$module$src$logger("event received: realtimePerformanceStarted")();this.currentPlayState=a;await this.initialize();await this.csoundWorkerMain.eventPromises.releaseStartPromise();this.publicEvents.triggerRealtimePerformanceStarted(this.csoundWorkerMain);break;case "realtimePerformanceEnded":logOldSpnMain$$module$src$logger("event received: realtimePerformanceEnded")();
+window[`__csound_wasm_iframe_parent_${this.contextUid}Node`]&&(window[`__csound_wasm_iframe_parent_${this.contextUid}Node`].disconnect(),delete window[`__csound_wasm_iframe_parent_${this.contextUid}Node`]);break;case "realtimePerformancePaused":this.csoundWorkerMain&&this.csoundWorkerMain.eventPromises&&(this.csoundWorkerMain.publicEvents&&this.csoundWorkerMain.publicEvents.triggerRealtimePerformancePaused(this),await this.csoundWorkerMain.eventPromises.releasePausePromise());break;case "realtimePerformanceResumed":this.csoundWorkerMain&&
+this.csoundWorkerMain.eventPromises&&(this.csoundWorkerMain.publicEvents&&this.csoundWorkerMain.publicEvents.triggerRealtimePerformanceResumed(this),await this.csoundWorkerMain.eventPromises.releaseResumePromise())}this.currentPlayState=a;!proxyPort$$module$src$mains$old_spn_main||"realtimePerformanceStarted"===a&&"renderStarted"===a||await proxyPort$$module$src$mains$old_spn_main.setPlayState({contextUid:this.contextUid,newPlayState:a})}}async initIframe(){if(void 0===window||void 0===window.document)throw new TypeError("Can only run SPN in Browser scope");
+const a=window.document;var b=['<!doctype html>\n<html lang="en">\n<head>\n<meta charset="UTF-8">\n</head>\n<body>',`<script type="text/javascript" src="${$jscompDefaultExport$$module$dist$__compiled_old_spn_worker_inline()}"></script>`,"</body>"].join("\n");b=new Blob([b],{type:"text/html"});this.iFrameElement=document.createElement("iframe");this.iFrameElement.src=URL.createObjectURL(b);this.iFrameElement.sandbox.add("allow-scripts","allow-same-origin");this.iFrameElement.style.cssText="position:absolute;left:0;top:-999px;width:1px;height:1px;";
+b=new Promise(c=>{this.iFrameElement.onload=()=>{c()}});a.body.append(this.iFrameElement);try{await b}catch(c){console.error(c)}spnWorker$$module$src$mains$old_spn_main=this.iFrameElement.contentWindow}async initialize(){if(!spnWorker$$module$src$mains$old_spn_main&&(await this.initIframe(),!spnWorker$$module$src$mains$old_spn_main)){console.error("SPN FATAL: Couldn't create iFrame");return}var a=`audioWorklet${UID$$module$src$mains$old_spn_main}`;this.contextUid=a;UID$$module$src$mains$old_spn_main+=
+1;proxyPort$$module$src$mains$old_spn_main||(proxyPort$$module$src$mains$old_spn_main=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(spnWorker$$module$src$mains$old_spn_main)));this.audioContext||(this.audioContextIsProvided&&console.error("fatal: the provided AudioContext was undefined"),this.audioContext=new (WebkitAudioContext$$module$src$utils())({sampleRate:this.sampleRate}));"closed"===this.audioContext.state&&(this.audioContextIsProvided&&
+console.error("fatal: the provided AudioContext was closed, falling back new AudioContext"),this.audioContext=new (WebkitAudioContext$$module$src$utils())({sampleRate:this.sampleRate}));this.audioContextIsProvided||this.sampleRate===this.audioContext.sampleRate||(this.audioContext=new (WebkitAudioContext$$module$src$utils())({sampleRate:this.sampleRate}));spnWorker$$module$src$mains$old_spn_main[a]=this.audioContext;window[`__csound_wasm_iframe_parent_${a}`]=this.audioContext;let b;this.isRequestingInput&&
+await new Promise(c=>{requestMicrophoneNode$$module$src$mains$io_utils(d=>{d&&(b=this.audioContext.createMediaStreamSource(d));c()})});logOldSpnMain$$module$src$logger("initializing proxyPort")();await proxyPort$$module$src$mains$old_spn_main.initialize(transfer$$module$node_modules$comlink$dist$esm$comlink_mjs({contextUid:a,hardwareBufferSize:32768,softwareBufferSize:2048,inputsCount:this.inputsCount,outputsCount:this.outputsCount,sampleRate:this.sampleRate,audioInputPort:this.ipcMessagePorts.audioWorkerAudioInputPort,
+messagePort:this.ipcMessagePorts.workerMessagePort2,requestPort:this.ipcMessagePorts.audioWorkerFrameRequestPort,audioContextIsProvided:this.audioContextIsProvided,autoConnect:this.autoConnect,initialPlayState:this.currentPlayState},[this.ipcMessagePorts.audioWorkerAudioInputPort,this.ipcMessagePorts.workerMessagePort2,this.ipcMessagePorts.audioWorkerFrameRequestPort]));logOldSpnMain$$module$src$logger("done initializing proxyPort")();(a=spnWorker$$module$src$mains$old_spn_main[`${a}Node`]||window[`__csound_wasm_iframe_parent_${a}Node`])&&
+b&&b.connect(a);this.publicEvents.triggerOnAudioNodeCreated(a);this.isRequestingMidi&&this.csoundWorkerMain&&this.csoundWorkerMain.handleMidiInput&&(logOldSpnMain$$module$src$logger("requesting for web-midi connection")(),requestMidi$$module$src$utils$request_midi({onMidiMessage:this.csoundWorkerMain.handleMidiInput.bind(this.csoundWorkerMain)}))}}var $jscompDefaultExport$$module$src$mains$old_spn_main=ScriptProcessorNodeMainThread$$module$src$mains$old_spn_main,module$src$mains$old_spn_main={};
+module$src$mains$old_spn_main.default=$jscompDefaultExport$$module$src$mains$old_spn_main;const dlinit$$module$src$dlinit=(a,b,c,d)=>{if(b.exports.csoundModuleInit){var e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=new WebAssembly.Global({value:"i32",mutable:!0},0);const h=new WebAssembly.Global({value:"i32",mutable:!0},0);let k=c.length;"function"===typeof b.exports.csoundModuleCreate&&(c.grow(1),e.value=k,c.set(k,b.exports.csoundModuleCreate),k+=1);"function"===typeof b.exports.csoundModuleInit&&(c.grow(1),f.value=k,c.set(k,
+b.exports.csoundModuleInit),k+=1);"function"===typeof b.exports.csoundModuleDestroy&&(c.grow(1),g.value=k,c.set(k,b.exports.csoundModuleDestroy),k+=1);"function"===typeof b.exports.csoundModuleErrorCodeToString&&(c.grow(1),h.value=k,c.set(k,b.exports.csoundModuleErrorCodeToString));a.exports.csoundWasiLoadPlugin(d,e,f,g,h)}else b.exports.csound_opcode_init||b.exports.csound_fgen_init?(e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=c.length,
+"function"===typeof b.exports.csound_opcode_init&&(e.value=g,c.grow(1),c.set(g,b.exports.csound_opcode_init),g+=1),"function"===typeof b.exports.csound_fgen_init&&(f.value=g,c.grow(1),c.set(g,b.exports.csound_fgen_init)),a.exports.csoundWasiLoadOpcodeLibrary(d,f,e)):console.error("Plugin doesn't export nececcary functions to quality as csound plugin.")};var module$src$dlinit={};module$src$dlinit.dlinit=dlinit$$module$src$dlinit;void 0!==goog.global&&(goog.global={});goog.global.BigInt||(goog.global.BigInt=void 0===BigInt?Number:BigInt);
+const WASI_ESUCCESS$$module$src$filesystem$constants=0,WASI_E2BIG$$module$src$filesystem$constants=1,WASI_EACCES$$module$src$filesystem$constants=2,WASI_EADDRINUSE$$module$src$filesystem$constants=3,WASI_EADDRNOTAVAIL$$module$src$filesystem$constants=4,WASI_EAFNOSUPPORT$$module$src$filesystem$constants=5,WASI_EAGAIN$$module$src$filesystem$constants=6,WASI_EALREADY$$module$src$filesystem$constants=7,WASI_EBADF$$module$src$filesystem$constants=8,WASI_EBADMSG$$module$src$filesystem$constants=9,WASI_EBUSY$$module$src$filesystem$constants=
+10,WASI_ECANCELED$$module$src$filesystem$constants=11,WASI_ECHILD$$module$src$filesystem$constants=12,WASI_ECONNABORTED$$module$src$filesystem$constants=13,WASI_ECONNREFUSED$$module$src$filesystem$constants=14,WASI_ECONNRESET$$module$src$filesystem$constants=15,WASI_EDEADLK$$module$src$filesystem$constants=16,WASI_EDESTADDRREQ$$module$src$filesystem$constants=17,WASI_EDOM$$module$src$filesystem$constants=18,WASI_EDQUOT$$module$src$filesystem$constants=19,WASI_EEXIST$$module$src$filesystem$constants=
+20,WASI_EFAULT$$module$src$filesystem$constants=21,WASI_EFBIG$$module$src$filesystem$constants=22,WASI_EHOSTUNREACH$$module$src$filesystem$constants=23,WASI_EIDRM$$module$src$filesystem$constants=24,WASI_EILSEQ$$module$src$filesystem$constants=25,WASI_EINPROGRESS$$module$src$filesystem$constants=26,WASI_EINTR$$module$src$filesystem$constants=27,WASI_EINVAL$$module$src$filesystem$constants=28,WASI_EIO$$module$src$filesystem$constants=29,WASI_EISCONN$$module$src$filesystem$constants=30,WASI_EISDIR$$module$src$filesystem$constants=
+31,WASI_ELOOP$$module$src$filesystem$constants=32,WASI_EMFILE$$module$src$filesystem$constants=33,WASI_EMLINK$$module$src$filesystem$constants=34,WASI_EMSGSIZE$$module$src$filesystem$constants=35,WASI_EMULTIHOP$$module$src$filesystem$constants=36,WASI_ENAMETOOLONG$$module$src$filesystem$constants=37,WASI_ENETDOWN$$module$src$filesystem$constants=38,WASI_ENETRESET$$module$src$filesystem$constants=39,WASI_ENETUNREACH$$module$src$filesystem$constants=40,WASI_ENFILE$$module$src$filesystem$constants=41,
+WASI_ENOBUFS$$module$src$filesystem$constants=42,WASI_ENODEV$$module$src$filesystem$constants=43,WASI_ENOENT$$module$src$filesystem$constants=44,WASI_ENOEXEC$$module$src$filesystem$constants=45,WASI_ENOLCK$$module$src$filesystem$constants=46,WASI_ENOLINK$$module$src$filesystem$constants=47,WASI_ENOMEM$$module$src$filesystem$constants=48,WASI_ENOMSG$$module$src$filesystem$constants=49,WASI_ENOPROTOOPT$$module$src$filesystem$constants=50,WASI_ENOSPC$$module$src$filesystem$constants=51,WASI_ENOSYS$$module$src$filesystem$constants=
+52,WASI_ENOTCONN$$module$src$filesystem$constants=53,WASI_ENOTDIR$$module$src$filesystem$constants=54,WASI_ENOTEMPTY$$module$src$filesystem$constants=55,WASI_ENOTRECOVERABLE$$module$src$filesystem$constants=56,WASI_ENOTSOCK$$module$src$filesystem$constants=57,WASI_ENOTSUP$$module$src$filesystem$constants=58,WASI_ENOTTY$$module$src$filesystem$constants=59,WASI_ENXIO$$module$src$filesystem$constants=60,WASI_EOVERFLOW$$module$src$filesystem$constants=61,WASI_EOWNERDEAD$$module$src$filesystem$constants=
+62,WASI_EPERM$$module$src$filesystem$constants=63,WASI_EPIPE$$module$src$filesystem$constants=64,WASI_EPROTO$$module$src$filesystem$constants=65,WASI_EPROTONOSUPPORT$$module$src$filesystem$constants=66,WASI_EPROTOTYPE$$module$src$filesystem$constants=67,WASI_ERANGE$$module$src$filesystem$constants=68,WASI_EROFS$$module$src$filesystem$constants=69,WASI_ESPIPE$$module$src$filesystem$constants=70,WASI_ESRCH$$module$src$filesystem$constants=71,WASI_ESTALE$$module$src$filesystem$constants=72,WASI_ETIMEDOUT$$module$src$filesystem$constants=
+73,WASI_ETXTBSY$$module$src$filesystem$constants=74,WASI_EXDEV$$module$src$filesystem$constants=75,WASI_ENOTCAPABLE$$module$src$filesystem$constants=76,WASI_SIGABRT$$module$src$filesystem$constants=0,WASI_SIGALRM$$module$src$filesystem$constants=1,WASI_SIGBUS$$module$src$filesystem$constants=2,WASI_SIGCHLD$$module$src$filesystem$constants=3,WASI_SIGCONT$$module$src$filesystem$constants=4,WASI_SIGFPE$$module$src$filesystem$constants=5,WASI_SIGHUP$$module$src$filesystem$constants=6,WASI_SIGILL$$module$src$filesystem$constants=
+7,WASI_SIGINT$$module$src$filesystem$constants=8,WASI_SIGKILL$$module$src$filesystem$constants=9,WASI_SIGPIPE$$module$src$filesystem$constants=10,WASI_SIGQUIT$$module$src$filesystem$constants=11,WASI_SIGSEGV$$module$src$filesystem$constants=12,WASI_SIGSTOP$$module$src$filesystem$constants=13,WASI_SIGTERM$$module$src$filesystem$constants=14,WASI_SIGTRAP$$module$src$filesystem$constants=15,WASI_SIGTSTP$$module$src$filesystem$constants=16,WASI_SIGTTIN$$module$src$filesystem$constants=17,WASI_SIGTTOU$$module$src$filesystem$constants=
+18,WASI_SIGURG$$module$src$filesystem$constants=19,WASI_SIGUSR1$$module$src$filesystem$constants=20,WASI_SIGUSR2$$module$src$filesystem$constants=21,WASI_SIGVTALRM$$module$src$filesystem$constants=22,WASI_SIGXCPU$$module$src$filesystem$constants=23,WASI_SIGXFSZ$$module$src$filesystem$constants=24,WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants=0,WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants=1,WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants=2,WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants=
+3,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants=4,WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants=5,WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants=6,WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants=7,WASI_FDFLAG_APPEND$$module$src$filesystem$constants=1,WASI_FDFLAG_DSYNC$$module$src$filesystem$constants=2,WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants=4,WASI_FDFLAG_RSYNC$$module$src$filesystem$constants=8,WASI_FDFLAG_SYNC$$module$src$filesystem$constants=
+16,WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants=goog.global.BigInt(1),WASI_RIGHT_FD_READ$$module$src$filesystem$constants=goog.global.BigInt(2),WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants=goog.global.BigInt(4),WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants=goog.global.BigInt(8),WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants=goog.global.BigInt(16),WASI_RIGHT_FD_TELL$$module$src$filesystem$constants=goog.global.BigInt(32),WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants=
+goog.global.BigInt(64),WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants=goog.global.BigInt(128),WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants=goog.global.BigInt(256),WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(512),WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants=goog.global.BigInt(1024),WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(2048),WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants=
+goog.global.BigInt(4096),WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants=goog.global.BigInt(8192),WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants=goog.global.BigInt(16384),WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants=goog.global.BigInt(32768),WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(65536),WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants=goog.global.BigInt(131072),WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants=
+goog.global.BigInt(262144),WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(524288),WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(1048576),WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants=goog.global.BigInt(2097152),WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(4194304),WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(8388608),WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants=
+goog.global.BigInt(16777216),WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(33554432),WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants=goog.global.BigInt(67108864),WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants=goog.global.BigInt(134217728),WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants=goog.global.BigInt(268435456),RIGHTS_ALL$$module$src$filesystem$constants=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|
+WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|
+WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|
+WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|
+WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants=
+WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|
+WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|
+WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|
+WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|
+WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants|RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants,RIGHTS_SOCKET_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|
+WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_SOCKET_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_TTY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,
+RIGHTS_TTY_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),WASI_CLOCK_REALTIME$$module$src$filesystem$constants=0,WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants=1,WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants=2,WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants=3,WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants=0,WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants=1,WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants=
+1,WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants=4,WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants=8,WASI_O_CREAT$$module$src$filesystem$constants=1,WASI_O_DIRECTORY$$module$src$filesystem$constants=2,WASI_O_EXCL$$module$src$filesystem$constants=4,WASI_O_TRUNC$$module$src$filesystem$constants=8,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants=0,WASI_DIRCOOKIE_START$$module$src$filesystem$constants=0,WASI_STDIN_FILENO$$module$src$filesystem$constants=
+0,WASI_STDOUT_FILENO$$module$src$filesystem$constants=1,WASI_STDERR_FILENO$$module$src$filesystem$constants=2,WASI_WHENCE_SET$$module$src$filesystem$constants=0,WASI_WHENCE_CUR$$module$src$filesystem$constants=1,WASI_WHENCE_END$$module$src$filesystem$constants=2;var module$src$filesystem$constants={};module$src$filesystem$constants.RIGHTS_ALL=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;
+module$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_BASE=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_INHERITING=RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants;
+module$src$filesystem$constants.RIGHTS_REGULAR_FILE_BASE=RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_REGULAR_FILE_INHERITING=RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_BASE=RIGHTS_SOCKET_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_TTY_BASE=RIGHTS_TTY_BASE$$module$src$filesystem$constants;
+module$src$filesystem$constants.RIGHTS_TTY_INHERITING=RIGHTS_TTY_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_MONOTONIC=WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_PROCESS_CPUTIME_ID=WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_REALTIME=WASI_CLOCK_REALTIME$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_CLOCK_THREAD_CPUTIME_ID=WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_DIRCOOKIE_START=WASI_DIRCOOKIE_START$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_E2BIG=WASI_E2BIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EACCES=WASI_EACCES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EADDRINUSE=WASI_EADDRINUSE$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EADDRNOTAVAIL=WASI_EADDRNOTAVAIL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAFNOSUPPORT=WASI_EAFNOSUPPORT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAGAIN=WASI_EAGAIN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EALREADY=WASI_EALREADY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBADF=WASI_EBADF$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EBADMSG=WASI_EBADMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBUSY=WASI_EBUSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECANCELED=WASI_ECANCELED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECHILD=WASI_ECHILD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNABORTED=WASI_ECONNABORTED$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_ECONNREFUSED=WASI_ECONNREFUSED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNRESET=WASI_ECONNRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDEADLK=WASI_EDEADLK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDESTADDRREQ=WASI_EDESTADDRREQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDOM=WASI_EDOM$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EDQUOT=WASI_EDQUOT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EEXIST=WASI_EEXIST$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFAULT=WASI_EFAULT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFBIG=WASI_EFBIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EHOSTUNREACH=WASI_EHOSTUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIDRM=WASI_EIDRM$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EILSEQ=WASI_EILSEQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINPROGRESS=WASI_EINPROGRESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINTR=WASI_EINTR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINVAL=WASI_EINVAL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIO=WASI_EIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EISCONN=WASI_EISCONN$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EISDIR=WASI_EISDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ELOOP=WASI_ELOOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMFILE=WASI_EMFILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMLINK=WASI_EMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMSGSIZE=WASI_EMSGSIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMULTIHOP=WASI_EMULTIHOP$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_ENAMETOOLONG=WASI_ENAMETOOLONG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETDOWN=WASI_ENETDOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETRESET=WASI_ENETRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETUNREACH=WASI_ENETUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENFILE=WASI_ENFILE$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_ENOBUFS=WASI_ENOBUFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENODEV=WASI_ENODEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOENT=WASI_ENOENT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOEXEC=WASI_ENOEXEC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLCK=WASI_ENOLCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLINK=WASI_ENOLINK$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_ENOMEM=WASI_ENOMEM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOMSG=WASI_ENOMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOPROTOOPT=WASI_ENOPROTOOPT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSPC=WASI_ENOSPC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSYS=WASI_ENOSYS$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_ENOTCAPABLE=WASI_ENOTCAPABLE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTCONN=WASI_ENOTCONN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTDIR=WASI_ENOTDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTEMPTY=WASI_ENOTEMPTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTRECOVERABLE=WASI_ENOTRECOVERABLE$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_ENOTSOCK=WASI_ENOTSOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTSUP=WASI_ENOTSUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTTY=WASI_ENOTTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENXIO=WASI_ENXIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EOVERFLOW=WASI_EOVERFLOW$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EOWNERDEAD=WASI_EOWNERDEAD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPERM=WASI_EPERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPIPE=WASI_EPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTO=WASI_EPROTO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTONOSUPPORT=WASI_EPROTONOSUPPORT$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EPROTOTYPE=WASI_EPROTOTYPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ERANGE=WASI_ERANGE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EROFS=WASI_EROFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESPIPE=WASI_ESPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESRCH=WASI_ESRCH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESTALE=WASI_ESTALE$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_ESUCCESS=WASI_ESUCCESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETIMEDOUT=WASI_ETIMEDOUT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETXTBSY=WASI_ETXTBSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_CLOCK=WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_FD_READ=WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_EVENTTYPE_FD_WRITE=WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EXDEV=WASI_EXDEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_APPEND=WASI_FDFLAG_APPEND$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_DSYNC=WASI_FDFLAG_DSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_NONBLOCK=WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_FDFLAG_RSYNC=WASI_FDFLAG_RSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_SYNC=WASI_FDFLAG_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM=WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM_NOW=WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_MTIM=WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_FILESTAT_SET_MTIM_NOW=WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_BLOCK_DEVICE=WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_CHARACTER_DEVICE=WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_DIRECTORY=WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_FILETYPE_REGULAR_FILE=WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_DGRAM=WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_STREAM=WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SYMBOLIC_LINK=WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_FILETYPE_UNKNOWN=WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_CREAT=WASI_O_CREAT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_DIRECTORY=WASI_O_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_EXCL=WASI_O_EXCL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_TRUNC=WASI_O_TRUNC$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_PREOPENTYPE_DIR=WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ADVISE=WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ALLOCATE=WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_DATASYNC=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FDSTAT_SET_FLAGS=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_GET=WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_SIZE=WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_TIMES=WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_READ=WASI_RIGHT_FD_READ$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_RIGHT_FD_READDIR=WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SEEK=WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SYNC=WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_TELL=WASI_RIGHT_FD_TELL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_WRITE=WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_DIRECTORY=WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_FILE=WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_GET=WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_SIZE=WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_TIMES=WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_SOURCE=WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_TARGET=WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_OPEN=WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_RIGHT_PATH_READLINK=WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_REMOVE_DIRECTORY=WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_SOURCE=WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_TARGET=WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_RIGHT_PATH_SYMLINK=WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_UNLINK_FILE=WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_POLL_FD_READWRITE=WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_SOCK_SHUTDOWN=WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_SIGABRT=WASI_SIGABRT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGALRM=WASI_SIGALRM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGBUS=WASI_SIGBUS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCHLD=WASI_SIGCHLD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCONT=WASI_SIGCONT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGFPE=WASI_SIGFPE$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_SIGHUP=WASI_SIGHUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGILL=WASI_SIGILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGINT=WASI_SIGINT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGKILL=WASI_SIGKILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGPIPE=WASI_SIGPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGQUIT=WASI_SIGQUIT$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_SIGSEGV=WASI_SIGSEGV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGSTOP=WASI_SIGSTOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTERM=WASI_SIGTERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTRAP=WASI_SIGTRAP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTSTP=WASI_SIGTSTP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTTIN=WASI_SIGTTIN$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_SIGTTOU=WASI_SIGTTOU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGURG=WASI_SIGURG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR1=WASI_SIGUSR1$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR2=WASI_SIGUSR2$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGVTALRM=WASI_SIGVTALRM$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_SIGXCPU=WASI_SIGXCPU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGXFSZ=WASI_SIGXFSZ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDERR_FILENO=WASI_STDERR_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDIN_FILENO=WASI_STDIN_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDOUT_FILENO=WASI_STDOUT_FILENO$$module$src$filesystem$constants;
+module$src$filesystem$constants.WASI_WHENCE_CUR=WASI_WHENCE_CUR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_END=WASI_WHENCE_END$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_SET=WASI_WHENCE_SET$$module$src$filesystem$constants;goog.debug={};function module$contents$goog$debug$Error_DebugError(a,b){if(Error.captureStackTrace)Error.captureStackTrace(this,module$contents$goog$debug$Error_DebugError);else{const c=Error().stack;c&&(this.stack=c)}a&&(this.message=String(a));void 0!==b&&(this.cause=b);this.reportErrorToServer=!0}goog.inherits(module$contents$goog$debug$Error_DebugError,Error);module$contents$goog$debug$Error_DebugError.prototype.name="CustomError";goog.debug.Error=module$contents$goog$debug$Error_DebugError;goog.dom={};goog.dom.NodeType={ELEMENT:1,ATTRIBUTE:2,TEXT:3,CDATA_SECTION:4,ENTITY_REFERENCE:5,ENTITY:6,PROCESSING_INSTRUCTION:7,COMMENT:8,DOCUMENT:9,DOCUMENT_TYPE:10,DOCUMENT_FRAGMENT:11,NOTATION:12};goog.asserts={};goog.asserts.ENABLE_ASSERTS=goog.DEBUG;function module$contents$goog$asserts_AssertionError(a,b){module$contents$goog$debug$Error_DebugError.call(this,module$contents$goog$asserts_subs(a,b));this.messagePattern=a}goog.inherits(module$contents$goog$asserts_AssertionError,module$contents$goog$debug$Error_DebugError);goog.asserts.AssertionError=module$contents$goog$asserts_AssertionError;module$contents$goog$asserts_AssertionError.prototype.name="AssertionError";
+goog.asserts.DEFAULT_ERROR_HANDLER=function(a){throw a;};let module$contents$goog$asserts_errorHandler_=goog.asserts.DEFAULT_ERROR_HANDLER;function module$contents$goog$asserts_subs(a,b){a=a.split("%s");let c="";const d=a.length-1;for(let e=0;e<d;e++)c+=a[e]+(e<b.length?b[e]:"%s");return c+a[d]}
+function module$contents$goog$asserts_doAssertFailure(a,b,c,d){let e="Assertion failed",f;c?(e+=": "+c,f=d):a&&(e+=": "+a,f=b);a=new module$contents$goog$asserts_AssertionError(""+e,f||[]);module$contents$goog$asserts_errorHandler_(a)}goog.asserts.setErrorHandler=function(a){goog.asserts.ENABLE_ASSERTS&&(module$contents$goog$asserts_errorHandler_=a)};
+goog.asserts.assert=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!a&&module$contents$goog$asserts_doAssertFailure("",null,b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertExists=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&null==a&&module$contents$goog$asserts_doAssertFailure("Expected to exist: %s.",[a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.fail=function(a,b){goog.asserts.ENABLE_ASSERTS&&module$contents$goog$asserts_errorHandler_(new module$contents$goog$asserts_AssertionError("Failure"+(a?": "+a:""),Array.prototype.slice.call(arguments,1)))};goog.asserts.assertNumber=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"number"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected number but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertString=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"string"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected string but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertFunction=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"function"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected function but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertObject=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isObject(a)&&module$contents$goog$asserts_doAssertFailure("Expected object but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertArray=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!Array.isArray(a)&&module$contents$goog$asserts_doAssertFailure("Expected array but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertBoolean=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"boolean"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected boolean but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertElement=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT||module$contents$goog$asserts_doAssertFailure("Expected Element but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertInstanceof=function(a,b,c,d){!goog.asserts.ENABLE_ASSERTS||a instanceof b||module$contents$goog$asserts_doAssertFailure("Expected instanceof %s but got %s.",[module$contents$goog$asserts_getType(b),module$contents$goog$asserts_getType(a)],c,Array.prototype.slice.call(arguments,3));return a};
+goog.asserts.assertFinite=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||"number"==typeof a&&isFinite(a)||module$contents$goog$asserts_doAssertFailure("Expected %s to be a finite number but it is not.",[a],b,Array.prototype.slice.call(arguments,2));return a};
+function module$contents$goog$asserts_getType(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.array={};goog.NATIVE_ARRAY_PROTOTYPES=goog.TRUSTED_SITE;const module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS=2012<goog.FEATURESET_YEAR;goog.array.ASSUME_NATIVE_FUNCTIONS=module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS;function module$contents$goog$array_peek(a){return a[a.length-1]}goog.array.peek=module$contents$goog$array_peek;goog.array.last=module$contents$goog$array_peek;
+const module$contents$goog$array_indexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.indexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.indexOf(b,c);for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1};goog.array.indexOf=module$contents$goog$array_indexOf;
+const module$contents$goog$array_lastIndexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.lastIndexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.lastIndexOf.call(a,b,null==c?a.length-1:c)}:function(a,b,c){c=null==c?a.length-1:c;0>c&&(c=Math.max(0,a.length+c));if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.lastIndexOf(b,c);for(;0<=c;c--)if(c in a&&a[c]===b)return c;return-1};
+goog.array.lastIndexOf=module$contents$goog$array_lastIndexOf;const module$contents$goog$array_forEach=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.forEach)?function(a,b,c){goog.asserts.assert(null!=a.length);Array.prototype.forEach.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)};goog.array.forEach=module$contents$goog$array_forEach;
+function module$contents$goog$array_forEachRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;--d)d in e&&b.call(c,e[d],d,a)}goog.array.forEachRight=module$contents$goog$array_forEachRight;
+const module$contents$goog$array_filter=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.filter)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.filter.call(a,b,c)}:function(a,b,c){const d=a.length,e=[];let f=0;const g="string"===typeof a?a.split(""):a;for(let h=0;h<d;h++)if(h in g){const k=g[h];b.call(c,k,h,a)&&(e[f++]=k)}return e};goog.array.filter=module$contents$goog$array_filter;
+const module$contents$goog$array_map=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.map)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.map.call(a,b,c)}:function(a,b,c){const d=a.length,e=Array(d),f="string"===typeof a?a.split(""):a;for(let g=0;g<d;g++)g in f&&(e[g]=b.call(c,f[g],g,a));return e};goog.array.map=module$contents$goog$array_map;
+const module$contents$goog$array_reduce=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduce)?function(a,b,c,d){goog.asserts.assert(null!=a.length);d&&(b=goog.bind(b,d));return Array.prototype.reduce.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEach(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduce=module$contents$goog$array_reduce;
+const module$contents$goog$array_reduceRight=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduceRight)?function(a,b,c,d){goog.asserts.assert(null!=a.length);goog.asserts.assert(null!=b);d&&(b=goog.bind(b,d));return Array.prototype.reduceRight.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEachRight(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduceRight=module$contents$goog$array_reduceRight;
+const module$contents$goog$array_some=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.some)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.some.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return!0;return!1};goog.array.some=module$contents$goog$array_some;
+const module$contents$goog$array_every=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.every)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.every.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&!b.call(c,e[f],f,a))return!1;return!0};goog.array.every=module$contents$goog$array_every;
+function module$contents$goog$array_count(a,b,c){let d=0;module$contents$goog$array_forEach(a,function(e,f,g){b.call(c,e,f,g)&&++d},c);return d}goog.array.count=module$contents$goog$array_count;function module$contents$goog$array_find(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.find=module$contents$goog$array_find;
+function module$contents$goog$array_findIndex(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return f;return-1}goog.array.findIndex=module$contents$goog$array_findIndex;function module$contents$goog$array_findRight(a,b,c){b=module$contents$goog$array_findIndexRight(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.findRight=module$contents$goog$array_findRight;
+function module$contents$goog$array_findIndexRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;d--)if(d in e&&b.call(c,e[d],d,a))return d;return-1}goog.array.findIndexRight=module$contents$goog$array_findIndexRight;function module$contents$goog$array_contains(a,b){return 0<=module$contents$goog$array_indexOf(a,b)}goog.array.contains=module$contents$goog$array_contains;function module$contents$goog$array_isEmpty(a){return 0==a.length}goog.array.isEmpty=module$contents$goog$array_isEmpty;
+function module$contents$goog$array_clear(a){if(!Array.isArray(a))for(let b=a.length-1;0<=b;b--)delete a[b];a.length=0}goog.array.clear=module$contents$goog$array_clear;function module$contents$goog$array_insert(a,b){module$contents$goog$array_contains(a,b)||a.push(b)}goog.array.insert=module$contents$goog$array_insert;function module$contents$goog$array_insertAt(a,b,c){module$contents$goog$array_splice(a,c,0,b)}goog.array.insertAt=module$contents$goog$array_insertAt;
+function module$contents$goog$array_insertArrayAt(a,b,c){goog.partial(module$contents$goog$array_splice,a,c,0).apply(null,b)}goog.array.insertArrayAt=module$contents$goog$array_insertArrayAt;function module$contents$goog$array_insertBefore(a,b,c){let d;2==arguments.length||0>(d=module$contents$goog$array_indexOf(a,c))?a.push(b):module$contents$goog$array_insertAt(a,b,d)}goog.array.insertBefore=module$contents$goog$array_insertBefore;
+function module$contents$goog$array_remove(a,b){b=module$contents$goog$array_indexOf(a,b);let c;(c=0<=b)&&module$contents$goog$array_removeAt(a,b);return c}goog.array.remove=module$contents$goog$array_remove;function module$contents$goog$array_removeLast(a,b){b=module$contents$goog$array_lastIndexOf(a,b);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeLast=module$contents$goog$array_removeLast;
+function module$contents$goog$array_removeAt(a,b){goog.asserts.assert(null!=a.length);return 1==Array.prototype.splice.call(a,b,1).length}goog.array.removeAt=module$contents$goog$array_removeAt;function module$contents$goog$array_removeIf(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeIf=module$contents$goog$array_removeIf;
+function module$contents$goog$array_removeAllIf(a,b,c){let d=0;module$contents$goog$array_forEachRight(a,function(e,f){b.call(c,e,f,a)&&module$contents$goog$array_removeAt(a,f)&&d++});return d}goog.array.removeAllIf=module$contents$goog$array_removeAllIf;function module$contents$goog$array_concat(a){return Array.prototype.concat.apply([],arguments)}goog.array.concat=module$contents$goog$array_concat;function module$contents$goog$array_join(a){return Array.prototype.concat.apply([],arguments)}
+goog.array.join=module$contents$goog$array_join;function module$contents$goog$array_toArray(a){const b=a.length;if(0<b){const c=Array(b);for(let d=0;d<b;d++)c[d]=a[d];return c}return[]}const module$contents$goog$array_clone=goog.array.toArray=module$contents$goog$array_toArray;goog.array.clone=module$contents$goog$array_toArray;
+function module$contents$goog$array_extend(a,b){for(let c=1;c<arguments.length;c++){const d=arguments[c];if(goog.isArrayLike(d)){const e=a.length||0,f=d.length||0;a.length=e+f;for(let g=0;g<f;g++)a[e+g]=d[g]}else a.push(d)}}goog.array.extend=module$contents$goog$array_extend;function module$contents$goog$array_splice(a,b,c,d){goog.asserts.assert(null!=a.length);return Array.prototype.splice.apply(a,module$contents$goog$array_slice(arguments,1))}goog.array.splice=module$contents$goog$array_splice;
+function module$contents$goog$array_slice(a,b,c){goog.asserts.assert(null!=a.length);return 2>=arguments.length?Array.prototype.slice.call(a,b):Array.prototype.slice.call(a,b,c)}goog.array.slice=module$contents$goog$array_slice;
+function module$contents$goog$array_removeDuplicates(a,b,c){b=b||a;var d=function(g){return goog.isObject(g)?"o"+goog.getUid(g):(typeof g).charAt(0)+g};c=c||d;let e=d=0;const f={};for(;e<a.length;){const g=a[e++],h=c(g);Object.prototype.hasOwnProperty.call(f,h)||(f[h]=!0,b[d++]=g)}b.length=d}goog.array.removeDuplicates=module$contents$goog$array_removeDuplicates;
+function module$contents$goog$array_binarySearch(a,b,c){return module$contents$goog$array_binarySearch_(a,c||module$contents$goog$array_defaultCompare,!1,b)}goog.array.binarySearch=module$contents$goog$array_binarySearch;function module$contents$goog$array_binarySelect(a,b,c){return module$contents$goog$array_binarySearch_(a,b,!0,void 0,c)}goog.array.binarySelect=module$contents$goog$array_binarySelect;
+function module$contents$goog$array_binarySearch_(a,b,c,d,e){let f=0,g=a.length,h;for(;f<g;){const k=f+(g-f>>>1);let n;n=c?b.call(e,a[k],k,a):b(d,a[k]);0<n?f=k+1:(g=k,h=!n)}return h?f:-f-1}function module$contents$goog$array_sort(a,b){a.sort(b||module$contents$goog$array_defaultCompare)}goog.array.sort=module$contents$goog$array_sort;
+function module$contents$goog$array_stableSort(a,b){const c=Array(a.length);for(let e=0;e<a.length;e++)c[e]={index:e,value:a[e]};const d=b||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(c,function(e,f){return d(e.value,f.value)||e.index-f.index});for(b=0;b<a.length;b++)a[b]=c[b].value}goog.array.stableSort=module$contents$goog$array_stableSort;
+function module$contents$goog$array_sortByKey(a,b,c){const d=c||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(a,function(e,f){return d(b(e),b(f))})}goog.array.sortByKey=module$contents$goog$array_sortByKey;function module$contents$goog$array_sortObjectsByKey(a,b,c){module$contents$goog$array_sortByKey(a,function(d){return d[b]},c)}goog.array.sortObjectsByKey=module$contents$goog$array_sortObjectsByKey;
+function module$contents$goog$array_isSorted(a,b,c){b=b||module$contents$goog$array_defaultCompare;for(let d=1;d<a.length;d++){const e=b(a[d-1],a[d]);if(0<e||0==e&&c)return!1}return!0}goog.array.isSorted=module$contents$goog$array_isSorted;function module$contents$goog$array_equals(a,b,c){if(!goog.isArrayLike(a)||!goog.isArrayLike(b)||a.length!=b.length)return!1;const d=a.length;c=c||module$contents$goog$array_defaultCompareEquality;for(let e=0;e<d;e++)if(!c(a[e],b[e]))return!1;return!0}
+goog.array.equals=module$contents$goog$array_equals;function module$contents$goog$array_compare3(a,b,c){c=c||module$contents$goog$array_defaultCompare;const d=Math.min(a.length,b.length);for(let e=0;e<d;e++){const f=c(a[e],b[e]);if(0!=f)return f}return module$contents$goog$array_defaultCompare(a.length,b.length)}goog.array.compare3=module$contents$goog$array_compare3;function module$contents$goog$array_defaultCompare(a,b){return a>b?1:a<b?-1:0}goog.array.defaultCompare=module$contents$goog$array_defaultCompare;
+function module$contents$goog$array_inverseDefaultCompare(a,b){return-module$contents$goog$array_defaultCompare(a,b)}goog.array.inverseDefaultCompare=module$contents$goog$array_inverseDefaultCompare;function module$contents$goog$array_defaultCompareEquality(a,b){return a===b}goog.array.defaultCompareEquality=module$contents$goog$array_defaultCompareEquality;
+function module$contents$goog$array_binaryInsert(a,b,c){c=module$contents$goog$array_binarySearch(a,b,c);return 0>c?(module$contents$goog$array_insertAt(a,b,-(c+1)),!0):!1}goog.array.binaryInsert=module$contents$goog$array_binaryInsert;function module$contents$goog$array_binaryRemove(a,b,c){b=module$contents$goog$array_binarySearch(a,b,c);return 0<=b?module$contents$goog$array_removeAt(a,b):!1}goog.array.binaryRemove=module$contents$goog$array_binaryRemove;
+function module$contents$goog$array_bucket(a,b,c){const d={};for(let e=0;e<a.length;e++){const f=a[e],g=b.call(c,f,e,a);void 0!==g&&(d[g]||(d[g]=[])).push(f)}return d}goog.array.bucket=module$contents$goog$array_bucket;function module$contents$goog$array_bucketToMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d],f=b(e,d,a);if(void 0!==f){let g=c.get(f);g||(g=[],c.set(f,g));g.push(e)}}return c}goog.array.bucketToMap=module$contents$goog$array_bucketToMap;
+function module$contents$goog$array_toObject(a,b,c){const d={};module$contents$goog$array_forEach(a,function(e,f){d[b.call(c,e,f,a)]=e});return d}goog.array.toObject=module$contents$goog$array_toObject;function module$contents$goog$array_toMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d];c.set(b(e,d,a),e)}return c}goog.array.toMap=module$contents$goog$array_toMap;
+function module$contents$goog$array_range(a,b,c){const d=[];let e=0,f=a;c=c||1;void 0!==b&&(e=a,f=b);if(0>c*(f-e))return[];if(0<c)for(a=e;a<f;a+=c)d.push(a);else for(a=e;a>f;a+=c)d.push(a);return d}goog.array.range=module$contents$goog$array_range;function module$contents$goog$array_repeat(a,b){const c=[];for(let d=0;d<b;d++)c[d]=a;return c}goog.array.repeat=module$contents$goog$array_repeat;
+function module$contents$goog$array_flatten(a){const b=[];for(let d=0;d<arguments.length;d++){const e=arguments[d];if(Array.isArray(e))for(let f=0;f<e.length;f+=8192){var c=module$contents$goog$array_slice(e,f,f+8192);c=module$contents$goog$array_flatten.apply(null,c);for(let g=0;g<c.length;g++)b.push(c[g])}else b.push(e)}return b}goog.array.flatten=module$contents$goog$array_flatten;
+function module$contents$goog$array_rotate(a,b){goog.asserts.assert(null!=a.length);a.length&&(b%=a.length,0<b?Array.prototype.unshift.apply(a,a.splice(-b,b)):0>b&&Array.prototype.push.apply(a,a.splice(0,-b)));return a}goog.array.rotate=module$contents$goog$array_rotate;function module$contents$goog$array_moveItem(a,b,c){goog.asserts.assert(0<=b&&b<a.length);goog.asserts.assert(0<=c&&c<a.length);b=Array.prototype.splice.call(a,b,1);Array.prototype.splice.call(a,c,0,b[0])}goog.array.moveItem=module$contents$goog$array_moveItem;
+function module$contents$goog$array_zip(a){if(!arguments.length)return[];const b=[];let c=arguments[0].length;for(var d=1;d<arguments.length;d++)arguments[d].length<c&&(c=arguments[d].length);for(d=0;d<c;d++){const e=[];for(let f=0;f<arguments.length;f++)e.push(arguments[f][d]);b.push(e)}return b}goog.array.zip=module$contents$goog$array_zip;function module$contents$goog$array_shuffle(a,b){b=b||Math.random;for(let c=a.length-1;0<c;c--){const d=Math.floor(b()*(c+1)),e=a[c];a[c]=a[d];a[d]=e}}
+goog.array.shuffle=module$contents$goog$array_shuffle;function module$contents$goog$array_copyByIndex(a,b){const c=[];module$contents$goog$array_forEach(b,function(d){c.push(a[d])});return c}goog.array.copyByIndex=module$contents$goog$array_copyByIndex;function module$contents$goog$array_concatMap(a,b,c){return module$contents$goog$array_concat.apply([],module$contents$goog$array_map(a,b,c))}goog.array.concatMap=module$contents$goog$array_concatMap;goog.dom.asserts={};goog.dom.asserts.assertIsLocation=function(a){if(goog.asserts.ENABLE_ASSERTS){var b=goog.dom.asserts.getWindow_(a);b&&(!a||!(a instanceof b.Location)&&a instanceof b.Element)&&goog.asserts.fail("Argument is not a Location (or a non-Element mock); got: %s",goog.dom.asserts.debugStringForType_(a))}return a};
+goog.dom.asserts.assertIsElementType_=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=goog.dom.asserts.getWindow_(a);c&&"undefined"!=typeof c[b]&&(a&&(a instanceof c[b]||!(a instanceof c.Location||a instanceof c.Element))||goog.asserts.fail("Argument is not a %s (or a non-Element, non-Location mock); got: %s",b,goog.dom.asserts.debugStringForType_(a)))}return a};goog.dom.asserts.assertIsHTMLAnchorElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAnchorElement")};
+goog.dom.asserts.assertIsHTMLButtonElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLButtonElement")};goog.dom.asserts.assertIsHTMLLinkElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLLinkElement")};goog.dom.asserts.assertIsHTMLImageElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLImageElement")};goog.dom.asserts.assertIsHTMLAudioElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAudioElement")};
+goog.dom.asserts.assertIsHTMLVideoElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLVideoElement")};goog.dom.asserts.assertIsHTMLInputElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLInputElement")};goog.dom.asserts.assertIsHTMLTextAreaElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLTextAreaElement")};goog.dom.asserts.assertIsHTMLCanvasElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLCanvasElement")};
+goog.dom.asserts.assertIsHTMLEmbedElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLEmbedElement")};goog.dom.asserts.assertIsHTMLFormElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFormElement")};goog.dom.asserts.assertIsHTMLFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFrameElement")};goog.dom.asserts.assertIsHTMLIFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLIFrameElement")};
+goog.dom.asserts.assertIsHTMLObjectElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLObjectElement")};goog.dom.asserts.assertIsHTMLScriptElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLScriptElement")};
+goog.dom.asserts.debugStringForType_=function(a){if(goog.isObject(a))try{return a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a)}catch(b){return"<object could not be stringified>"}else return void 0===a?"undefined":null===a?"null":typeof a};goog.dom.asserts.getWindow_=function(a){try{var b=a&&a.ownerDocument,c=b&&(b.defaultView||b.parentWindow);c=c||goog.global;if(c.Element&&c.Location)return c}catch(d){}return null};goog.functions={};goog.functions.constant=function(a){return function(){return a}};goog.functions.FALSE=function(){return!1};goog.functions.TRUE=function(){return!0};goog.functions.NULL=function(){return null};goog.functions.UNDEFINED=function(){};goog.functions.EMPTY=goog.functions.UNDEFINED;goog.functions.identity=function(a,b){return a};goog.functions.error=function(a){return function(){throw Error(a);}};goog.functions.fail=function(a){return function(){throw a;}};
+goog.functions.lock=function(a,b){b=b||0;return function(){return a.apply(this,Array.prototype.slice.call(arguments,0,b))}};goog.functions.nth=function(a){return function(){return arguments[a]}};goog.functions.partialRight=function(a,b){const c=Array.prototype.slice.call(arguments,1);return function(){let d=this;d===goog.global&&(d=void 0);const e=Array.prototype.slice.call(arguments);e.push.apply(e,c);return a.apply(d,e)}};
+goog.functions.withReturnValue=function(a,b){return goog.functions.sequence(a,goog.functions.constant(b))};goog.functions.equalTo=function(a,b){return function(c){return b?a==c:a===c}};goog.functions.compose=function(a,b){const c=arguments,d=c.length;return function(){let e;d&&(e=c[d-1].apply(this,arguments));for(let f=d-2;0<=f;f--)e=c[f].call(this,e);return e}};
+goog.functions.sequence=function(a){const b=arguments,c=b.length;return function(){let d;for(let e=0;e<c;e++)d=b[e].apply(this,arguments);return d}};goog.functions.and=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(!b[d].apply(this,arguments))return!1;return!0}};goog.functions.or=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(b[d].apply(this,arguments))return!0;return!1}};
+goog.functions.not=function(a){return function(){return!a.apply(this,arguments)}};goog.functions.create=function(a,b){var c=function(){};c.prototype=a.prototype;c=new c;a.apply(c,Array.prototype.slice.call(arguments,1));return c};goog.functions.CACHE_RETURN_VALUE=!0;goog.functions.cacheReturnValue=function(a){let b=!1,c;return function(){if(!goog.functions.CACHE_RETURN_VALUE)return a();b||(c=a(),b=!0);return c}};goog.functions.once=function(a){let b=a;return function(){if(b){const c=b;b=null;c()}}};
+goog.functions.debounce=function(a,b,c){let d=0;return function(e){goog.global.clearTimeout(d);const f=arguments;d=goog.global.setTimeout(function(){a.apply(c,f)},b)}};goog.functions.throttle=function(a,b,c){let d=0,e=!1,f=[];const g=function(){d=0;e&&(e=!1,h())},h=function(){d=goog.global.setTimeout(g,b);let k=f;f=[];a.apply(c,k)};return function(k){f=arguments;d?e=!0:h()}};
+goog.functions.rateLimit=function(a,b,c){let d=0;const e=function(){d=0};return function(f){d||(d=goog.global.setTimeout(e,b),a.apply(c,arguments))}};goog.functions.isFunction=a=>"function"===typeof a;goog.string={};goog.string.TypedString=function(){};goog.string.Const=function(a,b){this.stringConstValueWithSecurityContract__googStringSecurityPrivate_=a===goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_&&b||"";this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_=goog.string.Const.TYPE_MARKER_};goog.string.Const.prototype.implementsGoogStringTypedString=!0;goog.string.Const.prototype.getTypedStringValue=function(){return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_};
+goog.DEBUG&&(goog.string.Const.prototype.toString=function(){return"Const{"+this.stringConstValueWithSecurityContract__googStringSecurityPrivate_+"}"});goog.string.Const.unwrap=function(a){if(a instanceof goog.string.Const&&a.constructor===goog.string.Const&&a.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_===goog.string.Const.TYPE_MARKER_)return a.stringConstValueWithSecurityContract__googStringSecurityPrivate_;goog.asserts.fail("expected object of type Const, got '"+a+"'");return"type_error:Const"};
+goog.string.Const.from=function(a){return new goog.string.Const(goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_,a)};goog.string.Const.TYPE_MARKER_={};goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_={};goog.string.Const.EMPTY=goog.string.Const.from("");goog.html={};goog.html.trustedtypes={};goog.html.trustedtypes.POLICY_NAME=goog.TRUSTED_TYPES_POLICY_NAME?goog.TRUSTED_TYPES_POLICY_NAME+"#html":"";goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse=function(){if(!goog.html.trustedtypes.POLICY_NAME)return null;void 0===goog.html.trustedtypes.cachedPolicy_&&(goog.html.trustedtypes.cachedPolicy_=goog.createTrustedTypesPolicy(goog.html.trustedtypes.POLICY_NAME));return goog.html.trustedtypes.cachedPolicy_};const module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE={};
+class module$contents$goog$html$SafeScript_SafeScript{constructor(a,b){this.privateDoNotAccessOrElseSafeScriptWrappedValue_=b===module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static fromConstant(a){a=goog.string.Const.unwrap(a);return 0===a.length?module$contents$goog$html$SafeScript_SafeScript.EMPTY:module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(a)}static fromJson(a){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(module$contents$goog$html$SafeScript_SafeScript.stringify_(a))}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(a).toString()}static unwrapTrustedScript(a){if(a instanceof
+module$contents$goog$html$SafeScript_SafeScript&&a.constructor===module$contents$goog$html$SafeScript_SafeScript)return a.privateDoNotAccessOrElseSafeScriptWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeScript, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeScript"}static stringify_(a){return JSON.stringify(a).replace(/</g,"\\x3c")}static createSafeScriptSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScript(a):
+a;return new module$contents$goog$html$SafeScript_SafeScript(a,module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE)}}module$contents$goog$html$SafeScript_SafeScript.EMPTY=function(){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("")}();goog.html.SafeScript=module$contents$goog$html$SafeScript_SafeScript;goog.fs={};goog.fs.url={};goog.fs.url.createObjectUrl=function(a){return goog.fs.url.getUrlObject_().createObjectURL(a)};goog.fs.url.revokeObjectUrl=function(a){goog.fs.url.getUrlObject_().revokeObjectURL(a)};goog.fs.url.UrlObject_=function(){};goog.fs.url.UrlObject_.prototype.createObjectURL=function(a){};goog.fs.url.UrlObject_.prototype.revokeObjectURL=function(a){};
+goog.fs.url.getUrlObject_=function(){const a=goog.fs.url.findUrlObject_();if(null!=a)return a;throw Error("This browser doesn't seem to support blob URLs");};goog.fs.url.findUrlObject_=function(){return void 0!==goog.global.URL&&void 0!==goog.global.URL.createObjectURL?goog.global.URL:void 0!==goog.global.createObjectURL?goog.global:null};goog.fs.url.browserSupportsObjectUrls=function(){return null!=goog.fs.url.findUrlObject_()};goog.fs.blob={};goog.fs.blob.getBlob=function(a){var b=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==b){b=new b;for(let c=0;c<arguments.length;c++)b.append(arguments[c]);return b.getBlob()}return goog.fs.blob.getBlobWithProperties(Array.prototype.slice.call(arguments))};
+goog.fs.blob.getBlobWithProperties=function(a,b,c){var d=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==d){d=new d;for(let e=0;e<a.length;e++)d.append(a[e],c);return d.getBlob(b)}if(void 0!==goog.global.Blob)return d={},b&&(d.type=b),c&&(d.endings=c),new Blob(a,d);throw Error("This browser doesn't seem to support creating Blobs");};goog.html.TrustedResourceUrl=class{constructor(a,b){this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_=b===goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_+""}};goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString=!0;goog.html.TrustedResourceUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_.toString()};
+goog.html.TrustedResourceUrl.prototype.cloneWithParams=function(a,b){var c=goog.html.TrustedResourceUrl.unwrap(this);c=goog.html.TrustedResourceUrl.URL_PARAM_PARSER_.exec(c);var d=c[3]||"";return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(c[1]+goog.html.TrustedResourceUrl.stringifyParams_("?",c[2]||"",a)+goog.html.TrustedResourceUrl.stringifyParams_("#",d,b))};goog.html.TrustedResourceUrl.unwrap=function(a){return goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(a).toString()};
+goog.html.TrustedResourceUrl.unwrapTrustedScriptURL=function(a){if(a instanceof goog.html.TrustedResourceUrl&&a.constructor===goog.html.TrustedResourceUrl)return a.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;goog.asserts.fail("expected object of type TrustedResourceUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:TrustedResourceUrl"};
+goog.html.TrustedResourceUrl.format=function(a,b){var c=goog.string.Const.unwrap(a);if(!goog.html.TrustedResourceUrl.BASE_URL_.test(c))throw Error("Invalid TrustedResourceUrl format: "+c);a=c.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_,function(d,e){if(!Object.prototype.hasOwnProperty.call(b,e))throw Error('Found marker, "'+e+'", in format string, "'+c+'", but no valid label mapping found in args: '+JSON.stringify(b));d=b[e];return d instanceof goog.string.Const?goog.string.Const.unwrap(d):
+encodeURIComponent(String(d))});return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.FORMAT_MARKER_=/%{(\w+)}/g;goog.html.TrustedResourceUrl.BASE_URL_=RegExp("^((https:)?//[0-9a-z.:[\\]-]+/|/[^/\\\\]|[^:/\\\\%]+/|[^:/\\\\%]*[?#]|about:blank#)","i");goog.html.TrustedResourceUrl.URL_PARAM_PARSER_=/^([^?#]*)(\?[^#]*)?(#[\s\S]*)?/;
+goog.html.TrustedResourceUrl.formatWithParams=function(a,b,c,d){return goog.html.TrustedResourceUrl.format(a,b).cloneWithParams(c,d)};goog.html.TrustedResourceUrl.fromConstant=function(a){return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};goog.html.TrustedResourceUrl.fromConstants=function(a){for(var b="",c=0;c<a.length;c++)b+=goog.string.Const.unwrap(a[c]);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.TrustedResourceUrl.fromSafeScript=function(a){a=goog.fs.blob.getBlobWithProperties([module$contents$goog$html$SafeScript_SafeScript.unwrap(a)],"text/javascript");a=goog.fs.url.createObjectUrl(a);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};
+goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse=function(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScriptURL(a):a;return new goog.html.TrustedResourceUrl(a,goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};
+goog.html.TrustedResourceUrl.stringifyParams_=function(a,b,c){if(null==c)return b;if("string"===typeof c)return c?a+encodeURIComponent(c):"";for(var d in c)if(Object.prototype.hasOwnProperty.call(c,d)){var e=c[d];e=Array.isArray(e)?e:[e];for(var f=0;f<e.length;f++){var g=e[f];null!=g&&(b||(b=a),b+=(b.length>a.length?"&":"")+encodeURIComponent(d)+"="+encodeURIComponent(String(g)))}}return b};goog.string.internal={};goog.string.internal.startsWith=function(a,b){return 0==a.lastIndexOf(b,0)};goog.string.internal.endsWith=function(a,b){const c=a.length-b.length;return 0<=c&&a.indexOf(b,c)==c};goog.string.internal.caseInsensitiveStartsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(0,b.length))};goog.string.internal.caseInsensitiveEndsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(a.length-b.length))};
+goog.string.internal.caseInsensitiveEquals=function(a,b){return a.toLowerCase()==b.toLowerCase()};goog.string.internal.isEmptyOrWhitespace=function(a){return/^[\s\xa0]*$/.test(a)};goog.string.internal.trim=goog.TRUSTED_SITE&&String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(a)[1]};goog.string.internal.caseInsensitiveCompare=function(a,b){a=String(a).toLowerCase();b=String(b).toLowerCase();return a<b?-1:a==b?0:1};
+goog.string.internal.newLineToBr=function(a,b){return a.replace(/(\r\n|\r|\n)/g,b?"<br />":"<br>")};
+goog.string.internal.htmlEscape=function(a,b){if(b)a=a.replace(goog.string.internal.AMP_RE_,"&amp;").replace(goog.string.internal.LT_RE_,"&lt;").replace(goog.string.internal.GT_RE_,"&gt;").replace(goog.string.internal.QUOT_RE_,"&quot;").replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;").replace(goog.string.internal.NULL_RE_,"&#0;");else{if(!goog.string.internal.ALL_RE_.test(a))return a;-1!=a.indexOf("&")&&(a=a.replace(goog.string.internal.AMP_RE_,"&amp;"));-1!=a.indexOf("<")&&(a=a.replace(goog.string.internal.LT_RE_,
+"&lt;"));-1!=a.indexOf(">")&&(a=a.replace(goog.string.internal.GT_RE_,"&gt;"));-1!=a.indexOf('"')&&(a=a.replace(goog.string.internal.QUOT_RE_,"&quot;"));-1!=a.indexOf("'")&&(a=a.replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;"));-1!=a.indexOf("\x00")&&(a=a.replace(goog.string.internal.NULL_RE_,"&#0;"))}return a};goog.string.internal.AMP_RE_=/&/g;goog.string.internal.LT_RE_=/</g;goog.string.internal.GT_RE_=/>/g;goog.string.internal.QUOT_RE_=/"/g;goog.string.internal.SINGLE_QUOTE_RE_=/'/g;
+goog.string.internal.NULL_RE_=/\x00/g;goog.string.internal.ALL_RE_=/[\x00&<>"']/;goog.string.internal.whitespaceEscape=function(a,b){return goog.string.internal.newLineToBr(a.replace(/  /g," &#160;"),b)};goog.string.internal.contains=function(a,b){return-1!=a.indexOf(b)};goog.string.internal.caseInsensitiveContains=function(a,b){return goog.string.internal.contains(a.toLowerCase(),b.toLowerCase())};
+goog.string.internal.compareVersions=function(a,b){var c=0;a=goog.string.internal.trim(String(a)).split(".");b=goog.string.internal.trim(String(b)).split(".");const d=Math.max(a.length,b.length);for(let g=0;0==c&&g<d;g++){var e=a[g]||"",f=b[g]||"";do{e=/(\d*)(\D*)(.*)/.exec(e)||["","","",""];f=/(\d*)(\D*)(.*)/.exec(f)||["","","",""];if(0==e[0].length&&0==f[0].length)break;c=0==e[1].length?0:parseInt(e[1],10);const h=0==f[1].length?0:parseInt(f[1],10);c=goog.string.internal.compareElements_(c,h)||
+goog.string.internal.compareElements_(0==e[2].length,0==f[2].length)||goog.string.internal.compareElements_(e[2],f[2]);e=e[3];f=f[3]}while(0==c)}return c};goog.string.internal.compareElements_=function(a,b){return a<b?-1:a>b?1:0};goog.html.SafeUrl=class{constructor(a,b){this.privateDoNotAccessOrElseSafeUrlWrappedValue_=b===goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()}};goog.html.SafeUrl.INNOCUOUS_STRING="about:invalid#zClosurez";goog.html.SafeUrl.prototype.implementsGoogStringTypedString=!0;goog.html.SafeUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()};
+goog.html.SafeUrl.unwrap=function(a){if(a instanceof goog.html.SafeUrl&&a.constructor===goog.html.SafeUrl)return a.privateDoNotAccessOrElseSafeUrlWrappedValue_;goog.asserts.fail("expected object of type SafeUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeUrl"};goog.html.SafeUrl.fromConstant=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};
+goog.html.SAFE_MIME_TYPE_PATTERN_=RegExp('^(?:audio/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-matroska|x-wav|wav|webm)|font/\\w+|image/(?:bmp|gif|jpeg|jpg|png|tiff|webp|x-icon|heic|heif)|video/(?:mpeg|mp4|ogg|webm|quicktime|x-matroska))(?:;\\w+=(?:\\w+|"[\\w;,= ]+"))*$',"i");goog.html.SafeUrl.isSafeMimeType=function(a){return goog.html.SAFE_MIME_TYPE_PATTERN_.test(a)};
+goog.html.SafeUrl.fromBlob=function(a){a=goog.html.SafeUrl.isSafeMimeType(a.type)?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.revokeObjectUrl=function(a){a=a.getTypedStringValue();a!==goog.html.SafeUrl.INNOCUOUS_STRING&&goog.fs.url.revokeObjectUrl(a)};
+goog.html.SafeUrl.fromMediaSource=function(a){goog.asserts.assert("MediaSource"in goog.global,"No support for MediaSource");a=a instanceof MediaSource?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.DATA_URL_PATTERN_=/^data:(.*);base64,[a-z0-9+\/]+=*$/i;
+goog.html.SafeUrl.tryFromDataUrl=function(a){a=String(a);a=a.replace(/(%0A|%0D)/g,"");return a.match(goog.html.DATA_URL_PATTERN_)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):null};goog.html.SafeUrl.fromDataUrl=function(a){return goog.html.SafeUrl.tryFromDataUrl(a)||goog.html.SafeUrl.INNOCUOUS_URL};goog.html.SafeUrl.fromTelUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"tel:")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SIP_URL_PATTERN_=RegExp("^sip[s]?:[+a-z0-9_.!$%&'*\\/=^`{|}~-]+@([a-z0-9-]+\\.)+[a-z0-9]{2,63}$","i");goog.html.SafeUrl.fromSipUrl=function(a){goog.html.SIP_URL_PATTERN_.test(decodeURIComponent(a))||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromFacebookMessengerUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"fb-messenger://share")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeUrl.fromWhatsAppUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"whatsapp://send")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromSmsUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"sms:")&&goog.html.SafeUrl.isSmsUrlBodyValid_(a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeUrl.isSmsUrlBodyValid_=function(a){var b=a.indexOf("#");0<b&&(a=a.substring(0,b));b=a.match(/[?&]body=/gi);if(!b)return!0;if(1<b.length)return!1;a=a.match(/[?&]body=([^&]*)/)[1];if(!a)return!0;try{decodeURIComponent(a)}catch(c){return!1}return/^(?:[a-z0-9\-_.~]|%[0-9a-f]{2})+$/i.test(a)};goog.html.SafeUrl.fromSshUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"ssh://")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeUrl.sanitizeChromeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^chrome-extension:\/\/([^\/]+)\//,a,b)};goog.html.SafeUrl.sanitizeFirefoxExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^moz-extension:\/\/([^\/]+)\//,a,b)};goog.html.SafeUrl.sanitizeEdgeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^ms-browser-extension:\/\/([^\/]+)\//,a,b)};
+goog.html.SafeUrl.sanitizeExtensionUrl_=function(a,b,c){(a=a.exec(b))?(a=a[1],-1==(c instanceof goog.string.Const?[goog.string.Const.unwrap(c)]:c.map(function(d){return goog.string.Const.unwrap(d)})).indexOf(a)&&(b=goog.html.SafeUrl.INNOCUOUS_STRING)):b=goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};goog.html.SafeUrl.fromTrustedResourceUrl=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.TrustedResourceUrl.unwrap(a))};
+goog.html.SAFE_URL_PATTERN_=/^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;goog.html.SafeUrl.SAFE_URL_PATTERN=goog.html.SAFE_URL_PATTERN_;goog.html.SafeUrl.trySanitize=function(a){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return goog.html.SAFE_URL_PATTERN_.test(a)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):goog.html.SafeUrl.tryFromDataUrl(a)};
+goog.html.SafeUrl.sanitize=function(a){return goog.html.SafeUrl.trySanitize(a)||goog.html.SafeUrl.INNOCUOUS_URL};
+goog.html.SafeUrl.sanitizeAssertUnchanged=function(a,b){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);if(b&&/^data:/i.test(a)&&(b=goog.html.SafeUrl.fromDataUrl(a),b.getTypedStringValue()==a))return b;goog.asserts.assert(goog.html.SAFE_URL_PATTERN_.test(a),"%s does not match the safe URL pattern",a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse=function(a){return new goog.html.SafeUrl(a,goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};goog.html.SafeUrl.INNOCUOUS_URL=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.SafeUrl.INNOCUOUS_STRING);goog.html.SafeUrl.ABOUT_BLANK=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse("about:blank");const module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE={};
+class module$contents$goog$html$SafeStyle_SafeStyle{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleWrappedValue_=b===module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyle_SafeStyle.EMPTY;(0,goog.asserts.assert)((0,goog.string.internal.endsWith)(a,";"),`Last character of style string is not ';': ${a}`);(0,goog.asserts.assert)((0,goog.string.internal.contains)(a,
+":"),"Style string must contain at least one ':', to specify a \"name: value\" pair: "+a);return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_}toString(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_.toString()}static unwrap(a){if(a instanceof module$contents$goog$html$SafeStyle_SafeStyle&&a.constructor===module$contents$goog$html$SafeStyle_SafeStyle)return a.privateDoNotAccessOrElseSafeStyleWrappedValue_;
+(0,goog.asserts.fail)(`expected object of type SafeStyle, got '${a}`+"' of type "+goog.typeOf(a));return"type_error:SafeStyle"}static createSafeStyleSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyle_SafeStyle(a,module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE)}static create(a){let b="";for(let c in a)if(Object.prototype.hasOwnProperty.call(a,c)){if(!/^[-_a-zA-Z0-9]+$/.test(c))throw Error(`Name allows only [-_a-zA-Z0-9], got: ${c}`);let d=a[c];null!=d&&
+(d=Array.isArray(d)?d.map(module$contents$goog$html$SafeStyle_sanitizePropertyValue).join(" "):module$contents$goog$html$SafeStyle_sanitizePropertyValue(d),b+=`${c}:${d};`)}return b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(d)};Array.prototype.forEach.call(arguments,c);
+return b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}}module$contents$goog$html$SafeStyle_SafeStyle.EMPTY=module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse("");module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING="zClosurez";
+function module$contents$goog$html$SafeStyle_sanitizePropertyValue(a){if(a instanceof goog.html.SafeUrl)return'url("'+goog.html.SafeUrl.unwrap(a).replace(/</g,"%3c").replace(/[\\"]/g,"\\$&")+'")';a=a instanceof goog.string.Const?goog.string.Const.unwrap(a):module$contents$goog$html$SafeStyle_sanitizePropertyValueString(String(a));if(/[{;}]/.test(a))throw new module$contents$goog$asserts_AssertionError("Value does not allow [{;}], got: %s.",[a]);return a}
+function module$contents$goog$html$SafeStyle_sanitizePropertyValueString(a){const b=a.replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_URL_RE,"url");if(module$contents$goog$html$SafeStyle_VALUE_RE.test(b)){if(module$contents$goog$html$SafeStyle_COMMENT_RE.test(a))return(0,goog.asserts.fail)(`String value disallows comments, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;
+if(!module$contents$goog$html$SafeStyle_hasBalancedQuotes(a))return(0,goog.asserts.fail)(`String value requires balanced quotes, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;if(!module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a))return(0,goog.asserts.fail)("String value requires balanced square brackets and one identifier per pair of brackets, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING}else return(0,goog.asserts.fail)(`String value allows only ${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}`+
+" and simple functions, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;return module$contents$goog$html$SafeStyle_sanitizeUrl(a)}function module$contents$goog$html$SafeStyle_hasBalancedQuotes(a){let b=!0,c=!0;for(let d=0;d<a.length;d++){const e=a.charAt(d);"'"==e&&c?b=!b:'"'==e&&b&&(c=!c)}return b&&c}
+function module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a){let b=!0;const c=/^[-_a-zA-Z0-9]$/;for(let d=0;d<a.length;d++){const e=a.charAt(d);if("]"==e){if(b)return!1;b=!0}else if("["==e){if(!b)return!1;b=!1}else if(!b&&!c.test(e))return!1}return b}
+const module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS="[-,.\"'%_!#/ a-zA-Z0-9\\[\\]]",module$contents$goog$html$SafeStyle_VALUE_RE=new RegExp(`^${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}+\$`),module$contents$goog$html$SafeStyle_URL_RE=RegExp("\\b(url\\([ \t\n]*)('[ -&(-\\[\\]-~]*'|\"[ !#-\\[\\]-~]*\"|[!#-&*-\\[\\]-~]*)([ \t\n]*\\))","g"),module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS="calc cubic-bezier fit-content hsl hsla linear-gradient matrix minmax radial-gradient repeat rgb rgba (rotate|scale|translate)(X|Y|Z|3d)? steps var".split(" "),
+module$contents$goog$html$SafeStyle_FUNCTIONS_RE=new RegExp("\\b("+module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS.join("|")+")\\([-+*/0-9a-zA-Z.%#\\[\\], ]+\\)","g"),module$contents$goog$html$SafeStyle_COMMENT_RE=/\/\*/;function module$contents$goog$html$SafeStyle_sanitizeUrl(a){return a.replace(module$contents$goog$html$SafeStyle_URL_RE,(b,c,d,e)=>{let f="";d=d.replace(/^(['"])(.*)\1$/,(g,h,k)=>{f=h;return k});b=goog.html.SafeUrl.sanitize(d).getTypedStringValue();return c+f+b+f+e})}
+goog.html.SafeStyle=module$contents$goog$html$SafeStyle_SafeStyle;goog.object={};function module$contents$goog$object_forEach(a,b,c){for(const d in a)b.call(c,a[d],d,a)}function module$contents$goog$object_filter(a,b,c){const d={};for(const e in a)b.call(c,a[e],e,a)&&(d[e]=a[e]);return d}function module$contents$goog$object_map(a,b,c){const d={};for(const e in a)d[e]=b.call(c,a[e],e,a);return d}function module$contents$goog$object_some(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return!0;return!1}
+function module$contents$goog$object_every(a,b,c){for(const d in a)if(!b.call(c,a[d],d,a))return!1;return!0}function module$contents$goog$object_getCount(a){let b=0;for(const c in a)b++;return b}function module$contents$goog$object_getAnyKey(a){for(const b in a)return b}function module$contents$goog$object_getAnyValue(a){for(const b in a)return a[b]}function module$contents$goog$object_contains(a,b){return module$contents$goog$object_containsValue(a,b)}
+function module$contents$goog$object_getValues(a){const b=[];let c=0;for(const d in a)b[c++]=a[d];return b}function module$contents$goog$object_getKeys(a){const b=[];let c=0;for(const d in a)b[c++]=d;return b}function module$contents$goog$object_getValueByKeys(a,b){var c=goog.isArrayLike(b);const d=c?b:arguments;for(c=c?0:1;c<d.length;c++){if(null==a)return;a=a[d[c]]}return a}function module$contents$goog$object_containsKey(a,b){return null!==a&&b in a}
+function module$contents$goog$object_containsValue(a,b){for(const c in a)if(a[c]==b)return!0;return!1}function module$contents$goog$object_findKey(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return d}function module$contents$goog$object_findValue(a,b,c){return(b=module$contents$goog$object_findKey(a,b,c))&&a[b]}function module$contents$goog$object_isEmpty(a){for(const b in a)return!1;return!0}function module$contents$goog$object_clear(a){for(const b in a)delete a[b]}
+function module$contents$goog$object_remove(a,b){let c;(c=b in a)&&delete a[b];return c}function module$contents$goog$object_add(a,b,c){if(null!==a&&b in a)throw Error(`The object already contains the key "${b}"`);module$contents$goog$object_set(a,b,c)}function module$contents$goog$object_get(a,b,c){return null!==a&&b in a?a[b]:c}function module$contents$goog$object_set(a,b,c){a[b]=c}function module$contents$goog$object_setIfUndefined(a,b,c){return b in a?a[b]:a[b]=c}
+function module$contents$goog$object_setWithReturnValueIfNotSet(a,b,c){if(b in a)return a[b];c=c();return a[b]=c}function module$contents$goog$object_equals(a,b){for(const c in a)if(!(c in b)||a[c]!==b[c])return!1;for(const c in b)if(!(c in a))return!1;return!0}function module$contents$goog$object_clone(a){const b={};for(const c in a)b[c]=a[c];return b}
+function module$contents$goog$object_unsafeClone(a){if(!a||"object"!==typeof a)return a;if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);if(a instanceof Date)return new Date(a.getTime());const b=Array.isArray(a)?[]:"function"!==typeof ArrayBuffer||"function"!==typeof ArrayBuffer.isView||!ArrayBuffer.isView(a)||a instanceof DataView?{}:new a.constructor(a.length);for(const c in a)b[c]=
+module$contents$goog$object_unsafeClone(a[c]);return b}function module$contents$goog$object_transpose(a){const b={};for(const c in a)b[a[c]]=c;return b}const module$contents$goog$object_PROTOTYPE_FIELDS="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
+function module$contents$goog$object_extend(a,b){let c,d;for(let e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(let f=0;f<module$contents$goog$object_PROTOTYPE_FIELDS.length;f++)c=module$contents$goog$object_PROTOTYPE_FIELDS[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}}
+function module$contents$goog$object_create(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_create.apply(null,arguments[0]);if(b%2)throw Error("Uneven number of arguments");const c={};for(let d=0;d<b;d+=2)c[arguments[d]]=arguments[d+1];return c}
+function module$contents$goog$object_createSet(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_createSet.apply(null,arguments[0]);const c={};for(let d=0;d<b;d++)c[arguments[d]]=!0;return c}function module$contents$goog$object_createImmutableView(a){let b=a;Object.isFrozen&&!Object.isFrozen(a)&&(b=Object.create(a),Object.freeze(b));return b}function module$contents$goog$object_isImmutableView(a){return!!Object.isFrozen&&Object.isFrozen(a)}
+function module$contents$goog$object_getAllPropertyNames(a,b,c){if(!a)return[];if(!Object.getOwnPropertyNames||!Object.getPrototypeOf)return module$contents$goog$object_getKeys(a);const d={};for(;a&&(a!==Object.prototype||b)&&(a!==Function.prototype||c);){const e=Object.getOwnPropertyNames(a);for(let f=0;f<e.length;f++)d[e[f]]=!0;a=Object.getPrototypeOf(a)}return module$contents$goog$object_getKeys(d)}
+function module$contents$goog$object_getSuperClass(a){return(a=Object.getPrototypeOf(a.prototype))&&a.constructor}goog.object.add=module$contents$goog$object_add;goog.object.clear=module$contents$goog$object_clear;goog.object.clone=module$contents$goog$object_clone;goog.object.contains=module$contents$goog$object_contains;goog.object.containsKey=module$contents$goog$object_containsKey;goog.object.containsValue=module$contents$goog$object_containsValue;goog.object.create=module$contents$goog$object_create;
+goog.object.createImmutableView=module$contents$goog$object_createImmutableView;goog.object.createSet=module$contents$goog$object_createSet;goog.object.equals=module$contents$goog$object_equals;goog.object.every=module$contents$goog$object_every;goog.object.extend=module$contents$goog$object_extend;goog.object.filter=module$contents$goog$object_filter;goog.object.findKey=module$contents$goog$object_findKey;goog.object.findValue=module$contents$goog$object_findValue;goog.object.forEach=module$contents$goog$object_forEach;
+goog.object.get=module$contents$goog$object_get;goog.object.getAllPropertyNames=module$contents$goog$object_getAllPropertyNames;goog.object.getAnyKey=module$contents$goog$object_getAnyKey;goog.object.getAnyValue=module$contents$goog$object_getAnyValue;goog.object.getCount=module$contents$goog$object_getCount;goog.object.getKeys=module$contents$goog$object_getKeys;goog.object.getSuperClass=module$contents$goog$object_getSuperClass;goog.object.getValueByKeys=module$contents$goog$object_getValueByKeys;
+goog.object.getValues=module$contents$goog$object_getValues;goog.object.isEmpty=module$contents$goog$object_isEmpty;goog.object.isImmutableView=module$contents$goog$object_isImmutableView;goog.object.map=module$contents$goog$object_map;goog.object.remove=module$contents$goog$object_remove;goog.object.set=module$contents$goog$object_set;goog.object.setIfUndefined=module$contents$goog$object_setIfUndefined;goog.object.setWithReturnValueIfNotSet=module$contents$goog$object_setWithReturnValueIfNotSet;
+goog.object.some=module$contents$goog$object_some;goog.object.transpose=module$contents$goog$object_transpose;goog.object.unsafeClone=module$contents$goog$object_unsafeClone;const module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE={};
+class module$contents$goog$html$SafeStyleSheet_SafeStyleSheet{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_=b===module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_.toString()}static createRule(a,b){if((0,goog.string.internal.contains)(a,"<"))throw Error(`Selector does not allow '<', got: ${a}`);const c=a.replace(/('|")((?!\1)[^\r\n\f\\]|\\[\s\S])*\1/g,
+"");if(!/^[-_a-zA-Z0-9#.:* ,>+~[\]()=^$|]+$/.test(c))throw Error("Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|] and strings, got: "+a);if(!module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.hasBalancedBrackets_(c))throw Error("() and [] in selector must be balanced, got: "+a);b instanceof module$contents$goog$html$SafeStyle_SafeStyle||(b=module$contents$goog$html$SafeStyle_SafeStyle.create(b));a=`${a}{`+module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b).replace(/</g,"\\3C ")+"}";
+return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}static hasBalancedBrackets_(a){const b={"(":")","[":"]"},c=[];for(let d=0;d<a.length;d++){const e=a[d];if(b[e])c.push(b[e]);else if(module$contents$goog$object_contains(b,e)&&c.pop()!=e)return!1}return 0==c.length}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(d)};Array.prototype.forEach.call(arguments,
+c);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY;(0,goog.asserts.assert)(!(0,goog.string.internal.contains)(a,"<"),`Forbidden '<' character in style sheet string: ${a}`);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_}static unwrap(a){if(a instanceof
+module$contents$goog$html$SafeStyleSheet_SafeStyleSheet&&a.constructor===module$contents$goog$html$SafeStyleSheet_SafeStyleSheet)return a.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeStyleSheet, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeStyleSheet"}static createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyleSheet_SafeStyleSheet(a,module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE)}}
+module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse("");goog.html.SafeStyleSheet=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet;goog.dom.HtmlElement=function(){};goog.dom.TagName=class{static cast(a,b){return a}constructor(){}toString(){}};goog.dom.TagName.A="A";goog.dom.TagName.ABBR="ABBR";goog.dom.TagName.ACRONYM="ACRONYM";goog.dom.TagName.ADDRESS="ADDRESS";goog.dom.TagName.APPLET="APPLET";goog.dom.TagName.AREA="AREA";goog.dom.TagName.ARTICLE="ARTICLE";goog.dom.TagName.ASIDE="ASIDE";goog.dom.TagName.AUDIO="AUDIO";goog.dom.TagName.B="B";goog.dom.TagName.BASE="BASE";goog.dom.TagName.BASEFONT="BASEFONT";goog.dom.TagName.BDI="BDI";goog.dom.TagName.BDO="BDO";
+goog.dom.TagName.BIG="BIG";goog.dom.TagName.BLOCKQUOTE="BLOCKQUOTE";goog.dom.TagName.BODY="BODY";goog.dom.TagName.BR="BR";goog.dom.TagName.BUTTON="BUTTON";goog.dom.TagName.CANVAS="CANVAS";goog.dom.TagName.CAPTION="CAPTION";goog.dom.TagName.CENTER="CENTER";goog.dom.TagName.CITE="CITE";goog.dom.TagName.CODE="CODE";goog.dom.TagName.COL="COL";goog.dom.TagName.COLGROUP="COLGROUP";goog.dom.TagName.COMMAND="COMMAND";goog.dom.TagName.DATA="DATA";goog.dom.TagName.DATALIST="DATALIST";goog.dom.TagName.DD="DD";
+goog.dom.TagName.DEL="DEL";goog.dom.TagName.DETAILS="DETAILS";goog.dom.TagName.DFN="DFN";goog.dom.TagName.DIALOG="DIALOG";goog.dom.TagName.DIR="DIR";goog.dom.TagName.DIV="DIV";goog.dom.TagName.DL="DL";goog.dom.TagName.DT="DT";goog.dom.TagName.EM="EM";goog.dom.TagName.EMBED="EMBED";goog.dom.TagName.FIELDSET="FIELDSET";goog.dom.TagName.FIGCAPTION="FIGCAPTION";goog.dom.TagName.FIGURE="FIGURE";goog.dom.TagName.FONT="FONT";goog.dom.TagName.FOOTER="FOOTER";goog.dom.TagName.FORM="FORM";
+goog.dom.TagName.FRAME="FRAME";goog.dom.TagName.FRAMESET="FRAMESET";goog.dom.TagName.H1="H1";goog.dom.TagName.H2="H2";goog.dom.TagName.H3="H3";goog.dom.TagName.H4="H4";goog.dom.TagName.H5="H5";goog.dom.TagName.H6="H6";goog.dom.TagName.HEAD="HEAD";goog.dom.TagName.HEADER="HEADER";goog.dom.TagName.HGROUP="HGROUP";goog.dom.TagName.HR="HR";goog.dom.TagName.HTML="HTML";goog.dom.TagName.I="I";goog.dom.TagName.IFRAME="IFRAME";goog.dom.TagName.IMG="IMG";goog.dom.TagName.INPUT="INPUT";
+goog.dom.TagName.INS="INS";goog.dom.TagName.ISINDEX="ISINDEX";goog.dom.TagName.KBD="KBD";goog.dom.TagName.KEYGEN="KEYGEN";goog.dom.TagName.LABEL="LABEL";goog.dom.TagName.LEGEND="LEGEND";goog.dom.TagName.LI="LI";goog.dom.TagName.LINK="LINK";goog.dom.TagName.MAIN="MAIN";goog.dom.TagName.MAP="MAP";goog.dom.TagName.MARK="MARK";goog.dom.TagName.MATH="MATH";goog.dom.TagName.MENU="MENU";goog.dom.TagName.MENUITEM="MENUITEM";goog.dom.TagName.META="META";goog.dom.TagName.METER="METER";
+goog.dom.TagName.NAV="NAV";goog.dom.TagName.NOFRAMES="NOFRAMES";goog.dom.TagName.NOSCRIPT="NOSCRIPT";goog.dom.TagName.OBJECT="OBJECT";goog.dom.TagName.OL="OL";goog.dom.TagName.OPTGROUP="OPTGROUP";goog.dom.TagName.OPTION="OPTION";goog.dom.TagName.OUTPUT="OUTPUT";goog.dom.TagName.P="P";goog.dom.TagName.PARAM="PARAM";goog.dom.TagName.PICTURE="PICTURE";goog.dom.TagName.PRE="PRE";goog.dom.TagName.PROGRESS="PROGRESS";goog.dom.TagName.Q="Q";goog.dom.TagName.RP="RP";goog.dom.TagName.RT="RT";
+goog.dom.TagName.RTC="RTC";goog.dom.TagName.RUBY="RUBY";goog.dom.TagName.S="S";goog.dom.TagName.SAMP="SAMP";goog.dom.TagName.SCRIPT="SCRIPT";goog.dom.TagName.SECTION="SECTION";goog.dom.TagName.SELECT="SELECT";goog.dom.TagName.SMALL="SMALL";goog.dom.TagName.SOURCE="SOURCE";goog.dom.TagName.SPAN="SPAN";goog.dom.TagName.STRIKE="STRIKE";goog.dom.TagName.STRONG="STRONG";goog.dom.TagName.STYLE="STYLE";goog.dom.TagName.SUB="SUB";goog.dom.TagName.SUMMARY="SUMMARY";goog.dom.TagName.SUP="SUP";
+goog.dom.TagName.SVG="SVG";goog.dom.TagName.TABLE="TABLE";goog.dom.TagName.TBODY="TBODY";goog.dom.TagName.TD="TD";goog.dom.TagName.TEMPLATE="TEMPLATE";goog.dom.TagName.TEXTAREA="TEXTAREA";goog.dom.TagName.TFOOT="TFOOT";goog.dom.TagName.TH="TH";goog.dom.TagName.THEAD="THEAD";goog.dom.TagName.TIME="TIME";goog.dom.TagName.TITLE="TITLE";goog.dom.TagName.TR="TR";goog.dom.TagName.TRACK="TRACK";goog.dom.TagName.TT="TT";goog.dom.TagName.U="U";goog.dom.TagName.UL="UL";goog.dom.TagName.VAR="VAR";
+goog.dom.TagName.VIDEO="VIDEO";goog.dom.TagName.WBR="WBR";goog.labs={};goog.labs.userAgent={};const module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE="",module$contents$goog$labs$userAgent_USE_CLIENT_HINTS=!1;let module$contents$goog$labs$userAgent_forceClientHintsInTests=!1;goog.labs.userAgent.setUseClientHintsForTesting=a=>{module$contents$goog$labs$userAgent_forceClientHintsInTests=a};
+const module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride=module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE?!!goog.getObjectByName(module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE):!1;goog.labs.userAgent.useClientHints=()=>module$contents$goog$labs$userAgent_USE_CLIENT_HINTS||module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride||module$contents$goog$labs$userAgent_forceClientHintsInTests;goog.labs.userAgent.util={};const module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT=!1;function module$contents$goog$labs$userAgent$util_getNativeUserAgentString(){var a=module$contents$goog$labs$userAgent$util_getNavigator();return a&&(a=a.userAgent)?a:""}function module$contents$goog$labs$userAgent$util_getNativeUserAgentData(){const a=module$contents$goog$labs$userAgent$util_getNavigator();return a?a.userAgentData||null:null}
+function module$contents$goog$labs$userAgent$util_getNavigator(){return goog.global.navigator}let module$contents$goog$labs$userAgent$util_userAgentInternal=null,module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData();
+function module$contents$goog$labs$userAgent$util_setUserAgent(a){module$contents$goog$labs$userAgent$util_userAgentInternal="string"===typeof a?a:module$contents$goog$labs$userAgent$util_getNativeUserAgentString()}function module$contents$goog$labs$userAgent$util_getUserAgent(){return null==module$contents$goog$labs$userAgent$util_userAgentInternal?module$contents$goog$labs$userAgent$util_getNativeUserAgentString():module$contents$goog$labs$userAgent$util_userAgentInternal}
+function module$contents$goog$labs$userAgent$util_setUserAgentData(a){module$contents$goog$labs$userAgent$util_userAgentDataInternal=a}function module$contents$goog$labs$userAgent$util_resetUserAgentData(){module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData()}function module$contents$goog$labs$userAgent$util_getUserAgentData(){return module$contents$goog$labs$userAgent$util_userAgentDataInternal}
+function module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(a){if(!(0,goog.labs.userAgent.useClientHints)())return!1;const b=module$contents$goog$labs$userAgent$util_getUserAgentData();return b?b.brands.some(({brand:c})=>c&&(0,goog.string.internal.contains)(c,a)):!1}function module$contents$goog$labs$userAgent$util_matchUserAgent(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.contains)(b,a)}
+function module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.caseInsensitiveContains)(b,a)}function module$contents$goog$labs$userAgent$util_extractVersionTuples(a){const b=RegExp("([A-Z][\\w ]+)/([^\\s]+)\\s*(?:\\((.*?)\\))?","g"),c=[];let d;for(;d=b.exec(a);)c.push([d[1],d[2],d[3]||void 0]);return c}goog.labs.userAgent.util.ASSUME_CLIENT_HINTS_SUPPORT=module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT;
+goog.labs.userAgent.util.extractVersionTuples=module$contents$goog$labs$userAgent$util_extractVersionTuples;goog.labs.userAgent.util.getNativeUserAgentString=module$contents$goog$labs$userAgent$util_getNativeUserAgentString;goog.labs.userAgent.util.getUserAgent=module$contents$goog$labs$userAgent$util_getUserAgent;goog.labs.userAgent.util.getUserAgentData=module$contents$goog$labs$userAgent$util_getUserAgentData;goog.labs.userAgent.util.matchUserAgent=module$contents$goog$labs$userAgent$util_matchUserAgent;
+goog.labs.userAgent.util.matchUserAgentDataBrand=module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand;goog.labs.userAgent.util.matchUserAgentIgnoreCase=module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase;goog.labs.userAgent.util.resetUserAgentData=module$contents$goog$labs$userAgent$util_resetUserAgentData;goog.labs.userAgent.util.setUserAgent=module$contents$goog$labs$userAgent$util_setUserAgent;goog.labs.userAgent.util.setUserAgentData=module$contents$goog$labs$userAgent$util_setUserAgentData;var module$exports$goog$labs$userAgent$highEntropy$highEntropyValue={AsyncValue:class{getIfLoaded(){}load(){}},HighEntropyValue:class{constructor(a){this.key_=a;this.promise_=this.value_=void 0;this.pending_=!1}getIfLoaded(){if(module$contents$goog$labs$userAgent$util_getUserAgentData())return this.value_}async load(){const a=module$contents$goog$labs$userAgent$util_getUserAgentData();if(a)return this.promise_||(this.pending_=!0,this.promise_=(async()=>{try{return this.value_=(await a.getHighEntropyValues([this.key_]))[this.key_]}finally{this.pending_=
+!1}})()),await this.promise_}resetForTesting(){if(this.pending_)throw Error("Unsafe call to resetForTesting");this.value_=this.promise_=void 0;this.pending_=!1}},Version:class{constructor(a){this.versionString_=a}toVersionStringForLogging(){return this.versionString_}isAtLeast(a){return 0<=(0,goog.string.internal.compareVersions)(this.versionString_,a)}}};var module$exports$goog$labs$userAgent$highEntropy$highEntropyData={};module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("fullVersionList");module$exports$goog$labs$userAgent$highEntropy$highEntropyData.platformVersion=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("platformVersion");goog.labs.userAgent.browser={};const module$contents$goog$labs$userAgent$browser_Brand={ANDROID_BROWSER:"Android Browser",CHROMIUM:"Chromium",EDGE:"Microsoft Edge",FIREFOX:"Firefox",IE:"Internet Explorer",OPERA:"Opera",SAFARI:"Safari",SILK:"Silk"};goog.labs.userAgent.browser.Brand=module$contents$goog$labs$userAgent$browser_Brand;
+function module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(a=!1){if(module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT)return!0;if(!a&&!(0,goog.labs.userAgent.useClientHints)())return!1;a=module$contents$goog$labs$userAgent$util_getUserAgentData();return!!a&&0<a.brands.length}
+function module$contents$goog$labs$userAgent$browser_hasFullVersionList(){return module$contents$goog$labs$userAgent$browser_isAtLeast(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM,98)}function module$contents$goog$labs$userAgent$browser_matchOpera(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Opera")}
+function module$contents$goog$labs$userAgent$browser_matchIE(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Trident")||module$contents$goog$labs$userAgent$util_matchUserAgent("MSIE")}function module$contents$goog$labs$userAgent$browser_matchEdgeHtml(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Edge")}
+function module$contents$goog$labs$userAgent$browser_matchEdgeChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.EDGE):module$contents$goog$labs$userAgent$util_matchUserAgent("Edg/")}
+function module$contents$goog$labs$userAgent$browser_matchOperaChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.OPERA):module$contents$goog$labs$userAgent$util_matchUserAgent("OPR")}
+function module$contents$goog$labs$userAgent$browser_matchFirefox(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Firefox")||module$contents$goog$labs$userAgent$util_matchUserAgent("FxiOS")}
+function module$contents$goog$labs$userAgent$browser_matchSafari(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Safari")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchCoast()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_matchEdgeChromium()||module$contents$goog$labs$userAgent$browser_matchOperaChromium()||
+module$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_isSilk()||module$contents$goog$labs$userAgent$util_matchUserAgent("Android"))}function module$contents$goog$labs$userAgent$browser_matchCoast(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Coast")}
+function module$contents$goog$labs$userAgent$browser_matchIosWebview(){return(module$contents$goog$labs$userAgent$util_matchUserAgent("iPad")||module$contents$goog$labs$userAgent$util_matchUserAgent("iPhone"))&&!module$contents$goog$labs$userAgent$browser_matchSafari()&&!module$contents$goog$labs$userAgent$browser_matchChrome()&&!module$contents$goog$labs$userAgent$browser_matchCoast()&&!module$contents$goog$labs$userAgent$browser_matchFirefox()&&module$contents$goog$labs$userAgent$util_matchUserAgent("AppleWebKit")}
+function module$contents$goog$labs$userAgent$browser_matchChrome(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM):(module$contents$goog$labs$userAgent$util_matchUserAgent("Chrome")||module$contents$goog$labs$userAgent$util_matchUserAgent("CriOS"))&&!module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_isSilk()}
+function module$contents$goog$labs$userAgent$browser_matchAndroidBrowser(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Android")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_isSilk())}const module$contents$goog$labs$userAgent$browser_isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;
+goog.labs.userAgent.browser.isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;const module$contents$goog$labs$userAgent$browser_isIE=module$contents$goog$labs$userAgent$browser_matchIE;goog.labs.userAgent.browser.isIE=module$contents$goog$labs$userAgent$browser_matchIE;const module$contents$goog$labs$userAgent$browser_isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;goog.labs.userAgent.browser.isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;
+const module$contents$goog$labs$userAgent$browser_isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;goog.labs.userAgent.browser.isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;const module$contents$goog$labs$userAgent$browser_isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;goog.labs.userAgent.browser.isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;
+const module$contents$goog$labs$userAgent$browser_isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;goog.labs.userAgent.browser.isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;const module$contents$goog$labs$userAgent$browser_isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;goog.labs.userAgent.browser.isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;const module$contents$goog$labs$userAgent$browser_isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;
+goog.labs.userAgent.browser.isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;const module$contents$goog$labs$userAgent$browser_isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;goog.labs.userAgent.browser.isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;const module$contents$goog$labs$userAgent$browser_isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;goog.labs.userAgent.browser.isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;
+const module$contents$goog$labs$userAgent$browser_isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;goog.labs.userAgent.browser.isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;function module$contents$goog$labs$userAgent$browser_isSilk(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Silk")}goog.labs.userAgent.browser.isSilk=module$contents$goog$labs$userAgent$browser_isSilk;
+function module$contents$goog$labs$userAgent$browser_createVersionMap(a){const b={};a.forEach(c=>{b[c[0]]=c[1]});return c=>b[c.find(d=>d in b)]||""}
+function module$contents$goog$labs$userAgent$browser_getVersion(){var a=module$contents$goog$labs$userAgent$util_getUserAgent();if(module$contents$goog$labs$userAgent$browser_matchIE())return module$contents$goog$labs$userAgent$browser_getIEVersion(a);a=module$contents$goog$labs$userAgent$util_extractVersionTuples(a);const b=module$contents$goog$labs$userAgent$browser_createVersionMap(a);return module$contents$goog$labs$userAgent$browser_matchOpera()?b(["Version","Opera"]):module$contents$goog$labs$userAgent$browser_matchEdgeHtml()?
+b(["Edge"]):module$contents$goog$labs$userAgent$browser_matchEdgeChromium()?b(["Edg"]):module$contents$goog$labs$userAgent$browser_isSilk()?b(["Silk"]):module$contents$goog$labs$userAgent$browser_matchChrome()?b(["Chrome","CriOS","HeadlessChrome"]):(a=a[2])&&a[1]||""}goog.labs.userAgent.browser.getVersion=module$contents$goog$labs$userAgent$browser_getVersion;
+function module$contents$goog$labs$userAgent$browser_isVersionOrHigher(a){return 0<=(0,goog.string.internal.compareVersions)(module$contents$goog$labs$userAgent$browser_getVersion(),a)}goog.labs.userAgent.browser.isVersionOrHigher=module$contents$goog$labs$userAgent$browser_isVersionOrHigher;
+function module$contents$goog$labs$userAgent$browser_getIEVersion(a){var b=/rv: *([\d\.]*)/.exec(a);if(b&&b[1])return b[1];b="";const c=/MSIE +([\d\.]+)/.exec(a);if(c&&c[1])if(a=/Trident\/(\d.\d)/.exec(a),"7.0"==c[1])if(a&&a[1])switch(a[1]){case "4.0":b="8.0";break;case "5.0":b="9.0";break;case "6.0":b="10.0";break;case "7.0":b="11.0"}else b="7.0";else b=c[1];return b}
+function module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a){var b=module$contents$goog$labs$userAgent$util_getUserAgent();if(a===module$contents$goog$labs$userAgent$browser_Brand.IE)return module$contents$goog$labs$userAgent$browser_matchIE()?module$contents$goog$labs$userAgent$browser_getIEVersion(b):"";b=module$contents$goog$labs$userAgent$util_extractVersionTuples(b);const c=module$contents$goog$labs$userAgent$browser_createVersionMap(b);switch(a){case module$contents$goog$labs$userAgent$browser_Brand.OPERA:if(module$contents$goog$labs$userAgent$browser_matchOpera())return c(["Version",
+"Opera"]);if(module$contents$goog$labs$userAgent$browser_matchOperaChromium())return c(["OPR"]);break;case module$contents$goog$labs$userAgent$browser_Brand.EDGE:if(module$contents$goog$labs$userAgent$browser_matchEdgeHtml())return c(["Edge"]);if(module$contents$goog$labs$userAgent$browser_matchEdgeChromium())return c(["Edg"]);break;case module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM:if(module$contents$goog$labs$userAgent$browser_matchChrome())return c(["Chrome","CriOS","HeadlessChrome"])}return a===
+module$contents$goog$labs$userAgent$browser_Brand.FIREFOX&&module$contents$goog$labs$userAgent$browser_matchFirefox()||a===module$contents$goog$labs$userAgent$browser_Brand.SAFARI&&module$contents$goog$labs$userAgent$browser_matchSafari()||a===module$contents$goog$labs$userAgent$browser_Brand.ANDROID_BROWSER&&module$contents$goog$labs$userAgent$browser_matchAndroidBrowser()||a===module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_isSilk()?(a=b[2])&&
+a[1]||"":""}
+function module$contents$goog$labs$userAgent$browser_versionOf_(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()&&a!==module$contents$goog$labs$userAgent$browser_Brand.SILK){var b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);if(!b||!b.version)return NaN;b=b.version.split(".")}else{b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a);if(""===b)return NaN;b=b.split(".")}return 0===b.length?NaN:Number(b[0])}
+function module$contents$goog$labs$userAgent$browser_isAtLeast(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)>=b}goog.labs.userAgent.browser.isAtLeast=module$contents$goog$labs$userAgent$browser_isAtLeast;
+function module$contents$goog$labs$userAgent$browser_isAtMost(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)<=b}goog.labs.userAgent.browser.isAtMost=module$contents$goog$labs$userAgent$browser_isAtMost;
+class module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion{constructor(a,b,c){this.brand_=a;this.version_=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(c);this.useUach_=b}getIfLoaded(){if(this.useUach_){var a=module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.getIfLoaded();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}if(module$contents$goog$labs$userAgent$browser_preUachHasLoaded)return this.version_}async load(){if(this.useUach_){var a=
+await module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}else await 0;module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0;return this.version_}}let module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;
+async function module$contents$goog$labs$userAgent$browser_loadFullVersions(){module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)&&await module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0}goog.labs.userAgent.browser.loadFullVersions=module$contents$goog$labs$userAgent$browser_loadFullVersions;
+goog.labs.userAgent.browser.resetForTesting=()=>{module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.resetForTesting()};
+function module$contents$goog$labs$userAgent$browser_fullVersionOf(a){let b="";module$contents$goog$labs$userAgent$browser_hasFullVersionList()||(b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a));const c=a!==module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0);if(c){if(!module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:d})=>d===a))return}else if(""===b)return;return new module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion(a,
+c,b)}goog.labs.userAgent.browser.fullVersionOf=module$contents$goog$labs$userAgent$browser_fullVersionOf;
+function module$contents$goog$labs$userAgent$browser_getVersionStringForLogging(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)){var b=module$contents$goog$labs$userAgent$browser_fullVersionOf(a);if(b){if(b=b.getIfLoaded())return b.toVersionStringForLogging();b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);(0,goog.asserts.assertExists)(b);return b.version}return""}return module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a)}
+goog.labs.userAgent.browser.getVersionStringForLogging=module$contents$goog$labs$userAgent$browser_getVersionStringForLogging;goog.dom.tags={};goog.dom.tags.VOID_TAGS_={area:!0,base:!0,br:!0,col:!0,command:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};goog.dom.tags.isVoidTag=function(a){return!0===goog.dom.tags.VOID_TAGS_[a]};const module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE={};
+class module$contents$goog$html$SafeHtml_SafeHtml{constructor(a,b){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_=b===module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}toString(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(a).toString()}static unwrapTrustedHTML(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml&&
+a.constructor===module$contents$goog$html$SafeHtml_SafeHtml)return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_;goog.asserts.fail(`expected object of type SafeHtml, got '${a}' of type `+goog.typeOf(a));return"type_error:SafeHtml"}static htmlEscape(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.htmlEscape(a))}static htmlEscapePreservingNewlines(a){if(a instanceof
+module$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.newLineToBr(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static htmlEscapePreservingNewlinesAndSpaces(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.whitespaceEscape(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static comment(a){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("\x3c!--"+
+goog.string.internal.htmlEscape(a)+"--\x3e")}static create(a,b,c){module$contents$goog$html$SafeHtml_SafeHtml.verifyTagName(String(a));return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(String(a),b,c)}static verifyTagName(a){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Invalid tag name <${a}>.`:"");if(a.toUpperCase()in module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
+`Tag name <${a}> is not allowed for SafeHtml.`:"");}static createIframe(a,b,c,d){a&&goog.html.TrustedResourceUrl.unwrap(a);const e={};e.src=a||null;e.srcdoc=b&&module$contents$goog$html$SafeHtml_SafeHtml.unwrap(b);a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{sandbox:""},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static createSandboxIframe(a,b,c,d){if(!module$contents$goog$html$SafeHtml_SafeHtml.canUseSandboxIframe())throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
+"The browser does not support sandboxed iframes.":"");const e={};e.src=a?goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a)):null;e.srcdoc=b||null;e.sandbox="";a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static canUseSandboxIframe(){return goog.global.HTMLIFrameElement&&"sandbox"in goog.global.HTMLIFrameElement.prototype}static createScriptSrc(a,b){goog.html.TrustedResourceUrl.unwrap(a);
+a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({src:a},{},b);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",a)}static createScript(a,b){for(var c in b)if(Object.prototype.hasOwnProperty.call(b,c)){var d=c.toLowerCase();if("language"==d||"src"==d||"text"==d)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot set "${d}" attribute`:"");}c="";a=module$contents$goog$array_concat(a);for(d=0;d<
+a.length;d++)c+=module$contents$goog$html$SafeScript_SafeScript.unwrap(a[d]);a=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",b,a)}static createStyle(a,b){b=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({type:"text/css"},{},b);let c="";a=module$contents$goog$array_concat(a);for(let d=0;d<a.length;d++)c+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(a[d]);
+a=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("style",b,a)}static createMetaRefresh(a,b){a=goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a));(module$contents$goog$labs$userAgent$browser_matchIE()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml())&&goog.string.internal.contains(a,";")&&(a="'"+a.replace(/'/g,"%27")+"'");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("meta",
+{"http-equiv":"refresh",content:(b||0)+"; url="+a})}static join(a,b){a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);const c=[],d=e=>{Array.isArray(e)?e.forEach(d):(e=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(e),c.push(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(e)))};b.forEach(d);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c.join(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static concat(a){return module$contents$goog$html$SafeHtml_SafeHtml.join(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY,
+Array.prototype.slice.call(arguments))}static createSafeHtmlSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createHTML(a):a;return new module$contents$goog$html$SafeHtml_SafeHtml(a,module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE)}static createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(a,b,c){b=`<${a}`+module$contents$goog$html$SafeHtml_SafeHtml.stringifyAttributes(a,b);null==c?c=[]:Array.isArray(c)||(c=[c]);goog.dom.tags.isVoidTag(a.toLowerCase())?
+(goog.asserts.assert(!c.length,`Void tag <${a}> does not allow content.`),b+=">"):(c=module$contents$goog$html$SafeHtml_SafeHtml.concat(c),b+=">"+module$contents$goog$html$SafeHtml_SafeHtml.unwrap(c)+"</"+a+">");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)}static stringifyAttributes(a,b){let c="";if(b)for(let d in b)if(Object.prototype.hasOwnProperty.call(b,d)){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(d))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
+`Invalid attribute name "${d}".`:"");const e=b[d];null!=e&&(c+=" "+module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,d,e))}return c}static combineAttributes(a,b,c){const d={};for(var e in a)Object.prototype.hasOwnProperty.call(a,e)&&(goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=a[e]);for(const f in b)Object.prototype.hasOwnProperty.call(b,f)&&(goog.asserts.assert(f.toLowerCase()==f,"Must be lower case"),d[f]=b[f]);if(c)for(const f in c)if(Object.prototype.hasOwnProperty.call(c,
+f)){e=f.toLowerCase();if(e in a)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot override "${e}" attribute, got "`+f+'" with value "'+c[f]+'"':"");e in b&&delete d[e];d[f]=c[f]}return d}}module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES=goog.DEBUG;module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE=!0;module$contents$goog$html$SafeHtml_SafeHtml.from=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape;
+const module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG=/^[a-zA-Z0-9-]+$/,module$contents$goog$html$SafeHtml_URL_ATTRIBUTES={action:!0,cite:!0,data:!0,formaction:!0,href:!0,manifest:!0,poster:!0,src:!0},module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES={[goog.dom.TagName.APPLET]:!0,[goog.dom.TagName.BASE]:!0,[goog.dom.TagName.EMBED]:!0,[goog.dom.TagName.IFRAME]:!0,[goog.dom.TagName.LINK]:!0,[goog.dom.TagName.MATH]:!0,[goog.dom.TagName.META]:!0,[goog.dom.TagName.OBJECT]:!0,[goog.dom.TagName.SCRIPT]:!0,
+[goog.dom.TagName.STYLE]:!0,[goog.dom.TagName.SVG]:!0,[goog.dom.TagName.TEMPLATE]:!0};
+function module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,b,c){if(c instanceof goog.string.Const)c=goog.string.Const.unwrap(c);else if("style"==b.toLowerCase())if(module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE)c=module$contents$goog$html$SafeHtml_getStyleValue(c);else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?'Attribute "style" not supported.':"");else{if(/^on/i.test(b))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
+`Attribute "${b}`+'" requires goog.string.Const value, "'+c+'" given.':"");if(b.toLowerCase()in module$contents$goog$html$SafeHtml_URL_ATTRIBUTES)if(c instanceof goog.html.TrustedResourceUrl)c=goog.html.TrustedResourceUrl.unwrap(c);else if(c instanceof goog.html.SafeUrl)c=goog.html.SafeUrl.unwrap(c);else if("string"===typeof c)c=goog.html.SafeUrl.sanitize(c).getTypedStringValue();else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Attribute "${b}" on tag "${a}`+'" requires goog.html.SafeUrl, goog.string.Const, or string, value "'+
+c+'" given.':"");}c.implementsGoogStringTypedString&&(c=c.getTypedStringValue());goog.asserts.assert("string"===typeof c||"number"===typeof c,"String or number value expected, got "+typeof c+" with value: "+c);return`${b}="`+goog.string.internal.htmlEscape(String(c))+'"'}
+function module$contents$goog$html$SafeHtml_getStyleValue(a){if(!goog.isObject(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?'The "style" attribute requires goog.html.SafeStyle or map of style properties, '+typeof a+" given: "+a:"");a instanceof module$contents$goog$html$SafeStyle_SafeStyle||(a=module$contents$goog$html$SafeStyle_SafeStyle.create(a));return module$contents$goog$html$SafeStyle_SafeStyle.unwrap(a)}
+module$contents$goog$html$SafeHtml_SafeHtml.DOCTYPE_HTML=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<!DOCTYPE html>")}();module$contents$goog$html$SafeHtml_SafeHtml.EMPTY=new module$contents$goog$html$SafeHtml_SafeHtml(goog.global.trustedTypes&&goog.global.trustedTypes.emptyHTML||"",module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE);module$contents$goog$html$SafeHtml_SafeHtml.BR=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<br>")}();
+goog.html.SafeHtml=module$contents$goog$html$SafeHtml_SafeHtml;goog.html.uncheckedconversions={};goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.dom.safe={};goog.dom.safe.InsertAdjacentHtmlPosition={AFTERBEGIN:"afterbegin",AFTEREND:"afterend",BEFOREBEGIN:"beforebegin",BEFOREEND:"beforeend"};goog.dom.safe.insertAdjacentHtml=function(a,b,c){a.insertAdjacentHTML(b,module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(c))};goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_={MATH:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};
+goog.dom.safe.isInnerHtmlCleanupRecursive_=goog.functions.cacheReturnValue(function(){if(goog.DEBUG&&"undefined"===typeof document)return!1;var a=document.createElement("div"),b=document.createElement("div");b.appendChild(document.createElement("div"));a.appendChild(b);if(goog.DEBUG&&!a.firstChild)return!1;b=a.firstChild.firstChild;a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY);return!b.parentElement});
+goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse=function(a,b){if(goog.dom.safe.isInnerHtmlCleanupRecursive_())for(;a.lastChild;)a.removeChild(a.lastChild);a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};
+goog.dom.safe.setInnerHtml=function(a,b){if(goog.asserts.ENABLE_ASSERTS&&a.tagName){var c=a.tagName.toUpperCase();if(goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[c])throw Error("goog.dom.safe.setInnerHtml cannot be used to set content of "+a.tagName+".");}goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse(a,b)};
+goog.dom.safe.setInnerHtmlFromConstant=function(a,b){goog.dom.safe.setInnerHtml(a,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Constant HTML to be immediatelly used."),goog.string.Const.unwrap(b)))};goog.dom.safe.setOuterHtml=function(a,b){a.outerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};
+goog.dom.safe.setFormElementAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLFormElement(a).action=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setButtonFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLButtonElement(a).formAction=goog.html.SafeUrl.unwrap(b)};
+goog.dom.safe.setInputFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLInputElement(a).formAction=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setStyle=function(a,b){a.style.cssText=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b)};goog.dom.safe.documentWrite=function(a,b){a.write(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};
+goog.dom.safe.setAnchorHref=function(a,b){goog.dom.asserts.assertIsHTMLAnchorElement(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setAudioSrc=function(a,b){goog.dom.asserts.assertIsHTMLAudioElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:audio\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};
+goog.dom.safe.setVideoSrc=function(a,b){goog.dom.asserts.assertIsHTMLVideoElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:video\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setEmbedSrc=function(a,b){goog.dom.asserts.assertIsHTMLEmbedElement(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setFrameSrc=function(a,b){goog.dom.asserts.assertIsHTMLFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};
+goog.dom.safe.setIframeSrc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrcdoc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.srcdoc=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};
+goog.dom.safe.setLinkHrefAndRel=function(a,b,c){goog.dom.asserts.assertIsHTMLLinkElement(a);a.rel=c;goog.string.internal.caseInsensitiveContains(c,"stylesheet")?(goog.asserts.assert(b instanceof goog.html.TrustedResourceUrl,'URL must be TrustedResourceUrl because "rel" contains "stylesheet"'),a.href=goog.html.TrustedResourceUrl.unwrap(b),(b=goog.dom.safe.getStyleNonce(a.ownerDocument&&a.ownerDocument.defaultView))&&a.setAttribute("nonce",b)):a.href=b instanceof goog.html.TrustedResourceUrl?goog.html.TrustedResourceUrl.unwrap(b):
+b instanceof goog.html.SafeUrl?goog.html.SafeUrl.unwrap(b):goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitizeAssertUnchanged(b))};goog.dom.safe.setObjectData=function(a,b){goog.dom.asserts.assertIsHTMLObjectElement(a);a.data=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setScriptSrc=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};
+goog.dom.safe.setScriptContent=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.textContent=module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(b)};goog.dom.safe.setNonceForScriptElement_=function(a){const b=goog.dom.safe.getScriptNonce(a.ownerDocument&&a.ownerDocument.defaultView);b&&a.setAttribute("nonce",b)};
+goog.dom.safe.setLocationHref=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.assignLocation=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.assign(goog.html.SafeUrl.unwrap(b))};
+goog.dom.safe.replaceLocation=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.replace(goog.html.SafeUrl.unwrap(b))};goog.dom.safe.openInWindow=function(a,b,c,d){a=a instanceof goog.html.SafeUrl?a:goog.html.SafeUrl.sanitizeAssertUnchanged(a);b=b||goog.global;c=c instanceof goog.string.Const?goog.string.Const.unwrap(c):c||"";return void 0!==d?b.open(goog.html.SafeUrl.unwrap(a),c,d):b.open(goog.html.SafeUrl.unwrap(a),c)};
+goog.dom.safe.parseFromStringHtml=function(a,b){return goog.dom.safe.parseFromString(a,b,"text/html")};goog.dom.safe.parseFromString=function(a,b,c){return a.parseFromString(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b),c)};
+goog.dom.safe.createImageFromBlob=function(a){if(!/^image\/.*/g.test(a.type))throw Error("goog.dom.safe.createImageFromBlob only accepts MIME type image/.*.");var b=goog.global.URL.createObjectURL(a);a=new goog.global.Image;a.onload=function(){goog.global.URL.revokeObjectURL(b)};a.src=b;return a};goog.dom.safe.createContextualFragment=function(a,b){return a.createContextualFragment(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};
+goog.dom.safe.getScriptNonce=function(a){return goog.dom.safe.getNonce_("script[nonce]",a)};goog.dom.safe.getStyleNonce=function(a){return goog.dom.safe.getNonce_('style[nonce],link[rel="stylesheet"][nonce]',a)};goog.dom.safe.NONCE_PATTERN_=/^[\w+/_-]+[=]{0,2}$/;goog.dom.safe.getNonce_=function(a,b){b=(b||goog.global).document;return b.querySelector?(a=b.querySelector(a))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.dom.safe.NONCE_PATTERN_.test(a)?a:"":""};goog.string.DETECT_DOUBLE_ESCAPING=!1;goog.string.FORCE_NON_DOM_HTML_UNESCAPING=!1;goog.string.Unicode={NBSP:"\u00a0",ZERO_WIDTH_SPACE:"\u200b"};goog.string.startsWith=goog.string.internal.startsWith;goog.string.endsWith=goog.string.internal.endsWith;goog.string.caseInsensitiveStartsWith=goog.string.internal.caseInsensitiveStartsWith;goog.string.caseInsensitiveEndsWith=goog.string.internal.caseInsensitiveEndsWith;goog.string.caseInsensitiveEquals=goog.string.internal.caseInsensitiveEquals;
+goog.string.subs=function(a,b){const c=a.split("%s");let d="";const e=Array.prototype.slice.call(arguments,1);for(;e.length&&1<c.length;)d+=c.shift()+e.shift();return d+c.join("%s")};goog.string.collapseWhitespace=function(a){return a.replace(/[\s\xa0]+/g," ").replace(/^\s+|\s+$/g,"")};goog.string.isEmptyOrWhitespace=goog.string.internal.isEmptyOrWhitespace;goog.string.isEmptyString=function(a){return 0==a.length};goog.string.isEmpty=goog.string.isEmptyOrWhitespace;
+goog.string.isEmptyOrWhitespaceSafe=function(a){return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(a))};goog.string.isEmptySafe=goog.string.isEmptyOrWhitespaceSafe;goog.string.isBreakingWhitespace=function(a){return!/[^\t\n\r ]/.test(a)};goog.string.isAlpha=function(a){return!/[^a-zA-Z]/.test(a)};goog.string.isNumeric=function(a){return!/[^0-9]/.test(a)};goog.string.isAlphaNumeric=function(a){return!/[^a-zA-Z0-9]/.test(a)};goog.string.isSpace=function(a){return" "==a};
+goog.string.isUnicodeChar=function(a){return 1==a.length&&" "<=a&&"~">=a||"\u0080"<=a&&"\ufffd">=a};goog.string.stripNewlines=function(a){return a.replace(/(\r\n|\r|\n)+/g," ")};goog.string.canonicalizeNewlines=function(a){return a.replace(/(\r\n|\r|\n)/g,"\n")};goog.string.normalizeWhitespace=function(a){return a.replace(/\xa0|\s/g," ")};goog.string.normalizeSpaces=function(a){return a.replace(/\xa0|[ \t]+/g," ")};
+goog.string.collapseBreakingSpaces=function(a){return a.replace(/[\t\r\n ]+/g," ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g,"")};goog.string.trim=goog.string.internal.trim;goog.string.trimLeft=function(a){return a.replace(/^[\s\xa0]+/,"")};goog.string.trimRight=function(a){return a.replace(/[\s\xa0]+$/,"")};goog.string.caseInsensitiveCompare=goog.string.internal.caseInsensitiveCompare;
+goog.string.numberAwareCompare_=function(a,b,c){if(a==b)return 0;if(!a)return-1;if(!b)return 1;const d=a.toLowerCase().match(c),e=b.toLowerCase().match(c),f=Math.min(d.length,e.length);for(let g=0;g<f;g++){c=d[g];const h=e[g];if(c!=h)return a=parseInt(c,10),!isNaN(a)&&(b=parseInt(h,10),!isNaN(b)&&a-b)?a-b:c<h?-1:1}return d.length!=e.length?d.length-e.length:a<b?-1:1};goog.string.intAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\D+/g)};
+goog.string.floatAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\.\d+|\D+/g)};goog.string.numerateCompare=goog.string.floatAwareCompare;goog.string.urlEncode=function(a){return encodeURIComponent(String(a))};goog.string.urlDecode=function(a){return decodeURIComponent(a.replace(/\+/g," "))};goog.string.newLineToBr=goog.string.internal.newLineToBr;
+goog.string.htmlEscape=function(a,b){a=goog.string.internal.htmlEscape(a,b);goog.string.DETECT_DOUBLE_ESCAPING&&(a=a.replace(goog.string.E_RE_,"&#101;"));return a};goog.string.E_RE_=/e/g;goog.string.unescapeEntities=function(a){return goog.string.contains(a,"&")?!goog.string.FORCE_NON_DOM_HTML_UNESCAPING&&"document"in goog.global?goog.string.unescapeEntitiesUsingDom_(a):goog.string.unescapePureXmlEntities_(a):a};
+goog.string.unescapeEntitiesWithDocument=function(a,b){return goog.string.contains(a,"&")?goog.string.unescapeEntitiesUsingDom_(a,b):a};
+goog.string.unescapeEntitiesUsingDom_=function(a,b){const c={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"'};let d;d=b?b.createElement("div"):goog.global.document.createElement("div");return a.replace(goog.string.HTML_ENTITY_PATTERN_,function(e,f){let g=c[e];if(g)return g;"#"==f.charAt(0)&&(f=Number("0"+f.slice(1)),isNaN(f)||(g=String.fromCharCode(f)));g||(goog.dom.safe.setInnerHtml(d,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Single HTML entity."),
+e+" ")),g=d.firstChild.nodeValue.slice(0,-1));return c[e]=g})};goog.string.unescapePureXmlEntities_=function(a){return a.replace(/&([^;]+);/g,function(b,c){switch(c){case "amp":return"&";case "lt":return"<";case "gt":return">";case "quot":return'"';default:return"#"!=c.charAt(0)||(c=Number("0"+c.slice(1)),isNaN(c))?b:String.fromCharCode(c)}})};goog.string.HTML_ENTITY_PATTERN_=/&([^;\s<&]+);?/g;goog.string.whitespaceEscape=function(a,b){return goog.string.newLineToBr(a.replace(/  /g," &#160;"),b)};
+goog.string.preserveSpaces=function(a){return a.replace(/(^|[\n ]) /g,"$1"+goog.string.Unicode.NBSP)};goog.string.stripQuotes=function(a,b){const c=b.length;for(let d=0;d<c;d++){const e=1==c?b:b.charAt(d);if(a.charAt(0)==e&&a.charAt(a.length-1)==e)return a.substring(1,a.length-1)}return a};goog.string.truncate=function(a,b,c){c&&(a=goog.string.unescapeEntities(a));a.length>b&&(a=a.substring(0,b-3)+"...");c&&(a=goog.string.htmlEscape(a));return a};
+goog.string.truncateMiddle=function(a,b,c,d){c&&(a=goog.string.unescapeEntities(a));if(d&&a.length>b){d>b&&(d=b);var e=a.length-d;a=a.substring(0,b-d)+"..."+a.substring(e)}else a.length>b&&(d=Math.floor(b/2),e=a.length-d,a=a.substring(0,d+b%2)+"..."+a.substring(e));c&&(a=goog.string.htmlEscape(a));return a};goog.string.specialEscapeChars_={"\x00":"\\0","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\v":"\\x0B",'"':'\\"',"\\":"\\\\","<":"\\u003C"};goog.string.jsEscapeCache_={"'":"\\'"};
+goog.string.quote=function(a){a=String(a);const b=['"'];for(let c=0;c<a.length;c++){const d=a.charAt(c),e=d.charCodeAt(0);b[c+1]=goog.string.specialEscapeChars_[d]||(31<e&&127>e?d:goog.string.escapeChar(d))}b.push('"');return b.join("")};goog.string.escapeString=function(a){const b=[];for(let c=0;c<a.length;c++)b[c]=goog.string.escapeChar(a.charAt(c));return b.join("")};
+goog.string.escapeChar=function(a){if(a in goog.string.jsEscapeCache_)return goog.string.jsEscapeCache_[a];if(a in goog.string.specialEscapeChars_)return goog.string.jsEscapeCache_[a]=goog.string.specialEscapeChars_[a];let b;const c=a.charCodeAt(0);if(31<c&&127>c)b=a;else{if(256>c){if(b="\\x",16>c||256<c)b+="0"}else b="\\u",4096>c&&(b+="0");b+=c.toString(16).toUpperCase()}return goog.string.jsEscapeCache_[a]=b};goog.string.contains=goog.string.internal.contains;
+goog.string.caseInsensitiveContains=goog.string.internal.caseInsensitiveContains;goog.string.countOf=function(a,b){return a&&b?a.split(b).length-1:0};goog.string.removeAt=function(a,b,c){let d=a;0<=b&&b<a.length&&0<c&&(d=a.slice(0,b)+a.slice(b+c));return d};goog.string.remove=function(a,b){return a.replace(b,"")};goog.string.removeAll=function(a,b){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,"")};
+goog.string.replaceAll=function(a,b,c){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,c.replace(/\$/g,"$$$$"))};goog.string.regExpEscape=function(a){return String(a).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g,"\\$1").replace(/\x08/g,"\\x08")};goog.string.repeat=String.prototype.repeat?function(a,b){return a.repeat(b)}:function(a,b){return Array(b+1).join(a)};
+goog.string.padNumber=function(a,b,c){if(!Number.isFinite(a))return String(a);a=void 0!==c?a.toFixed(c):String(a);c=a.indexOf(".");-1===c&&(c=a.length);const d="-"===a[0]?"-":"";d&&(a=a.substring(1));return d+goog.string.repeat("0",Math.max(0,b-c))+a};goog.string.makeSafe=function(a){return null==a?"":String(a)};goog.string.getRandomString=function(){return Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^goog.now()).toString(36)};
+goog.string.compareVersions=goog.string.internal.compareVersions;goog.string.hashCode=function(a){let b=0;for(let c=0;c<a.length;++c)b=31*b+a.charCodeAt(c)>>>0;return b};goog.string.uniqueStringCounter_=2147483648*Math.random()|0;goog.string.createUniqueString=function(){return"goog_"+goog.string.uniqueStringCounter_++};goog.string.toNumber=function(a){const b=Number(a);return 0==b&&goog.string.isEmptyOrWhitespace(a)?NaN:b};goog.string.isLowerCamelCase=function(a){return/^[a-z]+([A-Z][a-z]*)*$/.test(a)};
+goog.string.isUpperCamelCase=function(a){return/^([A-Z][a-z]*)+$/.test(a)};goog.string.toCamelCase=function(a){return String(a).replace(/\-([a-z])/g,function(b,c){return c.toUpperCase()})};goog.string.toSelectorCase=function(a){return String(a).replace(/([A-Z])/g,"-$1").toLowerCase()};goog.string.toTitleCase=function(a,b){b="string"===typeof b?goog.string.regExpEscape(b):"\\s";return a.replace(new RegExp("(^"+(b?"|["+b+"]+":"")+")([a-z])","g"),function(c,d,e){return d+e.toUpperCase()})};
+goog.string.capitalize=function(a){return String(a.charAt(0)).toUpperCase()+String(a.slice(1)).toLowerCase()};goog.string.parseInt=function(a){isFinite(a)&&(a=String(a));return"string"===typeof a?/^\s*-?0x/i.test(a)?parseInt(a,16):parseInt(a,10):NaN};goog.string.splitLimit=function(a,b,c){a=a.split(b);const d=[];for(;0<c&&a.length;)d.push(a.shift()),c--;a.length&&d.push(a.join(b));return d};
+goog.string.lastComponent=function(a,b){if(b)"string"==typeof b&&(b=[b]);else return a;let c=-1;for(let d=0;d<b.length;d++){if(""==b[d])continue;const e=a.lastIndexOf(b[d]);e>c&&(c=e)}return-1==c?a:a.slice(c+1)};
+goog.string.editDistance=function(a,b){const c=[],d=[];if(a==b)return 0;if(!a.length||!b.length)return Math.max(a.length,b.length);for(var e=0;e<b.length+1;e++)c[e]=e;for(e=0;e<a.length;e++){d[0]=e+1;for(var f=0;f<b.length;f++)d[f+1]=Math.min(d[f]+1,c[f+1]+1,c[f]+Number(a[e]!=b[f]));for(f=0;f<c.length;f++)c[f]=d[f]}return d[b.length]};goog.string.path={};goog.string.path.baseName=function(a){const b=a.lastIndexOf("/")+1;return a.slice(b)};goog.string.path.basename=goog.string.path.baseName;goog.string.path.dirname=function(a){const b=a.lastIndexOf("/")+1;a=a.slice(0,b);/^\/+$/.test(a)||(a=a.replace(/\/+$/,""));return a};goog.string.path.extension=function(a){a=goog.string.path.baseName(a).replace(/\.+/g,".");const b=a.lastIndexOf(".");return 0>=b?"":a.slice(b+1)};
+goog.string.path.join=function(a){let b=arguments[0];for(let c=1;c<arguments.length;c++){const d=arguments[c];b=goog.string.startsWith(d,"/")?d:""==b||goog.string.endsWith(b,"/")?b+d:b+("/"+d)}return b};
+goog.string.path.normalizePath=function(a){if(""==a)return".";let b="";goog.string.startsWith(a,"/")&&(b="/",goog.string.startsWith(a,"//")&&!goog.string.startsWith(a,"///")&&(b="//"));a=a.split("/");const c=[];for(let d=0;d<a.length;d++){const e=a[d];""!=e&&"."!=e&&(".."!=e||!b&&!c.length||".."==module$contents$goog$array_peek(c)?c.push(e):c.pop())}return b+c.join("/")||"."};goog.string.path.split=function(a){const b=goog.string.path.dirname(a);a=goog.string.path.baseName(a);return[b,a]};const DEBUG_WASI$$module$src$filesystem$wasi=!1;function assertLeadingSlash$$module$src$filesystem$wasi(a){return/^\//g.test(a)?a:`/${a}`}function removeLeadingSlash$$module$src$filesystem$wasi(a){return a.replace(/^\//g,"")}function shouldOpenReader$$module$src$filesystem$wasi(a){return(a&(WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants))!==goog.global.BigInt(0)}
+function performanceNowPoly$$module$src$filesystem$wasi(){if("undefined"===typeof performance||"undefined"===typeof performance.now){const a=Date.now();return Date.now()-a}return performance.now()}function concatUint8Arrays$$module$src$filesystem$wasi(a){var b=a.reduce((d,e)=>d+e.length,0);if(0!==a.length){b=new Uint8Array(b);var c=0;for(const d of a)b.set(d,c),c+=d.length;return b}}
+const WASI$$module$src$filesystem$wasi=function({}){this.fd=Array.from({length:4});this.fd[0]={fd:0,path:"/dev/stdin",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[1]={fd:1,path:"/dev/stdout",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[2]={fd:2,path:"/dev/stderr",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[3]={fd:3,path:"/",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.getMemory=this.getMemory.bind(this);this.CPUTIME_START=0};
+WASI$$module$src$filesystem$wasi.prototype.start=function(a){this.CPUTIME_START=performanceNowPoly$$module$src$filesystem$wasi();a.exports._start()};WASI$$module$src$filesystem$wasi.prototype.getImports=function(a){const b={};a=WebAssembly.Module.imports(a);for(const c of a)"function"===c.kind&&c.module.startsWith("wasi_")&&("object"!==typeof b[c.module]&&(b[c.module]={}),b[c.module][c.name]=this[c.name].bind(this));return b};
+WASI$$module$src$filesystem$wasi.prototype.setMemory=function(a){this.memory=a};WASI$$module$src$filesystem$wasi.prototype.getMemory=function(){this.view&&this.view.buffer&&this.view.buffer.byteLength||(this.view=new DataView(this.memory.buffer));return this.view};WASI$$module$src$filesystem$wasi.prototype.msToNs=function(a){const b=Math.trunc(a);a=goog.global.BigInt(Math.round(1E6*(a-b)));return goog.global.BigInt(b)*goog.global.BigInt(1E6)+a};
+WASI$$module$src$filesystem$wasi.prototype.now=function(a){switch(a){case WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi());case WASI_CLOCK_REALTIME$$module$src$filesystem$constants:return this.msToNs(Date.now());case WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants:case WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi()-this.CPUTIME_START);
+default:return 0}};WASI$$module$src$filesystem$wasi.prototype.args_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,module$src$filesystem$constants);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.args_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.clock_res_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.clock_time_get=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("clock_time_get",a,b,c,arguments);const d=this.getMemory(),e=this.now(a);d.setBigUint64(c,goog.global.BigInt(e),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.environ_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.environ_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_advise=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_advise",a,b,c,d,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_allocate=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_allocate",a,b,c,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_close=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_close",a,arguments);this.fd[a]&&(this.fd[a].open=!1);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_datasync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_datasync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_get",a,b,arguments);const c=this.getMemory();c.setUint8(b+4,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);c.setUint16(b+2,0,!0);c.setUint16(b+4,0,!0);c.setBigUint64(b+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants),!0);c.setBigUint64(b+8+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants),
+!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_flags=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_flags",a,b,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_rights=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_rights",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_filestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_get",a,b,arguments);let c=0;this.fd[a]&&(c=this.fd[a].buffers.reduce(function(e,f){return e+(null==f?void 0:f.byteLength)?null==f?void 0:f.byteLength:0},0));const d=this.getMemory();d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setUint8(b,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);b+=8;d.setBigUint64(b,
+goog.global.BigInt(1),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(c),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);d.setBigUint64(b+8,this.msToNs(this.CPUTIME_START),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_size=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_size",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_times=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_times",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_pread=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_pread",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_prestat_dir_name=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_dir_name",a,b,c,this.fd[a]);if(!this.fd[a]&&!this.fd[a-1])return WASI_EBADF$$module$src$filesystem$constants;({path:c}=this.fd[a]);a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);(new Uint8Array(a.buffer)).set(c,b);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_prestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_get",a,b,this.fd[a]);if(!this.fd[a])return WASI_EBADF$$module$src$filesystem$constants;var {path:c}=this.fd[a];a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);a.setUint8(b,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants);a.setUint32(b+4,c.byteLength,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_pwrite=function(a,b,c,d,e){console.log("fd_pwrite",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_read=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_read",a,b,c,d,arguments);const e=this.fd[a]&&this.fd[a].buffers;var f=e.reduce((l,p)=>l+p.length,0);const g=this.getMemory();if(e&&0!==e.length){var h=Number(this.fd[a].seekPos),k=0,n=!1;if(h>=f)return k=g.getUint32(b,!0),g.setUint8(k,"\x00"),g.setUint32(d,0,!0),WASI_ESUCCESS$$module$src$filesystem$constants;for(f=0;f<c;f++){var m=b+8*f;const l=g.getUint32(m,!0);m=g.getUint32(m+
+4,!0);n||(k+=m,Array.from({length:m},(p,q)=>q).reduce((p,q)=>{if(n)return p;const [u,t]=p;let x=p=0,r=!1,y=0,v;if(0===q)for(;!r;)v=e[p]?e[p].byteLength:0,y<=h&&v+y>h?(r=!0,x=h-y):(y+=v,p+=1);else p=u,x=t;e[p]?(g.setUint8(l+q,e[p][x]),x+1>=e[p].byteLength?(p=u+1,x=0):x+=1):(g.setUint8(l+q,"\x00"),h+=q,n=!0);return[p,x]},[0,0]),n||(h+=m))}this.fd[a].seekPos=goog.global.BigInt(h);g.setUint32(d,k,!0);return WASI_ESUCCESS$$module$src$filesystem$constants}console.error("Reading non existent file",a,this.fd[a])};
+WASI$$module$src$filesystem$wasi.prototype.fd_readdir=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_readdir",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_renumber=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_renumber",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_seek=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_seek",a,b,c,d,arguments);const e=this.getMemory();switch(c){case WASI_WHENCE_CUR$$module$src$filesystem$constants:var f;this.fd[a].seekPos=(null!=(f=this.fd[a].seekPos)?f:goog.global.BigInt(0))+goog.global.BigInt(b);break;case WASI_WHENCE_END$$module$src$filesystem$constants:f=(this.fd[a].buffers||[]).reduce((g,h)=>g+h.length,0);this.fd[a].seekPos=BigInt(f)+BigInt(b);break;
+case WASI_WHENCE_SET$$module$src$filesystem$constants:this.fd[a].seekPos=BigInt(b)}e.setBigUint64(d,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_sync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_sync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_tell=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_tell",a,b,arguments);const c=this.getMemory();this.fd[a].seekPos||(this.fd[a].seekPos=goog.global.BigInt(0));c.setBigUint64(b,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.fd_write=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_write",{fd:a,iovs:b,iovsLength:c,nwritten:d});const e=this.getMemory();this.fd[a].buffers=this.fd[a].buffers||[];this.fd[a].buffers=0<this.fd[a].buffers.length?[concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)]:this.fd[a].buffers;let f=0;for(let k=0;k<c;k++){var g=b+8*k,h=e.getUint32(g,!0);g=e.getUint32(g+4,!0);f+=g;h=new Uint8Array(e.buffer,h,g);if(this.fd[a].buffers[0]&&
+this.fd[a].seekPos<this.fd[a].buffers[0].length){const n=Number(this.fd[a].seekPos);h.slice(0,g).forEach((m,l)=>{this.fd[a].buffers[0][n+l]=m})}else this.fd[a].buffers.push(h.slice(0,g))}this.fd[a].seekPos+=goog.global.BigInt(f);e.setUint32(d,f,!0);[1,2].includes(a)&&console.log(decoder$$module$src$utils$text_encoders.decode(concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)));return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.path_create_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_create_directory",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_filestat_get=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_get",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.path_filestat_set_times=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_set_times",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_link=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_link",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.path_open=function(a,b,c,d,e,f,g,h,k){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_open",a,b,c,d,e,f,g,h,k,arguments);const n=this.getMemory();var m=(this.fd[a]||{path:"/"}).path,l=new Uint8Array(n.buffer,c,d);l=decoder$$module$src$utils$text_encoders.decode(l);const p=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(goog.string.path.join(3===a?"":m,l)));DEBUG_WASI$$module$src$filesystem$wasi&&console.log(";; opening path",
+p,"withREader",shouldOpenReader$$module$src$filesystem$wasi(f));if(p.startsWith("/..")||"/._"===p||"/.AppleDouble"===p)return WASI_EBADF$$module$src$filesystem$constants;(m=Object.values(this.fd).find(q=>q.path===p&&Array.isArray(q.buffers)))?l=m.fd:(l=this.fd.length,this.fd[l]={fd:l});this.fd[l]={...this.fd[l],path:p,type:"file",seekPos:goog.global.BigInt(0),buffers:m?this.fd[l].buffers:[],open:!0};shouldOpenReader$$module$src$filesystem$wasi(f)&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("should open a read handle for",
+p);n.setUint32(k,l,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_readlink=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_readlink",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_remove_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_remove_directory",a,b,c);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.path_rename=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_rename",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_symlink=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_symlink",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.path_unlink_file=function(a,b,c){3<a&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_unlink_file",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.poll_oneoff=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("poll_oneoff",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.proc_exit=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_exit",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.proc_raise=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_raise",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.random_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("random_get",a,b);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sched_yield=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sched_yield",arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.sock_recv=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_recv",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sock_send=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_send",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};
+WASI$$module$src$filesystem$wasi.prototype.sock_shutdown=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_shutdown",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.findBuffers=function(a){const b=Object.values(this.fd).find(({path:c})=>c===a);return[b&&b.buffers,b.fd]};
+WASI$$module$src$filesystem$wasi.prototype.readdir=function(a){const b=(assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a))+"/").replace("//","/"),c=[];Object.values(this.fd).forEach(({path:d})=>!/\//g.test(d.replace(b,""))&&c.push(d));return c.map(d=>removeLeadingSlash$$module$src$filesystem$wasi(d.replace(b,""))).filter(d=>!!d)};
+WASI$$module$src$filesystem$wasi.prototype.writeFile=function(a,b){const c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));a=Object.keys(this.fd).length;const d=Object.values(this.fd).find(({path:e})=>e===c);this.fd[a]={fd:a,path:c,seekPos:goog.global.BigInt(0),buffers:[b]};d&&delete this.fd[d]};
+WASI$$module$src$filesystem$wasi.prototype.appendFile=function(a,b){var c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));[c]=this.findBuffers(c);c?c.push(b):console.error(`Can't append to non-existing file ${a}`)};
+WASI$$module$src$filesystem$wasi.prototype.readFile=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),[c,d]=this.findBuffers(b);this.fd[d]&&this.fd[d].open&&console.warn(`readFile: file ${a} hasn't been closed yet!`);if(c)return concatUint8Arrays$$module$src$filesystem$wasi(c)};
+WASI$$module$src$filesystem$wasi.prototype.readStdOut=function(){const a=Object.values(this.fd[0]);return concatUint8Arrays$$module$src$filesystem$wasi(a&&a.buffers||[])};WASI$$module$src$filesystem$wasi.prototype.unlink=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));(a=Object.values(this.fd).find(({path:c})=>c===b))?delete this.fd[a]:console.error(`While trying to unlink ${b}, path not found`)};
+WASI$$module$src$filesystem$wasi.prototype.mkdir=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),c=[];Object.values(this.fd).forEach(({path:d})=>d.startsWith(b)&&c.push(d));0<c.length?console.warn(`mkdir: path ${a} already exists`):(a=Object.keys(this.fd).length,this.fd[a]={fd:a,path:b})};var module$src$filesystem$wasi={};module$src$filesystem$wasi.WASI=WASI$$module$src$filesystem$wasi;const CompressionMethod$$module$src$zlib$zlib={DEFLATE:8,RESERVED:15};var module$src$zlib$zlib={};module$src$zlib$zlib.CompressionMethod=CompressionMethod$$module$src$zlib$zlib;/*
+ zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */
+function Huffman$$module$src$zlib$huffman(a){const b=a.length;let c=0,d=Number.POSITIVE_INFINITY,e,f,g,h;let k,n;for(k=0;k<b;++k)a[k]>c&&(c=a[k]),a[k]<d&&(d=a[k]);const m=1<<c,l=new Uint32Array(m);e=1;f=0;for(g=2;e<=c;){for(k=0;k<b;++k)if(a[k]===e){h=0;var p=f;for(n=0;n<e;++n)h=h<<1|p&1,p>>=1;p=e<<16|k;for(n=h;n<m;n+=g)l[n]=p;++f}++e;f<<=1;g<<=1}return[l,c,d]}var module$src$zlib$huffman={};module$src$zlib$huffman.Huffman=Huffman$$module$src$zlib$huffman;const ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate=32768;
+function RawInflate$$module$src$zlib$rawinflate(a,b){this.blocks=[];this.bufferSize=ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate;this.bitsbuflen=this.bitsbuf=this.ip=this.totalpos=0;this.input=new Uint8Array(a);this.bfinal=!1;this.bufferType=RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE;this.resize=!1;if(b||!(b={}))b.index&&(this.ip=b.index),b.bufferSize&&(this.bufferSize=b.bufferSize),b.bufferType&&(this.bufferType=b.bufferType),b.resize&&(this.resize=b.resize);switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.op=
+RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;this.output=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength+this.bufferSize+RawInflate$$module$src$zlib$rawinflate.MaxCopyLength);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.op=0;this.output=new Uint8Array(this.bufferSize);break;default:throw Error("invalid inflate mode");}}RawInflate$$module$src$zlib$rawinflate.BufferType={BLOCK:0,ADAPTIVE:1};
+RawInflate$$module$src$zlib$rawinflate.prototype.decompress=function(){for(;!this.bfinal;)this.parseBlock();switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:return this.concatBufferBlock();case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:return this.concatBufferDynamic();default:throw Error("invalid inflate mode");}};RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength=32768;RawInflate$$module$src$zlib$rawinflate.MaxCopyLength=258;
+RawInflate$$module$src$zlib$rawinflate.Order=function(a){return new Uint16Array(a)}([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]);RawInflate$$module$src$zlib$rawinflate.LengthCodeTable=function(a){return new Uint16Array(a)}([3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258]);RawInflate$$module$src$zlib$rawinflate.LengthExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0]);
+RawInflate$$module$src$zlib$rawinflate.DistCodeTable=function(a){return new Uint16Array(a)}([1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577]);RawInflate$$module$src$zlib$rawinflate.DistExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]);
+RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable=function(a){return a}(function(){const a=new Uint8Array(288);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=143>=b?8:255>=b?9:279>=b?7:8;return Huffman$$module$src$zlib$huffman(a)}());RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable=function(a){return a}(function(){const a=new Uint8Array(30);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=5;return Huffman$$module$src$zlib$huffman(a)}());
+RawInflate$$module$src$zlib$rawinflate.prototype.parseBlock=function(){let a=this.readBits(3);a&1&&(this.bfinal=!0);a>>>=1;switch(a){case 0:this.parseUncompressedBlock();break;case 1:this.parseFixedHuffmanBlock();break;case 2:this.parseDynamicHuffmanBlock();break;default:throw Error("unknown BTYPE: "+a);}};
+RawInflate$$module$src$zlib$rawinflate.prototype.readBits=function(a){let b=this.bitsbuf,c=this.bitsbuflen;const d=this.input;let e=this.ip;if(e+(a-c+7>>3)>=d.length)throw Error("input buffer is broken");for(;c<a;)b|=d[e++]<<c,c+=8;this.bitsbuf=b>>>a;this.bitsbuflen=c-a;this.ip=e;return b&(1<<a)-1};
+RawInflate$$module$src$zlib$rawinflate.prototype.readCodeByTable=function(a){let b=this.bitsbuf,c=this.bitsbuflen;var d=this.input;let e=this.ip;var f=d.length;const g=a[0];for(a=a[1];c<a&&!(e>=f);)b|=d[e++]<<c,c+=8;d=g[b&(1<<a)-1];f=d>>>16;if(f>c)throw Error("invalid code length: "+f);this.bitsbuf=b>>f;this.bitsbuflen=c-f;this.ip=e;return d&65535};
+RawInflate$$module$src$zlib$rawinflate.prototype.parseUncompressedBlock=function(){const a=this.input;let b=this.ip,c=this.output,d=this.op;var e=a.length;let f;const g=c.length;this.bitsbuflen=this.bitsbuf=0;if(b+1>=e)throw Error("invalid uncompressed block header: LEN");f=a[b++]|a[b++]<<8;if(b+1>=e)throw Error("invalid uncompressed block header: NLEN");e=a[b++]|a[b++]<<8;if(f===~e)throw Error("invalid uncompressed block header: length verify");if(b+f>a.length)throw Error("input buffer is broken");
+switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:for(;d+f>c.length;)e=g-d,f-=e,c.set(a.subarray(b,b+e),d),d+=e,b+=e,this.op=d,c=this.expandBufferBlock(),d=this.op;break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:for(;d+f>c.length;)c=this.expandBufferAdaptive({fixRatio:2});break;default:throw Error("invalid inflate mode");}c.set(a.subarray(b,b+f),d);this.ip=b+f;this.op=d+f;this.output=c};
+RawInflate$$module$src$zlib$rawinflate.prototype.parseFixedHuffmanBlock=function(){switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);
+break;default:throw Error("invalid inflate mode");}};
+RawInflate$$module$src$zlib$rawinflate.prototype.parseDynamicHuffmanBlock=function(){var a=this.readBits(5)+257,b=this.readBits(5)+1,c=this.readBits(4)+4,d=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.Order.length);let e;for(e=0;e<c;++e)d[RawInflate$$module$src$zlib$rawinflate.Order[e]]=this.readBits(3);d=Huffman$$module$src$zlib$huffman(d);c=new Uint8Array(a+b);e=0;for(b=a+b;e<b;){var f=this.readCodeByTable(d);switch(f){case 16:for(f=3+this.readBits(2);f--;)c[e++]=g;break;case 17:for(f=
+3+this.readBits(3);f--;)c[e++]=0;var g=0;break;case 18:for(f=11+this.readBits(7);f--;)c[e++]=0;g=0;break;default:g=c[e++]=f}}g=Huffman$$module$src$zlib$huffman(c.subarray(0,a));a=Huffman$$module$src$zlib$huffman(c.subarray(a));switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(g,a);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(g,a);break;default:throw Error("invalid inflate mode");}};
+RawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanBlock=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;const e=c.length-RawInflate$$module$src$zlib$rawinflate.MaxCopyLength;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,n=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,m=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,l=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=
+e&&(this.op=d,c=this.expandBufferBlock(),d=this.op),c[d++]=f;else for(f-=257,h=k[f],0<n[f]&&(h+=this.readBits(n[f])),f=this.readCodeByTable(b),g=m[f],0<l[f]&&(g+=this.readBits(l[f])),d>=e&&(this.op=d,c=this.expandBufferBlock(),d=this.op);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};
+RawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanAdaptive=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;let e=c.length;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,n=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,m=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,l=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=e&&(c=this.expandBufferAdaptive(),e=c.length),c[d++]=
+f;else for(f-=257,h=k[f],0<n[f]&&(h+=this.readBits(n[f])),f=this.readCodeByTable(b),g=m[f],0<l[f]&&(g+=this.readBits(l[f])),d+h>e&&(c=this.expandBufferAdaptive(),e=c.length);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};
+RawInflate$$module$src$zlib$rawinflate.prototype.expandBufferBlock=function(a){a=new Uint8Array(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength);const b=this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,c=this.output;a.set(c.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,a.length));this.blocks.push(a);this.totalpos+=a.length;c.set(c.subarray(b,b+RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));this.op=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;
+return c};RawInflate$$module$src$zlib$rawinflate.prototype.expandBufferAdaptive=function(a){let b=Math.trunc(this.input.length/this.ip+1);const c=this.input,d=this.output;a&&("number"===typeof a.fixRatio&&(b=a.fixRatio),"number"===typeof a.addRatio&&(b+=a.addRatio));2>b?(a=(c.length-this.ip)/this.currentLitlenTable[2],a=Math.trunc(a/2*258),a=a<d.length?d.length+a:d.length<<1):a=d.length*b;a=new Uint8Array(a);a.set(d);return this.output=a};
+RawInflate$$module$src$zlib$rawinflate.prototype.concatBufferBlock=function(){let a=0;const b=this.output,c=this.blocks;let d;const e=new Uint8Array(this.totalpos+(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));let f,g,h,k;if(0===c.length)return this.output.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,this.op);f=0;for(g=c.length;f<g;++f)for(d=c[f],h=0,k=d.length;h<k;++h)e[a++]=d[h];f=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;for(g=this.op;f<
+g;++f)e[a++]=b[f];this.blocks=[];return this.buffer=e};RawInflate$$module$src$zlib$rawinflate.prototype.concatBufferDynamic=function(){let a;const b=this.op;this.resize?(a=new Uint8Array(b),a.set(this.output.subarray(0,b))):a=this.output.subarray(0,b);return this.buffer=a};var module$src$zlib$rawinflate={};module$src$zlib$rawinflate.RawInflate=RawInflate$$module$src$zlib$rawinflate;function Util$$module$src$zlib$util(){}Util$$module$src$zlib$util.stringToByteArray=function(a){a=[...a];let b,c;b=0;for(c=a.length;b<c;b++)a[b]=(a[b].charPointAt(0)&255)>>>0;return new Uint8Array([a])};var module$src$zlib$util={};module$src$zlib$util.Util=Util$$module$src$zlib$util;function Adler32$$module$src$zlib$adler32(a){"string"===typeof a&&(a=Util$$module$src$zlib$util.stringToByteArray(a));return Adler32$$module$src$zlib$adler32.update(1,a)}Adler32$$module$src$zlib$adler32.update=function(a,b){let c=a&65535;a=a>>>16&65535;let d=b.length,e,f=0;for(;0<d;){e=d>Adler32$$module$src$zlib$adler32.OptimizationParameter?Adler32$$module$src$zlib$adler32.OptimizationParameter:d;d-=e;do c+=b[f++],a+=c;while(--e);c%=65521;a%=65521}return(a<<16|c)>>>0};
+Adler32$$module$src$zlib$adler32.OptimizationParameter=1024;var module$src$zlib$adler32={};module$src$zlib$adler32.Adler32=Adler32$$module$src$zlib$adler32;function Inflate$$module$src$zlib$inflate(a,b){this.input=a;this.ip=0;if(b||!(b={}))b.index&&(this.ip=b.index),b.verify&&(this.verify=b.verify);const c=a[this.ip++],d=a[this.ip++];switch(c&15){case CompressionMethod$$module$src$zlib$zlib.DEFLATE:this.method=CompressionMethod$$module$src$zlib$zlib.DEFLATE;break;default:throw Error("unsupported compression method");}if(0!==((c<<8)+d)%31)throw Error("invalid fcheck flag:"+((c<<8)+d)%31);if(d&32)throw Error("fdict flag is not supported");this.rawinflate=
+new RawInflate$$module$src$zlib$rawinflate(a,{index:this.ip,bufferSize:b.bufferSize,bufferType:b.bufferType,resize:b.resize})}Inflate$$module$src$zlib$inflate.BufferType=RawInflate$$module$src$zlib$rawinflate.BufferType;
+Inflate$$module$src$zlib$inflate.prototype.decompress=function(){var a=this.input;const b=this.rawinflate.decompress();this.ip=this.rawinflate.ip;if(this.verify&&(a=(a[this.ip++]<<24|a[this.ip++]<<16|a[this.ip++]<<8|a[this.ip++])>>>0,a!==Adler32$$module$src$zlib$adler32(b)))throw Error("invalid adler-32 checksum");return b};var module$src$zlib$inflate={};module$src$zlib$inflate.Inflate=Inflate$$module$src$zlib$inflate;const PAGE_SIZE$$module$src$module=65536,PAGES_PER_MB$$module$src$module=16,csoundWasiJsMessageCallback$$module$src$module=({memory:a,messagePort:b,streamBuffer:c})=>function(d,e,f,g){if(a){d=new Uint8Array(a.buffer,g,f);d=uint2String$$module$src$utils$text_encoders(d);var h=/\n$/g.test(d);e=/^\n/g.test(d);var k=d.split("\n").filter(m=>0<m.length),n=[];if(0===k.length&&h||e)n.push(c.join("")),clearArray$$module$src$utils$clear_array(c);k.forEach((m,l)=>{l+1===k.length?h?0===l?(n.push(c.join("")+m),
+clearArray$$module$src$utils$clear_array(c)):n.push(m):c.push(m):0===l?(n.push(c.join("")+m),clearArray$$module$src$utils$clear_array(c)):n.push(m)});n.forEach(m=>{m.replace(/(\r\n|\n|\r)/gm,"")&&b.post({log:m})})}},assertPluginExports$$module$src$module=a=>{if(a&&"object"===typeof a&&"object"===typeof a.exports){if(a.exports.__wasm_call_ctors){if(a.exports.csoundModuleCreate||a.exports.csound_opcode_init||a.exports.csound_fgen_init)return!0;console.error(a.exports,"A csound plugin turns out to be neither a plugin, opcode or module.\nPerhaps csdl.h or module.h wasn't imported correctly?");
+return!1}console.error("A csound plugin didn't export __wasm_call_ctors.\nPlease re-run wasm-ld with either --export-all or include --export=__wasm_call_ctors");return!1}console.error("Error instantiating a csound plugin, instance and/or export is missing!");return!1},getBinaryHeaderData$$module$src$module=a=>{function b(){let n=0,m=1;for(;;){const l=a[c++];n+=(l&127)*m;m*=128;if(!(l&128))break}return n}1836278016!==(new Uint32Array((new Uint8Array(a.subarray(0,24))).buffer))[0]&&console.error("Wasm magic number is missing!");
+if(0!==a[8])return logWasmModule$$module$src$logger("Dylink section wasn't found in wasm binary, assuming static wasm."),"static";let c=9;const d=b();c++;(0,goog.asserts.assert)(a[c]==="d".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="y".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="l".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="i".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="n".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="k".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]===
+".".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="0".codePointAt(0));c+=3;const e=b(),f=b(),g=b(),h=b(),k=b();return{sectionSize:d,memorySize:e,memoryAlign:f,neededDynlibsCount:k,tableSize:g,tableAlign:h}},loadStaticWasm$$module$src$module=async({wasmBytes:a,wasi:b,messagePort:c})=>{const d=await WebAssembly.compile(a);a=new WebAssembly.Memory({initial:16384});const e=b.getImports(d);e.env=e.env||{};e.env.csoundLoadModules=()=>0;e.env.memory=a;e.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:e.env.memory,
+streamBuffer:[],messagePort:c});c=await WebAssembly.instantiate(d,e);b.setMemory(a);b.start(c);c.exports.__wasi_js_csoundSetMessageStringCallback();return[c,b]};
+var $jscompDefaultExport$$module$src$module=async function({wasmDataURI:a,withPlugins:b=[],messagePort:c}){var d={};const e=new WASI$$module$src$filesystem$wasi({preopens:{"/":"/"}});a=new Uint8Array(a);a=(new Inflate$$module$src$zlib$inflate(a)).decompress();var f=getBinaryHeaderData$$module$src$module(a);if("static"===f)return await loadStaticWasm$$module$src$module({messagePort:c,wasmBytes:a,wasmFs:d,wasi:e});const {memorySize:g,memoryAlign:h,tableSize:k}=f;b=await b.reduce(async(v,z)=>{v=await v;
+let B,w;try{B=new Uint8Array(z),w=getBinaryHeaderData$$module$src$module(B)}catch(C){console.error("Error in plugin",C)}w&&v.push({headerData:w,wasmPluginBytes:B});return v},[]);var n=128*PAGES_PER_MB$$module$src$module;d=Math.ceil((g+h)/PAGE_SIZE$$module$src$module);f=Math.ceil(b.reduce((v,{headerData:z})=>"static"===z?0:v+(z.memorySize+h),0)/PAGE_SIZE$$module$src$module);f=d+f+n;const m=new WebAssembly.Memory({initial:f,maximum:1024*PAGES_PER_MB$$module$src$module}),l=new WebAssembly.Table({initial:k+
+1,element:"anyfunc"});e.setMemory(m);const p=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);f=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);n=new WebAssembly.Global({value:"i32",mutable:!1},n);const q=new WebAssembly.Global({value:"i32",mutable:!1},1),u=new WebAssembly.Global({value:"i32",mutable:!0},0);a=await WebAssembly.compile(a);const t=e.getImports(a);let x=[],r=d;t.env=t.env||{};t.env.memory=m;t.env.__indirect_function_table=
+l;t.env.__stack_pointer=p;t.env.__memory_base=n;t.env.__table_base=q;t.env.csoundLoadModules=v=>{x.forEach(z=>{void 0===y?console.error("csound-wasm internal: timing problem detected!"):dlinit$$module$src$dlinit(y,z,l,v)});return 0};t.env._ZTH5errno=function(){};t.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:m,messagePort:c,streamBuffer:[]});t.env.printDebugCallback=(v,z)=>{v=new Uint8Array(m.buffer,v,z);v=uint2String$$module$src$utils$text_encoders(v);console.log(v)};
+t["GOT.mem"]=t["GOT.mem"]||{};t["GOT.mem"].__heap_base=f;t["GOT.func"]=t["GOT.func"]||{};const y=await WebAssembly.instantiate(a,t);c=Object.assign({},y.exports);a={};a.exports=Object.assign(c,{memory:m});x=await b.reduce(async(v,{headerData:z,wasmPluginBytes:B})=>{v=await v;try{const {memorySize:w,memoryAlign:C,tableSize:F}=z,E=await WebAssembly.compile(B),A=e.getImports(E),G=new WebAssembly.Global({value:"i32",mutable:!1},r*PAGE_SIZE$$module$src$module);l.grow(F);A.env=Object.assign({},A.env);A.env.memory=
+m;A.env.__indirect_function_table=l;A.env.__memory_base=G;A.env.__stack_pointer=p;A.env.__table_base=q;A.env.csoundLoadModules=u;delete A.env.csoundWasiJsMessageCallback;r+=Math.ceil((w+C)/PAGE_SIZE$$module$src$module);const D=await WebAssembly.instantiate(E,A);assertPluginExports$$module$src$module(D)&&(D.exports.__wasm_call_ctors(),v.push(D))}catch(w){console.error("Error while compiling csound-plugin",w)}return v},[]);e.start(a);a.exports.__wasi_js_csoundSetMessageStringCallback();return[a,e]},
+module$src$module={};module$src$module.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module;module$src$module.default=$jscompDefaultExport$$module$src$module;function MessagePortState$$module$src$utils$message_port_state(){}MessagePortState$$module$src$utils$message_port_state.prototype.ready=!1;MessagePortState$$module$src$utils$message_port_state.prototype.port=void 0;MessagePortState$$module$src$utils$message_port_state.prototype.post=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.broadcastPlayState=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.workerState=void 0;
+MessagePortState$$module$src$utils$message_port_state.prototype.vanillaWorkerState=void 0;var $jscompDefaultExport$$module$src$utils$message_port_state=MessagePortState$$module$src$utils$message_port_state,module$src$utils$message_port_state={};module$src$utils$message_port_state.MessagePortState=MessagePortState$$module$src$utils$message_port_state;module$src$utils$message_port_state.default=$jscompDefaultExport$$module$src$utils$message_port_state;class ScriptProcessorNodeSingleThread$$module$src$mains$spn_main{constructor({audioContext:a,inputChannelCount:b=1,outputChannelCount:c=2}){this.publicEvents=new PublicEventAPI$$module$src$events(this);this.eventPromises=new EventPromises$$module$src$utils$event_promises;this.audioContext=a;this.onaudioprocess=this.onaudioprocess.bind(this);this.currentPlayState=void 0;this.onPlayStateChange=this.onPlayStateChange.bind(this);this.start=this.start.bind(this);this.stop=this.stop.bind(this);this.pause=
+this.pause.bind(this);this.resume=this.resume.bind(this);this.csoundApi=this.csoundInstance=this.wasm=void 0;this.exportApi={};this.spn=a.createScriptProcessor(0,b,c);this.spn.audioContext=a;this.spn.inputChannelCount=b;this.spn.outputChannelCount=c;this.spn.onaudioprocess=this.onaudioprocess;this.node=this.spn;this.exportApi.getNode=async()=>this.spn;this.sampleRate=a.sampleRate;this.messagePort=new $jscompDefaultExport$$module$src$utils$message_port_state;this.messagePort.post=d=>messageEventHandler$$module$src$mains$messages_main(this)({data:{log:d}});
+this.messagePort.ready=!0;this.started=this.running=!1}async terminateInstance(){this.spn&&(this.spn.disconnect(),delete this.spn);this.audioContext&&("closed"!==this.audioContext.state&&await this.audioContext.close(),delete this.audioContext);this.publicEvents&&(this.publicEvents.terminateInstance(),delete this.publicEvents);Object.keys(this.exportApi).forEach(a=>delete this.exportApi[a]);Object.keys(this).forEach(a=>delete this[a])}async onPlayStateChange(a){if(this.publicEvents&&this.currentPlayState!==
+a)switch(this.currentPlayState=a,a){case "realtimePerformanceStarted":this.publicEvents.triggerRealtimePerformanceStarted(this);break;case "realtimePerformanceEnded":this.publicEvents.triggerRealtimePerformanceEnded(this);break;case "realtimePerformancePaused":this.publicEvents.triggerRealtimePerformancePaused(this);break;case "realtimePerformanceResumed":this.publicEvents.triggerRealtimePerformanceResumed(this);break;case "renderStarted":this.publicEvents.triggerRenderStarted(this);break;case "renderEnded":this.publicEvents.triggerRenderEnded(this)}}async pause(){this.started&&
+this.running&&(this.running=!1,this.onPlayStateChange("realtimePerformancePaused"))}async resume(){this.started&&!this.running&&(this.running=!0,this.onPlayStateChange("realtimePerformanceResumed"))}async stop(){if(this.started){this.eventPromises.createStopPromise();const a=this.csoundApi.csoundStop(this.csoundInstance);await this.eventPromises.waitForStop();this.watcherStdOut&&(this.watcherStdOut.close(),delete this.watcherStdOut);this.watcherStdErr&&(this.watcherStdErr.close(),delete this.watcherStdErr);
+delete this.csoundInputBuffer;delete this.csoundOutputBuffer;delete this.currentPlayState;return a}}async start(){if(this.csoundApi){var a=(this.csoundApi.csoundGetOutputName(this.csoundInstance)||"test.wav").includes("dac");if(a&&"realtimePerformanceStarted"!==this.currentPlayState){this.result=0;this.csoundApi.csoundSetOption(this.csoundInstance,"--sample-rate="+this.sampleRate);this.nchnls_i=this.nchnls=-1;this.cnt=this.ksmps=a=this.csoundApi.csoundGetKsmps(this.csoundInstance);this.nchnls=this.csoundApi.csoundGetNchnls(this.csoundInstance);
+this.nchnls_i=this.csoundApi.csoundGetNchnlsInput(this.csoundInstance);var b=this.csoundApi.csoundGetSpout(this.csoundInstance);this.csoundOutputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,b,a*this.nchnls);b=this.csoundApi.csoundGetSpin(this.csoundInstance);this.csoundInputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,b,a*this.nchnls_i);this.zerodBFS=this.csoundApi.csoundGet0dBFS(this.csoundInstance);this.publicEvents.triggerOnAudioNodeCreated(this.spn);this.eventPromises.createStartPromise();
+a=this.csoundApi.csoundStart(this.csoundInstance);this.csoundApi._isRequestingRtMidiInput(this.csoundInstance)&&requestMidi$$module$src$utils$request_midi({onMidiMessage:({data:c})=>this.csoundApi.csoundPushMidiMessage(this.csoundInstance,c[0],c[1],c[2])});this.running=!0;await this.eventPromises.waitForStart();return a}if(!a&&"renderStarted"!==this.currentPlayState)return a=this.csoundApi.csoundStart(this.csoundInstance),this.onPlayStateChange("renderStarted"),setTimeout(()=>{let c=0;for(;0===c&&
+this.csoundApi&&this.csoundInstance;)c=this.csoundApi.csoundPerformKsmps(this.csoundInstance);this.onPlayStateChange&&this.onPlayStateChange("renderEnded")},0),a}else console.error("starting csound failed because csound instance wasn't created")}async initialize({wasmDataURI:a,withPlugins:b,autoConnect:c}){this.plugins||!b||isEmpty$$module$node_modules$rambda$dist$rambda_mjs(b)||(b=await fetchPlugins$$module$src$utils(b));if(!this.wasm){const [f,g]=await $jscompDefaultExport$$module$src$module({wasmDataURI:a(),
+withPlugins:b,messagePort:this.messagePort});this.wasm=f;this.wasi=g;f.wasi=g}const d=$jscompDefaultExport$$module$src$libcsound(this.wasm);this.csoundApi=d;const e=await d.csoundCreate(0);this.csoundInstance=e;c&&this.spn.connect(this.audioContext.destination);this.resetCsound(!1);Object.keys(d).reduce((f,g)=>{if(["mkdir","readdir","writeFile"].includes(g)){f.fs=f.fs||{};var h=async(...k)=>makeSingleThreadCallback$$module$src$utils(this.wasm,d[g]).apply({},k);h.toString=d[g].toString;f.fs[g]=h}else h=
+csoundApiRename$$module$src$utils(g),f[h]=(...k)=>makeSingleThreadCallback$$module$src$utils(e,d[g]).apply({},k),f[h].toString=d[g].toString;return f},this.exportApi);this.exportApi.pause=this.pause.bind(this);this.exportApi.resume=this.resume.bind(this);this.exportApi.start=this.start.bind(this);this.exportApi.stop=this.stop.bind(this);this.exportApi.terminateInstance=this.terminateInstance.bind(this);this.exportApi.getAudioContext=async()=>this.audioContext;this.exportApi.name="Csound: ScriptProcessor Node, Single-threaded";
+this.exportApi=this.publicEvents.decorateAPI(this.exportApi);this.exportApi.reset=()=>this.resetCsound(!0);this.exportApi.addListener("message",console.log);return this.exportApi}async resetCsound(a){if(a&&"realtimePerformanceEnded"!==this.currentPlayState&&"realtimePerformanceStarted"!==this.currentPlayState)return-1;if("realtimePerformanceStarted"===this.currentPlayState)this.onPlayStateChange("realtimePerformanceEnded");this.started=this.running=!1;this.result=0;const b=this.csoundInstance,c=this.csoundApi;
+a&&c.csoundReset(b);c.csoundSetOption(b,"--sample-rate="+this.sampleRate);this.nchnls_i=this.nchnls=-1;delete this.csoundOutputBuffer;delete this.csoundInputBuffer}onaudioprocess(a){if(this.csoundApi&&!["renderStarted","renderEnded"].includes(this.currentPlayState)){if(null===this.csoundOutputBuffer||!1===this.running){var b=a.outputBuffer,c=b.getChannelData(0);if(c){c=c.length;for(var d=0;d<c;d++)for(var e=0;e<b.numberOfChannels;e++)b.getChannelData(e)[d]=0}}this.running&&!this.started&&(this.started=
+!0,this.onPlayStateChange("realtimePerformanceStarted"),this.eventPromises&&this.eventPromises.releaseStartPromise());b=a.inputBuffer;a=a.outputBuffer;c=a.getChannelData(0).length;d=this.csoundOutputBuffer;e=this.csoundInputBuffer;var f=this.ksmps,g=this.zerodBFS,h=this.nchnls,k=this.nchnls_i,n=this.cnt||0,m=this.result||0;for(let u=0;u<c;u++,n++){n===f&&0===m&&(m=this.csoundApi.csoundPerformKsmps(this.csoundInstance),n=0,0!==m&&(this.started=this.running=!1,this.onPlayStateChange("realtimePerformanceEnded"),
+this.eventPromises&&this.eventPromises.releaseStopPromise()));d&&0!==d.length||(d=this.csoundOutputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,this.csoundApi.csoundGetSpout(this.csoundInstance),f*h));e&&0!==e.length||(e=this.csoundInputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,this.csoundApi.csoundGetSpin(this.csoundInstance),f*k));var l=Math.min(this.nchnls_i,b.numberOfChannels);for(var p=0;p<l;p++){var q=b.getChannelData(p);e[n*k+p]=q[u]*g}if(this.nchnls===a.numberOfChannels)for(l=
+0;l<a.numberOfChannels;l++)a.getChannelData(l)[u]=0===m?d[n*h+l]/g:0;else 2===this.nchnls&&1===a.numberOfChannels?a.getChannelData(0)[u]=0===m?.5*(d[n*h]/g+d[n*h+1]/g):0:1===this.nchnls&&2===a.numberOfChannels&&(l=a.getChannelData(0),p=a.getChannelData(1),0===m?(q=d[n*h]/g,l[u]=q,p[u]=q):(l[u]=0,p[u]=0))}this.cnt=n;this.result=m}}}var $jscompDefaultExport$$module$src$mains$spn_main=ScriptProcessorNodeSingleThread$$module$src$mains$spn_main,module$src$mains$spn_main={};
+module$src$mains$spn_main.default=$jscompDefaultExport$$module$src$mains$spn_main;var $jscompDefaultExport$$module$dist$__compiled_worklet_singlethread_worker_inline=()=>"data:application/javascript;base64,let self = AudioWorkletGlobalScope;
/*

 Copyright The Closure Library Authors.
 SPDX-License-Identifier: Apache-2.0
*/
var $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this||self;goog.exportPath_=function(a,b,c,d){a=a.split(".");d=d||goog.global;a[0]in d||"undefined"==typeof d.execScript||d.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)if(a.length||void 0===b)d=d[e]&&d[e]!==Object.prototype[e]?d[e]:d[e]={};else if(!c&&goog.isObject(b)&&goog.isObject(d[e]))for(var f in b)b.hasOwnProperty(f)&&(d[e][f]=b[f]);else d[e]=b};
goog.define=function(a,b){if(!COMPILED){var c=goog.global.CLOSURE_UNCOMPILED_DEFINES,d=goog.global.CLOSURE_DEFINES;c&&void 0===c.nodeType&&Object.prototype.hasOwnProperty.call(c,a)?b=c[a]:d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)&&(b=d[a])}return b};goog.FEATURESET_YEAR=2020;goog.DEBUG=!0;goog.LOCALE="en";goog.getLocale=function(){return goog.LOCALE};goog.TRUSTED_SITE=!0;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;
goog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b,c){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var d=a;(d=d.substring(0,d.lastIndexOf(".")))&&!goog.getObjectByName(d);)goog.implicitNamespaces_[d]=!0}goog.exportPath_(a,b,c)};goog.NONCE_PATTERN_=/^[\w+/_-]+[=]{0,2}$/;
goog.getScriptNonce_=function(a){a=(a||goog.global).document;return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module=function(a){if("string"!==typeof a||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");
goog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;
goog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG};goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1};
goog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0};
goog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error('Module with namespace "'+a+'" already exists.');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error('Module with namespace "'+
a+'" has been loaded incorrectly.');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){};COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&null!=goog.getObjectByName(a)},goog.implicitNamespaces_={"goog.module":!0});
goog.getObjectByName=function(a,b){a=a.split(".");b=b||goog.global;for(var c=0;c<a.length;c++)if(b=b[a[c]],null==b)return null;return b};goog.addDependency=function(a,b,c,d){!COMPILED&&goog.DEPENDENCIES_ENABLED&&goog.debugLoader_.addDependency(a,b,c,d)};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};
goog.require=function(a){if(!COMPILED){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_.requested(a);if(goog.isProvided_(a)){if(goog.isInModuleLoader_())return goog.module.getInternal_(a)}else if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{goog.debugLoader_.load_(a)}finally{goog.moduleLoaderState_=b}}return null}};goog.requireType=function(a){return{}};goog.basePath="";goog.abstractMethod=function(){throw Error("unimplemented abstract method");};
goog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";goog.ASSUME_ES_MODULES_TRANSPILED=!1;goog.TRUSTED_TYPES_POLICY_NAME="goog";
goog.hasBadLetScoping=null;
goog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:"",declareLegacyNamespace:!1,type:goog.ModuleType.GOOG};var c={},d=c;if("function"===typeof a)d=a.call(void 0,d);else if("string"===typeof a)d=goog.loadModuleFromSource_.call(void 0,d,a);else throw Error("Invalid module definition");var e=goog.moduleLoaderState_.moduleName;if("string"===typeof e&&e)goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(e,d,c!==d):goog.SEAL_MODULE_EXPORTS&&
Object.seal&&"object"==typeof d&&null!=d&&Object.seal(d),goog.loadedModules_[e]={exports:d,type:goog.ModuleType.GOOG,moduleId:goog.moduleLoaderState_.moduleName};else throw Error('Invalid module name "'+e+'"');}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a,b){eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(b));return a};goog.normalizePath_=function(a){a=a.split("/");for(var b=0;b<a.length;)"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++;return a.join("/")};
goog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC)return goog.global.CLOSURE_LOAD_FILE_SYNC(a);try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};goog.typeOf=function(a){var b=typeof a;return"object"!=b?b:a?Array.isArray(a)?"array":b:"null"};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};
goog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear};goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return Object.prototype.hasOwnProperty.call(a,goog.UID_PROPERTY_)&&a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return!!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute"in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};
goog.UID_PROPERTY_="closure_uid_"+(1E9*Math.random()>>>0);goog.uidCounter_=0;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};
goog.bindJs_=function(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var e=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(e,d);return a.apply(b,e)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};
goog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var d=c.slice();d.push.apply(d,arguments);return a.apply(this,d)}};goog.now=function(){return Date.now()};goog.globalEval=function(a){(0,eval)(a)};
goog.getCssName=function(a,b){if("."==String(a).charAt(0))throw Error('className passed in goog.getCssName must not start with ".". You passed: '+a);var c=function(e){return goog.cssNameMapping_[e]||e},d=function(e){e=e.split("-");for(var f=[],g=0;g<e.length;g++)f.push(c(e[g]));return f.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(e){return e};a=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(a):a};
goog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.GetMsgOptions=function(){};
goog.getMsg=function(a,b,c){c&&c.html&&(a=a.replace(/</g,"&lt;"));c&&c.unescapeHtmlEntities&&(a=a.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&apos;/g,"'").replace(/&quot;/g,'"').replace(/&amp;/g,"&"));b&&(a=a.replace(/\{\$([^}]+)}/g,function(d,e){return null!=b&&e in b?b[e]:d}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,!0,c)};goog.exportProperty=function(a,b,c){a[b]=c};
goog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(d,e,f){for(var g=Array(arguments.length-2),h=2;h<arguments.length;h++)g[h-2]=arguments[h];return b.prototype[e].apply(d,g)}};goog.scope=function(a){if(goog.isInModuleLoader_())throw Error("goog.scope is not supported within a module.");a.call(goog.global)};COMPILED||(goog.global.COMPILED=COMPILED);
goog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).");});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;
goog.defineClass.createSealingConstructor_=function(a,b){return goog.defineClass.SEAL_CLASS_INSTANCES?function(){var c=a.apply(this,arguments)||this;c[goog.UID_PROPERTY_]=c[goog.UID_PROPERTY_];return c}:a};goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
goog.defineClass.applyProperties_=function(a,b){for(var c in b)Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c]);for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++)c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])};goog.identity_=function(a){return a};
goog.createTrustedTypesPolicy=function(a){var b=null,c=goog.global.trustedTypes;if(!c||!c.createPolicy)return b;try{b=c.createPolicy(a,{createHTML:goog.identity_,createScript:goog.identity_,createScriptURL:goog.identity_})}catch(d){goog.logToConsole_(d.message)}return b};
!COMPILED&&goog.DEPENDENCIES_ENABLED&&(goog.isEdge_=function(){return!!(goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"").match(/Edge\/(\d+)(\.\d)*/i)},goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write"in a},goog.isDocumentLoading_=function(){var a=goog.global.document;return a.attachEvent?"complete"!=a.readyState:"loading"==a.readyState},goog.findBasePath_=function(){if(void 0!=goog.global.CLOSURE_BASE_PATH&&"string"===typeof goog.global.CLOSURE_BASE_PATH)goog.basePath=
goog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.slice(d-7,d)){goog.basePath=c.slice(0,d-7);break}}}},goog.findBasePath_(),goog.protectScriptTag_=function(a){return a.replace(/<\/(SCRIPT)/ig,"\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_={};this.idToPath_={};this.written_={};this.loadingDeps_=
[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory;this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){b=[];for(var e=0;e<a.length;e++){var f=this.getPathFromDeps_(a[e]);if(!f)throw Error("Unregonized namespace: "+a[e]);b.push(this.dependencies_[f])}f=goog.require;var g=0;for(e=0;e<a.length;e++)f(a[e]),b[e].onLoad(function(){++g==a.length&&c()})}else c()},
goog.DebugLoader_.prototype.loadClosureDeps=function(){this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath+"deps.js"),"deps.js",[],[],{}));this.loadDeps_()},goog.DebugLoader_.prototype.requested=function(a,b){(a=this.getPathFromDeps_(a))&&(b||this.areDepsLoaded_(this.dependencies_[a].requires))&&(b=this.deferredCallbacks_[a])&&(delete this.deferredCallbacks_[a],b())},goog.DebugLoader_.prototype.setDependencyFactory=function(a){this.factory_=a},goog.DebugLoader_.prototype.load_=
function(a){if(this.getPathFromDeps_(a)){var b=this,c=[],d=function(e){var f=b.getPathFromDeps_(e);if(!f)throw Error("Bad dependency path or symbol: "+e);if(!b.written_[f]){b.written_[f]=!0;e=b.dependencies_[f];for(f=0;f<e.requires.length;f++)goog.isProvided_(e.requires[f])||d(e.requires[f]);c.push(e)}};d(a);a=!!this.depsToLoad_.length;this.depsToLoad_=this.depsToLoad_.concat(c);this.paused_||a||this.loadDeps_()}else goog.logToConsole_("goog.require could not find: "+a)},goog.DebugLoader_.prototype.loadDeps_=
function(){for(var a=this,b=this.paused_;this.depsToLoad_.length&&!b;)(function(){var c=!1,d=a.depsToLoad_.shift(),e=!1;a.loading_(d);var f={pause:function(){if(c)throw Error("Cannot call pause after the call to load.");b=!0},resume:function(){c?a.resume_():b=!1},loaded:function(){if(e)throw Error("Double call to loaded.");e=!0;a.loaded_(d)},pending:function(){for(var g=[],h=0;h<a.loadingDeps_.length;h++)g.push(a.loadingDeps_[h]);return g},setModuleState:function(g){goog.moduleLoaderState_={type:g,
moduleName:"",declareLegacyNamespace:!1}},registerEs6ModuleExports:function(g,h,k){k&&(goog.loadedModules_[k]={exports:h,type:goog.ModuleType.ES6,moduleId:k||""})},registerGoogModuleExports:function(g,h){goog.loadedModules_[g]={exports:h,type:goog.ModuleType.GOOG,moduleId:g}},clearModuleState:function(){goog.moduleLoaderState_=null},defer:function(g){if(c)throw Error("Cannot register with defer after the call to load.");a.defer_(d,g)},areDepsLoaded:function(){return a.areDepsLoaded_(d.requires)}};
try{d.load(f)}finally{c=!0}})();b&&this.pause_()},goog.DebugLoader_.prototype.pause_=function(){this.paused_=!0},goog.DebugLoader_.prototype.resume_=function(){this.paused_&&(this.paused_=!1,this.loadDeps_())},goog.DebugLoader_.prototype.loading_=function(a){this.loadingDeps_.push(a)},goog.DebugLoader_.prototype.loaded_=function(a){for(var b=0;b<this.loadingDeps_.length;b++)if(this.loadingDeps_[b]==a){this.loadingDeps_.splice(b,1);break}for(b=0;b<this.deferredQueue_.length;b++)if(this.deferredQueue_[b]==
a.path){this.deferredQueue_.splice(b,1);break}if(this.loadingDeps_.length==this.deferredQueue_.length&&!this.depsToLoad_.length)for(;this.deferredQueue_.length;)this.requested(this.deferredQueue_.shift(),!0);a.loaded()},goog.DebugLoader_.prototype.areDepsLoaded_=function(a){for(var b=0;b<a.length;b++){var c=this.getPathFromDeps_(a[b]);if(!c||!(c in this.deferredCallbacks_||goog.isProvided_(a[b])))return!1}return!0},goog.DebugLoader_.prototype.getPathFromDeps_=function(a){return a in this.idToPath_?
this.idToPath_[a]:a in this.dependencies_?a:null},goog.DebugLoader_.prototype.defer_=function(a,b){this.deferredCallbacks_[a.path]=b;this.deferredQueue_.push(a.path)},goog.LoadController=function(){},goog.LoadController.prototype.pause=function(){},goog.LoadController.prototype.resume=function(){},goog.LoadController.prototype.loaded=function(){},goog.LoadController.prototype.pending=function(){},goog.LoadController.prototype.registerEs6ModuleExports=function(a,b,c){},goog.LoadController.prototype.setModuleState=
function(a){},goog.LoadController.prototype.clearModuleState=function(){},goog.LoadController.prototype.defer=function(a){},goog.LoadController.prototype.areDepsLoaded=function(){},goog.Dependency=function(a,b,c,d,e){this.path=a;this.relativePath=b;this.provides=c;this.requires=d;this.loadFlags=e;this.loaded_=!1;this.loadCallbacks_=[]},goog.Dependency.prototype.getPathName=function(){var a=this.path,b=a.indexOf("://");0<=b&&(a=a.substring(b+3),b=a.indexOf("/"),0<=b&&(a=a.substring(b+1)));return a},
goog.Dependency.prototype.onLoad=function(a){this.loaded_?a():this.loadCallbacks_.push(a)},goog.Dependency.prototype.loaded=function(){this.loaded_=!0;var a=this.loadCallbacks_;this.loadCallbacks_=[];for(var b=0;b<a.length;b++)a[b]()},goog.Dependency.defer_=!1,goog.Dependency.callbackMap_={},goog.Dependency.registerCallback_=function(a){var b=Math.random().toString(32);goog.Dependency.callbackMap_[b]=a;return b},goog.Dependency.unregisterCallback_=function(a){delete goog.Dependency.callbackMap_[a]},
goog.Dependency.callback_=function(a,b){if(a in goog.Dependency.callbackMap_){for(var c=goog.Dependency.callbackMap_[a],d=[],e=1;e<arguments.length;e++)d.push(arguments[e]);c.apply(void 0,d)}else throw Error("Callback key "+a+" does not exist (was base.js loaded more than once?).");},goog.Dependency.prototype.load=function(a){if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var b=goog.global.document;if("complete"==
b.readyState&&!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING){if(/\bdeps.js$/.test(this.path)){a.loaded();return}throw Error('Cannot write "'+this.path+'" after document load');}var c=goog.getScriptNonce_();if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&goog.isDocumentLoading_()){var d=function(h){h.readyState&&"complete"!=h.readyState?h.onload=d:(goog.Dependency.unregisterCallback_(e),a.loaded())};var e=goog.Dependency.registerCallback_(d);c=c?' nonce="'+c+'"':"";var f='<script src="'+this.path+'"'+
c+(goog.Dependency.defer_?" defer":"")+' id="script-'+e+'">\x3c/script>';f+="<script"+c+">";f=goog.Dependency.defer_?f+("document.getElementById('script-"+e+"').onload = function() {\n  goog.Dependency.callback_('"+e+"', this);\n};\n"):f+("goog.Dependency.callback_('"+e+"', document.getElementById('script-"+e+"'));");f+="\x3c/script>";b.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(f):f)}else{var g=b.createElement("script");g.defer=goog.Dependency.defer_;g.async=!1;c&&(g.nonce=
c);g.onload=function(){g.onload=null;a.loaded()};g.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path):this.path;b.head.appendChild(g)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."),a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,
b,c,d,e)},goog.inherits(goog.Es6ModuleDependency,goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(l,m){var n="",p=goog.getScriptNonce_();p&&(n=' nonce="'+p+'"');l=m?'<script type="module" crossorigin'+n+">"+m+"\x3c/script>":'<script type="module" crossorigin src="'+l+'"'+n+">\x3c/script>";d.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(l):l)}function c(l,m){var n=d.createElement("script");n.defer=!0;n.async=!1;n.type="module";n.setAttribute("crossorigin",
!0);var p=goog.getScriptNonce_();p&&(n.nonce=p);m?n.text=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScript(m):m:n.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(l):l;d.head.appendChild(n)}if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var d=goog.global.document,e=this;if(goog.isDocumentLoading_()){var f=b;goog.Dependency.defer_=!0}else f=c;var g=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(g);
a.setModuleState(goog.ModuleType.ES6)});f(void 0,'goog.Dependency.callback_("'+g+'")');f(this.path,void 0);var h=goog.Dependency.registerCallback_(function(l){goog.Dependency.unregisterCallback_(h);a.registerEs6ModuleExports(e.path,l,goog.moduleLoaderState_.moduleName)});f(void 0,'import * as m from "'+this.path+'"; goog.Dependency.callback_("'+h+'", m)');var k=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(k);a.clearModuleState();a.loaded()});f(void 0,'goog.Dependency.callback_("'+
k+'")')}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),a.pause()},goog.TransformedDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e);this.contents_=null;this.lazyFetch_=!goog.inHtmlDocument_()||!("noModule"in goog.global.document.createElement("script"))},goog.inherits(goog.TransformedDependency,goog.Dependency),goog.TransformedDependency.prototype.load=function(a){function b(){e.contents_=goog.loadFileSync_(e.path);e.contents_&&(e.contents_=
e.transform(e.contents_),e.contents_&&(e.contents_+="\n//# sourceURL="+e.path))}function c(){e.lazyFetch_&&b();if(e.contents_){f&&a.setModuleState(goog.ModuleType.ES6);try{var l=e.contents_;e.contents_=null;goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(l));if(f)var m=goog.moduleLoaderState_.moduleName}finally{f&&a.clearModuleState()}f&&goog.global.$jscomp.require.ensure([e.getPathName()],function(){a.registerEs6ModuleExports(e.path,goog.global.$jscomp.require(e.getPathName()),m)});a.loaded()}}
function d(){var l=goog.global.document,m=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(m);c()}),n=goog.getScriptNonce_();n="<script"+(n?' nonce="'+n+'"':"")+">"+goog.protectScriptTag_('goog.Dependency.callback_("'+m+'");')+"\x3c/script>";l.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(n):n)}var e=this;if(goog.global.CLOSURE_IMPORT_SCRIPT)b(),this.contents_&&goog.global.CLOSURE_IMPORT_SCRIPT("",this.contents_)?(this.contents_=null,a.loaded()):
a.pause();else{var f=this.loadFlags.module==goog.ModuleType.ES6;this.lazyFetch_||b();var g=1<a.pending().length;if(goog.Dependency.defer_&&(g||goog.isDocumentLoading_()))a.defer(function(){c()});else{var h=goog.global.document;g=goog.inHtmlDocument_()&&("ActiveXObject"in goog.global||goog.isEdge_());if(f&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()&&!g){goog.Dependency.defer_=!0;a.pause();var k=h.onreadystatechange;h.onreadystatechange=function(){"interactive"==h.readyState&&(h.onreadystatechange=
k,c(),a.resume());"function"===typeof k&&k.apply(void 0,arguments)}}else goog.inHtmlDocument_()&&goog.isDocumentLoading_()?d():c()}}},goog.TransformedDependency.prototype.transform=function(a){},goog.PreTranspiledEs6ModuleDependency=function(a,b,c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.PreTranspiledEs6ModuleDependency,goog.TransformedDependency),goog.PreTranspiledEs6ModuleDependency.prototype.transform=function(a){return a},goog.GoogModuleDependency=function(a,b,
c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.GoogModuleDependency,goog.TransformedDependency),goog.GoogModuleDependency.prototype.transform=function(a){return goog.LOAD_MODULE_USING_EVAL&&void 0!==goog.global.JSON?"goog.loadModule("+goog.global.JSON.stringify(a+"\n//# sourceURL="+this.path+"\n")+");":'goog.loadModule(function(exports) {"use strict";'+a+"\n;return exports});\n//# sourceURL="+this.path+"\n"},goog.DebugLoader_.prototype.addDependency=function(a,b,c,d){b=
b||[];a=a.replace(/\\/g,"/");var e=goog.normalizePath_(goog.basePath+a);d&&"boolean"!==typeof d||(d=d?{module:goog.ModuleType.GOOG}:{});c=this.factory_.createDependency(e,a,b,c,d);this.dependencies_[e]=c;for(c=0;c<b.length;c++)this.idToPath_[b[c]]=e;this.idToPath_[a]=e},goog.DependencyFactory=function(){},goog.DependencyFactory.prototype.createDependency=function(a,b,c,d,e){return e.module==goog.ModuleType.GOOG?new goog.GoogModuleDependency(a,b,c,d,e):e.module==goog.ModuleType.ES6?goog.ASSUME_ES_MODULES_TRANSPILED?
new goog.PreTranspiledEs6ModuleDependency(a,b,c,d,e):new goog.Es6ModuleDependency(a,b,c,d,e):new goog.Dependency(a,b,c,d,e)},goog.debugLoader_=new goog.DebugLoader_,goog.loadClosureDeps=function(){goog.debugLoader_.loadClosureDeps()},goog.setDependencyFactory=function(a){goog.debugLoader_.setDependencyFactory(a)},goog.TRUSTED_TYPES_POLICY_=goog.TRUSTED_TYPES_POLICY_NAME?goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME+"#base"):null,goog.global.CLOSURE_NO_DEPS||goog.debugLoader_.loadClosureDeps(),
goog.bootstrap=function(a,b){goog.debugLoader_.bootstrap(a,b)});if(!COMPILED){var isChrome87=!1;try{isChrome87=eval(goog.global.trustedTypes.emptyScript)!==goog.global.trustedTypes.emptyScript}catch(a){}goog.CLOSURE_EVAL_PREFILTER_=goog.global.trustedTypes&&isChrome87&&goog.createTrustedTypesPolicy("goog#base#devonly#eval")||{createScript:goog.identity_}};const proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.proxy"),createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.endpoint"),releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.releaseProxy"),throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs=Symbol("Comlink.thrown"),isObject$$module$node_modules$comlink$dist$esm$comlink_mjs=a=>"object"===typeof a&&null!==a||"function"===typeof a,proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs=
{canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs],serialize(a){const {port1:b,port2:c}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b);return[c,[c]]},deserialize(a){a.start();return wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a)}},throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs={canHandle:a=>isObject$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&
throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs in a,serialize({value:a}){return[a instanceof Error?{isError:!0,value:{message:a.message,name:a.name,stack:a.stack}}:{isError:!1,value:a},[]]},deserialize(a){if(a.isError)throw Object.assign(Error(a.value.message),a.value);throw a.value;}},transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs=new Map([["proxy",proxyTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs],["throw",throwTransferHandler$$module$node_modules$comlink$dist$esm$comlink_mjs]]);
function expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self){b.addEventListener("message",function e(d){if(d&&d.data){var {id:f,type:g,path:h}=Object.assign({path:[]},d.data),k=(d.data.argumentList||[]).map(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);try{const m=h.slice(0,-1).reduce((p,q)=>p[q],a),n=h.reduce((p,q)=>p[q],a);switch(g){case "GET":var l=n;break;case "SET":m[h.slice(-1)[0]]=fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(d.data.value);
l=!0;break;case "APPLY":l=n.apply(m,k);break;case "CONSTRUCT":const p=new n(...k);l=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(p);break;case "ENDPOINT":const {port1:q,port2:u}=new MessageChannel;expose$$module$node_modules$comlink$dist$esm$comlink_mjs(a,u);l=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(q,[q]);break;case "RELEASE":l=void 0;break;default:return}}catch(m){l={value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0}}Promise.resolve(l).catch(m=>
({value:m,[throwMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:0})).then(m=>{const [n,p]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(m);b.postMessage(Object.assign(Object.assign({},n),{id:f}),p);"RELEASE"===g&&(b.removeEventListener("message",e),closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(b))})}});b.start&&b.start()}function isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return"MessagePort"===a.constructor.name}
function closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a){isMessagePort$$module$node_modules$comlink$dist$esm$comlink_mjs(a)&&a.close()}function wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[],b)}function throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(a){if(a)throw Error("Proxy has been released and is not useable");}
function createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=[],c=function(){}){let d=!1;const e=new Proxy(c,{get(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);if(g===releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs)return()=>requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"RELEASE",path:b.map(h=>h.toString())}).then(()=>{closeEndPoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a);d=!0});if("then"===
g){if(0===b.length)return{then:()=>e};f=requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"GET",path:b.map(h=>h.toString())}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return f.then.bind(f)}return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,[...b,g])},set(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [k,l]=toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
{type:"SET",path:[...b,g].map(m=>m.toString()),value:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},apply(f,g,h){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);f=b[b.length-1];if(f===createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs)return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"ENDPOINT"}).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);if("bind"===f)return createProxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
b.slice(0,-1));const [k,l]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(h);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,{type:"APPLY",path:b.map(m=>m.toString()),argumentList:k},l).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)},construct(f,g){throwIfProxyReleased$$module$node_modules$comlink$dist$esm$comlink_mjs(d);const [h,k]=processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(g);return requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,
{type:"CONSTRUCT",path:b.map(l=>l.toString()),argumentList:h},k).then(fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs)}});return e}function myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Array.prototype.concat.apply([],a)}
function processArguments$$module$node_modules$comlink$dist$esm$comlink_mjs(a){a=a.map(toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs);return[a.map(b=>b[0]),myFlat$$module$node_modules$comlink$dist$esm$comlink_mjs(a.map(b=>b[1]))]}const transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs=new WeakMap;function transfer$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b){transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.set(a,b);return a}
function proxy$$module$node_modules$comlink$dist$esm$comlink_mjs(a){return Object.assign(a,{[proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs]:!0})}function windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b=self,c="*"){return{postMessage:(d,e)=>a.postMessage(d,c,e),addEventListener:b.addEventListener.bind(b),removeEventListener:b.removeEventListener.bind(b)}}
function toWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){for(const [b,c]of transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs)if(c.canHandle(a)){const [d,e]=c.serialize(a);return[{type:"HANDLER",name:b,value:d},e]}return[{type:"RAW",value:a},transferCache$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a)||[]]}
function fromWireValue$$module$node_modules$comlink$dist$esm$comlink_mjs(a){switch(a.type){case "HANDLER":return transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs.get(a.name).deserialize(a.value);case "RAW":return a.value}}
function requestResponseMessage$$module$node_modules$comlink$dist$esm$comlink_mjs(a,b,c){return new Promise(d=>{const e=generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs();a.addEventListener("message",function h(g){g.data&&g.data.id&&g.data.id===e&&(a.removeEventListener("message",h),d(g.data))});a.start&&a.start();a.postMessage(Object.assign({id:e},b),c)})}
function generateUUID$$module$node_modules$comlink$dist$esm$comlink_mjs(){return Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}var module$node_modules$comlink$dist$esm$comlink_mjs={};module$node_modules$comlink$dist$esm$comlink_mjs.createEndpoint=createEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.expose=expose$$module$node_modules$comlink$dist$esm$comlink_mjs;
module$node_modules$comlink$dist$esm$comlink_mjs.proxy=proxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.proxyMarker=proxyMarker$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.releaseProxy=releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.transfer=transfer$$module$node_modules$comlink$dist$esm$comlink_mjs;
module$node_modules$comlink$dist$esm$comlink_mjs.transferHandlers=transferHandlers$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.windowEndpoint=windowEndpoint$$module$node_modules$comlink$dist$esm$comlink_mjs;module$node_modules$comlink$dist$esm$comlink_mjs.wrap=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs;function MessagePortState$$module$src$utils$message_port_state(){}MessagePortState$$module$src$utils$message_port_state.prototype.ready=!1;MessagePortState$$module$src$utils$message_port_state.prototype.port=void 0;MessagePortState$$module$src$utils$message_port_state.prototype.post=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.broadcastPlayState=()=>{};MessagePortState$$module$src$utils$message_port_state.prototype.workerState=void 0;
MessagePortState$$module$src$utils$message_port_state.prototype.vanillaWorkerState=void 0;var $jscompDefaultExport$$module$src$utils$message_port_state=MessagePortState$$module$src$utils$message_port_state,module$src$utils$message_port_state={};module$src$utils$message_port_state.MessagePortState=MessagePortState$$module$src$utils$message_port_state;module$src$utils$message_port_state.default=$jscompDefaultExport$$module$src$utils$message_port_state;const csoundCreate$$module$src$modules$instantiation=a=>()=>a.exports.csoundCreateWasi();csoundCreate$$module$src$modules$instantiation.toString=()=>"create = async () => undefined;";const csoundDestroy$$module$src$modules$instantiation=a=>b=>a.exports.csoundDestroy(b);csoundDestroy$$module$src$modules$instantiation.toString=()=>"destroy = async () => undefined;";const csoundGetAPIVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetAPIVersion();
csoundGetAPIVersion$$module$src$modules$instantiation.toString=()=>"getAPIVersion = async () => Number;";const csoundGetVersion$$module$src$modules$instantiation=a=>()=>a.exports.csoundGetVersion();csoundGetVersion$$module$src$modules$instantiation.toString=()=>"getVersion = async () => Number;";const csoundInitialize$$module$src$modules$instantiation=a=>(b,c)=>a.exports.csoundInitialize(c);csoundInitialize$$module$src$modules$instantiation.toString=()=>"initialize = async () => Number;";
var module$src$modules$instantiation={};module$src$modules$instantiation.csoundCreate=csoundCreate$$module$src$modules$instantiation;module$src$modules$instantiation.csoundDestroy=csoundDestroy$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetAPIVersion=csoundGetAPIVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundGetVersion=csoundGetVersion$$module$src$modules$instantiation;module$src$modules$instantiation.csoundInitialize=csoundInitialize$$module$src$modules$instantiation;const WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders=1;function TextEncoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";return this}TextEncoderPoly$$module$src$utils$text_encoders.prototype.encode=function(a){if("string"!==typeof a)throw new TypeError("passed argument must be of type string "+a+" "+typeof a);a=unescape(encodeURIComponent(a));const b=new Uint8Array(a.length);[...a].forEach(function(c,d){b[d]=c.codePointAt(0)});return b};
function TextDecoderPoly$$module$src$utils$text_encoders(){this.encoding="utf8";this.ignoreBOM=!1;this.trimNull=a=>{const b=a.indexOf("\x00");return-1<b?a.slice(0,Math.max(0,b)):a};this.decode=function(a,b){if(void 0===a)return"";if("boolean"!==typeof(void 0!==b&&"stream"in b?b.stream:!1))throw new TypeError("stream option must be boolean");if(ArrayBuffer.isView(a)){a=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);const c=Array.from({length:a.length});a.forEach(function(d,e){c[e]=String.fromCodePoint(d)});
return this.trimNull(c.join(""))}throw new TypeError("passed argument must be an array buffer view");}}
const decoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextDecoderPoly$$module$src$utils$text_encoders:new TextDecoder("utf8"),encoder$$module$src$utils$text_encoders=WITH_TEXT_ENCODER_POLYFILL$$module$src$utils$text_encoders?new TextEncoderPoly$$module$src$utils$text_encoders:new TextEncoder("utf8"),uint2String$$module$src$utils$text_encoders=a=>decoder$$module$src$utils$text_encoders.decode(a);var module$src$utils$text_encoders={};
module$src$utils$text_encoders.decoder=decoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.encoder=encoder$$module$src$utils$text_encoders;module$src$utils$text_encoders.uint2String=uint2String$$module$src$utils$text_encoders;const trimNull$$module$src$utils$trim_null=a=>{const b=a.indexOf("\x00");return-1<b?a.substr(0,b):a};var module$src$utils$trim_null={};module$src$utils$trim_null.trimNull=trimNull$$module$src$utils$trim_null;const freeStringPtr$$module$src$utils$string_pointers=(a,b)=>{a.exports.freeStringMem(b)},ptr2string$$module$src$utils$string_pointers=(a,b)=>{({buffer:a}=a.wasi.memory);b=new Uint8Array(a,b);b=uint2String$$module$src$utils$text_encoders(b);return trimNull$$module$src$utils$trim_null(b)},string2ptr$$module$src$utils$string_pointers=(a,b)=>{if("string"!==typeof b)console.error("Expected string but got",typeof b);else{b=encoder$$module$src$utils$text_encoders.encode(b);var c=a.exports.allocStringMem(b.length);
({buffer:a}=a.wasi.memory);(new Uint8Array(a,c,b.length+1)).set(b);return c}};var module$src$utils$string_pointers={};module$src$utils$string_pointers.freeStringPtr=freeStringPtr$$module$src$utils$string_pointers;module$src$utils$string_pointers.ptr2string=ptr2string$$module$src$utils$string_pointers;module$src$utils$string_pointers.string2ptr=string2ptr$$module$src$utils$string_pointers;const csoundParseOrc$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundParseOrc(b,c);csoundParseOrc$$module$src$modules$performance.toString=()=>"parseOrc = async (orchestra) => Object;";const csoundCompileTree$$module$src$modules$performance=a=>(b,c)=>a.exports.csoundCompileTree(b,c);csoundCompileTree$$module$src$modules$performance.toString=()=>"compileTree = async (tree) => Number;";
const csoundCompileOrc$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileOrc(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileOrc$$module$src$modules$performance.toString=()=>"compileOrc = async (orchestra) => Number;";
const csoundEvalCode$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundEvalCode(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundEvalCode$$module$src$modules$performance.toString=()=>"csoundEvalCode = async (orchestra) => Number;";const csoundStart$$module$src$modules$performance=a=>b=>a.exports.csoundStartWasi(b);csoundStart$$module$src$modules$performance.toString=()=>"start = async () => Number;";
const csoundCompileCsd$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);let d;try{d=a.exports.csoundCompileCsd(b,c)}catch(e){console.error(e)}freeStringPtr$$module$src$utils$string_pointers(a,c);return d};csoundCompileCsd$$module$src$modules$performance.toString=()=>"compileCsd = async (path) => Number;";
const csoundCompileCsdText$$module$src$modules$performance=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundCompileCsdText(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundCompileCsdText$$module$src$modules$performance.toString=()=>"compileCsdText = async (csoundDocument) => Number;";const csoundPerform$$module$src$modules$performance=a=>b=>a.exports.csoundPerform(b);csoundPerform$$module$src$modules$performance.toString=()=>"perform = async () => Number;";
const csoundPerformKsmps$$module$src$modules$performance=a=>b=>a.exports.csoundPerformKsmpsWasi(b);csoundPerformKsmps$$module$src$modules$performance.toString=()=>"performKsmps = async (csound) => Number;";const csoundPerformBuffer$$module$src$modules$performance=a=>b=>a.exports.csoundPerformBuffer(b);csoundPerformBuffer$$module$src$modules$performance.toString=()=>"performBuffer = async (csound) => Number;";const csoundStop$$module$src$modules$performance=a=>b=>a.exports.csoundStop(b);
csoundStop$$module$src$modules$performance.toString=()=>"stop = async () => undefined;";const csoundCleanup$$module$src$modules$performance=a=>b=>a.exports.csoundCleanup(b);csoundCleanup$$module$src$modules$performance.toString=()=>"cleanup = async () => Number;";const csoundReset$$module$src$modules$performance=a=>b=>a.exports.csoundResetWasi(b);csoundReset$$module$src$modules$performance.toString=()=>"reset = async () => Number;";var module$src$modules$performance={};
module$src$modules$performance.csoundCleanup=csoundCleanup$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsd=csoundCompileCsd$$module$src$modules$performance;module$src$modules$performance.csoundCompileCsdText=csoundCompileCsdText$$module$src$modules$performance;module$src$modules$performance.csoundCompileOrc=csoundCompileOrc$$module$src$modules$performance;module$src$modules$performance.csoundCompileTree=csoundCompileTree$$module$src$modules$performance;
module$src$modules$performance.csoundEvalCode=csoundEvalCode$$module$src$modules$performance;module$src$modules$performance.csoundParseOrc=csoundParseOrc$$module$src$modules$performance;module$src$modules$performance.csoundPerform=csoundPerform$$module$src$modules$performance;module$src$modules$performance.csoundPerformBuffer=csoundPerformBuffer$$module$src$modules$performance;module$src$modules$performance.csoundPerformKsmps=csoundPerformKsmps$$module$src$modules$performance;
module$src$modules$performance.csoundReset=csoundReset$$module$src$modules$performance;module$src$modules$performance.csoundStart=csoundStart$$module$src$modules$performance;module$src$modules$performance.csoundStop=csoundStop$$module$src$modules$performance;const sizeOfPrimitive$$module$src$utils$native_sizes={int:4,MYFLT:4,char:1},sizeofStruct$$module$src$utils$native_sizes=a=>a.reduce((b,[,c,...d])=>b+("char"===c?sizeOfPrimitive$$module$src$utils$native_sizes[c]*d[0]:sizeOfPrimitive$$module$src$utils$native_sizes[c]),0);var module$src$utils$native_sizes={};module$src$utils$native_sizes.sizeOfPrimitive=sizeOfPrimitive$$module$src$utils$native_sizes;module$src$utils$native_sizes.sizeofStruct=sizeofStruct$$module$src$utils$native_sizes;const structBufferToObject$$module$src$utils$structure_buffer_to_object=(a,b)=>{[a]=a.reduce(([c,d],[e,f,...g])=>{g="char"===f?sizeOfPrimitive$$module$src$utils$native_sizes[f]*g[0]:sizeOfPrimitive$$module$src$utils$native_sizes[f];f="char"===f?trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(b.subarray(d,g)))||"":b[d];c[e]=f;return[c,d+g]},[{},0]);return a};var module$src$utils$structure_buffer_to_object={};
module$src$utils$structure_buffer_to_object.structBufferToObject=structBufferToObject$$module$src$utils$structure_buffer_to_object;const CSOUND_PARAMS$$module$src$structures=[["debug_mode","int"],["buffer_frames","int"],["hardware_buffer_frames","int"],["displays","int"],["ascii_graphs","int"],["postscript_graphs","int"],["message_level","int"],["tempo","int"],["ring_bell","int"],["use_cscore","int"],["terminate_on_midi","int"],["heartbeat","int"],["defer_gen01_load","int"],["midi_key","int"],["midi_key_cps","int"],["midi_key_oct","int"],["midi_key_pch","int"],["midi_velocity","int"],["midi_velocity_amp","int"],["no_default_paths",
"int"],["number_of_threads","int"],["syntax_check_only","int"],["csd_line_counts","int"],["compute_weights","int"],["realtime_mode","int"],["sample_accurate","int"],["sample_rate_override","MYFLT"],["control_rate_override","MYFLT"],["nchnls_override","int"],["nchnls_i_override","int"],["e0dbfs_override","MYFLT"],["daemon","int"],["ksmps_override","int"],["FFT_library","int"]],CS_MIDIDEVICE$$module$src$structures=[["device_name","char",64],["interface_name","char",64],["device_id","char",64],["midi_module",
"char",64],["isOutput","int"]];var module$src$structures={};const csoundGetSr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSr(b);csoundGetSr$$module$src$modules$attributes.toString=()=>"getSr = async () => Number;";const csoundGetKr$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKr(b);csoundGetKr$$module$src$modules$attributes.toString=()=>"getKr = async () => Number;";const csoundGetKsmps$$module$src$modules$attributes=a=>b=>a.exports.csoundGetKsmps(b);csoundGetKsmps$$module$src$modules$attributes.toString=()=>"getKsmps = async () => Number;";
const csoundGetNchnls$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnls(b);csoundGetNchnls$$module$src$modules$attributes.toString=()=>"getNchnls = async () => Number;";const csoundGetNchnlsInput$$module$src$modules$attributes=a=>b=>a.exports.csoundGetNchnlsInput(b);csoundGetNchnlsInput$$module$src$modules$attributes.toString=()=>"getNchnlsInput = async () => Number;";const csoundGet0dBFS$$module$src$modules$attributes=a=>b=>a.exports.csoundGet0dBFS(b);
csoundGet0dBFS$$module$src$modules$attributes.toString=()=>"get0dBFS = async () => Number;";const csoundGetA4$$module$src$modules$attributes=a=>b=>a.exports.csoundGetA4(b);csoundGetA4$$module$src$modules$attributes.toString=()=>"getA4 = async () => Number;";const csoundGetCurrentTimeSamples$$module$src$modules$attributes=a=>b=>a.exports.csoundGetCurrentTimeSamples(b);csoundGetCurrentTimeSamples$$module$src$modules$attributes.toString=()=>"getCurrentTimeSamples = async () => Number;";
const csoundGetSizeOfMYFLT$$module$src$modules$attributes=a=>b=>a.exports.csoundGetSizeOfMYFLT(b);csoundGetSizeOfMYFLT$$module$src$modules$attributes.toString=()=>"getSizeOfMYFLT = async () => Number;";const csoundSetOption$$module$src$modules$attributes=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundSetOption(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundSetOption$$module$src$modules$attributes.toString=()=>"setOption = async (option) => Number;";
const csoundSetParams$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetParams(b,c)};csoundSetParams$$module$src$modules$attributes.toString=()=>"setParams = async (csoundParams) => undefined;";
const csoundGetParams$$module$src$modules$attributes=a=>b=>{var {buffer:c}=a.wasi.memory;const d=sizeofStruct$$module$src$utils$native_sizes(CSOUND_PARAMS$$module$src$structures),e=a.exports.allocCsoundParamsStruct();c=new Uint8Array(c,e,d);a.exports.csoundGetParams(b,e);b=structBufferToObject$$module$src$utils$structure_buffer_to_object(CSOUND_PARAMS$$module$src$structures,c);a.exports.freeCsoundParams(e);return b};csoundGetParams$$module$src$modules$attributes.toString=()=>"getParams = async () => CSOUND_PARAMS;";
const csoundGetDebug$$module$src$modules$attributes=a=>b=>a.exports.csoundGetDebug(b);csoundGetDebug$$module$src$modules$attributes.toString=()=>"getDebug = async () => Number;";const csoundSetDebug$$module$src$modules$attributes=a=>(b,c)=>{a.exports.csoundSetDebug(b,c)};csoundSetDebug$$module$src$modules$attributes.toString=()=>"setDebug = async (number) => undefined;";var module$src$modules$attributes={};module$src$modules$attributes.csoundGet0dBFS=csoundGet0dBFS$$module$src$modules$attributes;
module$src$modules$attributes.csoundGetA4=csoundGetA4$$module$src$modules$attributes;module$src$modules$attributes.csoundGetCurrentTimeSamples=csoundGetCurrentTimeSamples$$module$src$modules$attributes;module$src$modules$attributes.csoundGetDebug=csoundGetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKr=csoundGetKr$$module$src$modules$attributes;module$src$modules$attributes.csoundGetKsmps=csoundGetKsmps$$module$src$modules$attributes;
module$src$modules$attributes.csoundGetNchnls=csoundGetNchnls$$module$src$modules$attributes;module$src$modules$attributes.csoundGetNchnlsInput=csoundGetNchnlsInput$$module$src$modules$attributes;module$src$modules$attributes.csoundGetParams=csoundGetParams$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSizeOfMYFLT=csoundGetSizeOfMYFLT$$module$src$modules$attributes;module$src$modules$attributes.csoundGetSr=csoundGetSr$$module$src$modules$attributes;
module$src$modules$attributes.csoundSetDebug=csoundSetDebug$$module$src$modules$attributes;module$src$modules$attributes.csoundSetOption=csoundSetOption$$module$src$modules$attributes;module$src$modules$attributes.csoundSetParams=csoundSetParams$$module$src$modules$attributes;const csoundGetInputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBufferSize(b);csoundGetInputBufferSize$$module$src$modules$rtaudio.toString=()=>"getInputBufferSize = async () => Number;";const csoundGetOutputBufferSize$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBufferSize(b);csoundGetOutputBufferSize$$module$src$modules$rtaudio.toString=()=>"getOutputBufferSize = async () => Number;";const csoundGetInputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetInputBuffer(b);
csoundGetInputBuffer$$module$src$modules$rtaudio.toString=()=>"getInputBuffer = async () => Number;";const csoundGetOutputBuffer$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetOutputBuffer(b);csoundGetOutputBuffer$$module$src$modules$rtaudio.toString=()=>"getOutputBuffer = async () => Number;";const csoundGetSpin$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpin(b);csoundGetSpin$$module$src$modules$rtaudio.toString=()=>"getSpin = async (csound) => Number;";
const csoundGetSpout$$module$src$modules$rtaudio=a=>b=>a.exports.csoundGetSpout(b);csoundGetSpout$$module$src$modules$rtaudio.toString=()=>"getSpout = async () => Number;";var module$src$modules$rtaudio={};module$src$modules$rtaudio.csoundGetInputBuffer=csoundGetInputBuffer$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetInputBufferSize=csoundGetInputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetOutputBuffer=csoundGetOutputBuffer$$module$src$modules$rtaudio;
module$src$modules$rtaudio.csoundGetOutputBufferSize=csoundGetOutputBufferSize$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpin=csoundGetSpin$$module$src$modules$rtaudio;module$src$modules$rtaudio.csoundGetSpout=csoundGetSpout$$module$src$modules$rtaudio;function add$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>add$$module$node_modules$rambda$dist$rambda_mjs(a,c):Number(a)+Number(b)}const cloneList$$module$node_modules$rambda$dist$rambda_mjs=a=>Array.prototype.slice.call(a);function curry$$module$node_modules$rambda$dist$rambda_mjs(a,b=[]){return(...c)=>{c=[...b,...c];return c.length>=a.length?a(...c):curry$$module$node_modules$rambda$dist$rambda_mjs(a,c)}}
function adjustFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d=0>a?c.length+a:a;if(a>=c.length||0>d)return c;a=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);a[d]=b(a[d]);return a}const adjust$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(adjustFn$$module$node_modules$rambda$dist$rambda_mjs);
function all$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>all$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(!a(b[c]))return!1;return!0}function allPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(!a[c](...b))return!1;c++}return!0}}function always$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>a}
function and$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>and$$module$node_modules$rambda$dist$rambda_mjs(a,c):a&&b}function any$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>any$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=0;for(;c<b.length;){if(a(b[c],c))return!0;c++}return!1}
function anyPass$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{let c=0;for(;c<a.length;){if(a[c](...b))return!0;c++}return!1}}function append$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>append$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.split("").concat(a);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);c.push(a);return c}
function apply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>apply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.apply(this,b)}const {isArray:isArray$$module$node_modules$rambda$dist$rambda_mjs}=Array;
function __findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a,b=0){for(const c in a)!1!==a.hasOwnProperty(c)&&"constructor"!==c&&("object"===typeof a[c]&&(b=Math.max(b,__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a[c]))),"function"===typeof a[c]&&(b=Math.max(b,a[c].length)));return b}
function __filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(){const a=[];let b=0;const c=arguments.length;for(;b<c&&"undefined"!==typeof arguments[b];)a[b]=arguments[b],b++;return a}
function __applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){var d=b-c.length;if(1===d)return f=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f));if(2===d)return(f,g)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g));if(3===d)return(f,g,h)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,
b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h));if(4===d)return(f,g,h,k)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,f,g,h,k));if(4<d)return(...f)=>__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,b,__filterUndefined$$module$node_modules$rambda$dist$rambda_mjs(...c,...f));if(isArray$$module$node_modules$rambda$dist$rambda_mjs(a)){var e=[];d=0;const f=a.length;
for(;d<f;d++){if("object"===typeof a[d]||isArray$$module$node_modules$rambda$dist$rambda_mjs(a[d]))e[d]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[d],b,c);"function"===typeof a[d]&&(e[d]=a[d](...c))}return e}d={};for(e in a)!1!==a.hasOwnProperty(e)&&"constructor"!==e&&("object"===typeof a[e]?d[e]=__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a[e],b,c):"function"===typeof a[e]&&(d[e]=a[e](...c)));return d}
function applySpec$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs(a);return 0===c?()=>({}):__applySpecWithArity$$module$node_modules$rambda$dist$rambda_mjs(a,c,b)}function assocFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return Object.assign({},c,{[a]:b})}const assoc$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocFn$$module$node_modules$rambda$dist$rambda_mjs);
function _isInteger$$module$node_modules$rambda$dist$rambda_mjs(a){return a<<0===a}const isInteger$$module$node_modules$rambda$dist$rambda_mjs=Number.isInteger||_isInteger$$module$node_modules$rambda$dist$rambda_mjs;
function assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d="string"===typeof a?a.split(".").map(e=>isInteger$$module$node_modules$rambda$dist$rambda_mjs(Number(e))?Number(e):e):a;if(0===d.length)return b;a=d[0];if(1<d.length){const e="object"===typeof c&&null!==c&&c.hasOwnProperty(a)?c[a]:isInteger$$module$node_modules$rambda$dist$rambda_mjs(d[1])?[]:{};b=assocPathFn$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(d,1),b,e)}return isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)&&
isArray$$module$node_modules$rambda$dist$rambda_mjs(c)?(c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c),c[a]=b,c):assoc$$module$node_modules$rambda$dist$rambda_mjs(a,b,c)}const assocPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(assocPathFn$$module$node_modules$rambda$dist$rambda_mjs);
function _curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return function(){var d=0;let e=0;const f=b.length,g=arguments.length,h=Array(f+g);for(;d<f;)h[d]=b[d],d++;for(;e<g;)h[f+e]=arguments[e],e++;d=a-h.length;return h.length>=a?c.apply(this,h):_arity$1$$module$node_modules$rambda$dist$rambda_mjs(d,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,h,c))}}
function _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};
case 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,m){return b.apply(this,arguments)};default:return function(c,d,e,f,g,h,k,l,m,n){return b.apply(this,arguments)}}}
function curryN$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>curryN$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(10<a)throw Error("First argument to _arity must be a non-negative integer no greater than ten");return _arity$1$$module$node_modules$rambda$dist$rambda_mjs(a,_curryN$$module$node_modules$rambda$dist$rambda_mjs(a,[],b))}
function bind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>bind$$module$node_modules$rambda$dist$rambda_mjs(a,c):curryN$$module$node_modules$rambda$dist$rambda_mjs(a.length,(...c)=>a.apply(b,c))}function both$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>both$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>a(...c)&&b(...c)}
function chain$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>chain$$module$node_modules$rambda$dist$rambda_mjs(a,c):[].concat(...b.map(a))}function clampFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(a>b)throw Error("min must not be greater than max in clamp(min, max, value)");if(c>=a&&c<=b)return c;if(c>b)return b;if(c<a)return a}const clamp$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(clampFn$$module$node_modules$rambda$dist$rambda_mjs);
function clone$$module$node_modules$rambda$dist$rambda_mjs(a){const b=isArray$$module$node_modules$rambda$dist$rambda_mjs(a)?Array(a.length):{};if(a&&a.getTime)return new Date(a.getTime());for(const c in a){const d=a[c];b[c]="object"===typeof d&&null!==d?d.getTime?new Date(d.getTime()):clone$$module$node_modules$rambda$dist$rambda_mjs(d):d}return b}function complement$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>!a(...b)}
class ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs{constructor(a){this.value=a}}function reduceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(c))throw new TypeError("reduce: list must be array or iterable");let d=0;const e=c.length;for(;d<e;){b=a(b,c[d],d,c);if(b instanceof ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs)return b.value;d++}return b}
const reduce$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(reduceFn$$module$node_modules$rambda$dist$rambda_mjs),reduceStopper$$module$node_modules$rambda$dist$rambda_mjs=a=>new ReduceStopper$$module$node_modules$rambda$dist$rambda_mjs(a);
function _arity$$module$node_modules$rambda$dist$rambda_mjs(a,b){switch(a){case 0:return function(){return b.apply(this,arguments)};case 1:return function(c){return b.apply(this,arguments)};case 2:return function(c,d){return b.apply(this,arguments)};case 3:return function(c,d,e){return b.apply(this,arguments)};case 4:return function(c,d,e,f){return b.apply(this,arguments)};case 5:return function(c,d,e,f,g){return b.apply(this,arguments)};case 6:return function(c,d,e,f,g,h){return b.apply(this,arguments)};
case 7:return function(c,d,e,f,g,h,k){return b.apply(this,arguments)};case 8:return function(c,d,e,f,g,h,k,l){return b.apply(this,arguments)};case 9:return function(c,d,e,f,g,h,k,l,m){return b.apply(this,arguments)};case 10:return function(c,d,e,f,g,h,k,l,m,n){return b.apply(this,arguments)};default:throw Error("First argument to _arity must be a non-negative integer no greater than ten");}}
function _pipe$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(){return b.call(this,a.apply(this,arguments))}}
function pipe$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("pipe requires at least one argument");return _arity$$module$node_modules$rambda$dist$rambda_mjs(arguments[0].length,reduceFn$$module$node_modules$rambda$dist$rambda_mjs(_pipe$$module$node_modules$rambda$dist$rambda_mjs,arguments[0],Array.prototype.slice.call(arguments,1,Infinity)))}
function compose$$module$node_modules$rambda$dist$rambda_mjs(){if(0===arguments.length)throw Error("compose requires at least one argument");return pipe$$module$node_modules$rambda$dist$rambda_mjs.apply(this,Array.prototype.slice.call(arguments,0).reverse())}function concat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>concat$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof a?`${a}${b}`:[...a,...b]}
function cond$$module$node_modules$rambda$dist$rambda_mjs(a){return b=>{let c=!1,d;a.forEach(([e,f])=>{!c&&e(b)&&(c=!0,d=f(b))});return d}}const {keys:keys$1$$module$node_modules$rambda$dist$rambda_mjs}=Object;function mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=Array(b.length);for(;d<b.length;)e[d]=c?a(b[d],d):a(b[d]),d++;return e}
function mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,g);let c=0;const d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b),e=d.length,f={};for(;c<e;){const g=d[c];f[g]=a(b[g],g,b);c++}return f}const mapObjIndexed$$module$node_modules$rambda$dist$rambda_mjs=mapObject$$module$node_modules$rambda$dist$rambda_mjs;
function map$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>map$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error(INCORRECT_ITERABLE_INPUT);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?mapArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):mapObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}
function max$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>max$$module$node_modules$rambda$dist$rambda_mjs(a,c):b>a?b:a}
function converge$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>converge$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=reduce$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>max$$module$node_modules$rambda$dist$rambda_mjs(d,e.length),0,b);return curryN$$module$node_modules$rambda$dist$rambda_mjs(c,function(){return a.apply(this,map$$module$node_modules$rambda$dist$rambda_mjs(d=>d.apply(this,arguments),b))})}
function count$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>count$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?b.filter(c=>a(c)).length:0}function countBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>countBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};b.forEach(d=>{d=a(d);c[d]?c[d]++:c[d]=1});return c}
const dec$$module$node_modules$rambda$dist$rambda_mjs=a=>a-1;function isFalsy$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a||!0===Number.isNaN(a)}function defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c):isFalsy$$module$node_modules$rambda$dist$rambda_mjs(b)?a:b}
function type$$module$node_modules$rambda$dist$rambda_mjs(a){if(null===a)return"Null";if(void 0===a)return"Undefined";if(Number.isNaN(a))return"NaN";a=Object.prototype.toString.call(a).slice(8,-1);return"AsyncFunction"===a?"Promise":a}
function _lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property 'indexOf' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.lastIndexOf(a);({length:c}=b);let d=-1;for(;-1<--c&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}
function _indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`Cannot read property 'indexOf' of ${b}`);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(!["Object","Array","NaN","RegExp"].includes(c))return b.indexOf(a);let d=c=-1;const {length:e}=b;for(;++c<e&&-1===d;)equals$$module$node_modules$rambda$dist$rambda_mjs(b[c],a)&&(d=c);return d}
function _arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a){const b=[];let c;for(;!(c=a.next()).done;)b.push(c.value);return b}function _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(a.size!==b.size)return!1;a=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(a.values());const c=_arrayFromIterator$$module$node_modules$rambda$dist$rambda_mjs(b.values());return 0===a.filter(d=>-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,c)).length}
function parseError$$module$node_modules$rambda$dist$rambda_mjs(a){const b=a.__proto__.toString();return["Error","TypeError"].includes(b)?[b,a.message]:[]}function parseDate$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toDateString?[!0,a.getTime()]:[!1]}function parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a){return a.constructor!==RegExp?[!1]:[!0,a.toString()]}
function equals$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>equals$$module$node_modules$rambda$dist$rambda_mjs(a,f);var c=type$$module$node_modules$rambda$dist$rambda_mjs(a);if(c!==type$$module$node_modules$rambda$dist$rambda_mjs(b))return!1;if("Function"===c)return void 0===a.name?!1:a.name===b.name;if(["NaN","Undefined","Null"].includes(c))return!0;if("Number"===c)return Object.is(-0,a)!==Object.is(-0,b)?!1:a.toString()===b.toString();if(["String","Boolean"].includes(c))return a.toString()===
b.toString();if("Array"===c){c=Array.from(a);const f=Array.from(b);if(c.toString()!==f.toString())return!1;let g=!0;c.forEach((h,k)=>{g&&(h===f[k]||equals$$module$node_modules$rambda$dist$rambda_mjs(h,f[k])||(g=!1))});return g}var d=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(a),e=parseRegex$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseDate$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseDate$$module$node_modules$rambda$dist$rambda_mjs(b);
if(d[0])return e[0]?d[1]===e[1]:!1;if(e[0])return!1;d=parseError$$module$node_modules$rambda$dist$rambda_mjs(a);e=parseError$$module$node_modules$rambda$dist$rambda_mjs(b);if(d[0])return e[0]?d[0]===e[0]&&d[1]===e[1]:!1;if("Set"===c)return _equalsSets$$module$node_modules$rambda$dist$rambda_mjs(a,b);if("Object"===c){c=Object.keys(a);if(c.length!==Object.keys(b).length)return!1;let f=!0;c.forEach(g=>{if(f){const h=a[g];g=b[g];h===g||equals$$module$node_modules$rambda$dist$rambda_mjs(h,g)||(f=!1)}});
return f}return!1}function includes$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>includes$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof b)return b.includes(a);if(!b)throw new TypeError(`Cannot read property \'indexOf\' of ${b}`);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b):!1}
class _Set$$module$node_modules$rambda$dist$rambda_mjs{constructor(){this.set=new Set;this.items={}}checkUniqueness(a){var b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Null","Undefined","NaN"].includes(b)?b in this.items?!1:this.items[b]=!0:["Object","Array"].includes(b)?b in this.items?-1===_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,this.items[b])?(this.items[b].push(a),!0):!1:(this.items[b]=[a],!0):(b=this.set.size,this.set.add(a),this.set.size!==b)}}
function uniq$$module$node_modules$rambda$dist$rambda_mjs(a){const b=new _Set$$module$node_modules$rambda$dist$rambda_mjs,c=[];a.forEach(d=>{b.checkUniqueness(d)&&c.push(d)});return c}function difference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>difference$$module$node_modules$rambda$dist$rambda_mjs(a,c):uniq$$module$node_modules$rambda$dist$rambda_mjs(a).filter(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b))}
function dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dissoc$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(null===b||void 0===b)return{};const c={};for(const d in b)c[d]=b[d];delete c[a];return c}function divide$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>divide$$module$node_modules$rambda$dist$rambda_mjs(a,c):a/b}
function drop$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>drop$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.slice(0<a?a:0)}function dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>dropLast$$module$node_modules$rambda$dist$rambda_mjs(a,c):0<a?b.slice(0,-a):b.slice()}
function dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(0===b.length)return b;const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if("function"!==typeof a)throw Error(`'predicate' is from wrong type ${typeof a}`);if(!c&&"string"!==typeof b)throw Error(`'iterable' is from wrong type ${typeof b}`);let d=!1;const e=[];let f=b.length;for(;0<f;)f--,d||!1!==a(b[f])?d&&e.push(b[f]):
(d=!0,e.push(b[f]));return c?e.reverse():e.reverse().join("")}function dropRepeats$$module$node_modules$rambda$dist$rambda_mjs(a){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`${a} is not a list`);const b=[];a.reduce((c,d)=>{equals$$module$node_modules$rambda$dist$rambda_mjs(c,d)||b.push(d);return d},void 0);return b}
function dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw Error(`${b} is not a list`);const c=[];b.reduce((d,e)=>{if(void 0===d)return c.push(e),e;a(d,e)||c.push(e);return e},void 0);return c}
function dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>dropWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!1;const e=[];let f=-1;for(;f++<b.length-1;)d?e.push(b[f]):a(b[f])||(d||(d=!0),e.push(b[f]));return c?e:e.join("")}
function either$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>either$$module$node_modules$rambda$dist$rambda_mjs(a,c):(...c)=>!(!a(...c)&&!b(...c))}
function endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>endsWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);if("string"===typeof b)return b.endsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;const c=b.length-a.length;let d=!0;return a.filter((e,f)=>{if(!d)return!1;(e=equals$$module$node_modules$rambda$dist$rambda_mjs(e,b[f+c]))||(d=!1);return e}).length===a.length}
function prop$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>prop$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(b)return b[a]}function eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a,b),prop$$module$node_modules$rambda$dist$rambda_mjs(a,c))}const eqProps$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(eqPropsFn$$module$node_modules$rambda$dist$rambda_mjs);
function evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapArray$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c,b,!0)}
function evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return mapObject$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>{if("Object"===type$$module$node_modules$rambda$dist$rambda_mjs(c)){const e=type$$module$node_modules$rambda$dist$rambda_mjs(a[d]);return"Function"===e?a[d](c):"Object"===e?evolve$$module$node_modules$rambda$dist$rambda_mjs(a[d],c):c}return"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?a[d](c):c},b)}
function evolve$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>evolve$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=type$$module$node_modules$rambda$dist$rambda_mjs(a),d=type$$module$node_modules$rambda$dist$rambda_mjs(b);if(d!==c)throw Error("iterableType !== rulesType");if(!["Object","Array"].includes(c))throw Error(`'iterable' and 'rules' are from wrong type ${c}`);return"Object"===d?evolveObject$$module$node_modules$rambda$dist$rambda_mjs(a,b):evolveArray$$module$node_modules$rambda$dist$rambda_mjs(a,
b)}function F$$module$node_modules$rambda$dist$rambda_mjs(){return!1}function filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(const d in b)a(b[d],d,b)&&(c[d]=b[d]);return c}function filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){let d=0;const e=b.length,f=[];for(;d<e;)(c?a(b[d],d):a(b[d]))&&f.push(b[d]),d++;return f}
function filter$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>filter$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!b)throw Error("Incorrect iterable input");return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?filterArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,!1):filterObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}
function find$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>find$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=0;const d=b.length;for(;c<d;){const e=b[c];if(a(e))return e;c++}}function findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>findIndex$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;let d=-1;for(;++d<c;)if(a(b[d]))return d;return-1}
function findLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLast$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return b[c]}function findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>findLastIndex$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=b.length;for(;0<=--c;)if(a(b[c]))return c;return-1}
function flatten$$module$node_modules$rambda$dist$rambda_mjs(a,b){b=void 0===b?[]:b;for(let c=0;c<a.length;c++)isArray$$module$node_modules$rambda$dist$rambda_mjs(a[c])?flatten$$module$node_modules$rambda$dist$rambda_mjs(a[c],b):b.push(a[c]);return b}
function flipFn$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>{if(1===b.length)return c=>a(c,b[0]);if(2===b.length)return a(b[1],b[0]);if(3===b.length)return a(b[1],b[0],b[2]);if(4===b.length)return a(b[1],b[0],b[2],b[3]);throw Error("R.flip doesn't work with arity > 4");}}function flip$$module$node_modules$rambda$dist$rambda_mjs(a){return flipFn$$module$node_modules$rambda$dist$rambda_mjs(a)}
function forEach$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>forEach$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(void 0!==b){if(isArray$$module$node_modules$rambda$dist$rambda_mjs(b))for(var c=0,d=b.length;c<d;)a(b[c]),c++;else{c=0;d=keys$1$$module$node_modules$rambda$dist$rambda_mjs(b);const e=d.length;for(;c<e;){const f=d[c];a(b[f],f,b);c++}}return b}}
function fromPairs$$module$node_modules$rambda$dist$rambda_mjs(a){const b={};a.forEach(([c,d])=>b[c]=d);return b}function groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>groupBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c={};for(let d=0;d<b.length;d++){const e=b[d],f=a(e);c[f]||(c[f]=[]);c[f].push(e)}return c}
function groupWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b))throw new TypeError("list.reduce is not a function");const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(b);if(1===b.length)return[c];const d=[];let e=[];c.reduce((f,g,h)=>{if(0===h)return g;const k=a(f,g),l=0===e.length;h=h===b.length-1;if(k)return l&&e.push(f),e.push(g),h&&d.push(e),g;if(l)return d.push([f]),h&&d.push([g]),g;d.push(e);h&&d.push([g]);e=[];return g},
void 0);return d}function has$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>has$$module$node_modules$rambda$dist$rambda_mjs(a,c):b?b.hasOwnProperty(a):!1}function createPath$$module$node_modules$rambda$dist$rambda_mjs(a,b="."){return"string"===typeof a?a.split(b):a}
function path$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>path$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=b,d=0,e=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);d<e.length;){if(null===c||void 0===c||null===c[e[d]])return;c=c[e[d]];d++}return c}}
function hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>hasPath$$module$node_modules$rambda$dist$rambda_mjs(a,c):void 0!==path$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function head$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[0]||"":a[0]}function _objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b}const objectIs$$module$node_modules$rambda$dist$rambda_mjs=Object.is||_objectIs$$module$node_modules$rambda$dist$rambda_mjs;
function identical$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>identical$$module$node_modules$rambda$dist$rambda_mjs(a,c):objectIs$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function identity$$module$node_modules$rambda$dist$rambda_mjs(a){return a}function ifElseFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return(...d)=>!0===("boolean"===typeof a?a:a(...d))?b(...d):c(...d)}
const ifElse$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(ifElseFn$$module$node_modules$rambda$dist$rambda_mjs),inc$$module$node_modules$rambda$dist$rambda_mjs=a=>a+1;function indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={};for(let d=0;d<b.length;d++){const e=b[d];c[path$$module$node_modules$rambda$dist$rambda_mjs(a,e)]=e}return c}
function indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>indexBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof a)return indexByPath$$module$node_modules$rambda$dist$rambda_mjs(a,b);const c={};for(let d=0;d<b.length;d++){const e=b[d];c[a(e)]=e}return c}
function indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_indexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=-1,{length:e}=a;c=c>e?e:c;0>c&&(c+=e);e=b>c?0:c-b>>>0;b>>>=0;for(c=Array(e);++d<e;)c[d]=a[d+b];return c}
function init$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.slice(0,-1):a.length?baseSlice$$module$node_modules$rambda$dist$rambda_mjs(a,0,-1):[]}function intersection$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>intersection$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b)}
function intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>intersperse$$module$node_modules$rambda$dist$rambda_mjs(a,f);let c=-1;const d=b.length,e=[];for(;++c<d;)c===d-1?e.push(b[c]):e.push(b[c],a);return e}function is$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>is$$module$node_modules$rambda$dist$rambda_mjs(a,c):null!=b&&b.constructor===a||b instanceof a}
function isEmpty$$module$node_modules$rambda$dist$rambda_mjs(a){const b=type$$module$node_modules$rambda$dist$rambda_mjs(a);return["Undefined","NaN","Number","Null"].includes(b)?!1:a?"Object"===b?0===Object.keys(a).length:"Array"===b?0===a.length:!1:!0}function isNil$$module$node_modules$rambda$dist$rambda_mjs(a){return void 0===a||null===a}
function join$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>join$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.join(a)}function juxt$$module$node_modules$rambda$dist$rambda_mjs(a){return(...b)=>a.map(c=>c(...b))}function keys$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.keys(a)}function last$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a[a.length-1]||"":a[a.length-1]}
function lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function length$$module$node_modules$rambda$dist$rambda_mjs(a){return isArray$$module$node_modules$rambda$dist$rambda_mjs(a)||"string"===typeof a?a.length:NaN}
function lens$$module$node_modules$rambda$dist$rambda_mjs(a,b){return function(c){return function(d){return c(a(d)).map(e=>b(e,d))}}}function nth$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>nth$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=0>a?b.length+a:a;return"[object String]"===Object.prototype.toString.call(b)?b.charAt(c):b[c]}
function updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);return-1===a?c.fill(b,a):c.fill(b,a,a+1)}const update$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(updateFn$$module$node_modules$rambda$dist$rambda_mjs);
function lensIndex$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(nth$$module$node_modules$rambda$dist$rambda_mjs(a),update$$module$node_modules$rambda$dist$rambda_mjs(a))}function lensPath$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a),assocPath$$module$node_modules$rambda$dist$rambda_mjs(a))}
function lensProp$$module$node_modules$rambda$dist$rambda_mjs(a){return lens$$module$node_modules$rambda$dist$rambda_mjs(prop$$module$node_modules$rambda$dist$rambda_mjs(a),assoc$$module$node_modules$rambda$dist$rambda_mjs(a))}function match$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>match$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=b.match(a);return null===c?[]:c}
function mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mathMod$$module$node_modules$rambda$dist$rambda_mjs(a,c):!isInteger$$module$node_modules$rambda$dist$rambda_mjs(a)||!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||1>b?NaN:(a%b+b)%b}function maxByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)>a(b)?c:b}const maxBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(maxByFn$$module$node_modules$rambda$dist$rambda_mjs);
function sum$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>b+c,0)}function mean$$module$node_modules$rambda$dist$rambda_mjs(a){return sum$$module$node_modules$rambda$dist$rambda_mjs(a)/a.length}function median$$module$node_modules$rambda$dist$rambda_mjs(a){var b=a.length;if(0===b)return NaN;const c=2-b%2;b=(b-c)/2;return mean$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,0).sort((d,e)=>d===e?0:d<e?-1:1).slice(b,b+c))}
function mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeRight$$module$node_modules$rambda$dist$rambda_mjs(a,c):Object.assign({},a||{},b||{})}function mergeAll$$module$node_modules$rambda$dist$rambda_mjs(a){let b={};map$$module$node_modules$rambda$dist$rambda_mjs(c=>{b=mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,c)},a);return b}
function mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=clone$$module$node_modules$rambda$dist$rambda_mjs(a);Object.keys(b).forEach(d=>{"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(b[d])?"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a[d])?c[d]=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(a[d],b[d]):c[d]=b[d]:c[d]=b[d]});return c}
function mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>mergeLeft$$module$node_modules$rambda$dist$rambda_mjs(a,c):mergeRight$$module$node_modules$rambda$dist$rambda_mjs(b,a)}function mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){const d={};Object.keys(b).forEach(e=>{d[e]=void 0===c[e]?b[e]:a(b[e],c[e])});Object.keys(c).forEach(e=>{void 0===d[e]&&(d[e]=void 0===b[e]?c[e]:a(b[e],c[e]))});return d}
const mergeWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(mergeWithFn$$module$node_modules$rambda$dist$rambda_mjs);function min$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>min$$module$node_modules$rambda$dist$rambda_mjs(a,c):b<a?b:a}function minByFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)<a(b)?c:b}const minBy$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(minByFn$$module$node_modules$rambda$dist$rambda_mjs);
function ownKeys$$module$node_modules$rambda$dist$rambda_mjs(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(e){return Object.getOwnPropertyDescriptor(a,e).enumerable}));c.push.apply(c,d)}return c}
function _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(a){for(var b=1;b<arguments.length;b++){var c=null!=arguments[b]?arguments[b]:{};b%2?ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c),!0).forEach(function(d){_defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,d,c[d])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(c)):ownKeys$$module$node_modules$rambda$dist$rambda_mjs(Object(c)).forEach(function(d){Object.defineProperty(a,
d,Object.getOwnPropertyDescriptor(c,d))})}return a}function _defineProperty$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c;return a}function isIterable$$module$node_modules$rambda$dist$rambda_mjs(a){return Array.isArray(a)||"Object"===type$$module$node_modules$rambda$dist$rambda_mjs(a)}
function modifyFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return isIterable$$module$node_modules$rambda$dist$rambda_mjs(c)&&void 0!==c[a]?isArray$$module$node_modules$rambda$dist$rambda_mjs(c)?updateFn$$module$node_modules$rambda$dist$rambda_mjs(a,b(c[a]),c):_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a]:b(c[a])}):c}const modify$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyFn$$module$node_modules$rambda$dist$rambda_mjs);
function modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){a=createPath$$module$node_modules$rambda$dist$rambda_mjs(a);if(1===a.length)return _objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},c),{},{[a[0]]:b(c[a[0]])});if(void 0===path$$module$node_modules$rambda$dist$rambda_mjs(a,c))return c;b=modifyPath$$module$node_modules$rambda$dist$rambda_mjs(Array.prototype.slice.call(a,1),b,c[a[0]]);return b===c[a[0]]?c:assoc$$module$node_modules$rambda$dist$rambda_mjs(a[0],
b,c)}const modifyPath$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs);function modulo$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>modulo$$module$node_modules$rambda$dist$rambda_mjs(a,c):a%b}
function moveFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){if(0>a||0>b)throw Error("Rambda.move does not support negative indexes");if(a>c.length-1||b>c.length-1)return c;const d=cloneList$$module$node_modules$rambda$dist$rambda_mjs(c);d[a]=c[b];d[b]=c[a];return d}const move$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(moveFn$$module$node_modules$rambda$dist$rambda_mjs);
function multiply$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>multiply$$module$node_modules$rambda$dist$rambda_mjs(a,c):a*b}function negate$$module$node_modules$rambda$dist$rambda_mjs(a){return-a}function none$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>none$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(let c=0;c<b.length;c++)if(a(b[c]))return!1;return!0}
function not$$module$node_modules$rambda$dist$rambda_mjs(a){return!a}function objOf$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>objOf$$module$node_modules$rambda$dist$rambda_mjs(a,c):{[a]:b}}function of$$module$node_modules$rambda$dist$rambda_mjs(a){return[a]}
function omit$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>omit$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(null!==b&&void 0!==b){var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={};for(const e in b)c.includes(e)||(d[e]=b[e]);return d}}
function on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,d){return 3===arguments.length?e=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,c,e):2===arguments.length?(e,f)=>on$$module$node_modules$rambda$dist$rambda_mjs(a,b,e,f):a(b(c),b(d))}function onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b){let c;return function(){a&&(c=a.apply(b||this,arguments),a=null);return c}}
function once$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length){const c=onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b);return curry$$module$node_modules$rambda$dist$rambda_mjs(c)}return onceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b)}function or$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>or$$module$node_modules$rambda$dist$rambda_mjs(a,c):a||b}const Identity$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(a))});
function overFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(d=>Identity$$module$node_modules$rambda$dist$rambda_mjs(b(d)))(c).x}const over$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(overFn$$module$node_modules$rambda$dist$rambda_mjs);
function partial$$module$node_modules$rambda$dist$rambda_mjs(a,...b){const c=a.length;return(...d)=>b.length+d.length>=c?a(...b,...d):partial$$module$node_modules$rambda$dist$rambda_mjs(a,...[...b,...d])}function partialObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return c=>a(mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs(c,b))}
function partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b){const c={},d={};Object.entries(b).forEach(([e,f])=>{a(f,e)?c[e]=f:d[e]=f});return[c,d]}function partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b,c=!1){const d=[],e=[];let f=-1;for(;f++<b.length-1;)(c?a(b[f],f):a(b[f]))?d.push(b[f]):e.push(b[f]);return[d,e]}
function partition$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>partition$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?partitionArray$$module$node_modules$rambda$dist$rambda_mjs(a,b):partitionObject$$module$node_modules$rambda$dist$rambda_mjs(a,b)}
function pathEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return equals$$module$node_modules$rambda$dist$rambda_mjs(path$$module$node_modules$rambda$dist$rambda_mjs(a,c),b)}const pathEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathEqFn$$module$node_modules$rambda$dist$rambda_mjs);
function pathOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,path$$module$node_modules$rambda$dist$rambda_mjs(b,c))}const pathOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(pathOrFn$$module$node_modules$rambda$dist$rambda_mjs);
function paths$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>paths$$module$node_modules$rambda$dist$rambda_mjs(a,c):a.map(c=>path$$module$node_modules$rambda$dist$rambda_mjs(c,b))}
function pick$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pick$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)c[e]in b&&(d[c[e]]=b[c[e]]),e++;return d}}
function pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>pickAll$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(null!==b&&void 0!==b){for(var c=createPath$$module$node_modules$rambda$dist$rambda_mjs(a,","),d={},e=0;e<c.length;)d[c[e]]=c[e]in b?b[c[e]]:void 0,e++;return d}}
function pluck$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>pluck$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=[];map$$module$node_modules$rambda$dist$rambda_mjs(d=>{void 0!==d[a]&&c.push(d[a])},b);return c}function prepend$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>prepend$$module$node_modules$rambda$dist$rambda_mjs(a,c):"string"===typeof b?[a].concat(b.split("")):[a].concat(b)}
const product$$module$node_modules$rambda$dist$rambda_mjs=reduce$$module$node_modules$rambda$dist$rambda_mjs(multiply$$module$node_modules$rambda$dist$rambda_mjs,1);function propEqFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?equals$$module$node_modules$rambda$dist$rambda_mjs(b,prop$$module$node_modules$rambda$dist$rambda_mjs(a,c)):!1}const propEq$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propEqFn$$module$node_modules$rambda$dist$rambda_mjs);
function propIsFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return is$$module$node_modules$rambda$dist$rambda_mjs(a,c[b])}const propIs$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propIsFn$$module$node_modules$rambda$dist$rambda_mjs);function propOrFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c?defaultTo$$module$node_modules$rambda$dist$rambda_mjs(a,c[b]):a}const propOr$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propOrFn$$module$node_modules$rambda$dist$rambda_mjs);
function props$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>props$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error("propsToPick is not a list");return mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>b[c],a)}function propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(prop$$module$node_modules$rambda$dist$rambda_mjs(b,c))}
const propSatisfies$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(propSatisfiesFn$$module$node_modules$rambda$dist$rambda_mjs);
function range$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>range$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(Number.isNaN(Number(a))||Number.isNaN(Number(b)))throw new TypeError("Both arguments to range must be numbers");if(b<a)return[];const c=b-a,d=Array(c);for(let e=0;e<c;e++)d[e]=a+e;return d}
function reject$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>reject$$module$node_modules$rambda$dist$rambda_mjs(a,c):filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!a(c),b)}function repeat$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>repeat$$module$node_modules$rambda$dist$rambda_mjs(a,c):Array(b).fill(a)}function replaceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.replace(a,b)}
const replace$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(replaceFn$$module$node_modules$rambda$dist$rambda_mjs);function reverse$$module$node_modules$rambda$dist$rambda_mjs(a){return"string"===typeof a?a.split("").reverse().join(""):a.slice().reverse()}function setFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return over$$module$node_modules$rambda$dist$rambda_mjs(a,always$$module$node_modules$rambda$dist$rambda_mjs(b),c)}
const set$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(setFn$$module$node_modules$rambda$dist$rambda_mjs);function sliceFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return c.slice(a,b)}const slice$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(sliceFn$$module$node_modules$rambda$dist$rambda_mjs);
function sort$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sort$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort(a)}function sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>sortBy$$module$node_modules$rambda$dist$rambda_mjs(a,c):cloneList$$module$node_modules$rambda$dist$rambda_mjs(b).sort((c,d)=>{c=a(c);d=a(d);return c===d?0:c<d?-1:1})}
function split$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>split$$module$node_modules$rambda$dist$rambda_mjs(a,c):b.split(a)}function maybe$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){b=a&&"Function"===type$$module$node_modules$rambda$dist$rambda_mjs(b)?b():b;c=a||"Function"!==type$$module$node_modules$rambda$dist$rambda_mjs(c)?c:c();return a?b:c}
function take$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>take$$module$node_modules$rambda$dist$rambda_mjs(a,c):0>a?b.slice():"string"===typeof b?b.slice(0,a):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,0,a)}
function splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>splitAt$$module$node_modules$rambda$dist$rambda_mjs(a,d);if(!b)throw new TypeError(`Cannot read property 'slice' of ${b}`);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(b)&&"string"!==typeof b)return[[],[]];const c=maybe$$module$node_modules$rambda$dist$rambda_mjs(0>a,0>b.length+a?0:b.length+a,a);return[take$$module$node_modules$rambda$dist$rambda_mjs(c,b),drop$$module$node_modules$rambda$dist$rambda_mjs(c,
b)]}function splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>splitEvery$$module$node_modules$rambda$dist$rambda_mjs(a,e);if(1>a)throw Error("First argument to splitEvery must be a positive integer");const c=[];let d=0;for(;d<b.length;)c.push(b.slice(d,d+=a));return c}
function splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>splitWhen$$module$node_modules$rambda$dist$rambda_mjs(a,g);if(!b)throw new TypeError(`Cannot read property 'length' of ${b}`);const c=[],d=[];let e=!1,f=-1;for(;f++<b.length-1;)e?d.push(b[f]):a(b[f])?(d.push(b[f]),e=!0):c.push(b[f]);return[c,d]}
function startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>startsWith$$module$node_modules$rambda$dist$rambda_mjs(a,d);if("string"===typeof b)return b.startsWith(a);if(!isArray$$module$node_modules$rambda$dist$rambda_mjs(a))return!1;let c=!0;return a.filter((d,e)=>{if(!c)return!1;(d=equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]))||(c=!1);return d}).length===a.length}
function subtract$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>subtract$$module$node_modules$rambda$dist$rambda_mjs(a,c):a-b}
function symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs(a,c):concat$$module$node_modules$rambda$dist$rambda_mjs(filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,b),a),filter$$module$node_modules$rambda$dist$rambda_mjs(c=>!includes$$module$node_modules$rambda$dist$rambda_mjs(c,a),b))}
function T$$module$node_modules$rambda$dist$rambda_mjs(){return!0}function tail$$module$node_modules$rambda$dist$rambda_mjs(a){return drop$$module$node_modules$rambda$dist$rambda_mjs(1,a)}
function takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>takeLast$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=b.length;if(0>a)return b.slice();let d=a>c?c:a;return"string"===typeof b?b.slice(c-d):baseSlice$$module$node_modules$rambda$dist$rambda_mjs(b,c-d,c)}
function takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return f=>takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs(a,f);if(0===b.length)return b;let c=!1;const d=[];let e=b.length;for(;!c||0===e;)e--,!1===a(b[e])?c=!0:c||d.push(b[e]);return isArray$$module$node_modules$rambda$dist$rambda_mjs(b)?d.reverse():d.reverse().join("")}
function takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return g=>takeWhile$$module$node_modules$rambda$dist$rambda_mjs(a,g);const c=isArray$$module$node_modules$rambda$dist$rambda_mjs(b);if(!c&&"string"!==typeof b)throw Error("`iterable` is neither list nor a string");let d=!0;const e=[];let f=-1;for(;f++<b.length-1;)a(b[f])?d&&e.push(b[f]):d&&(d=!1);return c?e:e.join("")}
function tap$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>tap$$module$node_modules$rambda$dist$rambda_mjs(a,c);a(b);return b}function test$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>test$$module$node_modules$rambda$dist$rambda_mjs(a,c);if("string"===typeof a)throw new TypeError(`\u2018test\u2019 requires a value of type RegExp as its first argument; received "${a}"`);return-1!==b.search(a)}
function times$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return c=>times$$module$node_modules$rambda$dist$rambda_mjs(a,c);if(!isInteger$$module$node_modules$rambda$dist$rambda_mjs(b)||0>b)throw new RangeError("n must be an integer");return map$$module$node_modules$rambda$dist$rambda_mjs(a,range$$module$node_modules$rambda$dist$rambda_mjs(0,b))}function toLower$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toLowerCase()}
function toPairs$$module$node_modules$rambda$dist$rambda_mjs(a){return Object.entries(a)}function toString$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toString()}function toUpper$$module$node_modules$rambda$dist$rambda_mjs(a){return a.toUpperCase()}function transpose$$module$node_modules$rambda$dist$rambda_mjs(a){return a.reduce((b,c)=>{c.forEach((d,e)=>isArray$$module$node_modules$rambda$dist$rambda_mjs(b[e])?b[e].push(d):b.push([d]));return b},[])}
function trim$$module$node_modules$rambda$dist$rambda_mjs(a){return a.trim()}const isFunction$$module$node_modules$rambda$dist$rambda_mjs=a=>["Promise","Function"].includes(type$$module$node_modules$rambda$dist$rambda_mjs(a));
function tryCatch$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(!isFunction$$module$node_modules$rambda$dist$rambda_mjs(a))throw Error(`R.tryCatch | fn '${a}'`);const c=isFunction$$module$node_modules$rambda$dist$rambda_mjs(b);return(...d)=>{try{return a(...d)}catch(e){return c?b(e,...d):b}}}function unapply$$module$node_modules$rambda$dist$rambda_mjs(a){return function(...b){return a.call(this,b)}}
function union$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>union$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=cloneList$$module$node_modules$rambda$dist$rambda_mjs(a);b.forEach(d=>{includes$$module$node_modules$rambda$dist$rambda_mjs(d,a)||c.push(d)});return c}
function uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>uniqBy$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=new Set;return b.filter(d=>{if(c.has(a(d)))return!1;c.add(a(d));return!0})}function includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){let d=!1,e=-1;for(;++e<c.length&&!d;)a(b,c[e])&&(d=!0);return d}
function uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>uniqWith$$module$node_modules$rambda$dist$rambda_mjs(a,e);let c=-1;const d=[];for(;++c<b.length;){const e=b[c];includesWith$$module$node_modules$rambda$dist$rambda_mjs(a,e,d)||d.push(e)}return d}function unless$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unless$$module$node_modules$rambda$dist$rambda_mjs(a,c):c=>a(c)?c:b(c)}
function unwind$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>unwind$$module$node_modules$rambda$dist$rambda_mjs(a,c):isArray$$module$node_modules$rambda$dist$rambda_mjs(b[a])?mapArray$$module$node_modules$rambda$dist$rambda_mjs(c=>_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs(_objectSpread2$$module$node_modules$rambda$dist$rambda_mjs({},b),{},{[a]:c}),b[a]):[b]}
function values$$module$node_modules$rambda$dist$rambda_mjs(a){return"Object"!==type$$module$node_modules$rambda$dist$rambda_mjs(a)?[]:Object.values(a)}const Const$$module$node_modules$rambda$dist$rambda_mjs=a=>({x:a,map:b=>Const$$module$node_modules$rambda$dist$rambda_mjs(a)});function view$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>view$$module$node_modules$rambda$dist$rambda_mjs(a,c):a(Const$$module$node_modules$rambda$dist$rambda_mjs)(b).x}
function whenFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return a(c)?b(c):c}const when$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(whenFn$$module$node_modules$rambda$dist$rambda_mjs);function where$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return d=>where$$module$node_modules$rambda$dist$rambda_mjs(a,d);let c=!0;for(const d in a){if(!c)continue;const e=a[d](b[d]);c&&!1===e&&(c=!1)}return c}
function whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(void 0===b)return c=>whereAny$$module$node_modules$rambda$dist$rambda_mjs(a,c);for(const c in a)if(a[c](b[c]))return!0;return!1}
function whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return d=>whereEq$$module$node_modules$rambda$dist$rambda_mjs(a,d);const c=filter$$module$node_modules$rambda$dist$rambda_mjs((d,e)=>equals$$module$node_modules$rambda$dist$rambda_mjs(d,b[e]),a);return Object.keys(c).length===Object.keys(a).length}
function without$$module$node_modules$rambda$dist$rambda_mjs(a,b){return void 0===b?c=>without$$module$node_modules$rambda$dist$rambda_mjs(a,c):reduce$$module$node_modules$rambda$dist$rambda_mjs((c,d)=>-1<_indexOf$$module$node_modules$rambda$dist$rambda_mjs(d,a)?c:c.concat(d),[],b)}function xor$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>xor$$module$node_modules$rambda$dist$rambda_mjs(a,c):!!a&&!b||!!b&&!a}
function zip$$module$node_modules$rambda$dist$rambda_mjs(a,b){if(1===arguments.length)return e=>zip$$module$node_modules$rambda$dist$rambda_mjs(a,e);const c=[],d=Math.min(a.length,b.length);for(let e=0;e<d;e++)c[e]=[a[e],b[e]];return c}function zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,b){return 1===arguments.length?c=>zipObj$$module$node_modules$rambda$dist$rambda_mjs(a,c):take$$module$node_modules$rambda$dist$rambda_mjs(b.length,a).reduce((c,d,e)=>{c[d]=b[e];return c},{})}
function zipWithFn$$module$node_modules$rambda$dist$rambda_mjs(a,b,c){return take$$module$node_modules$rambda$dist$rambda_mjs(b.length>c.length?c.length:b.length,b).map((d,e)=>a(d,c[e]))}const zipWith$$module$node_modules$rambda$dist$rambda_mjs=curry$$module$node_modules$rambda$dist$rambda_mjs(zipWithFn$$module$node_modules$rambda$dist$rambda_mjs);var module$node_modules$rambda$dist$rambda_mjs={};module$node_modules$rambda$dist$rambda_mjs.F=F$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.T=T$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.__findHighestArity=__findHighestArity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._arity=_arity$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._indexOf=_indexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs._lastIndexOf=_lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs._pipe=_pipe$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.add=add$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.adjust=adjust$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.all=all$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.allPass=allPass$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.always=always$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.and=and$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.any=any$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.anyPass=anyPass$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.append=append$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.apply=apply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.applySpec=applySpec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assoc=assoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.assocPath=assocPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.bind=bind$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.both=both$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.chain=chain$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clamp=clamp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.clone=clone$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.complement=complement$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.compose=compose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.concat=concat$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.cond=cond$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.converge=converge$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.count=count$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.countBy=countBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curry=curry$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.curryN=curryN$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dec=dec$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.defaultTo=defaultTo$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.difference=difference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dissoc=dissoc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.divide=divide$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.drop=drop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropLast=dropLast$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.dropLastWhile=dropLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeats=dropRepeats$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropRepeatsWith=dropRepeatsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.dropWhile=dropWhile$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.either=either$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.endsWith=endsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.eqProps=eqProps$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.equals=equals$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolve=evolve$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.evolveArray=evolveArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.evolveObject=evolveObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filter=filter$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterArray=filterArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.filterObject=filterObject$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.find=find$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findIndex=findIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLast=findLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.findLastIndex=findLastIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.flatten=flatten$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.flip=flip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.forEach=forEach$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.fromPairs=fromPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupBy=groupBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.groupWith=groupWith$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.has=has$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.hasPath=hasPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.head=head$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identical=identical$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.identity=identity$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.ifElse=ifElse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.inc=inc$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.includes=includes$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexBy=indexBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.indexOf=indexOf$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.init=init$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersection=intersection$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.intersperse=intersperse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.is=is$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.isEmpty=isEmpty$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.isNil=isNil$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.join=join$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.juxt=juxt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.keys=keys$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.last=last$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.lastIndexOf=lastIndexOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.length=length$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lens=lens$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensIndex=lensIndex$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.lensPath=lensPath$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.lensProp=lensProp$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.map=map$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapArray=mapArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObjIndexed=mapObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mapObject=mapObject$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.match=match$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mathMod=mathMod$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.max=max$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxBy=maxBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.maxByFn=maxByFn$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.mean=mean$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.median=median$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.merge=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeAll=mergeAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeDeepRight=mergeDeepRight$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.mergeLeft=mergeLeft$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeRight=mergeRight$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.mergeWith=mergeWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.min=min$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.minBy=minBy$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.minByFn=minByFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modify=modify$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPath=modifyPath$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modifyPathFn=modifyPathFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.modulo=modulo$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.move=move$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.multiply=multiply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.negate=negate$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.none=none$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.not=not$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.nth=nth$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.objOf=objOf$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.of=of$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.omit=omit$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.on=on$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.once=once$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.or=or$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.over=over$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partial=partial$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partialObject=partialObject$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.partition=partition$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionArray=partitionArray$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.partitionObject=partitionObject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.path=path$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pathEq=pathEq$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.pathOr=pathOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.paths=paths$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pick=pick$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pickAll=pickAll$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.pipe=pipe$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.pluck=pluck$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prepend=prepend$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.product=product$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.prop=prop$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propEq=propEq$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.propIs=propIs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propOr=propOr$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.propSatisfies=propSatisfies$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.props=props$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.range=range$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.reduce=reduce$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceFn=reduceFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reduceStopper=reduceStopper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reject=reject$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.repeat=repeat$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.replace=replace$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.reverse=reverse$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.set=set$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.slice=slice$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sort=sort$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.sortBy=sortBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.split=split$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitAt=splitAt$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitEvery=splitEvery$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.splitWhen=splitWhen$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.startsWith=startsWith$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.subtract=subtract$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.sum=sum$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.symmetricDifference=symmetricDifference$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tail=tail$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.take=take$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLast=takeLast$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeLastWhile=takeLastWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.takeWhile=takeWhile$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tap=tap$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.test=test$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.times=times$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toLower=toLower$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toPairs=toPairs$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.toString=toString$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.toUpper=toUpper$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.transpose=transpose$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.trim=trim$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.tryCatch=tryCatch$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.type=type$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.unapply=unapply$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.union=union$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniq=uniq$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqBy=uniqBy$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.uniqWith=uniqWith$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.unless=unless$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.unwind=unwind$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.update=update$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.updateFn=updateFn$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.values=values$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.view=view$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.when=when$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.where=where$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereAny=whereAny$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.whereEq=whereEq$$module$node_modules$rambda$dist$rambda_mjs;
module$node_modules$rambda$dist$rambda_mjs.without=without$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.xor=xor$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zip=zip$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipObj=zipObj$$module$node_modules$rambda$dist$rambda_mjs;module$node_modules$rambda$dist$rambda_mjs.zipWith=zipWith$$module$node_modules$rambda$dist$rambda_mjs;const csoundSetMidiCallbacks$$module$src$modules$rtmidi=a=>b=>{a.exports.csoundSetMidiCallbacks(b)},csoundGetMIDIDevList$$module$src$modules$rtmidi=a=>(b,c)=>{const {buffer:d}=a.wasi.memory,e=a.exports.csoundGetMIDIDevList(b,void 0,c?1:0);if(0===e)return[];const f=sizeofStruct$$module$src$utils$native_sizes(CS_MIDIDEVICE$$module$src$structures),g=a.exports.allocCsMidiDeviceStruct(e);a.exports.csoundGetMIDIDevList(b,g,c?1:0);const h=new Uint8Array(d,g,f*e);b=range$$module$node_modules$rambda$dist$rambda_mjs(0,
e).map(k=>structBufferToObject$$module$src$utils$structure_buffer_to_object(CS_MIDIDEVICE$$module$src$structures,h.subarray(k*f,f)));a.exports.freeCsMidiDeviceStruct(g);return b};csoundGetMIDIDevList$$module$src$modules$rtmidi.toString=()=>"getMIDIDevList = async (isOutput) => Object;";
const csoundGetRtMidiName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getRtMidiName(b);c=new Uint8Array(c,b,128);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetRtMidiName$$module$src$modules$rtmidi.toString=()=>"getRtMidiName = async () => String;";
const csoundGetMidiOutFileName$$module$src$modules$rtmidi=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.getMidiOutFileName(b);c=new Uint8Array(c,b,128);b&&0<b.length&&freeStringPtr$$module$src$utils$string_pointers(a,b);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""},_isRequestingRtMidiInput$$module$src$modules$rtmidi=a=>b=>a.exports.isRequestingRtMidiInput(b),csoundPushMidiMessage$$module$src$modules$rtmidi=a=>(b,c,d,e)=>{a.exports.pushMidiMessage(b,
c,d,e)};csoundPushMidiMessage$$module$src$modules$rtmidi.toString=()=>"midiMessage = async (status, data1, data2) => undefined;";var module$src$modules$rtmidi={};module$src$modules$rtmidi._isRequestingRtMidiInput=_isRequestingRtMidiInput$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMIDIDevList=csoundGetMIDIDevList$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundGetMidiOutFileName=csoundGetMidiOutFileName$$module$src$modules$rtmidi;
module$src$modules$rtmidi.csoundGetRtMidiName=csoundGetRtMidiName$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundPushMidiMessage=csoundPushMidiMessage$$module$src$modules$rtmidi;module$src$modules$rtmidi.csoundSetMidiCallbacks=csoundSetMidiCallbacks$$module$src$modules$rtmidi;const csoundInputMessage$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessage(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessage$$module$src$modules$control_events.toString=()=>"inputMessage = async (scoreEvent) => Number;";
const csoundInputMessageAsync$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundInputMessageAsync(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundInputMessageAsync$$module$src$modules$control_events.toString=()=>"inputMessageAsync = async (scoreEvent) => Number;";
const csoundGetControlChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetControlChannelWasi(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundGetControlChannel$$module$src$modules$control_events.toString=()=>"getControlChannel = async (channelName) => Number;";
const csoundSetControlChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);a.exports.csoundSetControlChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c)};csoundSetControlChannel$$module$src$modules$control_events.toString=()=>"setControlChannel = async (channelName, value) => void;";
const csoundGetStringChannel$$module$src$modules$control_events=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundGetStringChannelWasi(b,c);const d=ptr2string$$module$src$utils$string_pointers(a,b);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,b);return d};csoundGetStringChannel$$module$src$modules$control_events.toString=()=>"getStringChannel = async (channelName) => String;";
const csoundSetStringChannel$$module$src$modules$control_events=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);a.exports.csoundSetStringChannel(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d)};csoundSetStringChannel$$module$src$modules$control_events.toString=()=>"setStringChannel = async (channelName, value) => void;";var module$src$modules$control_events={};
module$src$modules$control_events.csoundGetControlChannel=csoundGetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundGetStringChannel=csoundGetStringChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessage=csoundInputMessage$$module$src$modules$control_events;module$src$modules$control_events.csoundInputMessageAsync=csoundInputMessageAsync$$module$src$modules$control_events;
module$src$modules$control_events.csoundSetControlChannel=csoundSetControlChannel$$module$src$modules$control_events;module$src$modules$control_events.csoundSetStringChannel=csoundSetStringChannel$$module$src$modules$control_events;const csoundGetOutputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetOutputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetOutputName$$module$src$modules$general_io.toString=()=>"getOutputName = async () => String;";
const csoundGetInputName$$module$src$modules$general_io=a=>b=>{var {buffer:c}=a.wasi.memory;b=a.exports.csoundGetInputName(b);c=new Uint8Array(c,b,64);return trimNull$$module$src$utils$trim_null(uint2String$$module$src$utils$text_encoders(c))||""};csoundGetInputName$$module$src$modules$general_io.toString=()=>"getInputName = async (csound) => String;";var module$src$modules$general_io={};module$src$modules$general_io.csoundGetInputName=csoundGetInputName$$module$src$modules$general_io;
module$src$modules$general_io.csoundGetOutputName=csoundGetOutputName$$module$src$modules$general_io;const csoundAppendEnv$$module$src$modules$extra=a=>(b,c,d)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);d=string2ptr$$module$src$utils$string_pointers(a,d);b=a.exports.csoundAppendEnv(b,c,d);freeStringPtr$$module$src$utils$string_pointers(a,c);freeStringPtr$$module$src$utils$string_pointers(a,d);return b};csoundAppendEnv$$module$src$modules$extra.toString=()=>"appendEnv = async (csound, variable, value) => Number;";const csoundShouldDaemonize$$module$src$modules$extra=a=>b=>a.exports.csoundShouldDaemonize(b);
var module$src$modules$extra={};module$src$modules$extra.csoundAppendEnv=csoundAppendEnv$$module$src$modules$extra;module$src$modules$extra.csoundShouldDaemonize=csoundShouldDaemonize$$module$src$modules$extra;const csoundIsScorePending$$module$src$modules$score_handling=a=>b=>a.exports.csoundIsScorePending(b);csoundIsScorePending$$module$src$modules$score_handling.toString=()=>"isScorePending = async () => Number;";const csoundSetScorePending$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScorePending(b,c);csoundSetScorePending$$module$src$modules$score_handling.toString=()=>"setScorePending = async (pending) => Number;";
const csoundReadScore$$module$src$modules$score_handling=a=>(b,c)=>{c=string2ptr$$module$src$utils$string_pointers(a,c);b=a.exports.csoundReadScore(b,c);freeStringPtr$$module$src$utils$string_pointers(a,c);return b};csoundReadScore$$module$src$modules$score_handling.toString=()=>"readScore = async (score) => Number;";const csoundGetScoreTime$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreTime(b);csoundGetScoreTime$$module$src$modules$score_handling.toString=()=>"getScoreTime = async () => Number;";
const csoundGetScoreOffsetSeconds$$module$src$modules$score_handling=a=>b=>a.exports.csoundGetScoreOffsetSeconds(b);csoundGetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"getScoreOffsetSeconds = async () => Number;";const csoundSetScoreOffsetSeconds$$module$src$modules$score_handling=a=>(b,c)=>a.exports.csoundSetScoreOffsetSeconds(b,c);csoundSetScoreOffsetSeconds$$module$src$modules$score_handling.toString=()=>"setScoreOffsetSeconds = async () => Number;";
const csoundRewindScore$$module$src$modules$score_handling=a=>b=>a.exports.csoundRewindScore(b);csoundRewindScore$$module$src$modules$score_handling.toString=()=>"rewindScore = async () => undefined;";var module$src$modules$score_handling={};module$src$modules$score_handling.csoundGetScoreOffsetSeconds=csoundGetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundGetScoreTime=csoundGetScoreTime$$module$src$modules$score_handling;
module$src$modules$score_handling.csoundIsScorePending=csoundIsScorePending$$module$src$modules$score_handling;module$src$modules$score_handling.csoundReadScore=csoundReadScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundRewindScore=csoundRewindScore$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScoreOffsetSeconds=csoundSetScoreOffsetSeconds$$module$src$modules$score_handling;module$src$modules$score_handling.csoundSetScorePending=csoundSetScorePending$$module$src$modules$score_handling;const csoundTableLength$$module$src$modules$table=a=>(b,c)=>a.exports.csoundTableLength(b,c);csoundTableLength$$module$src$modules$table.toString=()=>"tableLength = async (tableNum) => Number;";const csoundTableGet$$module$src$modules$table=a=>(b,c,d)=>a.exports.csoundTableGet(b,c,d);csoundTableGet$$module$src$modules$table.toString=()=>"tableGet = async (tableNum, tableIndex) => Number;";const csoundTableSet$$module$src$modules$table=a=>(b,c,d,e)=>a.exports.csoundTableSet(b,c,d,e);
csoundTableSet$$module$src$modules$table.toString=()=>"tableSet = async (tableNum, tableIndex, value) => undefined;";const csoundTableCopyIn$$module$src$modules$table=a=>(b,c,d)=>{const e=a.exports.allocFloatArray(d.length);(new Float64Array(a.wasi.memory.buffer,e,d.length)).set(d);a.exports.csoundTableCopyIn(b,c,e);a.exports.freeFloatArrayMem(e)};csoundTableCopyIn$$module$src$modules$table.toString=()=>"tableCopyIn = async (tableNum, float64Array) => undefined;";
const csoundTableCopyOut$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundTableLength(b,c);if(0<d){const e=a.exports.allocFloatArray(d);a.exports.csoundTableCopyOut(b,c,e);({buffer:b}=a.wasi.memory);d=new Float64Array(b,e,d);a.exports.freeFloatArrayMem(e);return Float64Array.from(d)}};csoundTableCopyOut$$module$src$modules$table.toString=()=>"tableCopyOut = async (tableNum) => ?Float64Array;";const csoundGetTable$$module$src$modules$table=csoundTableCopyOut$$module$src$modules$table;
csoundTableCopyOut$$module$src$modules$table.toString=csoundTableCopyOut$$module$src$modules$table.toString;const csoundGetTableArgs$$module$src$modules$table=a=>(b,c)=>{const d=a.exports.allocFloatArray(1024);a.exports.csoundGetTableArgs(b,d,c);({buffer:b}=a.wasi.memory);b=new Float64Array(b,d,1024);a.exports.freeFloatArrayMem(d);return b};csoundGetTableArgs$$module$src$modules$table.toString=()=>"getTableArgs = async (tableNum) => ?Float64Array;";
const csoundIsNamedGEN$$module$src$modules$table=a=>(b,c)=>a.exports.csoundIsNamedGEN(b,c);csoundIsNamedGEN$$module$src$modules$table.toString=()=>"isNamedGEN = async (tableNum) => number;";const csoundGetNamedGEN$$module$src$modules$table=a=>(b,c)=>{var d=a.exports.csoundIsNamedGEN(b,c);if(0<d){const e=a.exports.allocStringMem(d);a.exports.csoundGetNamedGEN(b,e,c,d);({buffer:b}=a.wasi.memory);d=new Uint8Array(b,e,d);return uint2String$$module$src$utils$text_encoders(d)}};
csoundGetNamedGEN$$module$src$modules$table.toString=()=>"getNamedGEN = async (tableNum) => ?string;";var module$src$modules$table={};module$src$modules$table.csoundGetNamedGEN=csoundGetNamedGEN$$module$src$modules$table;module$src$modules$table.csoundGetTable=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundGetTableArgs=csoundGetTableArgs$$module$src$modules$table;module$src$modules$table.csoundIsNamedGEN=csoundIsNamedGEN$$module$src$modules$table;
module$src$modules$table.csoundTableCopyIn=csoundTableCopyIn$$module$src$modules$table;module$src$modules$table.csoundTableCopyOut=csoundTableCopyOut$$module$src$modules$table;module$src$modules$table.csoundTableGet=csoundTableGet$$module$src$modules$table;module$src$modules$table.csoundTableLength=csoundTableLength$$module$src$modules$table;module$src$modules$table.csoundTableSet=csoundTableSet$$module$src$modules$table;function writeFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.writeFile(c,b)}}writeFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";function appendFile$$module$src$filesystem$worker_fs(a){return(b,c,d)=>{b="string"===typeof d?encoder$$module$src$utils$text_encoders.encode(d):d;a.wasi.appendFile(c,b)}}appendFile$$module$src$filesystem$worker_fs.toString=()=>"async (path, data) => void";
function readFile$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readFile(c)}readFile$$module$src$filesystem$worker_fs.toString=()=>"async (path) => ?Uint8Array";function unlink$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.unlink(c)}unlink$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";function readdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.readdir(c)}readdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => string[]";
function mkdir$$module$src$filesystem$worker_fs(a){return(b,c)=>a.wasi.mkdir(c)}mkdir$$module$src$filesystem$worker_fs.toString=()=>"async (path) => void";var module$src$filesystem$worker_fs={};module$src$filesystem$worker_fs.appendFile=appendFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.mkdir=mkdir$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readFile=readFile$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.readdir=readdir$$module$src$filesystem$worker_fs;
module$src$filesystem$worker_fs.unlink=unlink$$module$src$filesystem$worker_fs;module$src$filesystem$worker_fs.writeFile=writeFile$$module$src$filesystem$worker_fs;const api$$module$src$libcsound={csoundCreate:csoundCreate$$module$src$modules$instantiation,csoundDestroy:csoundDestroy$$module$src$modules$instantiation,csoundGetAPIVersion:csoundGetAPIVersion$$module$src$modules$instantiation,csoundGetVersion:csoundGetVersion$$module$src$modules$instantiation,csoundInitialize:csoundInitialize$$module$src$modules$instantiation,csoundParseOrc:csoundParseOrc$$module$src$modules$performance,csoundCompileTree:csoundCompileTree$$module$src$modules$performance,csoundCompileOrc:csoundCompileOrc$$module$src$modules$performance,
csoundEvalCode:csoundEvalCode$$module$src$modules$performance,csoundStart:csoundStart$$module$src$modules$performance,csoundCompileCsd:csoundCompileCsd$$module$src$modules$performance,csoundCompileCsdText:csoundCompileCsdText$$module$src$modules$performance,csoundPerform:csoundPerform$$module$src$modules$performance,csoundPerformKsmps:csoundPerformKsmps$$module$src$modules$performance,csoundPerformBuffer:csoundPerformBuffer$$module$src$modules$performance,csoundStop:csoundStop$$module$src$modules$performance,
csoundCleanup:csoundCleanup$$module$src$modules$performance,csoundReset:csoundReset$$module$src$modules$performance,csoundGetSr:csoundGetSr$$module$src$modules$attributes,csoundGetKr:csoundGetKr$$module$src$modules$attributes,csoundGetKsmps:csoundGetKsmps$$module$src$modules$attributes,csoundGetNchnls:csoundGetNchnls$$module$src$modules$attributes,csoundGetNchnlsInput:csoundGetNchnlsInput$$module$src$modules$attributes,csoundGet0dBFS:csoundGet0dBFS$$module$src$modules$attributes,csoundGetA4:csoundGetA4$$module$src$modules$attributes,
csoundGetCurrentTimeSamples:csoundGetCurrentTimeSamples$$module$src$modules$attributes,csoundGetSizeOfMYFLT:csoundGetSizeOfMYFLT$$module$src$modules$attributes,csoundSetOption:csoundSetOption$$module$src$modules$attributes,csoundSetParams:csoundSetParams$$module$src$modules$attributes,csoundGetParams:csoundGetParams$$module$src$modules$attributes,csoundGetDebug:csoundGetDebug$$module$src$modules$attributes,csoundSetDebug:csoundSetDebug$$module$src$modules$attributes,csoundGetInputBufferSize:csoundGetInputBufferSize$$module$src$modules$rtaudio,
csoundGetOutputBufferSize:csoundGetOutputBufferSize$$module$src$modules$rtaudio,csoundGetInputBuffer:csoundGetInputBuffer$$module$src$modules$rtaudio,csoundGetOutputBuffer:csoundGetOutputBuffer$$module$src$modules$rtaudio,csoundGetSpin:csoundGetSpin$$module$src$modules$rtaudio,csoundGetSpout:csoundGetSpout$$module$src$modules$rtaudio,csoundGetMIDIDevList:csoundGetMIDIDevList$$module$src$modules$rtmidi,csoundSetMidiCallbacks:csoundSetMidiCallbacks$$module$src$modules$rtmidi,csoundGetRtMidiName:csoundGetRtMidiName$$module$src$modules$rtmidi,
csoundGetMidiOutFileName:csoundGetMidiOutFileName$$module$src$modules$rtmidi,csoundPushMidiMessage:csoundPushMidiMessage$$module$src$modules$rtmidi,_isRequestingRtMidiInput:_isRequestingRtMidiInput$$module$src$modules$rtmidi,csoundInputMessage:csoundInputMessage$$module$src$modules$control_events,csoundInputMessageAsync:csoundInputMessageAsync$$module$src$modules$control_events,csoundGetControlChannel:csoundGetControlChannel$$module$src$modules$control_events,csoundSetControlChannel:csoundSetControlChannel$$module$src$modules$control_events,
csoundGetStringChannel:csoundGetStringChannel$$module$src$modules$control_events,csoundSetStringChannel:csoundSetStringChannel$$module$src$modules$control_events,csoundGetInputName:csoundGetInputName$$module$src$modules$general_io,csoundGetOutputName:csoundGetOutputName$$module$src$modules$general_io,csoundAppendEnv:csoundAppendEnv$$module$src$modules$extra,csoundShouldDaemonize:csoundShouldDaemonize$$module$src$modules$extra,csoundIsScorePending:csoundIsScorePending$$module$src$modules$score_handling,
csoundSetScorePending:csoundSetScorePending$$module$src$modules$score_handling,csoundReadScore:csoundReadScore$$module$src$modules$score_handling,csoundGetScoreTime:csoundGetScoreTime$$module$src$modules$score_handling,csoundGetScoreOffsetSeconds:csoundGetScoreOffsetSeconds$$module$src$modules$score_handling,csoundSetScoreOffsetSeconds:csoundSetScoreOffsetSeconds$$module$src$modules$score_handling,csoundRewindScore:csoundRewindScore$$module$src$modules$score_handling,csoundTableLength:csoundTableLength$$module$src$modules$table,
csoundTableGet:csoundTableGet$$module$src$modules$table,csoundTableSet:csoundTableSet$$module$src$modules$table,csoundTableCopyIn:csoundTableCopyIn$$module$src$modules$table,csoundTableCopyOut:csoundTableCopyOut$$module$src$modules$table,csoundGetTable:csoundTableCopyOut$$module$src$modules$table,csoundGetTableArgs:csoundGetTableArgs$$module$src$modules$table,csoundIsNamedGEN:csoundIsNamedGEN$$module$src$modules$table,csoundGetNamedGEN:csoundGetNamedGEN$$module$src$modules$table,fs:module$src$filesystem$worker_fs};
var $jscompDefaultExport$$module$src$libcsound=function(a){return mergeAll$$module$node_modules$rambda$dist$rambda_mjs([reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,api$$module$src$libcsound[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(dissoc$$module$node_modules$rambda$dist$rambda_mjs("fs")(api$$module$src$libcsound))),reduce$$module$node_modules$rambda$dist$rambda_mjs((b,c)=>assoc$$module$node_modules$rambda$dist$rambda_mjs(c,
api$$module$src$libcsound.fs[c](a),b),{},keys$$module$node_modules$rambda$dist$rambda_mjs(module$src$filesystem$worker_fs))])},module$src$libcsound={};module$src$libcsound.api=api$$module$src$libcsound;module$src$libcsound.default=$jscompDefaultExport$$module$src$libcsound;const dlinit$$module$src$dlinit=(a,b,c,d)=>{if(b.exports.csoundModuleInit){var e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=new WebAssembly.Global({value:"i32",mutable:!0},0);const h=new WebAssembly.Global({value:"i32",mutable:!0},0);let k=c.length;"function"===typeof b.exports.csoundModuleCreate&&(c.grow(1),e.value=k,c.set(k,b.exports.csoundModuleCreate),k+=1);"function"===typeof b.exports.csoundModuleInit&&(c.grow(1),f.value=k,c.set(k,
b.exports.csoundModuleInit),k+=1);"function"===typeof b.exports.csoundModuleDestroy&&(c.grow(1),g.value=k,c.set(k,b.exports.csoundModuleDestroy),k+=1);"function"===typeof b.exports.csoundModuleErrorCodeToString&&(c.grow(1),h.value=k,c.set(k,b.exports.csoundModuleErrorCodeToString));a.exports.csoundWasiLoadPlugin(d,e,f,g,h)}else b.exports.csound_opcode_init||b.exports.csound_fgen_init?(e=new WebAssembly.Global({value:"i32",mutable:!0},0),f=new WebAssembly.Global({value:"i32",mutable:!0},0),g=c.length,
"function"===typeof b.exports.csound_opcode_init&&(e.value=g,c.grow(1),c.set(g,b.exports.csound_opcode_init),g+=1),"function"===typeof b.exports.csound_fgen_init&&(f.value=g,c.grow(1),c.set(g,b.exports.csound_fgen_init)),a.exports.csoundWasiLoadOpcodeLibrary(d,f,e)):console.error("Plugin doesn't export nececcary functions to quality as csound plugin.")};var module$src$dlinit={};module$src$dlinit.dlinit=dlinit$$module$src$dlinit;void 0!==goog.global&&(goog.global={});goog.global.BigInt||(goog.global.BigInt=void 0===BigInt?Number:BigInt);
const WASI_ESUCCESS$$module$src$filesystem$constants=0,WASI_E2BIG$$module$src$filesystem$constants=1,WASI_EACCES$$module$src$filesystem$constants=2,WASI_EADDRINUSE$$module$src$filesystem$constants=3,WASI_EADDRNOTAVAIL$$module$src$filesystem$constants=4,WASI_EAFNOSUPPORT$$module$src$filesystem$constants=5,WASI_EAGAIN$$module$src$filesystem$constants=6,WASI_EALREADY$$module$src$filesystem$constants=7,WASI_EBADF$$module$src$filesystem$constants=8,WASI_EBADMSG$$module$src$filesystem$constants=9,WASI_EBUSY$$module$src$filesystem$constants=
10,WASI_ECANCELED$$module$src$filesystem$constants=11,WASI_ECHILD$$module$src$filesystem$constants=12,WASI_ECONNABORTED$$module$src$filesystem$constants=13,WASI_ECONNREFUSED$$module$src$filesystem$constants=14,WASI_ECONNRESET$$module$src$filesystem$constants=15,WASI_EDEADLK$$module$src$filesystem$constants=16,WASI_EDESTADDRREQ$$module$src$filesystem$constants=17,WASI_EDOM$$module$src$filesystem$constants=18,WASI_EDQUOT$$module$src$filesystem$constants=19,WASI_EEXIST$$module$src$filesystem$constants=
20,WASI_EFAULT$$module$src$filesystem$constants=21,WASI_EFBIG$$module$src$filesystem$constants=22,WASI_EHOSTUNREACH$$module$src$filesystem$constants=23,WASI_EIDRM$$module$src$filesystem$constants=24,WASI_EILSEQ$$module$src$filesystem$constants=25,WASI_EINPROGRESS$$module$src$filesystem$constants=26,WASI_EINTR$$module$src$filesystem$constants=27,WASI_EINVAL$$module$src$filesystem$constants=28,WASI_EIO$$module$src$filesystem$constants=29,WASI_EISCONN$$module$src$filesystem$constants=30,WASI_EISDIR$$module$src$filesystem$constants=
31,WASI_ELOOP$$module$src$filesystem$constants=32,WASI_EMFILE$$module$src$filesystem$constants=33,WASI_EMLINK$$module$src$filesystem$constants=34,WASI_EMSGSIZE$$module$src$filesystem$constants=35,WASI_EMULTIHOP$$module$src$filesystem$constants=36,WASI_ENAMETOOLONG$$module$src$filesystem$constants=37,WASI_ENETDOWN$$module$src$filesystem$constants=38,WASI_ENETRESET$$module$src$filesystem$constants=39,WASI_ENETUNREACH$$module$src$filesystem$constants=40,WASI_ENFILE$$module$src$filesystem$constants=41,
WASI_ENOBUFS$$module$src$filesystem$constants=42,WASI_ENODEV$$module$src$filesystem$constants=43,WASI_ENOENT$$module$src$filesystem$constants=44,WASI_ENOEXEC$$module$src$filesystem$constants=45,WASI_ENOLCK$$module$src$filesystem$constants=46,WASI_ENOLINK$$module$src$filesystem$constants=47,WASI_ENOMEM$$module$src$filesystem$constants=48,WASI_ENOMSG$$module$src$filesystem$constants=49,WASI_ENOPROTOOPT$$module$src$filesystem$constants=50,WASI_ENOSPC$$module$src$filesystem$constants=51,WASI_ENOSYS$$module$src$filesystem$constants=
52,WASI_ENOTCONN$$module$src$filesystem$constants=53,WASI_ENOTDIR$$module$src$filesystem$constants=54,WASI_ENOTEMPTY$$module$src$filesystem$constants=55,WASI_ENOTRECOVERABLE$$module$src$filesystem$constants=56,WASI_ENOTSOCK$$module$src$filesystem$constants=57,WASI_ENOTSUP$$module$src$filesystem$constants=58,WASI_ENOTTY$$module$src$filesystem$constants=59,WASI_ENXIO$$module$src$filesystem$constants=60,WASI_EOVERFLOW$$module$src$filesystem$constants=61,WASI_EOWNERDEAD$$module$src$filesystem$constants=
62,WASI_EPERM$$module$src$filesystem$constants=63,WASI_EPIPE$$module$src$filesystem$constants=64,WASI_EPROTO$$module$src$filesystem$constants=65,WASI_EPROTONOSUPPORT$$module$src$filesystem$constants=66,WASI_EPROTOTYPE$$module$src$filesystem$constants=67,WASI_ERANGE$$module$src$filesystem$constants=68,WASI_EROFS$$module$src$filesystem$constants=69,WASI_ESPIPE$$module$src$filesystem$constants=70,WASI_ESRCH$$module$src$filesystem$constants=71,WASI_ESTALE$$module$src$filesystem$constants=72,WASI_ETIMEDOUT$$module$src$filesystem$constants=
73,WASI_ETXTBSY$$module$src$filesystem$constants=74,WASI_EXDEV$$module$src$filesystem$constants=75,WASI_ENOTCAPABLE$$module$src$filesystem$constants=76,WASI_SIGABRT$$module$src$filesystem$constants=0,WASI_SIGALRM$$module$src$filesystem$constants=1,WASI_SIGBUS$$module$src$filesystem$constants=2,WASI_SIGCHLD$$module$src$filesystem$constants=3,WASI_SIGCONT$$module$src$filesystem$constants=4,WASI_SIGFPE$$module$src$filesystem$constants=5,WASI_SIGHUP$$module$src$filesystem$constants=6,WASI_SIGILL$$module$src$filesystem$constants=
7,WASI_SIGINT$$module$src$filesystem$constants=8,WASI_SIGKILL$$module$src$filesystem$constants=9,WASI_SIGPIPE$$module$src$filesystem$constants=10,WASI_SIGQUIT$$module$src$filesystem$constants=11,WASI_SIGSEGV$$module$src$filesystem$constants=12,WASI_SIGSTOP$$module$src$filesystem$constants=13,WASI_SIGTERM$$module$src$filesystem$constants=14,WASI_SIGTRAP$$module$src$filesystem$constants=15,WASI_SIGTSTP$$module$src$filesystem$constants=16,WASI_SIGTTIN$$module$src$filesystem$constants=17,WASI_SIGTTOU$$module$src$filesystem$constants=
18,WASI_SIGURG$$module$src$filesystem$constants=19,WASI_SIGUSR1$$module$src$filesystem$constants=20,WASI_SIGUSR2$$module$src$filesystem$constants=21,WASI_SIGVTALRM$$module$src$filesystem$constants=22,WASI_SIGXCPU$$module$src$filesystem$constants=23,WASI_SIGXFSZ$$module$src$filesystem$constants=24,WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants=0,WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants=1,WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants=2,WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants=
3,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants=4,WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants=5,WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants=6,WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants=7,WASI_FDFLAG_APPEND$$module$src$filesystem$constants=1,WASI_FDFLAG_DSYNC$$module$src$filesystem$constants=2,WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants=4,WASI_FDFLAG_RSYNC$$module$src$filesystem$constants=8,WASI_FDFLAG_SYNC$$module$src$filesystem$constants=
16,WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants=goog.global.BigInt(1),WASI_RIGHT_FD_READ$$module$src$filesystem$constants=goog.global.BigInt(2),WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants=goog.global.BigInt(4),WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants=goog.global.BigInt(8),WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants=goog.global.BigInt(16),WASI_RIGHT_FD_TELL$$module$src$filesystem$constants=goog.global.BigInt(32),WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants=
goog.global.BigInt(64),WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants=goog.global.BigInt(128),WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants=goog.global.BigInt(256),WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(512),WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants=goog.global.BigInt(1024),WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(2048),WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants=
goog.global.BigInt(4096),WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants=goog.global.BigInt(8192),WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants=goog.global.BigInt(16384),WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants=goog.global.BigInt(32768),WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants=goog.global.BigInt(65536),WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants=goog.global.BigInt(131072),WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants=
goog.global.BigInt(262144),WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(524288),WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(1048576),WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants=goog.global.BigInt(2097152),WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants=goog.global.BigInt(4194304),WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants=goog.global.BigInt(8388608),WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants=
goog.global.BigInt(16777216),WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants=goog.global.BigInt(33554432),WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants=goog.global.BigInt(67108864),WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants=goog.global.BigInt(134217728),WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants=goog.global.BigInt(268435456),RIGHTS_ALL$$module$src$filesystem$constants=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|
WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|
WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|
WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|
WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_BLOCK_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_BASE$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_CHARACTER_DEVICE_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants=
WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_TELL$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|
WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants|WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants|
WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants|WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants|WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants|WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants|WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants|
WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants|WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants|WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants|WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants|WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants|
WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants|RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants,RIGHTS_SOCKET_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|
WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants|WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants,RIGHTS_SOCKET_INHERITING$$module$src$filesystem$constants=RIGHTS_ALL$$module$src$filesystem$constants,RIGHTS_TTY_BASE$$module$src$filesystem$constants=WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants|WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants|WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants|WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants,
RIGHTS_TTY_INHERITING$$module$src$filesystem$constants=goog.global.BigInt(0),WASI_CLOCK_REALTIME$$module$src$filesystem$constants=0,WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants=1,WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants=2,WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants=3,WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants=0,WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants=1,WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants=
1,WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants=2,WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants=4,WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants=8,WASI_O_CREAT$$module$src$filesystem$constants=1,WASI_O_DIRECTORY$$module$src$filesystem$constants=2,WASI_O_EXCL$$module$src$filesystem$constants=4,WASI_O_TRUNC$$module$src$filesystem$constants=8,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants=0,WASI_DIRCOOKIE_START$$module$src$filesystem$constants=0,WASI_STDIN_FILENO$$module$src$filesystem$constants=
0,WASI_STDOUT_FILENO$$module$src$filesystem$constants=1,WASI_STDERR_FILENO$$module$src$filesystem$constants=2,WASI_WHENCE_SET$$module$src$filesystem$constants=0,WASI_WHENCE_CUR$$module$src$filesystem$constants=1,WASI_WHENCE_END$$module$src$filesystem$constants=2;var module$src$filesystem$constants={};module$src$filesystem$constants.RIGHTS_ALL=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;
module$src$filesystem$constants.RIGHTS_BLOCK_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_BASE=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_CHARACTER_DEVICE_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_BASE=RIGHTS_DIRECTORY_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_DIRECTORY_INHERITING=RIGHTS_DIRECTORY_INHERITING$$module$src$filesystem$constants;
module$src$filesystem$constants.RIGHTS_REGULAR_FILE_BASE=RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_REGULAR_FILE_INHERITING=RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_BASE=RIGHTS_SOCKET_BASE$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_SOCKET_INHERITING=RIGHTS_ALL$$module$src$filesystem$constants;module$src$filesystem$constants.RIGHTS_TTY_BASE=RIGHTS_TTY_BASE$$module$src$filesystem$constants;
module$src$filesystem$constants.RIGHTS_TTY_INHERITING=RIGHTS_TTY_INHERITING$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_MONOTONIC=WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_PROCESS_CPUTIME_ID=WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_CLOCK_REALTIME=WASI_CLOCK_REALTIME$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_CLOCK_THREAD_CPUTIME_ID=WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_DIRCOOKIE_START=WASI_DIRCOOKIE_START$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_E2BIG=WASI_E2BIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EACCES=WASI_EACCES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EADDRINUSE=WASI_EADDRINUSE$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EADDRNOTAVAIL=WASI_EADDRNOTAVAIL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAFNOSUPPORT=WASI_EAFNOSUPPORT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EAGAIN=WASI_EAGAIN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EALREADY=WASI_EALREADY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBADF=WASI_EBADF$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EBADMSG=WASI_EBADMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EBUSY=WASI_EBUSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECANCELED=WASI_ECANCELED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECHILD=WASI_ECHILD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNABORTED=WASI_ECONNABORTED$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_ECONNREFUSED=WASI_ECONNREFUSED$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ECONNRESET=WASI_ECONNRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDEADLK=WASI_EDEADLK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDESTADDRREQ=WASI_EDESTADDRREQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EDOM=WASI_EDOM$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EDQUOT=WASI_EDQUOT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EEXIST=WASI_EEXIST$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFAULT=WASI_EFAULT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EFBIG=WASI_EFBIG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EHOSTUNREACH=WASI_EHOSTUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIDRM=WASI_EIDRM$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EILSEQ=WASI_EILSEQ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINPROGRESS=WASI_EINPROGRESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINTR=WASI_EINTR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EINVAL=WASI_EINVAL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EIO=WASI_EIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EISCONN=WASI_EISCONN$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EISDIR=WASI_EISDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ELOOP=WASI_ELOOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMFILE=WASI_EMFILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMLINK=WASI_EMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMSGSIZE=WASI_EMSGSIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EMULTIHOP=WASI_EMULTIHOP$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_ENAMETOOLONG=WASI_ENAMETOOLONG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETDOWN=WASI_ENETDOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETRESET=WASI_ENETRESET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENETUNREACH=WASI_ENETUNREACH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENFILE=WASI_ENFILE$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_ENOBUFS=WASI_ENOBUFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENODEV=WASI_ENODEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOENT=WASI_ENOENT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOEXEC=WASI_ENOEXEC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLCK=WASI_ENOLCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOLINK=WASI_ENOLINK$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_ENOMEM=WASI_ENOMEM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOMSG=WASI_ENOMSG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOPROTOOPT=WASI_ENOPROTOOPT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSPC=WASI_ENOSPC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOSYS=WASI_ENOSYS$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_ENOTCAPABLE=WASI_ENOTCAPABLE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTCONN=WASI_ENOTCONN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTDIR=WASI_ENOTDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTEMPTY=WASI_ENOTEMPTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTRECOVERABLE=WASI_ENOTRECOVERABLE$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_ENOTSOCK=WASI_ENOTSOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTSUP=WASI_ENOTSUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENOTTY=WASI_ENOTTY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ENXIO=WASI_ENXIO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EOVERFLOW=WASI_EOVERFLOW$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EOWNERDEAD=WASI_EOWNERDEAD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPERM=WASI_EPERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPIPE=WASI_EPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTO=WASI_EPROTO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EPROTONOSUPPORT=WASI_EPROTONOSUPPORT$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EPROTOTYPE=WASI_EPROTOTYPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ERANGE=WASI_ERANGE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EROFS=WASI_EROFS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESPIPE=WASI_ESPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESRCH=WASI_ESRCH$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ESTALE=WASI_ESTALE$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_ESUCCESS=WASI_ESUCCESS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETIMEDOUT=WASI_ETIMEDOUT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_ETXTBSY=WASI_ETXTBSY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_CLOCK=WASI_EVENTTYPE_CLOCK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EVENTTYPE_FD_READ=WASI_EVENTTYPE_FD_READ$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_EVENTTYPE_FD_WRITE=WASI_EVENTTYPE_FD_WRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_EXDEV=WASI_EXDEV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_APPEND=WASI_FDFLAG_APPEND$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_DSYNC=WASI_FDFLAG_DSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_NONBLOCK=WASI_FDFLAG_NONBLOCK$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_FDFLAG_RSYNC=WASI_FDFLAG_RSYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FDFLAG_SYNC=WASI_FDFLAG_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM=WASI_FILESTAT_SET_ATIM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_ATIM_NOW=WASI_FILESTAT_SET_ATIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILESTAT_SET_MTIM=WASI_FILESTAT_SET_MTIM$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_FILESTAT_SET_MTIM_NOW=WASI_FILESTAT_SET_MTIM_NOW$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_BLOCK_DEVICE=WASI_FILETYPE_BLOCK_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_CHARACTER_DEVICE=WASI_FILETYPE_CHARACTER_DEVICE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_DIRECTORY=WASI_FILETYPE_DIRECTORY$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_FILETYPE_REGULAR_FILE=WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_DGRAM=WASI_FILETYPE_SOCKET_DGRAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SOCKET_STREAM=WASI_FILETYPE_SOCKET_STREAM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_FILETYPE_SYMBOLIC_LINK=WASI_FILETYPE_SYMBOLIC_LINK$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_FILETYPE_UNKNOWN=WASI_FILETYPE_UNKNOWN$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_CREAT=WASI_O_CREAT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_DIRECTORY=WASI_O_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_EXCL=WASI_O_EXCL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_O_TRUNC=WASI_O_TRUNC$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_PREOPENTYPE_DIR=WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ADVISE=WASI_RIGHT_FD_ADVISE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_ALLOCATE=WASI_RIGHT_FD_ALLOCATE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_DATASYNC=WASI_RIGHT_FD_DATASYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FDSTAT_SET_FLAGS=WASI_RIGHT_FD_FDSTAT_SET_FLAGS$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_GET=WASI_RIGHT_FD_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_SIZE=WASI_RIGHT_FD_FILESTAT_SET_SIZE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_FILESTAT_SET_TIMES=WASI_RIGHT_FD_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_READ=WASI_RIGHT_FD_READ$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_RIGHT_FD_READDIR=WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SEEK=WASI_RIGHT_FD_SEEK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_SYNC=WASI_RIGHT_FD_SYNC$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_TELL=WASI_RIGHT_FD_TELL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_FD_WRITE=WASI_RIGHT_FD_WRITE$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_DIRECTORY=WASI_RIGHT_PATH_CREATE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_CREATE_FILE=WASI_RIGHT_PATH_CREATE_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_GET=WASI_RIGHT_PATH_FILESTAT_GET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_SIZE=WASI_RIGHT_PATH_FILESTAT_SET_SIZE$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_RIGHT_PATH_FILESTAT_SET_TIMES=WASI_RIGHT_PATH_FILESTAT_SET_TIMES$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_SOURCE=WASI_RIGHT_PATH_LINK_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_LINK_TARGET=WASI_RIGHT_PATH_LINK_TARGET$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_OPEN=WASI_RIGHT_PATH_OPEN$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_RIGHT_PATH_READLINK=WASI_RIGHT_PATH_READLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_REMOVE_DIRECTORY=WASI_RIGHT_PATH_REMOVE_DIRECTORY$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_SOURCE=WASI_RIGHT_PATH_RENAME_SOURCE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_RENAME_TARGET=WASI_RIGHT_PATH_RENAME_TARGET$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_RIGHT_PATH_SYMLINK=WASI_RIGHT_PATH_SYMLINK$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_PATH_UNLINK_FILE=WASI_RIGHT_PATH_UNLINK_FILE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_POLL_FD_READWRITE=WASI_RIGHT_POLL_FD_READWRITE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_RIGHT_SOCK_SHUTDOWN=WASI_RIGHT_SOCK_SHUTDOWN$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_SIGABRT=WASI_SIGABRT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGALRM=WASI_SIGALRM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGBUS=WASI_SIGBUS$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCHLD=WASI_SIGCHLD$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGCONT=WASI_SIGCONT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGFPE=WASI_SIGFPE$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_SIGHUP=WASI_SIGHUP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGILL=WASI_SIGILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGINT=WASI_SIGINT$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGKILL=WASI_SIGKILL$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGPIPE=WASI_SIGPIPE$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGQUIT=WASI_SIGQUIT$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_SIGSEGV=WASI_SIGSEGV$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGSTOP=WASI_SIGSTOP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTERM=WASI_SIGTERM$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTRAP=WASI_SIGTRAP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTSTP=WASI_SIGTSTP$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGTTIN=WASI_SIGTTIN$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_SIGTTOU=WASI_SIGTTOU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGURG=WASI_SIGURG$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR1=WASI_SIGUSR1$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGUSR2=WASI_SIGUSR2$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGVTALRM=WASI_SIGVTALRM$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_SIGXCPU=WASI_SIGXCPU$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_SIGXFSZ=WASI_SIGXFSZ$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDERR_FILENO=WASI_STDERR_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDIN_FILENO=WASI_STDIN_FILENO$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_STDOUT_FILENO=WASI_STDOUT_FILENO$$module$src$filesystem$constants;
module$src$filesystem$constants.WASI_WHENCE_CUR=WASI_WHENCE_CUR$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_END=WASI_WHENCE_END$$module$src$filesystem$constants;module$src$filesystem$constants.WASI_WHENCE_SET=WASI_WHENCE_SET$$module$src$filesystem$constants;goog.debug={};function module$contents$goog$debug$Error_DebugError(a,b){if(Error.captureStackTrace)Error.captureStackTrace(this,module$contents$goog$debug$Error_DebugError);else{const c=Error().stack;c&&(this.stack=c)}a&&(this.message=String(a));void 0!==b&&(this.cause=b);this.reportErrorToServer=!0}goog.inherits(module$contents$goog$debug$Error_DebugError,Error);module$contents$goog$debug$Error_DebugError.prototype.name="CustomError";goog.debug.Error=module$contents$goog$debug$Error_DebugError;goog.dom={};goog.dom.NodeType={ELEMENT:1,ATTRIBUTE:2,TEXT:3,CDATA_SECTION:4,ENTITY_REFERENCE:5,ENTITY:6,PROCESSING_INSTRUCTION:7,COMMENT:8,DOCUMENT:9,DOCUMENT_TYPE:10,DOCUMENT_FRAGMENT:11,NOTATION:12};goog.asserts={};goog.asserts.ENABLE_ASSERTS=goog.DEBUG;function module$contents$goog$asserts_AssertionError(a,b){module$contents$goog$debug$Error_DebugError.call(this,module$contents$goog$asserts_subs(a,b));this.messagePattern=a}goog.inherits(module$contents$goog$asserts_AssertionError,module$contents$goog$debug$Error_DebugError);goog.asserts.AssertionError=module$contents$goog$asserts_AssertionError;module$contents$goog$asserts_AssertionError.prototype.name="AssertionError";
goog.asserts.DEFAULT_ERROR_HANDLER=function(a){throw a;};let module$contents$goog$asserts_errorHandler_=goog.asserts.DEFAULT_ERROR_HANDLER;function module$contents$goog$asserts_subs(a,b){a=a.split("%s");let c="";const d=a.length-1;for(let e=0;e<d;e++)c+=a[e]+(e<b.length?b[e]:"%s");return c+a[d]}
function module$contents$goog$asserts_doAssertFailure(a,b,c,d){let e="Assertion failed",f;c?(e+=": "+c,f=d):a&&(e+=": "+a,f=b);a=new module$contents$goog$asserts_AssertionError(""+e,f||[]);module$contents$goog$asserts_errorHandler_(a)}goog.asserts.setErrorHandler=function(a){goog.asserts.ENABLE_ASSERTS&&(module$contents$goog$asserts_errorHandler_=a)};
goog.asserts.assert=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!a&&module$contents$goog$asserts_doAssertFailure("",null,b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertExists=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&null==a&&module$contents$goog$asserts_doAssertFailure("Expected to exist: %s.",[a],b,Array.prototype.slice.call(arguments,2));return a};
goog.asserts.fail=function(a,b){goog.asserts.ENABLE_ASSERTS&&module$contents$goog$asserts_errorHandler_(new module$contents$goog$asserts_AssertionError("Failure"+(a?": "+a:""),Array.prototype.slice.call(arguments,1)))};goog.asserts.assertNumber=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"number"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected number but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
goog.asserts.assertString=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"string"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected string but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertFunction=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"function"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected function but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
goog.asserts.assertObject=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isObject(a)&&module$contents$goog$asserts_doAssertFailure("Expected object but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertArray=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!Array.isArray(a)&&module$contents$goog$asserts_doAssertFailure("Expected array but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
goog.asserts.assertBoolean=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&"boolean"!==typeof a&&module$contents$goog$asserts_doAssertFailure("Expected boolean but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
goog.asserts.assertElement=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT||module$contents$goog$asserts_doAssertFailure("Expected Element but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
goog.asserts.assertInstanceof=function(a,b,c,d){!goog.asserts.ENABLE_ASSERTS||a instanceof b||module$contents$goog$asserts_doAssertFailure("Expected instanceof %s but got %s.",[module$contents$goog$asserts_getType(b),module$contents$goog$asserts_getType(a)],c,Array.prototype.slice.call(arguments,3));return a};
goog.asserts.assertFinite=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||"number"==typeof a&&isFinite(a)||module$contents$goog$asserts_doAssertFailure("Expected %s to be a finite number but it is not.",[a],b,Array.prototype.slice.call(arguments,2));return a};
function module$contents$goog$asserts_getType(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.array={};goog.NATIVE_ARRAY_PROTOTYPES=goog.TRUSTED_SITE;const module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS=2012<goog.FEATURESET_YEAR;goog.array.ASSUME_NATIVE_FUNCTIONS=module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS;function module$contents$goog$array_peek(a){return a[a.length-1]}goog.array.peek=module$contents$goog$array_peek;goog.array.last=module$contents$goog$array_peek;
const module$contents$goog$array_indexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.indexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.indexOf(b,c);for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1};goog.array.indexOf=module$contents$goog$array_indexOf;
const module$contents$goog$array_lastIndexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.lastIndexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.lastIndexOf.call(a,b,null==c?a.length-1:c)}:function(a,b,c){c=null==c?a.length-1:c;0>c&&(c=Math.max(0,a.length+c));if("string"===typeof a)return"string"!==typeof b||1!=b.length?-1:a.lastIndexOf(b,c);for(;0<=c;c--)if(c in a&&a[c]===b)return c;return-1};
goog.array.lastIndexOf=module$contents$goog$array_lastIndexOf;const module$contents$goog$array_forEach=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.forEach)?function(a,b,c){goog.asserts.assert(null!=a.length);Array.prototype.forEach.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)};goog.array.forEach=module$contents$goog$array_forEach;
function module$contents$goog$array_forEachRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;--d)d in e&&b.call(c,e[d],d,a)}goog.array.forEachRight=module$contents$goog$array_forEachRight;
const module$contents$goog$array_filter=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.filter)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.filter.call(a,b,c)}:function(a,b,c){const d=a.length,e=[];let f=0;const g="string"===typeof a?a.split(""):a;for(let h=0;h<d;h++)if(h in g){const k=g[h];b.call(c,k,h,a)&&(e[f++]=k)}return e};goog.array.filter=module$contents$goog$array_filter;
const module$contents$goog$array_map=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.map)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.map.call(a,b,c)}:function(a,b,c){const d=a.length,e=Array(d),f="string"===typeof a?a.split(""):a;for(let g=0;g<d;g++)g in f&&(e[g]=b.call(c,f[g],g,a));return e};goog.array.map=module$contents$goog$array_map;
const module$contents$goog$array_reduce=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduce)?function(a,b,c,d){goog.asserts.assert(null!=a.length);d&&(b=goog.bind(b,d));return Array.prototype.reduce.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEach(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduce=module$contents$goog$array_reduce;
const module$contents$goog$array_reduceRight=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduceRight)?function(a,b,c,d){goog.asserts.assert(null!=a.length);goog.asserts.assert(null!=b);d&&(b=goog.bind(b,d));return Array.prototype.reduceRight.call(a,b,c)}:function(a,b,c,d){let e=c;module$contents$goog$array_forEachRight(a,function(f,g){e=b.call(d,e,f,g,a)});return e};goog.array.reduceRight=module$contents$goog$array_reduceRight;
const module$contents$goog$array_some=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.some)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.some.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return!0;return!1};goog.array.some=module$contents$goog$array_some;
const module$contents$goog$array_every=goog.NATIVE_ARRAY_PROTOTYPES&&(module$contents$goog$array_ASSUME_NATIVE_FUNCTIONS||Array.prototype.every)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.every.call(a,b,c)}:function(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&!b.call(c,e[f],f,a))return!1;return!0};goog.array.every=module$contents$goog$array_every;
function module$contents$goog$array_count(a,b,c){let d=0;module$contents$goog$array_forEach(a,function(e,f,g){b.call(c,e,f,g)&&++d},c);return d}goog.array.count=module$contents$goog$array_count;function module$contents$goog$array_find(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.find=module$contents$goog$array_find;
function module$contents$goog$array_findIndex(a,b,c){const d=a.length,e="string"===typeof a?a.split(""):a;for(let f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return f;return-1}goog.array.findIndex=module$contents$goog$array_findIndex;function module$contents$goog$array_findRight(a,b,c){b=module$contents$goog$array_findIndexRight(a,b,c);return 0>b?null:"string"===typeof a?a.charAt(b):a[b]}goog.array.findRight=module$contents$goog$array_findRight;
function module$contents$goog$array_findIndexRight(a,b,c){var d=a.length;const e="string"===typeof a?a.split(""):a;for(--d;0<=d;d--)if(d in e&&b.call(c,e[d],d,a))return d;return-1}goog.array.findIndexRight=module$contents$goog$array_findIndexRight;function module$contents$goog$array_contains(a,b){return 0<=module$contents$goog$array_indexOf(a,b)}goog.array.contains=module$contents$goog$array_contains;function module$contents$goog$array_isEmpty(a){return 0==a.length}goog.array.isEmpty=module$contents$goog$array_isEmpty;
function module$contents$goog$array_clear(a){if(!Array.isArray(a))for(let b=a.length-1;0<=b;b--)delete a[b];a.length=0}goog.array.clear=module$contents$goog$array_clear;function module$contents$goog$array_insert(a,b){module$contents$goog$array_contains(a,b)||a.push(b)}goog.array.insert=module$contents$goog$array_insert;function module$contents$goog$array_insertAt(a,b,c){module$contents$goog$array_splice(a,c,0,b)}goog.array.insertAt=module$contents$goog$array_insertAt;
function module$contents$goog$array_insertArrayAt(a,b,c){goog.partial(module$contents$goog$array_splice,a,c,0).apply(null,b)}goog.array.insertArrayAt=module$contents$goog$array_insertArrayAt;function module$contents$goog$array_insertBefore(a,b,c){let d;2==arguments.length||0>(d=module$contents$goog$array_indexOf(a,c))?a.push(b):module$contents$goog$array_insertAt(a,b,d)}goog.array.insertBefore=module$contents$goog$array_insertBefore;
function module$contents$goog$array_remove(a,b){b=module$contents$goog$array_indexOf(a,b);let c;(c=0<=b)&&module$contents$goog$array_removeAt(a,b);return c}goog.array.remove=module$contents$goog$array_remove;function module$contents$goog$array_removeLast(a,b){b=module$contents$goog$array_lastIndexOf(a,b);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeLast=module$contents$goog$array_removeLast;
function module$contents$goog$array_removeAt(a,b){goog.asserts.assert(null!=a.length);return 1==Array.prototype.splice.call(a,b,1).length}goog.array.removeAt=module$contents$goog$array_removeAt;function module$contents$goog$array_removeIf(a,b,c){b=module$contents$goog$array_findIndex(a,b,c);return 0<=b?(module$contents$goog$array_removeAt(a,b),!0):!1}goog.array.removeIf=module$contents$goog$array_removeIf;
function module$contents$goog$array_removeAllIf(a,b,c){let d=0;module$contents$goog$array_forEachRight(a,function(e,f){b.call(c,e,f,a)&&module$contents$goog$array_removeAt(a,f)&&d++});return d}goog.array.removeAllIf=module$contents$goog$array_removeAllIf;function module$contents$goog$array_concat(a){return Array.prototype.concat.apply([],arguments)}goog.array.concat=module$contents$goog$array_concat;function module$contents$goog$array_join(a){return Array.prototype.concat.apply([],arguments)}
goog.array.join=module$contents$goog$array_join;function module$contents$goog$array_toArray(a){const b=a.length;if(0<b){const c=Array(b);for(let d=0;d<b;d++)c[d]=a[d];return c}return[]}const module$contents$goog$array_clone=goog.array.toArray=module$contents$goog$array_toArray;goog.array.clone=module$contents$goog$array_toArray;
function module$contents$goog$array_extend(a,b){for(let c=1;c<arguments.length;c++){const d=arguments[c];if(goog.isArrayLike(d)){const e=a.length||0,f=d.length||0;a.length=e+f;for(let g=0;g<f;g++)a[e+g]=d[g]}else a.push(d)}}goog.array.extend=module$contents$goog$array_extend;function module$contents$goog$array_splice(a,b,c,d){goog.asserts.assert(null!=a.length);return Array.prototype.splice.apply(a,module$contents$goog$array_slice(arguments,1))}goog.array.splice=module$contents$goog$array_splice;
function module$contents$goog$array_slice(a,b,c){goog.asserts.assert(null!=a.length);return 2>=arguments.length?Array.prototype.slice.call(a,b):Array.prototype.slice.call(a,b,c)}goog.array.slice=module$contents$goog$array_slice;
function module$contents$goog$array_removeDuplicates(a,b,c){b=b||a;var d=function(g){return goog.isObject(g)?"o"+goog.getUid(g):(typeof g).charAt(0)+g};c=c||d;let e=d=0;const f={};for(;e<a.length;){const g=a[e++],h=c(g);Object.prototype.hasOwnProperty.call(f,h)||(f[h]=!0,b[d++]=g)}b.length=d}goog.array.removeDuplicates=module$contents$goog$array_removeDuplicates;
function module$contents$goog$array_binarySearch(a,b,c){return module$contents$goog$array_binarySearch_(a,c||module$contents$goog$array_defaultCompare,!1,b)}goog.array.binarySearch=module$contents$goog$array_binarySearch;function module$contents$goog$array_binarySelect(a,b,c){return module$contents$goog$array_binarySearch_(a,b,!0,void 0,c)}goog.array.binarySelect=module$contents$goog$array_binarySelect;
function module$contents$goog$array_binarySearch_(a,b,c,d,e){let f=0,g=a.length,h;for(;f<g;){const k=f+(g-f>>>1);let l;l=c?b.call(e,a[k],k,a):b(d,a[k]);0<l?f=k+1:(g=k,h=!l)}return h?f:-f-1}function module$contents$goog$array_sort(a,b){a.sort(b||module$contents$goog$array_defaultCompare)}goog.array.sort=module$contents$goog$array_sort;
function module$contents$goog$array_stableSort(a,b){const c=Array(a.length);for(let e=0;e<a.length;e++)c[e]={index:e,value:a[e]};const d=b||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(c,function(e,f){return d(e.value,f.value)||e.index-f.index});for(b=0;b<a.length;b++)a[b]=c[b].value}goog.array.stableSort=module$contents$goog$array_stableSort;
function module$contents$goog$array_sortByKey(a,b,c){const d=c||module$contents$goog$array_defaultCompare;module$contents$goog$array_sort(a,function(e,f){return d(b(e),b(f))})}goog.array.sortByKey=module$contents$goog$array_sortByKey;function module$contents$goog$array_sortObjectsByKey(a,b,c){module$contents$goog$array_sortByKey(a,function(d){return d[b]},c)}goog.array.sortObjectsByKey=module$contents$goog$array_sortObjectsByKey;
function module$contents$goog$array_isSorted(a,b,c){b=b||module$contents$goog$array_defaultCompare;for(let d=1;d<a.length;d++){const e=b(a[d-1],a[d]);if(0<e||0==e&&c)return!1}return!0}goog.array.isSorted=module$contents$goog$array_isSorted;function module$contents$goog$array_equals(a,b,c){if(!goog.isArrayLike(a)||!goog.isArrayLike(b)||a.length!=b.length)return!1;const d=a.length;c=c||module$contents$goog$array_defaultCompareEquality;for(let e=0;e<d;e++)if(!c(a[e],b[e]))return!1;return!0}
goog.array.equals=module$contents$goog$array_equals;function module$contents$goog$array_compare3(a,b,c){c=c||module$contents$goog$array_defaultCompare;const d=Math.min(a.length,b.length);for(let e=0;e<d;e++){const f=c(a[e],b[e]);if(0!=f)return f}return module$contents$goog$array_defaultCompare(a.length,b.length)}goog.array.compare3=module$contents$goog$array_compare3;function module$contents$goog$array_defaultCompare(a,b){return a>b?1:a<b?-1:0}goog.array.defaultCompare=module$contents$goog$array_defaultCompare;
function module$contents$goog$array_inverseDefaultCompare(a,b){return-module$contents$goog$array_defaultCompare(a,b)}goog.array.inverseDefaultCompare=module$contents$goog$array_inverseDefaultCompare;function module$contents$goog$array_defaultCompareEquality(a,b){return a===b}goog.array.defaultCompareEquality=module$contents$goog$array_defaultCompareEquality;
function module$contents$goog$array_binaryInsert(a,b,c){c=module$contents$goog$array_binarySearch(a,b,c);return 0>c?(module$contents$goog$array_insertAt(a,b,-(c+1)),!0):!1}goog.array.binaryInsert=module$contents$goog$array_binaryInsert;function module$contents$goog$array_binaryRemove(a,b,c){b=module$contents$goog$array_binarySearch(a,b,c);return 0<=b?module$contents$goog$array_removeAt(a,b):!1}goog.array.binaryRemove=module$contents$goog$array_binaryRemove;
function module$contents$goog$array_bucket(a,b,c){const d={};for(let e=0;e<a.length;e++){const f=a[e],g=b.call(c,f,e,a);void 0!==g&&(d[g]||(d[g]=[])).push(f)}return d}goog.array.bucket=module$contents$goog$array_bucket;function module$contents$goog$array_bucketToMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d],f=b(e,d,a);if(void 0!==f){let g=c.get(f);g||(g=[],c.set(f,g));g.push(e)}}return c}goog.array.bucketToMap=module$contents$goog$array_bucketToMap;
function module$contents$goog$array_toObject(a,b,c){const d={};module$contents$goog$array_forEach(a,function(e,f){d[b.call(c,e,f,a)]=e});return d}goog.array.toObject=module$contents$goog$array_toObject;function module$contents$goog$array_toMap(a,b){const c=new Map;for(let d=0;d<a.length;d++){const e=a[d];c.set(b(e,d,a),e)}return c}goog.array.toMap=module$contents$goog$array_toMap;
function module$contents$goog$array_range(a,b,c){const d=[];let e=0,f=a;c=c||1;void 0!==b&&(e=a,f=b);if(0>c*(f-e))return[];if(0<c)for(a=e;a<f;a+=c)d.push(a);else for(a=e;a>f;a+=c)d.push(a);return d}goog.array.range=module$contents$goog$array_range;function module$contents$goog$array_repeat(a,b){const c=[];for(let d=0;d<b;d++)c[d]=a;return c}goog.array.repeat=module$contents$goog$array_repeat;
function module$contents$goog$array_flatten(a){const b=[];for(let d=0;d<arguments.length;d++){const e=arguments[d];if(Array.isArray(e))for(let f=0;f<e.length;f+=8192){var c=module$contents$goog$array_slice(e,f,f+8192);c=module$contents$goog$array_flatten.apply(null,c);for(let g=0;g<c.length;g++)b.push(c[g])}else b.push(e)}return b}goog.array.flatten=module$contents$goog$array_flatten;
function module$contents$goog$array_rotate(a,b){goog.asserts.assert(null!=a.length);a.length&&(b%=a.length,0<b?Array.prototype.unshift.apply(a,a.splice(-b,b)):0>b&&Array.prototype.push.apply(a,a.splice(0,-b)));return a}goog.array.rotate=module$contents$goog$array_rotate;function module$contents$goog$array_moveItem(a,b,c){goog.asserts.assert(0<=b&&b<a.length);goog.asserts.assert(0<=c&&c<a.length);b=Array.prototype.splice.call(a,b,1);Array.prototype.splice.call(a,c,0,b[0])}goog.array.moveItem=module$contents$goog$array_moveItem;
function module$contents$goog$array_zip(a){if(!arguments.length)return[];const b=[];let c=arguments[0].length;for(var d=1;d<arguments.length;d++)arguments[d].length<c&&(c=arguments[d].length);for(d=0;d<c;d++){const e=[];for(let f=0;f<arguments.length;f++)e.push(arguments[f][d]);b.push(e)}return b}goog.array.zip=module$contents$goog$array_zip;function module$contents$goog$array_shuffle(a,b){b=b||Math.random;for(let c=a.length-1;0<c;c--){const d=Math.floor(b()*(c+1)),e=a[c];a[c]=a[d];a[d]=e}}
goog.array.shuffle=module$contents$goog$array_shuffle;function module$contents$goog$array_copyByIndex(a,b){const c=[];module$contents$goog$array_forEach(b,function(d){c.push(a[d])});return c}goog.array.copyByIndex=module$contents$goog$array_copyByIndex;function module$contents$goog$array_concatMap(a,b,c){return module$contents$goog$array_concat.apply([],module$contents$goog$array_map(a,b,c))}goog.array.concatMap=module$contents$goog$array_concatMap;goog.dom.asserts={};goog.dom.asserts.assertIsLocation=function(a){if(goog.asserts.ENABLE_ASSERTS){var b=goog.dom.asserts.getWindow_(a);b&&(!a||!(a instanceof b.Location)&&a instanceof b.Element)&&goog.asserts.fail("Argument is not a Location (or a non-Element mock); got: %s",goog.dom.asserts.debugStringForType_(a))}return a};
goog.dom.asserts.assertIsElementType_=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=goog.dom.asserts.getWindow_(a);c&&"undefined"!=typeof c[b]&&(a&&(a instanceof c[b]||!(a instanceof c.Location||a instanceof c.Element))||goog.asserts.fail("Argument is not a %s (or a non-Element, non-Location mock); got: %s",b,goog.dom.asserts.debugStringForType_(a)))}return a};goog.dom.asserts.assertIsHTMLAnchorElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAnchorElement")};
goog.dom.asserts.assertIsHTMLButtonElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLButtonElement")};goog.dom.asserts.assertIsHTMLLinkElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLLinkElement")};goog.dom.asserts.assertIsHTMLImageElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLImageElement")};goog.dom.asserts.assertIsHTMLAudioElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAudioElement")};
goog.dom.asserts.assertIsHTMLVideoElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLVideoElement")};goog.dom.asserts.assertIsHTMLInputElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLInputElement")};goog.dom.asserts.assertIsHTMLTextAreaElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLTextAreaElement")};goog.dom.asserts.assertIsHTMLCanvasElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLCanvasElement")};
goog.dom.asserts.assertIsHTMLEmbedElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLEmbedElement")};goog.dom.asserts.assertIsHTMLFormElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFormElement")};goog.dom.asserts.assertIsHTMLFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFrameElement")};goog.dom.asserts.assertIsHTMLIFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLIFrameElement")};
goog.dom.asserts.assertIsHTMLObjectElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLObjectElement")};goog.dom.asserts.assertIsHTMLScriptElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLScriptElement")};
goog.dom.asserts.debugStringForType_=function(a){if(goog.isObject(a))try{return a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a)}catch(b){return"<object could not be stringified>"}else return void 0===a?"undefined":null===a?"null":typeof a};goog.dom.asserts.getWindow_=function(a){try{var b=a&&a.ownerDocument,c=b&&(b.defaultView||b.parentWindow);c=c||goog.global;if(c.Element&&c.Location)return c}catch(d){}return null};goog.functions={};goog.functions.constant=function(a){return function(){return a}};goog.functions.FALSE=function(){return!1};goog.functions.TRUE=function(){return!0};goog.functions.NULL=function(){return null};goog.functions.UNDEFINED=function(){};goog.functions.EMPTY=goog.functions.UNDEFINED;goog.functions.identity=function(a,b){return a};goog.functions.error=function(a){return function(){throw Error(a);}};goog.functions.fail=function(a){return function(){throw a;}};
goog.functions.lock=function(a,b){b=b||0;return function(){return a.apply(this,Array.prototype.slice.call(arguments,0,b))}};goog.functions.nth=function(a){return function(){return arguments[a]}};goog.functions.partialRight=function(a,b){const c=Array.prototype.slice.call(arguments,1);return function(){let d=this;d===goog.global&&(d=void 0);const e=Array.prototype.slice.call(arguments);e.push.apply(e,c);return a.apply(d,e)}};
goog.functions.withReturnValue=function(a,b){return goog.functions.sequence(a,goog.functions.constant(b))};goog.functions.equalTo=function(a,b){return function(c){return b?a==c:a===c}};goog.functions.compose=function(a,b){const c=arguments,d=c.length;return function(){let e;d&&(e=c[d-1].apply(this,arguments));for(let f=d-2;0<=f;f--)e=c[f].call(this,e);return e}};
goog.functions.sequence=function(a){const b=arguments,c=b.length;return function(){let d;for(let e=0;e<c;e++)d=b[e].apply(this,arguments);return d}};goog.functions.and=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(!b[d].apply(this,arguments))return!1;return!0}};goog.functions.or=function(a){const b=arguments,c=b.length;return function(){for(let d=0;d<c;d++)if(b[d].apply(this,arguments))return!0;return!1}};
goog.functions.not=function(a){return function(){return!a.apply(this,arguments)}};goog.functions.create=function(a,b){var c=function(){};c.prototype=a.prototype;c=new c;a.apply(c,Array.prototype.slice.call(arguments,1));return c};goog.functions.CACHE_RETURN_VALUE=!0;goog.functions.cacheReturnValue=function(a){let b=!1,c;return function(){if(!goog.functions.CACHE_RETURN_VALUE)return a();b||(c=a(),b=!0);return c}};goog.functions.once=function(a){let b=a;return function(){if(b){const c=b;b=null;c()}}};
goog.functions.debounce=function(a,b,c){let d=0;return function(e){goog.global.clearTimeout(d);const f=arguments;d=goog.global.setTimeout(function(){a.apply(c,f)},b)}};goog.functions.throttle=function(a,b,c){let d=0,e=!1,f=[];const g=function(){d=0;e&&(e=!1,h())},h=function(){d=goog.global.setTimeout(g,b);let k=f;f=[];a.apply(c,k)};return function(k){f=arguments;d?e=!0:h()}};
goog.functions.rateLimit=function(a,b,c){let d=0;const e=function(){d=0};return function(f){d||(d=goog.global.setTimeout(e,b),a.apply(c,arguments))}};goog.functions.isFunction=a=>"function"===typeof a;goog.string={};goog.string.TypedString=function(){};goog.string.Const=function(a,b){this.stringConstValueWithSecurityContract__googStringSecurityPrivate_=a===goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_&&b||"";this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_=goog.string.Const.TYPE_MARKER_};goog.string.Const.prototype.implementsGoogStringTypedString=!0;goog.string.Const.prototype.getTypedStringValue=function(){return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_};
goog.DEBUG&&(goog.string.Const.prototype.toString=function(){return"Const{"+this.stringConstValueWithSecurityContract__googStringSecurityPrivate_+"}"});goog.string.Const.unwrap=function(a){if(a instanceof goog.string.Const&&a.constructor===goog.string.Const&&a.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_===goog.string.Const.TYPE_MARKER_)return a.stringConstValueWithSecurityContract__googStringSecurityPrivate_;goog.asserts.fail("expected object of type Const, got '"+a+"'");return"type_error:Const"};
goog.string.Const.from=function(a){return new goog.string.Const(goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_,a)};goog.string.Const.TYPE_MARKER_={};goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_={};goog.string.Const.EMPTY=goog.string.Const.from("");goog.html={};goog.html.trustedtypes={};goog.html.trustedtypes.POLICY_NAME=goog.TRUSTED_TYPES_POLICY_NAME?goog.TRUSTED_TYPES_POLICY_NAME+"#html":"";goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse=function(){if(!goog.html.trustedtypes.POLICY_NAME)return null;void 0===goog.html.trustedtypes.cachedPolicy_&&(goog.html.trustedtypes.cachedPolicy_=goog.createTrustedTypesPolicy(goog.html.trustedtypes.POLICY_NAME));return goog.html.trustedtypes.cachedPolicy_};const module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE={};
class module$contents$goog$html$SafeScript_SafeScript{constructor(a,b){this.privateDoNotAccessOrElseSafeScriptWrappedValue_=b===module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static fromConstant(a){a=goog.string.Const.unwrap(a);return 0===a.length?module$contents$goog$html$SafeScript_SafeScript.EMPTY:module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(a)}static fromJson(a){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(module$contents$goog$html$SafeScript_SafeScript.stringify_(a))}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(a).toString()}static unwrapTrustedScript(a){if(a instanceof
module$contents$goog$html$SafeScript_SafeScript&&a.constructor===module$contents$goog$html$SafeScript_SafeScript)return a.privateDoNotAccessOrElseSafeScriptWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeScript, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeScript"}static stringify_(a){return JSON.stringify(a).replace(/</g,"\\x3c")}static createSafeScriptSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScript(a):
a;return new module$contents$goog$html$SafeScript_SafeScript(a,module$contents$goog$html$SafeScript_CONSTRUCTOR_TOKEN_PRIVATE)}}module$contents$goog$html$SafeScript_SafeScript.EMPTY=function(){return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("")}();goog.html.SafeScript=module$contents$goog$html$SafeScript_SafeScript;goog.fs={};goog.fs.url={};goog.fs.url.createObjectUrl=function(a){return goog.fs.url.getUrlObject_().createObjectURL(a)};goog.fs.url.revokeObjectUrl=function(a){goog.fs.url.getUrlObject_().revokeObjectURL(a)};goog.fs.url.UrlObject_=function(){};goog.fs.url.UrlObject_.prototype.createObjectURL=function(a){};goog.fs.url.UrlObject_.prototype.revokeObjectURL=function(a){};
goog.fs.url.getUrlObject_=function(){const a=goog.fs.url.findUrlObject_();if(null!=a)return a;throw Error("This browser doesn't seem to support blob URLs");};goog.fs.url.findUrlObject_=function(){return void 0!==goog.global.URL&&void 0!==goog.global.URL.createObjectURL?goog.global.URL:void 0!==goog.global.createObjectURL?goog.global:null};goog.fs.url.browserSupportsObjectUrls=function(){return null!=goog.fs.url.findUrlObject_()};goog.fs.blob={};goog.fs.blob.getBlob=function(a){var b=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==b){b=new b;for(let c=0;c<arguments.length;c++)b.append(arguments[c]);return b.getBlob()}return goog.fs.blob.getBlobWithProperties(Array.prototype.slice.call(arguments))};
goog.fs.blob.getBlobWithProperties=function(a,b,c){var d=goog.global.BlobBuilder||goog.global.WebKitBlobBuilder;if(void 0!==d){d=new d;for(let e=0;e<a.length;e++)d.append(a[e],c);return d.getBlob(b)}if(void 0!==goog.global.Blob)return d={},b&&(d.type=b),c&&(d.endings=c),new Blob(a,d);throw Error("This browser doesn't seem to support creating Blobs");};goog.html.TrustedResourceUrl=class{constructor(a,b){this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_=b===goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_+""}};goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString=!0;goog.html.TrustedResourceUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_.toString()};
goog.html.TrustedResourceUrl.prototype.cloneWithParams=function(a,b){var c=goog.html.TrustedResourceUrl.unwrap(this);c=goog.html.TrustedResourceUrl.URL_PARAM_PARSER_.exec(c);var d=c[3]||"";return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(c[1]+goog.html.TrustedResourceUrl.stringifyParams_("?",c[2]||"",a)+goog.html.TrustedResourceUrl.stringifyParams_("#",d,b))};goog.html.TrustedResourceUrl.unwrap=function(a){return goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(a).toString()};
goog.html.TrustedResourceUrl.unwrapTrustedScriptURL=function(a){if(a instanceof goog.html.TrustedResourceUrl&&a.constructor===goog.html.TrustedResourceUrl)return a.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;goog.asserts.fail("expected object of type TrustedResourceUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:TrustedResourceUrl"};
goog.html.TrustedResourceUrl.format=function(a,b){var c=goog.string.Const.unwrap(a);if(!goog.html.TrustedResourceUrl.BASE_URL_.test(c))throw Error("Invalid TrustedResourceUrl format: "+c);a=c.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_,function(d,e){if(!Object.prototype.hasOwnProperty.call(b,e))throw Error('Found marker, "'+e+'", in format string, "'+c+'", but no valid label mapping found in args: '+JSON.stringify(b));d=b[e];return d instanceof goog.string.Const?goog.string.Const.unwrap(d):
encodeURIComponent(String(d))});return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.FORMAT_MARKER_=/%{(\w+)}/g;goog.html.TrustedResourceUrl.BASE_URL_=RegExp("^((https:)?//[0-9a-z.:[\\]-]+/|/[^/\\\\]|[^:/\\\\%]+/|[^:/\\\\%]*[?#]|about:blank#)","i");goog.html.TrustedResourceUrl.URL_PARAM_PARSER_=/^([^?#]*)(\?[^#]*)?(#[\s\S]*)?/;
goog.html.TrustedResourceUrl.formatWithParams=function(a,b,c,d){return goog.html.TrustedResourceUrl.format(a,b).cloneWithParams(c,d)};goog.html.TrustedResourceUrl.fromConstant=function(a){return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};goog.html.TrustedResourceUrl.fromConstants=function(a){for(var b="",c=0;c<a.length;c++)b+=goog.string.Const.unwrap(a[c]);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};
goog.html.TrustedResourceUrl.fromSafeScript=function(a){a=goog.fs.blob.getBlobWithProperties([module$contents$goog$html$SafeScript_SafeScript.unwrap(a)],"text/javascript");a=goog.fs.url.createObjectUrl(a);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};
goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse=function(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createScriptURL(a):a;return new goog.html.TrustedResourceUrl(a,goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};
goog.html.TrustedResourceUrl.stringifyParams_=function(a,b,c){if(null==c)return b;if("string"===typeof c)return c?a+encodeURIComponent(c):"";for(var d in c)if(Object.prototype.hasOwnProperty.call(c,d)){var e=c[d];e=Array.isArray(e)?e:[e];for(var f=0;f<e.length;f++){var g=e[f];null!=g&&(b||(b=a),b+=(b.length>a.length?"&":"")+encodeURIComponent(d)+"="+encodeURIComponent(String(g)))}}return b};goog.string.internal={};goog.string.internal.startsWith=function(a,b){return 0==a.lastIndexOf(b,0)};goog.string.internal.endsWith=function(a,b){const c=a.length-b.length;return 0<=c&&a.indexOf(b,c)==c};goog.string.internal.caseInsensitiveStartsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(0,b.length))};goog.string.internal.caseInsensitiveEndsWith=function(a,b){return 0==goog.string.internal.caseInsensitiveCompare(b,a.slice(a.length-b.length))};
goog.string.internal.caseInsensitiveEquals=function(a,b){return a.toLowerCase()==b.toLowerCase()};goog.string.internal.isEmptyOrWhitespace=function(a){return/^[\s\xa0]*$/.test(a)};goog.string.internal.trim=goog.TRUSTED_SITE&&String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(a)[1]};goog.string.internal.caseInsensitiveCompare=function(a,b){a=String(a).toLowerCase();b=String(b).toLowerCase();return a<b?-1:a==b?0:1};
goog.string.internal.newLineToBr=function(a,b){return a.replace(/(\r\n|\r|\n)/g,b?"<br />":"<br>")};
goog.string.internal.htmlEscape=function(a,b){if(b)a=a.replace(goog.string.internal.AMP_RE_,"&amp;").replace(goog.string.internal.LT_RE_,"&lt;").replace(goog.string.internal.GT_RE_,"&gt;").replace(goog.string.internal.QUOT_RE_,"&quot;").replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;").replace(goog.string.internal.NULL_RE_,"&#0;");else{if(!goog.string.internal.ALL_RE_.test(a))return a;-1!=a.indexOf("&")&&(a=a.replace(goog.string.internal.AMP_RE_,"&amp;"));-1!=a.indexOf("<")&&(a=a.replace(goog.string.internal.LT_RE_,
"&lt;"));-1!=a.indexOf(">")&&(a=a.replace(goog.string.internal.GT_RE_,"&gt;"));-1!=a.indexOf('"')&&(a=a.replace(goog.string.internal.QUOT_RE_,"&quot;"));-1!=a.indexOf("'")&&(a=a.replace(goog.string.internal.SINGLE_QUOTE_RE_,"&#39;"));-1!=a.indexOf("\x00")&&(a=a.replace(goog.string.internal.NULL_RE_,"&#0;"))}return a};goog.string.internal.AMP_RE_=/&/g;goog.string.internal.LT_RE_=/</g;goog.string.internal.GT_RE_=/>/g;goog.string.internal.QUOT_RE_=/"/g;goog.string.internal.SINGLE_QUOTE_RE_=/'/g;
goog.string.internal.NULL_RE_=/\x00/g;goog.string.internal.ALL_RE_=/[\x00&<>"']/;goog.string.internal.whitespaceEscape=function(a,b){return goog.string.internal.newLineToBr(a.replace(/  /g," &#160;"),b)};goog.string.internal.contains=function(a,b){return-1!=a.indexOf(b)};goog.string.internal.caseInsensitiveContains=function(a,b){return goog.string.internal.contains(a.toLowerCase(),b.toLowerCase())};
goog.string.internal.compareVersions=function(a,b){var c=0;a=goog.string.internal.trim(String(a)).split(".");b=goog.string.internal.trim(String(b)).split(".");const d=Math.max(a.length,b.length);for(let g=0;0==c&&g<d;g++){var e=a[g]||"",f=b[g]||"";do{e=/(\d*)(\D*)(.*)/.exec(e)||["","","",""];f=/(\d*)(\D*)(.*)/.exec(f)||["","","",""];if(0==e[0].length&&0==f[0].length)break;c=0==e[1].length?0:parseInt(e[1],10);const h=0==f[1].length?0:parseInt(f[1],10);c=goog.string.internal.compareElements_(c,h)||
goog.string.internal.compareElements_(0==e[2].length,0==f[2].length)||goog.string.internal.compareElements_(e[2],f[2]);e=e[3];f=f[3]}while(0==c)}return c};goog.string.internal.compareElements_=function(a,b){return a<b?-1:a>b?1:0};goog.html.SafeUrl=class{constructor(a,b){this.privateDoNotAccessOrElseSafeUrlWrappedValue_=b===goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_?a:""}toString(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()}};goog.html.SafeUrl.INNOCUOUS_STRING="about:invalid#zClosurez";goog.html.SafeUrl.prototype.implementsGoogStringTypedString=!0;goog.html.SafeUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString()};
goog.html.SafeUrl.unwrap=function(a){if(a instanceof goog.html.SafeUrl&&a.constructor===goog.html.SafeUrl)return a.privateDoNotAccessOrElseSafeUrlWrappedValue_;goog.asserts.fail("expected object of type SafeUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeUrl"};goog.html.SafeUrl.fromConstant=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};
goog.html.SAFE_MIME_TYPE_PATTERN_=RegExp('^(?:audio/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-matroska|x-wav|wav|webm)|font/\\w+|image/(?:bmp|gif|jpeg|jpg|png|tiff|webp|x-icon|heic|heif)|video/(?:mpeg|mp4|ogg|webm|quicktime|x-matroska))(?:;\\w+=(?:\\w+|"[\\w;,= ]+"))*$',"i");goog.html.SafeUrl.isSafeMimeType=function(a){return goog.html.SAFE_MIME_TYPE_PATTERN_.test(a)};
goog.html.SafeUrl.fromBlob=function(a){a=goog.html.SafeUrl.isSafeMimeType(a.type)?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.revokeObjectUrl=function(a){a=a.getTypedStringValue();a!==goog.html.SafeUrl.INNOCUOUS_STRING&&goog.fs.url.revokeObjectUrl(a)};
goog.html.SafeUrl.fromMediaSource=function(a){goog.asserts.assert("MediaSource"in goog.global,"No support for MediaSource");a=a instanceof MediaSource?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.DATA_URL_PATTERN_=/^data:(.*);base64,[a-z0-9+\/]+=*$/i;
goog.html.SafeUrl.tryFromDataUrl=function(a){a=String(a);a=a.replace(/(%0A|%0D)/g,"");return a.match(goog.html.DATA_URL_PATTERN_)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):null};goog.html.SafeUrl.fromDataUrl=function(a){return goog.html.SafeUrl.tryFromDataUrl(a)||goog.html.SafeUrl.INNOCUOUS_URL};goog.html.SafeUrl.fromTelUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"tel:")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
goog.html.SIP_URL_PATTERN_=RegExp("^sip[s]?:[+a-z0-9_.!$%&'*\\/=^`{|}~-]+@([a-z0-9-]+\\.)+[a-z0-9]{2,63}$","i");goog.html.SafeUrl.fromSipUrl=function(a){goog.html.SIP_URL_PATTERN_.test(decodeURIComponent(a))||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromFacebookMessengerUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"fb-messenger://share")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
goog.html.SafeUrl.fromWhatsAppUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"whatsapp://send")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromSmsUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"sms:")&&goog.html.SafeUrl.isSmsUrlBodyValid_(a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
goog.html.SafeUrl.isSmsUrlBodyValid_=function(a){var b=a.indexOf("#");0<b&&(a=a.substring(0,b));b=a.match(/[?&]body=/gi);if(!b)return!0;if(1<b.length)return!1;a=a.match(/[?&]body=([^&]*)/)[1];if(!a)return!0;try{decodeURIComponent(a)}catch(c){return!1}return/^(?:[a-z0-9\-_.~]|%[0-9a-f]{2})+$/i.test(a)};goog.html.SafeUrl.fromSshUrl=function(a){goog.string.internal.caseInsensitiveStartsWith(a,"ssh://")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
goog.html.SafeUrl.sanitizeChromeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^chrome-extension:\/\/([^\/]+)\//,a,b)};goog.html.SafeUrl.sanitizeFirefoxExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^moz-extension:\/\/([^\/]+)\//,a,b)};goog.html.SafeUrl.sanitizeEdgeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^ms-browser-extension:\/\/([^\/]+)\//,a,b)};
goog.html.SafeUrl.sanitizeExtensionUrl_=function(a,b,c){(a=a.exec(b))?(a=a[1],-1==(c instanceof goog.string.Const?[goog.string.Const.unwrap(c)]:c.map(function(d){return goog.string.Const.unwrap(d)})).indexOf(a)&&(b=goog.html.SafeUrl.INNOCUOUS_STRING)):b=goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};goog.html.SafeUrl.fromTrustedResourceUrl=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.TrustedResourceUrl.unwrap(a))};
goog.html.SAFE_URL_PATTERN_=/^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;goog.html.SafeUrl.SAFE_URL_PATTERN=goog.html.SAFE_URL_PATTERN_;goog.html.SafeUrl.trySanitize=function(a){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return goog.html.SAFE_URL_PATTERN_.test(a)?goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a):goog.html.SafeUrl.tryFromDataUrl(a)};
goog.html.SafeUrl.sanitize=function(a){return goog.html.SafeUrl.trySanitize(a)||goog.html.SafeUrl.INNOCUOUS_URL};
goog.html.SafeUrl.sanitizeAssertUnchanged=function(a,b){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);if(b&&/^data:/i.test(a)&&(b=goog.html.SafeUrl.fromDataUrl(a),b.getTypedStringValue()==a))return b;goog.asserts.assert(goog.html.SAFE_URL_PATTERN_.test(a),"%s does not match the safe URL pattern",a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_={};goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse=function(a){return new goog.html.SafeUrl(a,goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_)};goog.html.SafeUrl.INNOCUOUS_URL=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.SafeUrl.INNOCUOUS_STRING);goog.html.SafeUrl.ABOUT_BLANK=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse("about:blank");const module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE={};
class module$contents$goog$html$SafeStyle_SafeStyle{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleWrappedValue_=b===module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyle_SafeStyle.EMPTY;(0,goog.asserts.assert)((0,goog.string.internal.endsWith)(a,";"),`Last character of style string is not ';': ${a}`);(0,goog.asserts.assert)((0,goog.string.internal.contains)(a,
":"),"Style string must contain at least one ':', to specify a \"name: value\" pair: "+a);return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_}toString(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_.toString()}static unwrap(a){if(a instanceof module$contents$goog$html$SafeStyle_SafeStyle&&a.constructor===module$contents$goog$html$SafeStyle_SafeStyle)return a.privateDoNotAccessOrElseSafeStyleWrappedValue_;
(0,goog.asserts.fail)(`expected object of type SafeStyle, got '${a}`+"' of type "+goog.typeOf(a));return"type_error:SafeStyle"}static createSafeStyleSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyle_SafeStyle(a,module$contents$goog$html$SafeStyle_CONSTRUCTOR_TOKEN_PRIVATE)}static create(a){let b="";for(let c in a)if(Object.prototype.hasOwnProperty.call(a,c)){if(!/^[-_a-zA-Z0-9]+$/.test(c))throw Error(`Name allows only [-_a-zA-Z0-9], got: ${c}`);let d=a[c];null!=d&&
(d=Array.isArray(d)?d.map(module$contents$goog$html$SafeStyle_sanitizePropertyValue).join(" "):module$contents$goog$html$SafeStyle_sanitizePropertyValue(d),b+=`${c}:${d};`)}return b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(d)};Array.prototype.forEach.call(arguments,c);
return b?module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):module$contents$goog$html$SafeStyle_SafeStyle.EMPTY}}module$contents$goog$html$SafeStyle_SafeStyle.EMPTY=module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse("");module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING="zClosurez";
function module$contents$goog$html$SafeStyle_sanitizePropertyValue(a){if(a instanceof goog.html.SafeUrl)return'url("'+goog.html.SafeUrl.unwrap(a).replace(/</g,"%3c").replace(/[\\"]/g,"\\$&")+'")';a=a instanceof goog.string.Const?goog.string.Const.unwrap(a):module$contents$goog$html$SafeStyle_sanitizePropertyValueString(String(a));if(/[{;}]/.test(a))throw new module$contents$goog$asserts_AssertionError("Value does not allow [{;}], got: %s.",[a]);return a}
function module$contents$goog$html$SafeStyle_sanitizePropertyValueString(a){const b=a.replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_FUNCTIONS_RE,"$1").replace(module$contents$goog$html$SafeStyle_URL_RE,"url");if(module$contents$goog$html$SafeStyle_VALUE_RE.test(b)){if(module$contents$goog$html$SafeStyle_COMMENT_RE.test(a))return(0,goog.asserts.fail)(`String value disallows comments, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;
if(!module$contents$goog$html$SafeStyle_hasBalancedQuotes(a))return(0,goog.asserts.fail)(`String value requires balanced quotes, got: ${a}`),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;if(!module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a))return(0,goog.asserts.fail)("String value requires balanced square brackets and one identifier per pair of brackets, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING}else return(0,goog.asserts.fail)(`String value allows only ${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}`+
" and simple functions, got: "+a),module$contents$goog$html$SafeStyle_SafeStyle.INNOCUOUS_STRING;return module$contents$goog$html$SafeStyle_sanitizeUrl(a)}function module$contents$goog$html$SafeStyle_hasBalancedQuotes(a){let b=!0,c=!0;for(let d=0;d<a.length;d++){const e=a.charAt(d);"'"==e&&c?b=!b:'"'==e&&b&&(c=!c)}return b&&c}
function module$contents$goog$html$SafeStyle_hasBalancedSquareBrackets(a){let b=!0;const c=/^[-_a-zA-Z0-9]$/;for(let d=0;d<a.length;d++){const e=a.charAt(d);if("]"==e){if(b)return!1;b=!0}else if("["==e){if(!b)return!1;b=!1}else if(!b&&!c.test(e))return!1}return b}
const module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS="[-,.\"'%_!#/ a-zA-Z0-9\\[\\]]",module$contents$goog$html$SafeStyle_VALUE_RE=new RegExp(`^${module$contents$goog$html$SafeStyle_VALUE_ALLOWED_CHARS}+\$`),module$contents$goog$html$SafeStyle_URL_RE=RegExp("\\b(url\\([ \t\n]*)('[ -&(-\\[\\]-~]*'|\"[ !#-\\[\\]-~]*\"|[!#-&*-\\[\\]-~]*)([ \t\n]*\\))","g"),module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS="calc cubic-bezier fit-content hsl hsla linear-gradient matrix minmax radial-gradient repeat rgb rgba (rotate|scale|translate)(X|Y|Z|3d)? steps var".split(" "),
module$contents$goog$html$SafeStyle_FUNCTIONS_RE=new RegExp("\\b("+module$contents$goog$html$SafeStyle_ALLOWED_FUNCTIONS.join("|")+")\\([-+*/0-9a-zA-Z.%#\\[\\], ]+\\)","g"),module$contents$goog$html$SafeStyle_COMMENT_RE=/\/\*/;function module$contents$goog$html$SafeStyle_sanitizeUrl(a){return a.replace(module$contents$goog$html$SafeStyle_URL_RE,(b,c,d,e)=>{let f="";d=d.replace(/^(['"])(.*)\1$/,(g,h,k)=>{f=h;return k});b=goog.html.SafeUrl.sanitize(d).getTypedStringValue();return c+f+b+f+e})}
goog.html.SafeStyle=module$contents$goog$html$SafeStyle_SafeStyle;goog.object={};function module$contents$goog$object_forEach(a,b,c){for(const d in a)b.call(c,a[d],d,a)}function module$contents$goog$object_filter(a,b,c){const d={};for(const e in a)b.call(c,a[e],e,a)&&(d[e]=a[e]);return d}function module$contents$goog$object_map(a,b,c){const d={};for(const e in a)d[e]=b.call(c,a[e],e,a);return d}function module$contents$goog$object_some(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return!0;return!1}
function module$contents$goog$object_every(a,b,c){for(const d in a)if(!b.call(c,a[d],d,a))return!1;return!0}function module$contents$goog$object_getCount(a){let b=0;for(const c in a)b++;return b}function module$contents$goog$object_getAnyKey(a){for(const b in a)return b}function module$contents$goog$object_getAnyValue(a){for(const b in a)return a[b]}function module$contents$goog$object_contains(a,b){return module$contents$goog$object_containsValue(a,b)}
function module$contents$goog$object_getValues(a){const b=[];let c=0;for(const d in a)b[c++]=a[d];return b}function module$contents$goog$object_getKeys(a){const b=[];let c=0;for(const d in a)b[c++]=d;return b}function module$contents$goog$object_getValueByKeys(a,b){var c=goog.isArrayLike(b);const d=c?b:arguments;for(c=c?0:1;c<d.length;c++){if(null==a)return;a=a[d[c]]}return a}function module$contents$goog$object_containsKey(a,b){return null!==a&&b in a}
function module$contents$goog$object_containsValue(a,b){for(const c in a)if(a[c]==b)return!0;return!1}function module$contents$goog$object_findKey(a,b,c){for(const d in a)if(b.call(c,a[d],d,a))return d}function module$contents$goog$object_findValue(a,b,c){return(b=module$contents$goog$object_findKey(a,b,c))&&a[b]}function module$contents$goog$object_isEmpty(a){for(const b in a)return!1;return!0}function module$contents$goog$object_clear(a){for(const b in a)delete a[b]}
function module$contents$goog$object_remove(a,b){let c;(c=b in a)&&delete a[b];return c}function module$contents$goog$object_add(a,b,c){if(null!==a&&b in a)throw Error(`The object already contains the key "${b}"`);module$contents$goog$object_set(a,b,c)}function module$contents$goog$object_get(a,b,c){return null!==a&&b in a?a[b]:c}function module$contents$goog$object_set(a,b,c){a[b]=c}function module$contents$goog$object_setIfUndefined(a,b,c){return b in a?a[b]:a[b]=c}
function module$contents$goog$object_setWithReturnValueIfNotSet(a,b,c){if(b in a)return a[b];c=c();return a[b]=c}function module$contents$goog$object_equals(a,b){for(const c in a)if(!(c in b)||a[c]!==b[c])return!1;for(const c in b)if(!(c in a))return!1;return!0}function module$contents$goog$object_clone(a){const b={};for(const c in a)b[c]=a[c];return b}
function module$contents$goog$object_unsafeClone(a){if(!a||"object"!==typeof a)return a;if("function"===typeof a.clone)return a.clone();if("undefined"!==typeof Map&&a instanceof Map)return new Map(a);if("undefined"!==typeof Set&&a instanceof Set)return new Set(a);if(a instanceof Date)return new Date(a.getTime());const b=Array.isArray(a)?[]:"function"!==typeof ArrayBuffer||"function"!==typeof ArrayBuffer.isView||!ArrayBuffer.isView(a)||a instanceof DataView?{}:new a.constructor(a.length);for(const c in a)b[c]=
module$contents$goog$object_unsafeClone(a[c]);return b}function module$contents$goog$object_transpose(a){const b={};for(const c in a)b[a[c]]=c;return b}const module$contents$goog$object_PROTOTYPE_FIELDS="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
function module$contents$goog$object_extend(a,b){let c,d;for(let e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(let f=0;f<module$contents$goog$object_PROTOTYPE_FIELDS.length;f++)c=module$contents$goog$object_PROTOTYPE_FIELDS[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}}
function module$contents$goog$object_create(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_create.apply(null,arguments[0]);if(b%2)throw Error("Uneven number of arguments");const c={};for(let d=0;d<b;d+=2)c[arguments[d]]=arguments[d+1];return c}
function module$contents$goog$object_createSet(a){const b=arguments.length;if(1==b&&Array.isArray(arguments[0]))return module$contents$goog$object_createSet.apply(null,arguments[0]);const c={};for(let d=0;d<b;d++)c[arguments[d]]=!0;return c}function module$contents$goog$object_createImmutableView(a){let b=a;Object.isFrozen&&!Object.isFrozen(a)&&(b=Object.create(a),Object.freeze(b));return b}function module$contents$goog$object_isImmutableView(a){return!!Object.isFrozen&&Object.isFrozen(a)}
function module$contents$goog$object_getAllPropertyNames(a,b,c){if(!a)return[];if(!Object.getOwnPropertyNames||!Object.getPrototypeOf)return module$contents$goog$object_getKeys(a);const d={};for(;a&&(a!==Object.prototype||b)&&(a!==Function.prototype||c);){const e=Object.getOwnPropertyNames(a);for(let f=0;f<e.length;f++)d[e[f]]=!0;a=Object.getPrototypeOf(a)}return module$contents$goog$object_getKeys(d)}
function module$contents$goog$object_getSuperClass(a){return(a=Object.getPrototypeOf(a.prototype))&&a.constructor}goog.object.add=module$contents$goog$object_add;goog.object.clear=module$contents$goog$object_clear;goog.object.clone=module$contents$goog$object_clone;goog.object.contains=module$contents$goog$object_contains;goog.object.containsKey=module$contents$goog$object_containsKey;goog.object.containsValue=module$contents$goog$object_containsValue;goog.object.create=module$contents$goog$object_create;
goog.object.createImmutableView=module$contents$goog$object_createImmutableView;goog.object.createSet=module$contents$goog$object_createSet;goog.object.equals=module$contents$goog$object_equals;goog.object.every=module$contents$goog$object_every;goog.object.extend=module$contents$goog$object_extend;goog.object.filter=module$contents$goog$object_filter;goog.object.findKey=module$contents$goog$object_findKey;goog.object.findValue=module$contents$goog$object_findValue;goog.object.forEach=module$contents$goog$object_forEach;
goog.object.get=module$contents$goog$object_get;goog.object.getAllPropertyNames=module$contents$goog$object_getAllPropertyNames;goog.object.getAnyKey=module$contents$goog$object_getAnyKey;goog.object.getAnyValue=module$contents$goog$object_getAnyValue;goog.object.getCount=module$contents$goog$object_getCount;goog.object.getKeys=module$contents$goog$object_getKeys;goog.object.getSuperClass=module$contents$goog$object_getSuperClass;goog.object.getValueByKeys=module$contents$goog$object_getValueByKeys;
goog.object.getValues=module$contents$goog$object_getValues;goog.object.isEmpty=module$contents$goog$object_isEmpty;goog.object.isImmutableView=module$contents$goog$object_isImmutableView;goog.object.map=module$contents$goog$object_map;goog.object.remove=module$contents$goog$object_remove;goog.object.set=module$contents$goog$object_set;goog.object.setIfUndefined=module$contents$goog$object_setIfUndefined;goog.object.setWithReturnValueIfNotSet=module$contents$goog$object_setWithReturnValueIfNotSet;
goog.object.some=module$contents$goog$object_some;goog.object.transpose=module$contents$goog$object_transpose;goog.object.unsafeClone=module$contents$goog$object_unsafeClone;const module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE={};
class module$contents$goog$html$SafeStyleSheet_SafeStyleSheet{constructor(a,b){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_=b===module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}toString(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_.toString()}static createRule(a,b){if((0,goog.string.internal.contains)(a,"<"))throw Error(`Selector does not allow '<', got: ${a}`);const c=a.replace(/('|")((?!\1)[^\r\n\f\\]|\\[\s\S])*\1/g,
"");if(!/^[-_a-zA-Z0-9#.:* ,>+~[\]()=^$|]+$/.test(c))throw Error("Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|] and strings, got: "+a);if(!module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.hasBalancedBrackets_(c))throw Error("() and [] in selector must be balanced, got: "+a);b instanceof module$contents$goog$html$SafeStyle_SafeStyle||(b=module$contents$goog$html$SafeStyle_SafeStyle.create(b));a=`${a}{`+module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b).replace(/</g,"\\3C ")+"}";
return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}static hasBalancedBrackets_(a){const b={"(":")","[":"]"},c=[];for(let d=0;d<a.length;d++){const e=a[d];if(b[e])c.push(b[e]);else if(module$contents$goog$object_contains(b,e)&&c.pop()!=e)return!1}return 0==c.length}static concat(a){let b="";const c=d=>{Array.isArray(d)?d.forEach(c):b+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(d)};Array.prototype.forEach.call(arguments,
c);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)}static fromConstant(a){a=goog.string.Const.unwrap(a);if(0===a.length)return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY;(0,goog.asserts.assert)(!(0,goog.string.internal.contains)(a,"<"),`Forbidden '<' character in style sheet string: ${a}`);return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_}static unwrap(a){if(a instanceof
module$contents$goog$html$SafeStyleSheet_SafeStyleSheet&&a.constructor===module$contents$goog$html$SafeStyleSheet_SafeStyleSheet)return a.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;(0,goog.asserts.fail)("expected object of type SafeStyleSheet, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeStyleSheet"}static createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a){return new module$contents$goog$html$SafeStyleSheet_SafeStyleSheet(a,module$contents$goog$html$SafeStyleSheet_CONSTRUCTOR_TOKEN_PRIVATE)}}
module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.EMPTY=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse("");goog.html.SafeStyleSheet=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet;goog.dom.HtmlElement=function(){};goog.dom.TagName=class{static cast(a,b){return a}constructor(){}toString(){}};goog.dom.TagName.A="A";goog.dom.TagName.ABBR="ABBR";goog.dom.TagName.ACRONYM="ACRONYM";goog.dom.TagName.ADDRESS="ADDRESS";goog.dom.TagName.APPLET="APPLET";goog.dom.TagName.AREA="AREA";goog.dom.TagName.ARTICLE="ARTICLE";goog.dom.TagName.ASIDE="ASIDE";goog.dom.TagName.AUDIO="AUDIO";goog.dom.TagName.B="B";goog.dom.TagName.BASE="BASE";goog.dom.TagName.BASEFONT="BASEFONT";goog.dom.TagName.BDI="BDI";goog.dom.TagName.BDO="BDO";
goog.dom.TagName.BIG="BIG";goog.dom.TagName.BLOCKQUOTE="BLOCKQUOTE";goog.dom.TagName.BODY="BODY";goog.dom.TagName.BR="BR";goog.dom.TagName.BUTTON="BUTTON";goog.dom.TagName.CANVAS="CANVAS";goog.dom.TagName.CAPTION="CAPTION";goog.dom.TagName.CENTER="CENTER";goog.dom.TagName.CITE="CITE";goog.dom.TagName.CODE="CODE";goog.dom.TagName.COL="COL";goog.dom.TagName.COLGROUP="COLGROUP";goog.dom.TagName.COMMAND="COMMAND";goog.dom.TagName.DATA="DATA";goog.dom.TagName.DATALIST="DATALIST";goog.dom.TagName.DD="DD";
goog.dom.TagName.DEL="DEL";goog.dom.TagName.DETAILS="DETAILS";goog.dom.TagName.DFN="DFN";goog.dom.TagName.DIALOG="DIALOG";goog.dom.TagName.DIR="DIR";goog.dom.TagName.DIV="DIV";goog.dom.TagName.DL="DL";goog.dom.TagName.DT="DT";goog.dom.TagName.EM="EM";goog.dom.TagName.EMBED="EMBED";goog.dom.TagName.FIELDSET="FIELDSET";goog.dom.TagName.FIGCAPTION="FIGCAPTION";goog.dom.TagName.FIGURE="FIGURE";goog.dom.TagName.FONT="FONT";goog.dom.TagName.FOOTER="FOOTER";goog.dom.TagName.FORM="FORM";
goog.dom.TagName.FRAME="FRAME";goog.dom.TagName.FRAMESET="FRAMESET";goog.dom.TagName.H1="H1";goog.dom.TagName.H2="H2";goog.dom.TagName.H3="H3";goog.dom.TagName.H4="H4";goog.dom.TagName.H5="H5";goog.dom.TagName.H6="H6";goog.dom.TagName.HEAD="HEAD";goog.dom.TagName.HEADER="HEADER";goog.dom.TagName.HGROUP="HGROUP";goog.dom.TagName.HR="HR";goog.dom.TagName.HTML="HTML";goog.dom.TagName.I="I";goog.dom.TagName.IFRAME="IFRAME";goog.dom.TagName.IMG="IMG";goog.dom.TagName.INPUT="INPUT";
goog.dom.TagName.INS="INS";goog.dom.TagName.ISINDEX="ISINDEX";goog.dom.TagName.KBD="KBD";goog.dom.TagName.KEYGEN="KEYGEN";goog.dom.TagName.LABEL="LABEL";goog.dom.TagName.LEGEND="LEGEND";goog.dom.TagName.LI="LI";goog.dom.TagName.LINK="LINK";goog.dom.TagName.MAIN="MAIN";goog.dom.TagName.MAP="MAP";goog.dom.TagName.MARK="MARK";goog.dom.TagName.MATH="MATH";goog.dom.TagName.MENU="MENU";goog.dom.TagName.MENUITEM="MENUITEM";goog.dom.TagName.META="META";goog.dom.TagName.METER="METER";
goog.dom.TagName.NAV="NAV";goog.dom.TagName.NOFRAMES="NOFRAMES";goog.dom.TagName.NOSCRIPT="NOSCRIPT";goog.dom.TagName.OBJECT="OBJECT";goog.dom.TagName.OL="OL";goog.dom.TagName.OPTGROUP="OPTGROUP";goog.dom.TagName.OPTION="OPTION";goog.dom.TagName.OUTPUT="OUTPUT";goog.dom.TagName.P="P";goog.dom.TagName.PARAM="PARAM";goog.dom.TagName.PICTURE="PICTURE";goog.dom.TagName.PRE="PRE";goog.dom.TagName.PROGRESS="PROGRESS";goog.dom.TagName.Q="Q";goog.dom.TagName.RP="RP";goog.dom.TagName.RT="RT";
goog.dom.TagName.RTC="RTC";goog.dom.TagName.RUBY="RUBY";goog.dom.TagName.S="S";goog.dom.TagName.SAMP="SAMP";goog.dom.TagName.SCRIPT="SCRIPT";goog.dom.TagName.SECTION="SECTION";goog.dom.TagName.SELECT="SELECT";goog.dom.TagName.SMALL="SMALL";goog.dom.TagName.SOURCE="SOURCE";goog.dom.TagName.SPAN="SPAN";goog.dom.TagName.STRIKE="STRIKE";goog.dom.TagName.STRONG="STRONG";goog.dom.TagName.STYLE="STYLE";goog.dom.TagName.SUB="SUB";goog.dom.TagName.SUMMARY="SUMMARY";goog.dom.TagName.SUP="SUP";
goog.dom.TagName.SVG="SVG";goog.dom.TagName.TABLE="TABLE";goog.dom.TagName.TBODY="TBODY";goog.dom.TagName.TD="TD";goog.dom.TagName.TEMPLATE="TEMPLATE";goog.dom.TagName.TEXTAREA="TEXTAREA";goog.dom.TagName.TFOOT="TFOOT";goog.dom.TagName.TH="TH";goog.dom.TagName.THEAD="THEAD";goog.dom.TagName.TIME="TIME";goog.dom.TagName.TITLE="TITLE";goog.dom.TagName.TR="TR";goog.dom.TagName.TRACK="TRACK";goog.dom.TagName.TT="TT";goog.dom.TagName.U="U";goog.dom.TagName.UL="UL";goog.dom.TagName.VAR="VAR";
goog.dom.TagName.VIDEO="VIDEO";goog.dom.TagName.WBR="WBR";goog.labs={};goog.labs.userAgent={};const module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE="",module$contents$goog$labs$userAgent_USE_CLIENT_HINTS=!1;let module$contents$goog$labs$userAgent_forceClientHintsInTests=!1;goog.labs.userAgent.setUseClientHintsForTesting=a=>{module$contents$goog$labs$userAgent_forceClientHintsInTests=a};
const module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride=module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE?!!goog.getObjectByName(module$contents$goog$labs$userAgent_USE_CLIENT_HINTS_OVERRIDE):!1;goog.labs.userAgent.useClientHints=()=>module$contents$goog$labs$userAgent_USE_CLIENT_HINTS||module$contents$goog$labs$userAgent_useClientHintsRuntimeOverride||module$contents$goog$labs$userAgent_forceClientHintsInTests;goog.labs.userAgent.util={};const module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT=!1;function module$contents$goog$labs$userAgent$util_getNativeUserAgentString(){var a=module$contents$goog$labs$userAgent$util_getNavigator();return a&&(a=a.userAgent)?a:""}function module$contents$goog$labs$userAgent$util_getNativeUserAgentData(){const a=module$contents$goog$labs$userAgent$util_getNavigator();return a?a.userAgentData||null:null}
function module$contents$goog$labs$userAgent$util_getNavigator(){return goog.global.navigator}let module$contents$goog$labs$userAgent$util_userAgentInternal=null,module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData();
function module$contents$goog$labs$userAgent$util_setUserAgent(a){module$contents$goog$labs$userAgent$util_userAgentInternal="string"===typeof a?a:module$contents$goog$labs$userAgent$util_getNativeUserAgentString()}function module$contents$goog$labs$userAgent$util_getUserAgent(){return null==module$contents$goog$labs$userAgent$util_userAgentInternal?module$contents$goog$labs$userAgent$util_getNativeUserAgentString():module$contents$goog$labs$userAgent$util_userAgentInternal}
function module$contents$goog$labs$userAgent$util_setUserAgentData(a){module$contents$goog$labs$userAgent$util_userAgentDataInternal=a}function module$contents$goog$labs$userAgent$util_resetUserAgentData(){module$contents$goog$labs$userAgent$util_userAgentDataInternal=module$contents$goog$labs$userAgent$util_getNativeUserAgentData()}function module$contents$goog$labs$userAgent$util_getUserAgentData(){return module$contents$goog$labs$userAgent$util_userAgentDataInternal}
function module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(a){if(!(0,goog.labs.userAgent.useClientHints)())return!1;const b=module$contents$goog$labs$userAgent$util_getUserAgentData();return b?b.brands.some(({brand:c})=>c&&(0,goog.string.internal.contains)(c,a)):!1}function module$contents$goog$labs$userAgent$util_matchUserAgent(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.contains)(b,a)}
function module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase(a){const b=module$contents$goog$labs$userAgent$util_getUserAgent();return(0,goog.string.internal.caseInsensitiveContains)(b,a)}function module$contents$goog$labs$userAgent$util_extractVersionTuples(a){const b=RegExp("([A-Z][\\w ]+)/([^\\s]+)\\s*(?:\\((.*?)\\))?","g"),c=[];let d;for(;d=b.exec(a);)c.push([d[1],d[2],d[3]||void 0]);return c}goog.labs.userAgent.util.ASSUME_CLIENT_HINTS_SUPPORT=module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT;
goog.labs.userAgent.util.extractVersionTuples=module$contents$goog$labs$userAgent$util_extractVersionTuples;goog.labs.userAgent.util.getNativeUserAgentString=module$contents$goog$labs$userAgent$util_getNativeUserAgentString;goog.labs.userAgent.util.getUserAgent=module$contents$goog$labs$userAgent$util_getUserAgent;goog.labs.userAgent.util.getUserAgentData=module$contents$goog$labs$userAgent$util_getUserAgentData;goog.labs.userAgent.util.matchUserAgent=module$contents$goog$labs$userAgent$util_matchUserAgent;
goog.labs.userAgent.util.matchUserAgentDataBrand=module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand;goog.labs.userAgent.util.matchUserAgentIgnoreCase=module$contents$goog$labs$userAgent$util_matchUserAgentIgnoreCase;goog.labs.userAgent.util.resetUserAgentData=module$contents$goog$labs$userAgent$util_resetUserAgentData;goog.labs.userAgent.util.setUserAgent=module$contents$goog$labs$userAgent$util_setUserAgent;goog.labs.userAgent.util.setUserAgentData=module$contents$goog$labs$userAgent$util_setUserAgentData;var module$exports$goog$labs$userAgent$highEntropy$highEntropyValue={AsyncValue:class{getIfLoaded(){}load(){}},HighEntropyValue:class{constructor(a){this.key_=a;this.promise_=this.value_=void 0;this.pending_=!1}getIfLoaded(){if(module$contents$goog$labs$userAgent$util_getUserAgentData())return this.value_}async load(){const a=module$contents$goog$labs$userAgent$util_getUserAgentData();if(a)return this.promise_||(this.pending_=!0,this.promise_=(async()=>{try{return this.value_=(await a.getHighEntropyValues([this.key_]))[this.key_]}finally{this.pending_=
!1}})()),await this.promise_}resetForTesting(){if(this.pending_)throw Error("Unsafe call to resetForTesting");this.value_=this.promise_=void 0;this.pending_=!1}},Version:class{constructor(a){this.versionString_=a}toVersionStringForLogging(){return this.versionString_}isAtLeast(a){return 0<=(0,goog.string.internal.compareVersions)(this.versionString_,a)}}};var module$exports$goog$labs$userAgent$highEntropy$highEntropyData={};module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("fullVersionList");module$exports$goog$labs$userAgent$highEntropy$highEntropyData.platformVersion=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.HighEntropyValue("platformVersion");goog.labs.userAgent.browser={};const module$contents$goog$labs$userAgent$browser_Brand={ANDROID_BROWSER:"Android Browser",CHROMIUM:"Chromium",EDGE:"Microsoft Edge",FIREFOX:"Firefox",IE:"Internet Explorer",OPERA:"Opera",SAFARI:"Safari",SILK:"Silk"};goog.labs.userAgent.browser.Brand=module$contents$goog$labs$userAgent$browser_Brand;
function module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(a=!1){if(module$contents$goog$labs$userAgent$util_ASSUME_CLIENT_HINTS_SUPPORT)return!0;if(!a&&!(0,goog.labs.userAgent.useClientHints)())return!1;a=module$contents$goog$labs$userAgent$util_getUserAgentData();return!!a&&0<a.brands.length}
function module$contents$goog$labs$userAgent$browser_hasFullVersionList(){return module$contents$goog$labs$userAgent$browser_isAtLeast(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM,98)}function module$contents$goog$labs$userAgent$browser_matchOpera(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Opera")}
function module$contents$goog$labs$userAgent$browser_matchIE(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Trident")||module$contents$goog$labs$userAgent$util_matchUserAgent("MSIE")}function module$contents$goog$labs$userAgent$browser_matchEdgeHtml(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Edge")}
function module$contents$goog$labs$userAgent$browser_matchEdgeChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.EDGE):module$contents$goog$labs$userAgent$util_matchUserAgent("Edg/")}
function module$contents$goog$labs$userAgent$browser_matchOperaChromium(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.OPERA):module$contents$goog$labs$userAgent$util_matchUserAgent("OPR")}
function module$contents$goog$labs$userAgent$browser_matchFirefox(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Firefox")||module$contents$goog$labs$userAgent$util_matchUserAgent("FxiOS")}
function module$contents$goog$labs$userAgent$browser_matchSafari(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Safari")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchCoast()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_matchEdgeChromium()||module$contents$goog$labs$userAgent$browser_matchOperaChromium()||
module$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_isSilk()||module$contents$goog$labs$userAgent$util_matchUserAgent("Android"))}function module$contents$goog$labs$userAgent$browser_matchCoast(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?!1:module$contents$goog$labs$userAgent$util_matchUserAgent("Coast")}
function module$contents$goog$labs$userAgent$browser_matchIosWebview(){return(module$contents$goog$labs$userAgent$util_matchUserAgent("iPad")||module$contents$goog$labs$userAgent$util_matchUserAgent("iPhone"))&&!module$contents$goog$labs$userAgent$browser_matchSafari()&&!module$contents$goog$labs$userAgent$browser_matchChrome()&&!module$contents$goog$labs$userAgent$browser_matchCoast()&&!module$contents$goog$labs$userAgent$browser_matchFirefox()&&module$contents$goog$labs$userAgent$util_matchUserAgent("AppleWebKit")}
function module$contents$goog$labs$userAgent$browser_matchChrome(){return module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()?module$contents$goog$labs$userAgent$util_matchUserAgentDataBrand(module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM):(module$contents$goog$labs$userAgent$util_matchUserAgent("Chrome")||module$contents$goog$labs$userAgent$util_matchUserAgent("CriOS"))&&!module$contents$goog$labs$userAgent$browser_matchEdgeHtml()||module$contents$goog$labs$userAgent$browser_isSilk()}
function module$contents$goog$labs$userAgent$browser_matchAndroidBrowser(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Android")&&!(module$contents$goog$labs$userAgent$browser_matchChrome()||module$contents$goog$labs$userAgent$browser_matchFirefox()||module$contents$goog$labs$userAgent$browser_matchOpera()||module$contents$goog$labs$userAgent$browser_isSilk())}const module$contents$goog$labs$userAgent$browser_isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;
goog.labs.userAgent.browser.isOpera=module$contents$goog$labs$userAgent$browser_matchOpera;const module$contents$goog$labs$userAgent$browser_isIE=module$contents$goog$labs$userAgent$browser_matchIE;goog.labs.userAgent.browser.isIE=module$contents$goog$labs$userAgent$browser_matchIE;const module$contents$goog$labs$userAgent$browser_isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;goog.labs.userAgent.browser.isEdge=module$contents$goog$labs$userAgent$browser_matchEdgeHtml;
const module$contents$goog$labs$userAgent$browser_isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;goog.labs.userAgent.browser.isEdgeChromium=module$contents$goog$labs$userAgent$browser_matchEdgeChromium;const module$contents$goog$labs$userAgent$browser_isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;goog.labs.userAgent.browser.isOperaChromium=module$contents$goog$labs$userAgent$browser_matchOperaChromium;
const module$contents$goog$labs$userAgent$browser_isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;goog.labs.userAgent.browser.isFirefox=module$contents$goog$labs$userAgent$browser_matchFirefox;const module$contents$goog$labs$userAgent$browser_isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;goog.labs.userAgent.browser.isSafari=module$contents$goog$labs$userAgent$browser_matchSafari;const module$contents$goog$labs$userAgent$browser_isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;
goog.labs.userAgent.browser.isCoast=module$contents$goog$labs$userAgent$browser_matchCoast;const module$contents$goog$labs$userAgent$browser_isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;goog.labs.userAgent.browser.isIosWebview=module$contents$goog$labs$userAgent$browser_matchIosWebview;const module$contents$goog$labs$userAgent$browser_isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;goog.labs.userAgent.browser.isChrome=module$contents$goog$labs$userAgent$browser_matchChrome;
const module$contents$goog$labs$userAgent$browser_isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;goog.labs.userAgent.browser.isAndroidBrowser=module$contents$goog$labs$userAgent$browser_matchAndroidBrowser;function module$contents$goog$labs$userAgent$browser_isSilk(){return module$contents$goog$labs$userAgent$util_matchUserAgent("Silk")}goog.labs.userAgent.browser.isSilk=module$contents$goog$labs$userAgent$browser_isSilk;
function module$contents$goog$labs$userAgent$browser_createVersionMap(a){const b={};a.forEach(c=>{b[c[0]]=c[1]});return c=>b[c.find(d=>d in b)]||""}
function module$contents$goog$labs$userAgent$browser_getVersion(){var a=module$contents$goog$labs$userAgent$util_getUserAgent();if(module$contents$goog$labs$userAgent$browser_matchIE())return module$contents$goog$labs$userAgent$browser_getIEVersion(a);a=module$contents$goog$labs$userAgent$util_extractVersionTuples(a);const b=module$contents$goog$labs$userAgent$browser_createVersionMap(a);return module$contents$goog$labs$userAgent$browser_matchOpera()?b(["Version","Opera"]):module$contents$goog$labs$userAgent$browser_matchEdgeHtml()?
b(["Edge"]):module$contents$goog$labs$userAgent$browser_matchEdgeChromium()?b(["Edg"]):module$contents$goog$labs$userAgent$browser_isSilk()?b(["Silk"]):module$contents$goog$labs$userAgent$browser_matchChrome()?b(["Chrome","CriOS","HeadlessChrome"]):(a=a[2])&&a[1]||""}goog.labs.userAgent.browser.getVersion=module$contents$goog$labs$userAgent$browser_getVersion;
function module$contents$goog$labs$userAgent$browser_isVersionOrHigher(a){return 0<=(0,goog.string.internal.compareVersions)(module$contents$goog$labs$userAgent$browser_getVersion(),a)}goog.labs.userAgent.browser.isVersionOrHigher=module$contents$goog$labs$userAgent$browser_isVersionOrHigher;
function module$contents$goog$labs$userAgent$browser_getIEVersion(a){var b=/rv: *([\d\.]*)/.exec(a);if(b&&b[1])return b[1];b="";const c=/MSIE +([\d\.]+)/.exec(a);if(c&&c[1])if(a=/Trident\/(\d.\d)/.exec(a),"7.0"==c[1])if(a&&a[1])switch(a[1]){case "4.0":b="8.0";break;case "5.0":b="9.0";break;case "6.0":b="10.0";break;case "7.0":b="11.0"}else b="7.0";else b=c[1];return b}
function module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a){var b=module$contents$goog$labs$userAgent$util_getUserAgent();if(a===module$contents$goog$labs$userAgent$browser_Brand.IE)return module$contents$goog$labs$userAgent$browser_matchIE()?module$contents$goog$labs$userAgent$browser_getIEVersion(b):"";b=module$contents$goog$labs$userAgent$util_extractVersionTuples(b);const c=module$contents$goog$labs$userAgent$browser_createVersionMap(b);switch(a){case module$contents$goog$labs$userAgent$browser_Brand.OPERA:if(module$contents$goog$labs$userAgent$browser_matchOpera())return c(["Version",
"Opera"]);if(module$contents$goog$labs$userAgent$browser_matchOperaChromium())return c(["OPR"]);break;case module$contents$goog$labs$userAgent$browser_Brand.EDGE:if(module$contents$goog$labs$userAgent$browser_matchEdgeHtml())return c(["Edge"]);if(module$contents$goog$labs$userAgent$browser_matchEdgeChromium())return c(["Edg"]);break;case module$contents$goog$labs$userAgent$browser_Brand.CHROMIUM:if(module$contents$goog$labs$userAgent$browser_matchChrome())return c(["Chrome","CriOS","HeadlessChrome"])}return a===
module$contents$goog$labs$userAgent$browser_Brand.FIREFOX&&module$contents$goog$labs$userAgent$browser_matchFirefox()||a===module$contents$goog$labs$userAgent$browser_Brand.SAFARI&&module$contents$goog$labs$userAgent$browser_matchSafari()||a===module$contents$goog$labs$userAgent$browser_Brand.ANDROID_BROWSER&&module$contents$goog$labs$userAgent$browser_matchAndroidBrowser()||a===module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_isSilk()?(a=b[2])&&
a[1]||"":""}
function module$contents$goog$labs$userAgent$browser_versionOf_(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand()&&a!==module$contents$goog$labs$userAgent$browser_Brand.SILK){var b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);if(!b||!b.version)return NaN;b=b.version.split(".")}else{b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a);if(""===b)return NaN;b=b.split(".")}return 0===b.length?NaN:Number(b[0])}
function module$contents$goog$labs$userAgent$browser_isAtLeast(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)>=b}goog.labs.userAgent.browser.isAtLeast=module$contents$goog$labs$userAgent$browser_isAtLeast;
function module$contents$goog$labs$userAgent$browser_isAtMost(a,b){(0,goog.asserts.assert)(Math.floor(b)===b,"Major version must be an integer");return module$contents$goog$labs$userAgent$browser_versionOf_(a)<=b}goog.labs.userAgent.browser.isAtMost=module$contents$goog$labs$userAgent$browser_isAtMost;
class module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion{constructor(a,b,c){this.brand_=a;this.version_=new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(c);this.useUach_=b}getIfLoaded(){if(this.useUach_){var a=module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.getIfLoaded();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}if(module$contents$goog$labs$userAgent$browser_preUachHasLoaded)return this.version_}async load(){if(this.useUach_){var a=
await module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();if(void 0!==a)return a=a.find(({brand:b})=>this.brand_===b),(0,goog.asserts.assertExists)(a),new module$exports$goog$labs$userAgent$highEntropy$highEntropyValue.Version(a.version)}else await 0;module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0;return this.version_}}let module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;
async function module$contents$goog$labs$userAgent$browser_loadFullVersions(){module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)&&await module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.load();module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!0}goog.labs.userAgent.browser.loadFullVersions=module$contents$goog$labs$userAgent$browser_loadFullVersions;
goog.labs.userAgent.browser.resetForTesting=()=>{module$contents$goog$labs$userAgent$browser_preUachHasLoaded=!1;module$exports$goog$labs$userAgent$highEntropy$highEntropyData.fullVersionList.resetForTesting()};
function module$contents$goog$labs$userAgent$browser_fullVersionOf(a){let b="";module$contents$goog$labs$userAgent$browser_hasFullVersionList()||(b=module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a));const c=a!==module$contents$goog$labs$userAgent$browser_Brand.SILK&&module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0);if(c){if(!module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:d})=>d===a))return}else if(""===b)return;return new module$contents$goog$labs$userAgent$browser_HighEntropyBrandVersion(a,
c,b)}goog.labs.userAgent.browser.fullVersionOf=module$contents$goog$labs$userAgent$browser_fullVersionOf;
function module$contents$goog$labs$userAgent$browser_getVersionStringForLogging(a){if(module$contents$goog$labs$userAgent$browser_useUserAgentDataBrand(!0)){var b=module$contents$goog$labs$userAgent$browser_fullVersionOf(a);if(b){if(b=b.getIfLoaded())return b.toVersionStringForLogging();b=module$contents$goog$labs$userAgent$util_getUserAgentData().brands.find(({brand:c})=>c===a);(0,goog.asserts.assertExists)(b);return b.version}return""}return module$contents$goog$labs$userAgent$browser_getFullVersionFromUserAgentString(a)}
goog.labs.userAgent.browser.getVersionStringForLogging=module$contents$goog$labs$userAgent$browser_getVersionStringForLogging;goog.dom.tags={};goog.dom.tags.VOID_TAGS_={area:!0,base:!0,br:!0,col:!0,command:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};goog.dom.tags.isVoidTag=function(a){return!0===goog.dom.tags.VOID_TAGS_[a]};const module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE={};
class module$contents$goog$html$SafeHtml_SafeHtml{constructor(a,b){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_=b===module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE?a:"";this.implementsGoogStringTypedString=!0}getTypedStringValue(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}toString(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString()}static unwrap(a){return module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(a).toString()}static unwrapTrustedHTML(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml&&
a.constructor===module$contents$goog$html$SafeHtml_SafeHtml)return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_;goog.asserts.fail(`expected object of type SafeHtml, got '${a}' of type `+goog.typeOf(a));return"type_error:SafeHtml"}static htmlEscape(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.htmlEscape(a))}static htmlEscapePreservingNewlines(a){if(a instanceof
module$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.newLineToBr(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static htmlEscapePreservingNewlinesAndSpaces(a){if(a instanceof module$contents$goog$html$SafeHtml_SafeHtml)return a;a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.internal.whitespaceEscape(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static comment(a){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("\x3c!--"+
goog.string.internal.htmlEscape(a)+"--\x3e")}static create(a,b,c){module$contents$goog$html$SafeHtml_SafeHtml.verifyTagName(String(a));return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(String(a),b,c)}static verifyTagName(a){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Invalid tag name <${a}>.`:"");if(a.toUpperCase()in module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
`Tag name <${a}> is not allowed for SafeHtml.`:"");}static createIframe(a,b,c,d){a&&goog.html.TrustedResourceUrl.unwrap(a);const e={};e.src=a||null;e.srcdoc=b&&module$contents$goog$html$SafeHtml_SafeHtml.unwrap(b);a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{sandbox:""},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static createSandboxIframe(a,b,c,d){if(!module$contents$goog$html$SafeHtml_SafeHtml.canUseSandboxIframe())throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
"The browser does not support sandboxed iframes.":"");const e={};e.src=a?goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a)):null;e.srcdoc=b||null;e.sandbox="";a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes(e,{},c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)}static canUseSandboxIframe(){return goog.global.HTMLIFrameElement&&"sandbox"in goog.global.HTMLIFrameElement.prototype}static createScriptSrc(a,b){goog.html.TrustedResourceUrl.unwrap(a);
a=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({src:a},{},b);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",a)}static createScript(a,b){for(var c in b)if(Object.prototype.hasOwnProperty.call(b,c)){var d=c.toLowerCase();if("language"==d||"src"==d||"text"==d)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot set "${d}" attribute`:"");}c="";a=module$contents$goog$array_concat(a);for(d=0;d<
a.length;d++)c+=module$contents$goog$html$SafeScript_SafeScript.unwrap(a[d]);a=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",b,a)}static createStyle(a,b){b=module$contents$goog$html$SafeHtml_SafeHtml.combineAttributes({type:"text/css"},{},b);let c="";a=module$contents$goog$array_concat(a);for(let d=0;d<a.length;d++)c+=module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.unwrap(a[d]);
a=module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("style",b,a)}static createMetaRefresh(a,b){a=goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a));(module$contents$goog$labs$userAgent$browser_matchIE()||module$contents$goog$labs$userAgent$browser_matchEdgeHtml())&&goog.string.internal.contains(a,";")&&(a="'"+a.replace(/'/g,"%27")+"'");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("meta",
{"http-equiv":"refresh",content:(b||0)+"; url="+a})}static join(a,b){a=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(a);const c=[],d=e=>{Array.isArray(e)?e.forEach(d):(e=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape(e),c.push(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(e)))};b.forEach(d);return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c.join(module$contents$goog$html$SafeHtml_SafeHtml.unwrap(a)))}static concat(a){return module$contents$goog$html$SafeHtml_SafeHtml.join(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY,
Array.prototype.slice.call(arguments))}static createSafeHtmlSecurityPrivateDoNotAccessOrElse(a){const b=goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();a=b?b.createHTML(a):a;return new module$contents$goog$html$SafeHtml_SafeHtml(a,module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE)}static createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(a,b,c){b=`<${a}`+module$contents$goog$html$SafeHtml_SafeHtml.stringifyAttributes(a,b);null==c?c=[]:Array.isArray(c)||(c=[c]);goog.dom.tags.isVoidTag(a.toLowerCase())?
(goog.asserts.assert(!c.length,`Void tag <${a}> does not allow content.`),b+=">"):(c=module$contents$goog$html$SafeHtml_SafeHtml.concat(c),b+=">"+module$contents$goog$html$SafeHtml_SafeHtml.unwrap(c)+"</"+a+">");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)}static stringifyAttributes(a,b){let c="";if(b)for(let d in b)if(Object.prototype.hasOwnProperty.call(b,d)){if(!module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG.test(d))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
`Invalid attribute name "${d}".`:"");const e=b[d];null!=e&&(c+=" "+module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,d,e))}return c}static combineAttributes(a,b,c){const d={};for(var e in a)Object.prototype.hasOwnProperty.call(a,e)&&(goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=a[e]);for(const f in b)Object.prototype.hasOwnProperty.call(b,f)&&(goog.asserts.assert(f.toLowerCase()==f,"Must be lower case"),d[f]=b[f]);if(c)for(const f in c)if(Object.prototype.hasOwnProperty.call(c,
f)){e=f.toLowerCase();if(e in a)throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Cannot override "${e}" attribute, got "`+f+'" with value "'+c[f]+'"':"");e in b&&delete d[e];d[f]=c[f]}return d}}module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES=goog.DEBUG;module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE=!0;module$contents$goog$html$SafeHtml_SafeHtml.from=module$contents$goog$html$SafeHtml_SafeHtml.htmlEscape;
const module$contents$goog$html$SafeHtml_VALID_NAMES_IN_TAG=/^[a-zA-Z0-9-]+$/,module$contents$goog$html$SafeHtml_URL_ATTRIBUTES={action:!0,cite:!0,data:!0,formaction:!0,href:!0,manifest:!0,poster:!0,src:!0},module$contents$goog$html$SafeHtml_NOT_ALLOWED_TAG_NAMES={[goog.dom.TagName.APPLET]:!0,[goog.dom.TagName.BASE]:!0,[goog.dom.TagName.EMBED]:!0,[goog.dom.TagName.IFRAME]:!0,[goog.dom.TagName.LINK]:!0,[goog.dom.TagName.MATH]:!0,[goog.dom.TagName.META]:!0,[goog.dom.TagName.OBJECT]:!0,[goog.dom.TagName.SCRIPT]:!0,
[goog.dom.TagName.STYLE]:!0,[goog.dom.TagName.SVG]:!0,[goog.dom.TagName.TEMPLATE]:!0};
function module$contents$goog$html$SafeHtml_getAttrNameAndValue(a,b,c){if(c instanceof goog.string.Const)c=goog.string.Const.unwrap(c);else if("style"==b.toLowerCase())if(module$contents$goog$html$SafeHtml_SafeHtml.SUPPORT_STYLE_ATTRIBUTE)c=module$contents$goog$html$SafeHtml_getStyleValue(c);else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?'Attribute "style" not supported.':"");else{if(/^on/i.test(b))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?
`Attribute "${b}`+'" requires goog.string.Const value, "'+c+'" given.':"");if(b.toLowerCase()in module$contents$goog$html$SafeHtml_URL_ATTRIBUTES)if(c instanceof goog.html.TrustedResourceUrl)c=goog.html.TrustedResourceUrl.unwrap(c);else if(c instanceof goog.html.SafeUrl)c=goog.html.SafeUrl.unwrap(c);else if("string"===typeof c)c=goog.html.SafeUrl.sanitize(c).getTypedStringValue();else throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?`Attribute "${b}" on tag "${a}`+'" requires goog.html.SafeUrl, goog.string.Const, or string, value "'+
c+'" given.':"");}c.implementsGoogStringTypedString&&(c=c.getTypedStringValue());goog.asserts.assert("string"===typeof c||"number"===typeof c,"String or number value expected, got "+typeof c+" with value: "+c);return`${b}="`+goog.string.internal.htmlEscape(String(c))+'"'}
function module$contents$goog$html$SafeHtml_getStyleValue(a){if(!goog.isObject(a))throw Error(module$contents$goog$html$SafeHtml_SafeHtml.ENABLE_ERROR_MESSAGES?'The "style" attribute requires goog.html.SafeStyle or map of style properties, '+typeof a+" given: "+a:"");a instanceof module$contents$goog$html$SafeStyle_SafeStyle||(a=module$contents$goog$html$SafeStyle_SafeStyle.create(a));return module$contents$goog$html$SafeStyle_SafeStyle.unwrap(a)}
module$contents$goog$html$SafeHtml_SafeHtml.DOCTYPE_HTML=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<!DOCTYPE html>")}();module$contents$goog$html$SafeHtml_SafeHtml.EMPTY=new module$contents$goog$html$SafeHtml_SafeHtml(goog.global.trustedTypes&&goog.global.trustedTypes.emptyHTML||"",module$contents$goog$html$SafeHtml_CONSTRUCTOR_TOKEN_PRIVATE);module$contents$goog$html$SafeHtml_SafeHtml.BR=function(){return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<br>")}();
goog.html.SafeHtml=module$contents$goog$html$SafeHtml_SafeHtml;goog.html.uncheckedconversions={};goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeHtml_SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b)};
goog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeScript_SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(b)};
goog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyle_SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};
goog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return module$contents$goog$html$SafeStyleSheet_SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};
goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};
goog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.dom.safe={};goog.dom.safe.InsertAdjacentHtmlPosition={AFTERBEGIN:"afterbegin",AFTEREND:"afterend",BEFOREBEGIN:"beforebegin",BEFOREEND:"beforeend"};goog.dom.safe.insertAdjacentHtml=function(a,b,c){a.insertAdjacentHTML(b,module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(c))};goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_={MATH:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};
goog.dom.safe.isInnerHtmlCleanupRecursive_=goog.functions.cacheReturnValue(function(){if(goog.DEBUG&&"undefined"===typeof document)return!1;var a=document.createElement("div"),b=document.createElement("div");b.appendChild(document.createElement("div"));a.appendChild(b);if(goog.DEBUG&&!a.firstChild)return!1;b=a.firstChild.firstChild;a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(module$contents$goog$html$SafeHtml_SafeHtml.EMPTY);return!b.parentElement});
goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse=function(a,b){if(goog.dom.safe.isInnerHtmlCleanupRecursive_())for(;a.lastChild;)a.removeChild(a.lastChild);a.innerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};
goog.dom.safe.setInnerHtml=function(a,b){if(goog.asserts.ENABLE_ASSERTS&&a.tagName){var c=a.tagName.toUpperCase();if(goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[c])throw Error("goog.dom.safe.setInnerHtml cannot be used to set content of "+a.tagName+".");}goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse(a,b)};
goog.dom.safe.setInnerHtmlFromConstant=function(a,b){goog.dom.safe.setInnerHtml(a,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Constant HTML to be immediatelly used."),goog.string.Const.unwrap(b)))};goog.dom.safe.setOuterHtml=function(a,b){a.outerHTML=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};
goog.dom.safe.setFormElementAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLFormElement(a).action=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setButtonFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLButtonElement(a).formAction=goog.html.SafeUrl.unwrap(b)};
goog.dom.safe.setInputFormAction=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLInputElement(a).formAction=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setStyle=function(a,b){a.style.cssText=module$contents$goog$html$SafeStyle_SafeStyle.unwrap(b)};goog.dom.safe.documentWrite=function(a,b){a.write(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};
goog.dom.safe.setAnchorHref=function(a,b){goog.dom.asserts.assertIsHTMLAnchorElement(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setAudioSrc=function(a,b){goog.dom.asserts.assertIsHTMLAudioElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:audio\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};
goog.dom.safe.setVideoSrc=function(a,b){goog.dom.asserts.assertIsHTMLVideoElement(a);if(!(b instanceof goog.html.SafeUrl)){var c=/^data:video\//i.test(b);b=goog.html.SafeUrl.sanitizeAssertUnchanged(b,c)}a.src=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.setEmbedSrc=function(a,b){goog.dom.asserts.assertIsHTMLEmbedElement(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setFrameSrc=function(a,b){goog.dom.asserts.assertIsHTMLFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};
goog.dom.safe.setIframeSrc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrcdoc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.srcdoc=module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b)};
goog.dom.safe.setLinkHrefAndRel=function(a,b,c){goog.dom.asserts.assertIsHTMLLinkElement(a);a.rel=c;goog.string.internal.caseInsensitiveContains(c,"stylesheet")?(goog.asserts.assert(b instanceof goog.html.TrustedResourceUrl,'URL must be TrustedResourceUrl because "rel" contains "stylesheet"'),a.href=goog.html.TrustedResourceUrl.unwrap(b),(b=goog.dom.safe.getStyleNonce(a.ownerDocument&&a.ownerDocument.defaultView))&&a.setAttribute("nonce",b)):a.href=b instanceof goog.html.TrustedResourceUrl?goog.html.TrustedResourceUrl.unwrap(b):
b instanceof goog.html.SafeUrl?goog.html.SafeUrl.unwrap(b):goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitizeAssertUnchanged(b))};goog.dom.safe.setObjectData=function(a,b){goog.dom.asserts.assertIsHTMLObjectElement(a);a.data=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};goog.dom.safe.setScriptSrc=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.src=goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b)};
goog.dom.safe.setScriptContent=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);goog.dom.safe.setNonceForScriptElement_(a);a.textContent=module$contents$goog$html$SafeScript_SafeScript.unwrapTrustedScript(b)};goog.dom.safe.setNonceForScriptElement_=function(a){const b=goog.dom.safe.getScriptNonce(a.ownerDocument&&a.ownerDocument.defaultView);b&&a.setAttribute("nonce",b)};
goog.dom.safe.setLocationHref=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(b)};goog.dom.safe.assignLocation=function(a,b){goog.dom.asserts.assertIsLocation(a);b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.assign(goog.html.SafeUrl.unwrap(b))};
goog.dom.safe.replaceLocation=function(a,b){b=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.replace(goog.html.SafeUrl.unwrap(b))};goog.dom.safe.openInWindow=function(a,b,c,d){a=a instanceof goog.html.SafeUrl?a:goog.html.SafeUrl.sanitizeAssertUnchanged(a);b=b||goog.global;c=c instanceof goog.string.Const?goog.string.Const.unwrap(c):c||"";return void 0!==d?b.open(goog.html.SafeUrl.unwrap(a),c,d):b.open(goog.html.SafeUrl.unwrap(a),c)};
goog.dom.safe.parseFromStringHtml=function(a,b){return goog.dom.safe.parseFromString(a,b,"text/html")};goog.dom.safe.parseFromString=function(a,b,c){return a.parseFromString(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b),c)};
goog.dom.safe.createImageFromBlob=function(a){if(!/^image\/.*/g.test(a.type))throw Error("goog.dom.safe.createImageFromBlob only accepts MIME type image/.*.");var b=goog.global.URL.createObjectURL(a);a=new goog.global.Image;a.onload=function(){goog.global.URL.revokeObjectURL(b)};a.src=b;return a};goog.dom.safe.createContextualFragment=function(a,b){return a.createContextualFragment(module$contents$goog$html$SafeHtml_SafeHtml.unwrapTrustedHTML(b))};
goog.dom.safe.getScriptNonce=function(a){return goog.dom.safe.getNonce_("script[nonce]",a)};goog.dom.safe.getStyleNonce=function(a){return goog.dom.safe.getNonce_('style[nonce],link[rel="stylesheet"][nonce]',a)};goog.dom.safe.NONCE_PATTERN_=/^[\w+/_-]+[=]{0,2}$/;goog.dom.safe.getNonce_=function(a,b){b=(b||goog.global).document;return b.querySelector?(a=b.querySelector(a))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.dom.safe.NONCE_PATTERN_.test(a)?a:"":""};goog.string.DETECT_DOUBLE_ESCAPING=!1;goog.string.FORCE_NON_DOM_HTML_UNESCAPING=!1;goog.string.Unicode={NBSP:"\u00a0",ZERO_WIDTH_SPACE:"\u200b"};goog.string.startsWith=goog.string.internal.startsWith;goog.string.endsWith=goog.string.internal.endsWith;goog.string.caseInsensitiveStartsWith=goog.string.internal.caseInsensitiveStartsWith;goog.string.caseInsensitiveEndsWith=goog.string.internal.caseInsensitiveEndsWith;goog.string.caseInsensitiveEquals=goog.string.internal.caseInsensitiveEquals;
goog.string.subs=function(a,b){const c=a.split("%s");let d="";const e=Array.prototype.slice.call(arguments,1);for(;e.length&&1<c.length;)d+=c.shift()+e.shift();return d+c.join("%s")};goog.string.collapseWhitespace=function(a){return a.replace(/[\s\xa0]+/g," ").replace(/^\s+|\s+$/g,"")};goog.string.isEmptyOrWhitespace=goog.string.internal.isEmptyOrWhitespace;goog.string.isEmptyString=function(a){return 0==a.length};goog.string.isEmpty=goog.string.isEmptyOrWhitespace;
goog.string.isEmptyOrWhitespaceSafe=function(a){return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(a))};goog.string.isEmptySafe=goog.string.isEmptyOrWhitespaceSafe;goog.string.isBreakingWhitespace=function(a){return!/[^\t\n\r ]/.test(a)};goog.string.isAlpha=function(a){return!/[^a-zA-Z]/.test(a)};goog.string.isNumeric=function(a){return!/[^0-9]/.test(a)};goog.string.isAlphaNumeric=function(a){return!/[^a-zA-Z0-9]/.test(a)};goog.string.isSpace=function(a){return" "==a};
goog.string.isUnicodeChar=function(a){return 1==a.length&&" "<=a&&"~">=a||"\u0080"<=a&&"\ufffd">=a};goog.string.stripNewlines=function(a){return a.replace(/(\r\n|\r|\n)+/g," ")};goog.string.canonicalizeNewlines=function(a){return a.replace(/(\r\n|\r|\n)/g,"\n")};goog.string.normalizeWhitespace=function(a){return a.replace(/\xa0|\s/g," ")};goog.string.normalizeSpaces=function(a){return a.replace(/\xa0|[ \t]+/g," ")};
goog.string.collapseBreakingSpaces=function(a){return a.replace(/[\t\r\n ]+/g," ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g,"")};goog.string.trim=goog.string.internal.trim;goog.string.trimLeft=function(a){return a.replace(/^[\s\xa0]+/,"")};goog.string.trimRight=function(a){return a.replace(/[\s\xa0]+$/,"")};goog.string.caseInsensitiveCompare=goog.string.internal.caseInsensitiveCompare;
goog.string.numberAwareCompare_=function(a,b,c){if(a==b)return 0;if(!a)return-1;if(!b)return 1;const d=a.toLowerCase().match(c),e=b.toLowerCase().match(c),f=Math.min(d.length,e.length);for(let g=0;g<f;g++){c=d[g];const h=e[g];if(c!=h)return a=parseInt(c,10),!isNaN(a)&&(b=parseInt(h,10),!isNaN(b)&&a-b)?a-b:c<h?-1:1}return d.length!=e.length?d.length-e.length:a<b?-1:1};goog.string.intAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\D+/g)};
goog.string.floatAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\.\d+|\D+/g)};goog.string.numerateCompare=goog.string.floatAwareCompare;goog.string.urlEncode=function(a){return encodeURIComponent(String(a))};goog.string.urlDecode=function(a){return decodeURIComponent(a.replace(/\+/g," "))};goog.string.newLineToBr=goog.string.internal.newLineToBr;
goog.string.htmlEscape=function(a,b){a=goog.string.internal.htmlEscape(a,b);goog.string.DETECT_DOUBLE_ESCAPING&&(a=a.replace(goog.string.E_RE_,"&#101;"));return a};goog.string.E_RE_=/e/g;goog.string.unescapeEntities=function(a){return goog.string.contains(a,"&")?!goog.string.FORCE_NON_DOM_HTML_UNESCAPING&&"document"in goog.global?goog.string.unescapeEntitiesUsingDom_(a):goog.string.unescapePureXmlEntities_(a):a};
goog.string.unescapeEntitiesWithDocument=function(a,b){return goog.string.contains(a,"&")?goog.string.unescapeEntitiesUsingDom_(a,b):a};
goog.string.unescapeEntitiesUsingDom_=function(a,b){const c={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"'};let d;d=b?b.createElement("div"):goog.global.document.createElement("div");return a.replace(goog.string.HTML_ENTITY_PATTERN_,function(e,f){let g=c[e];if(g)return g;"#"==f.charAt(0)&&(f=Number("0"+f.slice(1)),isNaN(f)||(g=String.fromCharCode(f)));g||(goog.dom.safe.setInnerHtml(d,goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Single HTML entity."),
e+" ")),g=d.firstChild.nodeValue.slice(0,-1));return c[e]=g})};goog.string.unescapePureXmlEntities_=function(a){return a.replace(/&([^;]+);/g,function(b,c){switch(c){case "amp":return"&";case "lt":return"<";case "gt":return">";case "quot":return'"';default:return"#"!=c.charAt(0)||(c=Number("0"+c.slice(1)),isNaN(c))?b:String.fromCharCode(c)}})};goog.string.HTML_ENTITY_PATTERN_=/&([^;\s<&]+);?/g;goog.string.whitespaceEscape=function(a,b){return goog.string.newLineToBr(a.replace(/  /g," &#160;"),b)};
goog.string.preserveSpaces=function(a){return a.replace(/(^|[\n ]) /g,"$1"+goog.string.Unicode.NBSP)};goog.string.stripQuotes=function(a,b){const c=b.length;for(let d=0;d<c;d++){const e=1==c?b:b.charAt(d);if(a.charAt(0)==e&&a.charAt(a.length-1)==e)return a.substring(1,a.length-1)}return a};goog.string.truncate=function(a,b,c){c&&(a=goog.string.unescapeEntities(a));a.length>b&&(a=a.substring(0,b-3)+"...");c&&(a=goog.string.htmlEscape(a));return a};
goog.string.truncateMiddle=function(a,b,c,d){c&&(a=goog.string.unescapeEntities(a));if(d&&a.length>b){d>b&&(d=b);var e=a.length-d;a=a.substring(0,b-d)+"..."+a.substring(e)}else a.length>b&&(d=Math.floor(b/2),e=a.length-d,a=a.substring(0,d+b%2)+"..."+a.substring(e));c&&(a=goog.string.htmlEscape(a));return a};goog.string.specialEscapeChars_={"\x00":"\\0","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\v":"\\x0B",'"':'\\"',"\\":"\\\\","<":"\\u003C"};goog.string.jsEscapeCache_={"'":"\\'"};
goog.string.quote=function(a){a=String(a);const b=['"'];for(let c=0;c<a.length;c++){const d=a.charAt(c),e=d.charCodeAt(0);b[c+1]=goog.string.specialEscapeChars_[d]||(31<e&&127>e?d:goog.string.escapeChar(d))}b.push('"');return b.join("")};goog.string.escapeString=function(a){const b=[];for(let c=0;c<a.length;c++)b[c]=goog.string.escapeChar(a.charAt(c));return b.join("")};
goog.string.escapeChar=function(a){if(a in goog.string.jsEscapeCache_)return goog.string.jsEscapeCache_[a];if(a in goog.string.specialEscapeChars_)return goog.string.jsEscapeCache_[a]=goog.string.specialEscapeChars_[a];let b;const c=a.charCodeAt(0);if(31<c&&127>c)b=a;else{if(256>c){if(b="\\x",16>c||256<c)b+="0"}else b="\\u",4096>c&&(b+="0");b+=c.toString(16).toUpperCase()}return goog.string.jsEscapeCache_[a]=b};goog.string.contains=goog.string.internal.contains;
goog.string.caseInsensitiveContains=goog.string.internal.caseInsensitiveContains;goog.string.countOf=function(a,b){return a&&b?a.split(b).length-1:0};goog.string.removeAt=function(a,b,c){let d=a;0<=b&&b<a.length&&0<c&&(d=a.slice(0,b)+a.slice(b+c));return d};goog.string.remove=function(a,b){return a.replace(b,"")};goog.string.removeAll=function(a,b){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,"")};
goog.string.replaceAll=function(a,b,c){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,c.replace(/\$/g,"$$$$"))};goog.string.regExpEscape=function(a){return String(a).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g,"\\$1").replace(/\x08/g,"\\x08")};goog.string.repeat=String.prototype.repeat?function(a,b){return a.repeat(b)}:function(a,b){return Array(b+1).join(a)};
goog.string.padNumber=function(a,b,c){if(!Number.isFinite(a))return String(a);a=void 0!==c?a.toFixed(c):String(a);c=a.indexOf(".");-1===c&&(c=a.length);const d="-"===a[0]?"-":"";d&&(a=a.substring(1));return d+goog.string.repeat("0",Math.max(0,b-c))+a};goog.string.makeSafe=function(a){return null==a?"":String(a)};goog.string.getRandomString=function(){return Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^goog.now()).toString(36)};
goog.string.compareVersions=goog.string.internal.compareVersions;goog.string.hashCode=function(a){let b=0;for(let c=0;c<a.length;++c)b=31*b+a.charCodeAt(c)>>>0;return b};goog.string.uniqueStringCounter_=2147483648*Math.random()|0;goog.string.createUniqueString=function(){return"goog_"+goog.string.uniqueStringCounter_++};goog.string.toNumber=function(a){const b=Number(a);return 0==b&&goog.string.isEmptyOrWhitespace(a)?NaN:b};goog.string.isLowerCamelCase=function(a){return/^[a-z]+([A-Z][a-z]*)*$/.test(a)};
goog.string.isUpperCamelCase=function(a){return/^([A-Z][a-z]*)+$/.test(a)};goog.string.toCamelCase=function(a){return String(a).replace(/\-([a-z])/g,function(b,c){return c.toUpperCase()})};goog.string.toSelectorCase=function(a){return String(a).replace(/([A-Z])/g,"-$1").toLowerCase()};goog.string.toTitleCase=function(a,b){b="string"===typeof b?goog.string.regExpEscape(b):"\\s";return a.replace(new RegExp("(^"+(b?"|["+b+"]+":"")+")([a-z])","g"),function(c,d,e){return d+e.toUpperCase()})};
goog.string.capitalize=function(a){return String(a.charAt(0)).toUpperCase()+String(a.slice(1)).toLowerCase()};goog.string.parseInt=function(a){isFinite(a)&&(a=String(a));return"string"===typeof a?/^\s*-?0x/i.test(a)?parseInt(a,16):parseInt(a,10):NaN};goog.string.splitLimit=function(a,b,c){a=a.split(b);const d=[];for(;0<c&&a.length;)d.push(a.shift()),c--;a.length&&d.push(a.join(b));return d};
goog.string.lastComponent=function(a,b){if(b)"string"==typeof b&&(b=[b]);else return a;let c=-1;for(let d=0;d<b.length;d++){if(""==b[d])continue;const e=a.lastIndexOf(b[d]);e>c&&(c=e)}return-1==c?a:a.slice(c+1)};
goog.string.editDistance=function(a,b){const c=[],d=[];if(a==b)return 0;if(!a.length||!b.length)return Math.max(a.length,b.length);for(var e=0;e<b.length+1;e++)c[e]=e;for(e=0;e<a.length;e++){d[0]=e+1;for(var f=0;f<b.length;f++)d[f+1]=Math.min(d[f]+1,c[f+1]+1,c[f]+Number(a[e]!=b[f]));for(f=0;f<c.length;f++)c[f]=d[f]}return d[b.length]};goog.string.path={};goog.string.path.baseName=function(a){const b=a.lastIndexOf("/")+1;return a.slice(b)};goog.string.path.basename=goog.string.path.baseName;goog.string.path.dirname=function(a){const b=a.lastIndexOf("/")+1;a=a.slice(0,b);/^\/+$/.test(a)||(a=a.replace(/\/+$/,""));return a};goog.string.path.extension=function(a){a=goog.string.path.baseName(a).replace(/\.+/g,".");const b=a.lastIndexOf(".");return 0>=b?"":a.slice(b+1)};
goog.string.path.join=function(a){let b=arguments[0];for(let c=1;c<arguments.length;c++){const d=arguments[c];b=goog.string.startsWith(d,"/")?d:""==b||goog.string.endsWith(b,"/")?b+d:b+("/"+d)}return b};
goog.string.path.normalizePath=function(a){if(""==a)return".";let b="";goog.string.startsWith(a,"/")&&(b="/",goog.string.startsWith(a,"//")&&!goog.string.startsWith(a,"///")&&(b="//"));a=a.split("/");const c=[];for(let d=0;d<a.length;d++){const e=a[d];""!=e&&"."!=e&&(".."!=e||!b&&!c.length||".."==module$contents$goog$array_peek(c)?c.push(e):c.pop())}return b+c.join("/")||"."};goog.string.path.split=function(a){const b=goog.string.path.dirname(a);a=goog.string.path.baseName(a);return[b,a]};const DEBUG_WASI$$module$src$filesystem$wasi=!1;function assertLeadingSlash$$module$src$filesystem$wasi(a){return/^\//g.test(a)?a:`/${a}`}function removeLeadingSlash$$module$src$filesystem$wasi(a){return a.replace(/^\//g,"")}function shouldOpenReader$$module$src$filesystem$wasi(a){return(a&(WASI_RIGHT_FD_READ$$module$src$filesystem$constants|WASI_RIGHT_FD_READDIR$$module$src$filesystem$constants))!==goog.global.BigInt(0)}
function performanceNowPoly$$module$src$filesystem$wasi(){if("undefined"===typeof performance||"undefined"===typeof performance.now){const a=Date.now();return Date.now()-a}return performance.now()}function concatUint8Arrays$$module$src$filesystem$wasi(a){var b=a.reduce((d,e)=>d+e.length,0);if(0!==a.length){b=new Uint8Array(b);var c=0;for(const d of a)b.set(d,c),c+=d.length;return b}}
const WASI$$module$src$filesystem$wasi=function({}){this.fd=Array.from({length:4});this.fd[0]={fd:0,path:"/dev/stdin",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[1]={fd:1,path:"/dev/stdout",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[2]={fd:2,path:"/dev/stderr",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.fd[3]={fd:3,path:"/",seekPos:goog.global.BigInt(0),buffers:[],open:!1};this.getMemory=this.getMemory.bind(this);this.CPUTIME_START=0};
WASI$$module$src$filesystem$wasi.prototype.start=function(a){this.CPUTIME_START=performanceNowPoly$$module$src$filesystem$wasi();a.exports._start()};WASI$$module$src$filesystem$wasi.prototype.getImports=function(a){const b={};a=WebAssembly.Module.imports(a);for(const c of a)"function"===c.kind&&c.module.startsWith("wasi_")&&("object"!==typeof b[c.module]&&(b[c.module]={}),b[c.module][c.name]=this[c.name].bind(this));return b};
WASI$$module$src$filesystem$wasi.prototype.setMemory=function(a){this.memory=a};WASI$$module$src$filesystem$wasi.prototype.getMemory=function(){this.view&&this.view.buffer&&this.view.buffer.byteLength||(this.view=new DataView(this.memory.buffer));return this.view};WASI$$module$src$filesystem$wasi.prototype.msToNs=function(a){const b=Math.trunc(a);a=goog.global.BigInt(Math.round(1E6*(a-b)));return goog.global.BigInt(b)*goog.global.BigInt(1E6)+a};
WASI$$module$src$filesystem$wasi.prototype.now=function(a){switch(a){case WASI_CLOCK_MONOTONIC$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi());case WASI_CLOCK_REALTIME$$module$src$filesystem$constants:return this.msToNs(Date.now());case WASI_CLOCK_PROCESS_CPUTIME_ID$$module$src$filesystem$constants:case WASI_CLOCK_THREAD_CPUTIME_ID$$module$src$filesystem$constants:return Math.floor(performanceNowPoly$$module$src$filesystem$wasi()-this.CPUTIME_START);
default:return 0}};WASI$$module$src$filesystem$wasi.prototype.args_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,module$src$filesystem$constants);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.args_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.clock_res_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("args_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.clock_time_get=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("clock_time_get",a,b,c,arguments);const d=this.getMemory(),e=this.now(a);d.setBigUint64(c,goog.global.BigInt(e),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.environ_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.environ_sizes_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("environ_sizes_get",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_advise=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_advise",a,b,c,d,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_allocate=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_allocate",a,b,c,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_close=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_close",a,arguments);this.fd[a]&&(this.fd[a].open=!1);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_datasync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_datasync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_get",a,b,arguments);const c=this.getMemory();c.setUint8(b+4,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);c.setUint16(b+2,0,!0);c.setUint16(b+4,0,!0);c.setBigUint64(b+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_BASE$$module$src$filesystem$constants),!0);c.setBigUint64(b+8+8,goog.global.BigInt(RIGHTS_REGULAR_FILE_INHERITING$$module$src$filesystem$constants),
!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_flags=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_flags",a,b,arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_fdstat_set_rights=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_fdstat_set_rights",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_filestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_get",a,b,arguments);let c=0;this.fd[a]&&(c=this.fd[a].buffers.reduce(function(e,f){return e+(null==f?void 0:f.byteLength)?null==f?void 0:f.byteLength:0},0));const d=this.getMemory();d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(a),!0);b+=8;d.setUint8(b,WASI_FILETYPE_REGULAR_FILE$$module$src$filesystem$constants);b+=8;d.setBigUint64(b,
goog.global.BigInt(1),!0);b+=8;d.setBigUint64(b,goog.global.BigInt(c),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);b+=8;d.setBigUint64(b,this.msToNs(this.CPUTIME_START),!0);d.setBigUint64(b+8,this.msToNs(this.CPUTIME_START),!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_size=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_size",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_filestat_set_times=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_filestat_set_times",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_pread=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_pread",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_prestat_dir_name=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_dir_name",a,b,c,this.fd[a]);if(!this.fd[a]&&!this.fd[a-1])return WASI_EBADF$$module$src$filesystem$constants;({path:c}=this.fd[a]);a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);(new Uint8Array(a.buffer)).set(c,b);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_prestat_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_prestat_get",a,b,this.fd[a]);if(!this.fd[a])return WASI_EBADF$$module$src$filesystem$constants;var {path:c}=this.fd[a];a=this.getMemory();c=encoder$$module$src$utils$text_encoders.encode(c);a.setUint8(b,WASI_PREOPENTYPE_DIR$$module$src$filesystem$constants);a.setUint32(b+4,c.byteLength,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_pwrite=function(a,b,c,d,e){console.log("fd_pwrite",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_read=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_read",a,b,c,d,arguments);const e=this.fd[a]&&this.fd[a].buffers;var f=e.reduce((n,p)=>n+p.length,0);const g=this.getMemory();if(e&&0!==e.length){var h=Number(this.fd[a].seekPos),k=0,l=!1;if(h>=f)return k=g.getUint32(b,!0),g.setUint8(k,"\x00"),g.setUint32(d,0,!0),WASI_ESUCCESS$$module$src$filesystem$constants;for(f=0;f<c;f++){var m=b+8*f;const n=g.getUint32(m,!0);m=g.getUint32(m+
4,!0);l||(k+=m,Array.from({length:m},(p,q)=>q).reduce((p,q)=>{if(l)return p;const [u,t]=p;let v=p=0,A=!1,y=0,r;if(0===q)for(;!A;)r=e[p]?e[p].byteLength:0,y<=h&&r+y>h?(A=!0,v=h-y):(y+=r,p+=1);else p=u,v=t;e[p]?(g.setUint8(n+q,e[p][v]),v+1>=e[p].byteLength?(p=u+1,v=0):v+=1):(g.setUint8(n+q,"\x00"),h+=q,l=!0);return[p,v]},[0,0]),l||(h+=m))}this.fd[a].seekPos=goog.global.BigInt(h);g.setUint32(d,k,!0);return WASI_ESUCCESS$$module$src$filesystem$constants}console.error("Reading non existent file",a,this.fd[a])};
WASI$$module$src$filesystem$wasi.prototype.fd_readdir=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_readdir",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_renumber=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_renumber",a,b,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_seek=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_seek",a,b,c,d,arguments);const e=this.getMemory();switch(c){case WASI_WHENCE_CUR$$module$src$filesystem$constants:var f;this.fd[a].seekPos=(null!=(f=this.fd[a].seekPos)?f:goog.global.BigInt(0))+goog.global.BigInt(b);break;case WASI_WHENCE_END$$module$src$filesystem$constants:f=(this.fd[a].buffers||[]).reduce((g,h)=>g+h.length,0);this.fd[a].seekPos=BigInt(f)+BigInt(b);break;
case WASI_WHENCE_SET$$module$src$filesystem$constants:this.fd[a].seekPos=BigInt(b)}e.setBigUint64(d,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.fd_sync=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_sync",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_tell=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_tell",a,b,arguments);const c=this.getMemory();this.fd[a].seekPos||(this.fd[a].seekPos=goog.global.BigInt(0));c.setBigUint64(b,this.fd[a].seekPos,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.fd_write=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("fd_write",{fd:a,iovs:b,iovsLength:c,nwritten:d});const e=this.getMemory();this.fd[a].buffers=this.fd[a].buffers||[];this.fd[a].buffers=0<this.fd[a].buffers.length?[concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)]:this.fd[a].buffers;let f=0;for(let k=0;k<c;k++){var g=b+8*k,h=e.getUint32(g,!0);g=e.getUint32(g+4,!0);f+=g;h=new Uint8Array(e.buffer,h,g);if(this.fd[a].buffers[0]&&
this.fd[a].seekPos<this.fd[a].buffers[0].length){const l=Number(this.fd[a].seekPos);h.slice(0,g).forEach((m,n)=>{this.fd[a].buffers[0][l+n]=m})}else this.fd[a].buffers.push(h.slice(0,g))}this.fd[a].seekPos+=goog.global.BigInt(f);e.setUint32(d,f,!0);[1,2].includes(a)&&console.log(decoder$$module$src$utils$text_encoders.decode(concatUint8Arrays$$module$src$filesystem$wasi(this.fd[a].buffers)));return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.path_create_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_create_directory",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_filestat_get=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_get",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.path_filestat_set_times=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_filestat_set_times",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_link=function(a,b,c,d,e,f,g){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_link",a,b,c,d,e,f,g,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.path_open=function(a,b,c,d,e,f,g,h,k){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_open",a,b,c,d,e,f,g,h,k,arguments);const l=this.getMemory();var m=(this.fd[a]||{path:"/"}).path,n=new Uint8Array(l.buffer,c,d);n=decoder$$module$src$utils$text_encoders.decode(n);const p=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(goog.string.path.join(3===a?"":m,n)));DEBUG_WASI$$module$src$filesystem$wasi&&console.log(";; opening path",
p,"withREader",shouldOpenReader$$module$src$filesystem$wasi(f));if(p.startsWith("/..")||"/._"===p||"/.AppleDouble"===p)return WASI_EBADF$$module$src$filesystem$constants;(m=Object.values(this.fd).find(q=>q.path===p&&Array.isArray(q.buffers)))?n=m.fd:(n=this.fd.length,this.fd[n]={fd:n});this.fd[n]={...this.fd[n],path:p,type:"file",seekPos:goog.global.BigInt(0),buffers:m?this.fd[n].buffers:[],open:!0};shouldOpenReader$$module$src$filesystem$wasi(f)&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("should open a read handle for",
p);l.setUint32(k,n,!0);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_readlink=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_readlink",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_remove_directory=function(a,b,c){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_remove_directory",a,b,c);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.path_rename=function(a,b,c,d,e,f){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_rename",a,b,c,d,e,f,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.path_symlink=function(a,b,c,d,e){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_symlink",a,b,c,d,e,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.path_unlink_file=function(a,b,c){3<a&&DEBUG_WASI$$module$src$filesystem$wasi&&console.log("path_unlink_file",a,b,c,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.poll_oneoff=function(a,b,c,d){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("poll_oneoff",a,b,c,d,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.proc_exit=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_exit",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.proc_raise=function(a){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("proc_raise",a,arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.random_get=function(a,b){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("random_get",a,b);return WASI_ESUCCESS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sched_yield=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sched_yield",arguments);return WASI_ESUCCESS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.sock_recv=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_recv",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.sock_send=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_send",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};
WASI$$module$src$filesystem$wasi.prototype.sock_shutdown=function(){DEBUG_WASI$$module$src$filesystem$wasi&&console.log("sock_shutdown",arguments);return WASI_ENOSYS$$module$src$filesystem$constants};WASI$$module$src$filesystem$wasi.prototype.findBuffers=function(a){const b=Object.values(this.fd).find(({path:c})=>c===a);return[b&&b.buffers,b.fd]};
WASI$$module$src$filesystem$wasi.prototype.readdir=function(a){const b=(assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a))+"/").replace("//","/"),c=[];Object.values(this.fd).forEach(({path:d})=>!/\//g.test(d.replace(b,""))&&c.push(d));return c.map(d=>removeLeadingSlash$$module$src$filesystem$wasi(d.replace(b,""))).filter(d=>!!d)};
WASI$$module$src$filesystem$wasi.prototype.writeFile=function(a,b){const c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));a=Object.keys(this.fd).length;const d=Object.values(this.fd).find(({path:e})=>e===c);this.fd[a]={fd:a,path:c,seekPos:goog.global.BigInt(0),buffers:[b]};d&&delete this.fd[d]};
WASI$$module$src$filesystem$wasi.prototype.appendFile=function(a,b){var c=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));[c]=this.findBuffers(c);c?c.push(b):console.error(`Can't append to non-existing file ${a}`)};
WASI$$module$src$filesystem$wasi.prototype.readFile=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),[c,d]=this.findBuffers(b);this.fd[d]&&this.fd[d].open&&console.warn(`readFile: file ${a} hasn't been closed yet!`);if(c)return concatUint8Arrays$$module$src$filesystem$wasi(c)};
WASI$$module$src$filesystem$wasi.prototype.readStdOut=function(){const a=Object.values(this.fd[0]);return concatUint8Arrays$$module$src$filesystem$wasi(a&&a.buffers||[])};WASI$$module$src$filesystem$wasi.prototype.unlink=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a));(a=Object.values(this.fd).find(({path:c})=>c===b))?delete this.fd[a]:console.error(`While trying to unlink ${b}, path not found`)};
WASI$$module$src$filesystem$wasi.prototype.mkdir=function(a){const b=assertLeadingSlash$$module$src$filesystem$wasi((0,goog.string.path.normalizePath)(a)),c=[];Object.values(this.fd).forEach(({path:d})=>d.startsWith(b)&&c.push(d));0<c.length?console.warn(`mkdir: path ${a} already exists`):(a=Object.keys(this.fd).length,this.fd[a]={fd:a,path:b})};var module$src$filesystem$wasi={};module$src$filesystem$wasi.WASI=WASI$$module$src$filesystem$wasi;function clearArray$$module$src$utils$clear_array(a){for(;0<a.length;)a.pop()}var module$src$utils$clear_array={};module$src$utils$clear_array.clearArray=clearArray$$module$src$utils$clear_array;var module$node_modules$lines_logger$lib$index={default:{}};module$node_modules$lines_logger$lib$index.default.__esModule=!0;module$node_modules$lines_logger$lib$index.default.LoggerFactory=module$node_modules$lines_logger$lib$index.default.logLevels=void 0;module$node_modules$lines_logger$lib$index.default.logLevels={log_raise_error:1,log_with_warnings:2,trace:3,debug:4,info:5,warn:6,error:7,disable:8};
var LoggerFactory$$module$node_modules$lines_logger$lib$index=function(){function a(b,c){if(void 0===b&&(b="log_with_warnings"),void 0===c&&(c=null),this.logLevel=b,!module$node_modules$lines_logger$lib$index.default.logLevels[b])throw Error("Invalid log level "+b+" allowed: "+JSON.stringify(module$node_modules$lines_logger$lib$index.default.logLevels));this.mockConsole=c||console}return a.prototype.dummy=function(){},a.prototype.setLogWarnings=function(b){this.logLevel=b},a.prototype.getLogWarnings=
function(){return this.logLevel},a.prototype.getSingleLoggerColor=function(b,c,d){return this.getSingleLoggerStyle(b,this.getColorStyle(c),d)},a.prototype.getSingleLogger=function(b,c){var d=this.getRandomColor(b);return this.getSingleLoggerStyle(b,this.getColorStyle(d),c)},a.prototype.getSingleLoggerStyle=function(b,c,d,e){var f=this;return void 0===e&&(e="log_with_warnings"),function(){for(var g=[],h=0;h<arguments.length;h++)g[h]=arguments[h];if(module$node_modules$lines_logger$lib$index.default.logLevels[f.logLevel]>
module$node_modules$lines_logger$lib$index.default.logLevels[e])return f.dummy;g=Array.prototype.slice.call(g);h=g.shift().split("{}");for(var k=[f.mockConsole,"%c"+b,c],l=0;l<h.length;l++)k.push(h[l]),void 0!==g[l]&&k.push(g[l]);if(h.length-1!==g.length)if("log_with_warnings"===f.logLevel)f.mockConsole.error("MissMatch amount of arguments");else if("log_raise_error"===f.logLevel)throw Error("MissMatch amount of arguments");return Function.prototype.bind.apply(d,k)}},a.prototype.getLoggerColor=function(b,
c){return this.getLoggerStyle(b,this.getColorStyle(c))},a.prototype.getColorStyle=function(b){return"color: white; background-color: "+b+"; padding: 2px 6px; border-radius: 2px; font-size: 10px"},a.getHash=function(b,c){void 0===c&&(c=0);var d=3735928559^c;c^=1103547991;for(var e=0,f;e<b.length;e++)f=b.charCodeAt(e),d=Math.imul(d^f,2654435761),c=Math.imul(c^f,1597334677);return d=Math.imul(d^d>>>16,2246822507)^Math.imul(c^c>>>13,3266489909),4294967296*(2097151&(Math.imul(c^c>>>16,2246822507)^Math.imul(d^
d>>>13,3266489909)))+(d>>>0)},a.prototype.getRandomColor=function(b){void 0===b&&(b="");b=a.getHash(b);for(var c="#",d=0;3>d;d++)c+=("00"+(8+(b>>7*d&127)).toString(16)).substr(-2);return c},a.prototype.getLogger=function(b){return this.getLoggerColor(b,this.getRandomColor(b))},a.prototype.getLoggerStyle=function(b,c){return{trace:this.getSingleLoggerStyle(b,c,this.mockConsole.trace,"trace"),debug:this.getSingleLoggerStyle(b,c,this.mockConsole.debug,"debug"),log:this.getSingleLoggerStyle(b,c,this.mockConsole.log,
"info"),warn:this.getSingleLoggerStyle(b,c,this.mockConsole.warn,"warn"),error:this.getSingleLoggerStyle(b,c,this.mockConsole.error,"error")}},a}();module$node_modules$lines_logger$lib$index.default.LoggerFactory=LoggerFactory$$module$node_modules$lines_logger$lib$index;let logWorkletMain$$module$src$logger,logWorkletWorker$$module$src$logger,logSABMain$$module$src$logger,logSABWorker$$module$src$logger,logVANMain$$module$src$logger,logVANWorker$$module$src$logger,logOldSpnMain$$module$src$logger,logOldSpnWorker$$module$src$logger,logIndex$$module$src$logger,logSPNMainSingle$$module$src$logger,logSinglethreadWorkletMain$$module$src$logger,logSinglethreadWorkletWorker$$module$src$logger,logCommonUtils$$module$src$logger,logWasmModule$$module$src$logger,logMidiRequest$$module$src$logger;
const isProd$$module$src$logger=1;logWorkletMain$$module$src$logger=a=>b=>{};logWorkletWorker$$module$src$logger=a=>b=>{};logSABMain$$module$src$logger=a=>b=>{};logSABWorker$$module$src$logger=a=>b=>{};logVANMain$$module$src$logger=a=>b=>{};logVANWorker$$module$src$logger=a=>b=>{};logOldSpnMain$$module$src$logger=a=>b=>{};logOldSpnWorker$$module$src$logger=a=>b=>{};logIndex$$module$src$logger=a=>b=>{};logSPNMainSingle$$module$src$logger=a=>b=>{};
logSinglethreadWorkletMain$$module$src$logger=a=>b=>{};logSinglethreadWorkletWorker$$module$src$logger=a=>b=>{};logCommonUtils$$module$src$logger=a=>b=>{};logWasmModule$$module$src$logger=a=>b=>{};logMidiRequest$$module$src$logger=a=>b=>{};var $jscompDefaultExport$$module$src$logger=a=>b=>{},module$src$logger={};module$src$logger.default=$jscompDefaultExport$$module$src$logger;module$src$logger.logCommonUtils=logCommonUtils$$module$src$logger;module$src$logger.logIndex=logIndex$$module$src$logger;
module$src$logger.logMidiRequest=logMidiRequest$$module$src$logger;module$src$logger.logOldSpnMain=logOldSpnMain$$module$src$logger;module$src$logger.logOldSpnWorker=logOldSpnWorker$$module$src$logger;module$src$logger.logSABMain=logSABMain$$module$src$logger;module$src$logger.logSABWorker=logSABWorker$$module$src$logger;module$src$logger.logSPNMainSingle=logSPNMainSingle$$module$src$logger;module$src$logger.logSinglethreadWorkletMain=logSinglethreadWorkletMain$$module$src$logger;
module$src$logger.logSinglethreadWorkletWorker=logSinglethreadWorkletWorker$$module$src$logger;module$src$logger.logVANMain=logVANMain$$module$src$logger;module$src$logger.logVANWorker=logVANWorker$$module$src$logger;module$src$logger.logWasmModule=logWasmModule$$module$src$logger;module$src$logger.logWorkletMain=logWorkletMain$$module$src$logger;module$src$logger.logWorkletWorker=logWorkletWorker$$module$src$logger;const CompressionMethod$$module$src$zlib$zlib={DEFLATE:8,RESERVED:15};var module$src$zlib$zlib={};module$src$zlib$zlib.CompressionMethod=CompressionMethod$$module$src$zlib$zlib;/*
 zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */
function Huffman$$module$src$zlib$huffman(a){const b=a.length;let c=0,d=Number.POSITIVE_INFINITY,e,f,g,h;let k,l;for(k=0;k<b;++k)a[k]>c&&(c=a[k]),a[k]<d&&(d=a[k]);const m=1<<c,n=new Uint32Array(m);e=1;f=0;for(g=2;e<=c;){for(k=0;k<b;++k)if(a[k]===e){h=0;var p=f;for(l=0;l<e;++l)h=h<<1|p&1,p>>=1;p=e<<16|k;for(l=h;l<m;l+=g)n[l]=p;++f}++e;f<<=1;g<<=1}return[n,c,d]}var module$src$zlib$huffman={};module$src$zlib$huffman.Huffman=Huffman$$module$src$zlib$huffman;const ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate=32768;
function RawInflate$$module$src$zlib$rawinflate(a,b){this.blocks=[];this.bufferSize=ZLIB_RAW_INFLATE_BUFFER_SIZE$$module$src$zlib$rawinflate;this.bitsbuflen=this.bitsbuf=this.ip=this.totalpos=0;this.input=new Uint8Array(a);this.bfinal=!1;this.bufferType=RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE;this.resize=!1;if(b||!(b={}))b.index&&(this.ip=b.index),b.bufferSize&&(this.bufferSize=b.bufferSize),b.bufferType&&(this.bufferType=b.bufferType),b.resize&&(this.resize=b.resize);switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.op=
RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;this.output=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength+this.bufferSize+RawInflate$$module$src$zlib$rawinflate.MaxCopyLength);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.op=0;this.output=new Uint8Array(this.bufferSize);break;default:throw Error("invalid inflate mode");}}RawInflate$$module$src$zlib$rawinflate.BufferType={BLOCK:0,ADAPTIVE:1};
RawInflate$$module$src$zlib$rawinflate.prototype.decompress=function(){for(;!this.bfinal;)this.parseBlock();switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:return this.concatBufferBlock();case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:return this.concatBufferDynamic();default:throw Error("invalid inflate mode");}};RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength=32768;RawInflate$$module$src$zlib$rawinflate.MaxCopyLength=258;
RawInflate$$module$src$zlib$rawinflate.Order=function(a){return new Uint16Array(a)}([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]);RawInflate$$module$src$zlib$rawinflate.LengthCodeTable=function(a){return new Uint16Array(a)}([3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258]);RawInflate$$module$src$zlib$rawinflate.LengthExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0]);
RawInflate$$module$src$zlib$rawinflate.DistCodeTable=function(a){return new Uint16Array(a)}([1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577]);RawInflate$$module$src$zlib$rawinflate.DistExtraTable=function(a){return new Uint8Array(a)}([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]);
RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable=function(a){return a}(function(){const a=new Uint8Array(288);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=143>=b?8:255>=b?9:279>=b?7:8;return Huffman$$module$src$zlib$huffman(a)}());RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable=function(a){return a}(function(){const a=new Uint8Array(30);let b,c;b=0;for(c=a.length;b<c;++b)a[b]=5;return Huffman$$module$src$zlib$huffman(a)}());
RawInflate$$module$src$zlib$rawinflate.prototype.parseBlock=function(){let a=this.readBits(3);a&1&&(this.bfinal=!0);a>>>=1;switch(a){case 0:this.parseUncompressedBlock();break;case 1:this.parseFixedHuffmanBlock();break;case 2:this.parseDynamicHuffmanBlock();break;default:throw Error("unknown BTYPE: "+a);}};
RawInflate$$module$src$zlib$rawinflate.prototype.readBits=function(a){let b=this.bitsbuf,c=this.bitsbuflen;const d=this.input;let e=this.ip;if(e+(a-c+7>>3)>=d.length)throw Error("input buffer is broken");for(;c<a;)b|=d[e++]<<c,c+=8;this.bitsbuf=b>>>a;this.bitsbuflen=c-a;this.ip=e;return b&(1<<a)-1};
RawInflate$$module$src$zlib$rawinflate.prototype.readCodeByTable=function(a){let b=this.bitsbuf,c=this.bitsbuflen;var d=this.input;let e=this.ip;var f=d.length;const g=a[0];for(a=a[1];c<a&&!(e>=f);)b|=d[e++]<<c,c+=8;d=g[b&(1<<a)-1];f=d>>>16;if(f>c)throw Error("invalid code length: "+f);this.bitsbuf=b>>f;this.bitsbuflen=c-f;this.ip=e;return d&65535};
RawInflate$$module$src$zlib$rawinflate.prototype.parseUncompressedBlock=function(){const a=this.input;let b=this.ip,c=this.output,d=this.op;var e=a.length;let f;const g=c.length;this.bitsbuflen=this.bitsbuf=0;if(b+1>=e)throw Error("invalid uncompressed block header: LEN");f=a[b++]|a[b++]<<8;if(b+1>=e)throw Error("invalid uncompressed block header: NLEN");e=a[b++]|a[b++]<<8;if(f===~e)throw Error("invalid uncompressed block header: length verify");if(b+f>a.length)throw Error("input buffer is broken");
switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:for(;d+f>c.length;)e=g-d,f-=e,c.set(a.subarray(b,b+e),d),d+=e,b+=e,this.op=d,c=this.expandBufferBlock(),d=this.op;break;case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:for(;d+f>c.length;)c=this.expandBufferAdaptive({fixRatio:2});break;default:throw Error("invalid inflate mode");}c.set(a.subarray(b,b+f),d);this.ip=b+f;this.op=d+f;this.output=c};
RawInflate$$module$src$zlib$rawinflate.prototype.parseFixedHuffmanBlock=function(){switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(RawInflate$$module$src$zlib$rawinflate.FixedLiteralLengthTable,RawInflate$$module$src$zlib$rawinflate.FixedDistanceTable);
break;default:throw Error("invalid inflate mode");}};
RawInflate$$module$src$zlib$rawinflate.prototype.parseDynamicHuffmanBlock=function(){var a=this.readBits(5)+257,b=this.readBits(5)+1,c=this.readBits(4)+4,d=new Uint8Array(RawInflate$$module$src$zlib$rawinflate.Order.length);let e;for(e=0;e<c;++e)d[RawInflate$$module$src$zlib$rawinflate.Order[e]]=this.readBits(3);d=Huffman$$module$src$zlib$huffman(d);c=new Uint8Array(a+b);e=0;for(b=a+b;e<b;){var f=this.readCodeByTable(d);switch(f){case 16:for(f=3+this.readBits(2);f--;)c[e++]=g;break;case 17:for(f=
3+this.readBits(3);f--;)c[e++]=0;var g=0;break;case 18:for(f=11+this.readBits(7);f--;)c[e++]=0;g=0;break;default:g=c[e++]=f}}g=Huffman$$module$src$zlib$huffman(c.subarray(0,a));a=Huffman$$module$src$zlib$huffman(c.subarray(a));switch(this.bufferType){case RawInflate$$module$src$zlib$rawinflate.BufferType.ADAPTIVE:this.decodeHuffmanAdaptive(g,a);break;case RawInflate$$module$src$zlib$rawinflate.BufferType.BLOCK:this.decodeHuffmanBlock(g,a);break;default:throw Error("invalid inflate mode");}};
RawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanBlock=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;const e=c.length-RawInflate$$module$src$zlib$rawinflate.MaxCopyLength;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,l=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,m=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,n=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=
e&&(this.op=d,c=this.expandBufferBlock(),d=this.op),c[d++]=f;else for(f-=257,h=k[f],0<l[f]&&(h+=this.readBits(l[f])),f=this.readCodeByTable(b),g=m[f],0<n[f]&&(g+=this.readBits(n[f])),d>=e&&(this.op=d,c=this.expandBufferBlock(),d=this.op);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};
RawInflate$$module$src$zlib$rawinflate.prototype.decodeHuffmanAdaptive=function(a,b){let c=this.output,d=this.op;this.currentLitlenTable=a;let e=c.length;var f;let g,h;const k=RawInflate$$module$src$zlib$rawinflate.LengthCodeTable,l=RawInflate$$module$src$zlib$rawinflate.LengthExtraTable,m=RawInflate$$module$src$zlib$rawinflate.DistCodeTable,n=RawInflate$$module$src$zlib$rawinflate.DistExtraTable;for(;256!==(f=this.readCodeByTable(a));)if(256>f)d>=e&&(c=this.expandBufferAdaptive(),e=c.length),c[d++]=
f;else for(f-=257,h=k[f],0<l[f]&&(h+=this.readBits(l[f])),f=this.readCodeByTable(b),g=m[f],0<n[f]&&(g+=this.readBits(n[f])),d+h>e&&(c=this.expandBufferAdaptive(),e=c.length);h--;)c[d]=c[d++-g];for(;8<=this.bitsbuflen;)this.bitsbuflen-=8,this.ip--;this.op=d};
RawInflate$$module$src$zlib$rawinflate.prototype.expandBufferBlock=function(a){a=new Uint8Array(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength);const b=this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,c=this.output;a.set(c.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,a.length));this.blocks.push(a);this.totalpos+=a.length;c.set(c.subarray(b,b+RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));this.op=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;
return c};RawInflate$$module$src$zlib$rawinflate.prototype.expandBufferAdaptive=function(a){let b=Math.trunc(this.input.length/this.ip+1);const c=this.input,d=this.output;a&&("number"===typeof a.fixRatio&&(b=a.fixRatio),"number"===typeof a.addRatio&&(b+=a.addRatio));2>b?(a=(c.length-this.ip)/this.currentLitlenTable[2],a=Math.trunc(a/2*258),a=a<d.length?d.length+a:d.length<<1):a=d.length*b;a=new Uint8Array(a);a.set(d);return this.output=a};
RawInflate$$module$src$zlib$rawinflate.prototype.concatBufferBlock=function(){let a=0;const b=this.output,c=this.blocks;let d;const e=new Uint8Array(this.totalpos+(this.op-RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength));let f,g,h,k;if(0===c.length)return this.output.subarray(RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength,this.op);f=0;for(g=c.length;f<g;++f)for(d=c[f],h=0,k=d.length;h<k;++h)e[a++]=d[h];f=RawInflate$$module$src$zlib$rawinflate.MaxBackwardLength;for(g=this.op;f<
g;++f)e[a++]=b[f];this.blocks=[];return this.buffer=e};RawInflate$$module$src$zlib$rawinflate.prototype.concatBufferDynamic=function(){let a;const b=this.op;this.resize?(a=new Uint8Array(b),a.set(this.output.subarray(0,b))):a=this.output.subarray(0,b);return this.buffer=a};var module$src$zlib$rawinflate={};module$src$zlib$rawinflate.RawInflate=RawInflate$$module$src$zlib$rawinflate;function Util$$module$src$zlib$util(){}Util$$module$src$zlib$util.stringToByteArray=function(a){a=[...a];let b,c;b=0;for(c=a.length;b<c;b++)a[b]=(a[b].charPointAt(0)&255)>>>0;return new Uint8Array([a])};var module$src$zlib$util={};module$src$zlib$util.Util=Util$$module$src$zlib$util;function Adler32$$module$src$zlib$adler32(a){"string"===typeof a&&(a=Util$$module$src$zlib$util.stringToByteArray(a));return Adler32$$module$src$zlib$adler32.update(1,a)}Adler32$$module$src$zlib$adler32.update=function(a,b){let c=a&65535;a=a>>>16&65535;let d=b.length,e,f=0;for(;0<d;){e=d>Adler32$$module$src$zlib$adler32.OptimizationParameter?Adler32$$module$src$zlib$adler32.OptimizationParameter:d;d-=e;do c+=b[f++],a+=c;while(--e);c%=65521;a%=65521}return(a<<16|c)>>>0};
Adler32$$module$src$zlib$adler32.OptimizationParameter=1024;var module$src$zlib$adler32={};module$src$zlib$adler32.Adler32=Adler32$$module$src$zlib$adler32;function Inflate$$module$src$zlib$inflate(a,b){this.input=a;this.ip=0;if(b||!(b={}))b.index&&(this.ip=b.index),b.verify&&(this.verify=b.verify);const c=a[this.ip++],d=a[this.ip++];switch(c&15){case CompressionMethod$$module$src$zlib$zlib.DEFLATE:this.method=CompressionMethod$$module$src$zlib$zlib.DEFLATE;break;default:throw Error("unsupported compression method");}if(0!==((c<<8)+d)%31)throw Error("invalid fcheck flag:"+((c<<8)+d)%31);if(d&32)throw Error("fdict flag is not supported");this.rawinflate=
new RawInflate$$module$src$zlib$rawinflate(a,{index:this.ip,bufferSize:b.bufferSize,bufferType:b.bufferType,resize:b.resize})}Inflate$$module$src$zlib$inflate.BufferType=RawInflate$$module$src$zlib$rawinflate.BufferType;
Inflate$$module$src$zlib$inflate.prototype.decompress=function(){var a=this.input;const b=this.rawinflate.decompress();this.ip=this.rawinflate.ip;if(this.verify&&(a=(a[this.ip++]<<24|a[this.ip++]<<16|a[this.ip++]<<8|a[this.ip++])>>>0,a!==Adler32$$module$src$zlib$adler32(b)))throw Error("invalid adler-32 checksum");return b};var module$src$zlib$inflate={};module$src$zlib$inflate.Inflate=Inflate$$module$src$zlib$inflate;const PAGE_SIZE$$module$src$module=65536,PAGES_PER_MB$$module$src$module=16,csoundWasiJsMessageCallback$$module$src$module=({memory:a,messagePort:b,streamBuffer:c})=>function(d,e,f,g){if(a){d=new Uint8Array(a.buffer,g,f);d=uint2String$$module$src$utils$text_encoders(d);var h=/\n$/g.test(d);e=/^\n/g.test(d);var k=d.split("\n").filter(m=>0<m.length),l=[];if(0===k.length&&h||e)l.push(c.join("")),clearArray$$module$src$utils$clear_array(c);k.forEach((m,n)=>{n+1===k.length?h?0===n?(l.push(c.join("")+m),
clearArray$$module$src$utils$clear_array(c)):l.push(m):c.push(m):0===n?(l.push(c.join("")+m),clearArray$$module$src$utils$clear_array(c)):l.push(m)});l.forEach(m=>{m.replace(/(\r\n|\n|\r)/gm,"")&&b.post({log:m})})}},assertPluginExports$$module$src$module=a=>{if(a&&"object"===typeof a&&"object"===typeof a.exports){if(a.exports.__wasm_call_ctors){if(a.exports.csoundModuleCreate||a.exports.csound_opcode_init||a.exports.csound_fgen_init)return!0;console.error(a.exports,"A csound plugin turns out to be neither a plugin, opcode or module.\nPerhaps csdl.h or module.h wasn't imported correctly?");
return!1}console.error("A csound plugin didn't export __wasm_call_ctors.\nPlease re-run wasm-ld with either --export-all or include --export=__wasm_call_ctors");return!1}console.error("Error instantiating a csound plugin, instance and/or export is missing!");return!1},getBinaryHeaderData$$module$src$module=a=>{function b(){let l=0,m=1;for(;;){const n=a[c++];l+=(n&127)*m;m*=128;if(!(n&128))break}return l}1836278016!==(new Uint32Array((new Uint8Array(a.subarray(0,24))).buffer))[0]&&console.error("Wasm magic number is missing!");
if(0!==a[8])return logWasmModule$$module$src$logger("Dylink section wasn't found in wasm binary, assuming static wasm."),"static";let c=9;const d=b();c++;(0,goog.asserts.assert)(a[c]==="d".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="y".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="l".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="i".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="n".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="k".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]===
".".codePointAt(0));c++;(0,goog.asserts.assert)(a[c]==="0".codePointAt(0));c+=3;const e=b(),f=b(),g=b(),h=b(),k=b();return{sectionSize:d,memorySize:e,memoryAlign:f,neededDynlibsCount:k,tableSize:g,tableAlign:h}},loadStaticWasm$$module$src$module=async({wasmBytes:a,wasi:b,messagePort:c})=>{const d=await WebAssembly.compile(a);a=new WebAssembly.Memory({initial:16384});const e=b.getImports(d);e.env=e.env||{};e.env.csoundLoadModules=()=>0;e.env.memory=a;e.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:e.env.memory,
streamBuffer:[],messagePort:c});c=await WebAssembly.instantiate(d,e);b.setMemory(a);b.start(c);c.exports.__wasi_js_csoundSetMessageStringCallback();return[c,b]};
var $jscompDefaultExport$$module$src$module=async function({wasmDataURI:a,withPlugins:b=[],messagePort:c}){var d={};const e=new WASI$$module$src$filesystem$wasi({preopens:{"/":"/"}});a=new Uint8Array(a);a=(new Inflate$$module$src$zlib$inflate(a)).decompress();var f=getBinaryHeaderData$$module$src$module(a);if("static"===f)return await loadStaticWasm$$module$src$module({messagePort:c,wasmBytes:a,wasmFs:d,wasi:e});const {memorySize:g,memoryAlign:h,tableSize:k}=f;b=await b.reduce(async(r,w)=>{r=await r;
let B,z;try{B=new Uint8Array(w),z=getBinaryHeaderData$$module$src$module(B)}catch(C){console.error("Error in plugin",C)}z&&r.push({headerData:z,wasmPluginBytes:B});return r},[]);var l=128*PAGES_PER_MB$$module$src$module;d=Math.ceil((g+h)/PAGE_SIZE$$module$src$module);f=Math.ceil(b.reduce((r,{headerData:w})=>"static"===w?0:r+(w.memorySize+h),0)/PAGE_SIZE$$module$src$module);f=d+f+l;const m=new WebAssembly.Memory({initial:f,maximum:1024*PAGES_PER_MB$$module$src$module}),n=new WebAssembly.Table({initial:k+
1,element:"anyfunc"});e.setMemory(m);const p=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);f=new WebAssembly.Global({value:"i32",mutable:!0},f*PAGE_SIZE$$module$src$module);l=new WebAssembly.Global({value:"i32",mutable:!1},l);const q=new WebAssembly.Global({value:"i32",mutable:!1},1),u=new WebAssembly.Global({value:"i32",mutable:!0},0);a=await WebAssembly.compile(a);const t=e.getImports(a);let v=[],A=d;t.env=t.env||{};t.env.memory=m;t.env.__indirect_function_table=
n;t.env.__stack_pointer=p;t.env.__memory_base=l;t.env.__table_base=q;t.env.csoundLoadModules=r=>{v.forEach(w=>{void 0===y?console.error("csound-wasm internal: timing problem detected!"):dlinit$$module$src$dlinit(y,w,n,r)});return 0};t.env._ZTH5errno=function(){};t.env.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module({memory:m,messagePort:c,streamBuffer:[]});t.env.printDebugCallback=(r,w)=>{r=new Uint8Array(m.buffer,r,w);r=uint2String$$module$src$utils$text_encoders(r);console.log(r)};
t["GOT.mem"]=t["GOT.mem"]||{};t["GOT.mem"].__heap_base=f;t["GOT.func"]=t["GOT.func"]||{};const y=await WebAssembly.instantiate(a,t);c=Object.assign({},y.exports);a={};a.exports=Object.assign(c,{memory:m});v=await b.reduce(async(r,{headerData:w,wasmPluginBytes:B})=>{r=await r;try{const {memorySize:z,memoryAlign:C,tableSize:F}=w,E=await WebAssembly.compile(B),x=e.getImports(E),G=new WebAssembly.Global({value:"i32",mutable:!1},A*PAGE_SIZE$$module$src$module);n.grow(F);x.env=Object.assign({},x.env);x.env.memory=
m;x.env.__indirect_function_table=n;x.env.__memory_base=G;x.env.__stack_pointer=p;x.env.__table_base=q;x.env.csoundLoadModules=u;delete x.env.csoundWasiJsMessageCallback;A+=Math.ceil((z+C)/PAGE_SIZE$$module$src$module);const D=await WebAssembly.instantiate(E,x);assertPluginExports$$module$src$module(D)&&(D.exports.__wasm_call_ctors(),r.push(D))}catch(z){console.error("Error while compiling csound-plugin",z)}return r},[]);e.start(a);a.exports.__wasi_js_csoundSetMessageStringCallback();return[a,e]},
module$src$module={};module$src$module.csoundWasiJsMessageCallback=csoundWasiJsMessageCallback$$module$src$module;module$src$module.default=$jscompDefaultExport$$module$src$module;const handleCsoundStart$$module$src$workers$common_utils=(a,b,c,d,e)=>f=>{const {csound:g}=f,h=1===b.csoundShouldDaemonize(g);h&&(b.csoundSetOption(g,"--daemon"),b.csoundSetOption(g,"-odac"));const k=b.csoundStart(g),l=b.csoundGetOutputName(g)||"test.wav";logCommonUtils$$module$src$logger(`handleCsoundStart: actual csoundStart result ${k}, outputName: ${l}`)();0!==k&&a.post(`error: csoundStart failed while trying to render ${l},`+" look out for errors in options and syntax");setTimeout(()=>{const m=
b._isRequestingRtMidiInput(g);if(h||m||l.includes("dac"))d(f);else if(a.broadcastPlayState("renderStarted"),e)e(f);else for(;0===b.csoundPerformKsmps(g););},0);return k},instantiateAudioPacket$$module$src$workers$common_utils=(a,b)=>{const c=[];for(let d=0;d<a;d++)c.push(new Float64Array(b));return c},renderFunction$$module$src$workers$common_utils=({libraryCsound:a,workerMessagePort:b})=>async({csound:c})=>{const d=a.csoundGetKr(c);let e=0,f=0;for(;("renderStarted"===b.vanillaWorkerState||"renderStarted"===
b.workerState)&&0===e;)e=a.csoundPerformKsmps(c),f+=1,"function"===typeof setTimeout&&0===e&&0===f%(2*d)&&await new Promise(g=>setTimeout(g,0));b.broadcastPlayState("renderEnded")};var module$src$workers$common_utils={};module$src$workers$common_utils.handleCsoundStart=handleCsoundStart$$module$src$workers$common_utils;module$src$workers$common_utils.instantiateAudioPacket=instantiateAudioPacket$$module$src$workers$common_utils;module$src$workers$common_utils.renderFunction=renderFunction$$module$src$workers$common_utils;let libraryCsound$$module$src$workers$worklet_singlethread_worker,combined$$module$src$workers$worklet_singlethread_worker;const rtmidiQueue$$module$src$workers$worklet_singlethread_worker=[],callUncloned$$module$src$workers$worklet_singlethread_worker=async(a,b)=>(a=combined$$module$src$workers$worklet_singlethread_worker.get(a))&&a.apply({},b||[]);
class WorkletSinglethreadWorker$$module$src$workers$worklet_singlethread_worker extends AudioWorkletProcessor{static get parameterDescriptors(){return[]}constructor(a){super(a);this.sampleRate=sampleRate;this.options=a;this.initialize=this.initialize.bind(this);this.pause=this.pause.bind(this);this.process=this.process.bind(this);this.resume=this.resume.bind(this);this.start=this.start.bind(this);this.isPaused=this.needsStartNotification=!1;this.callUncloned=()=>console.error("Csound worklet thread is still uninitialized!");
this.port.start();expose$$module$node_modules$comlink$dist$esm$comlink_mjs(this,this.port);this.workerMessagePort=new $jscompDefaultExport$$module$src$utils$message_port_state;this.initializeMessagePort=({messagePort:b,rtmidiPort:c})=>{this.workerMessagePort.post=d=>b.postMessage({log:d});this.workerMessagePort.broadcastPlayState=d=>{this.workerMessagePort.workerState!==d&&(this.workerMessagePort.workerState=d);b.postMessage({playStateChange:d})};this.workerMessagePort.ready=!0;logSinglethreadWorkletWorker$$module$src$logger("initRtMidiEventPort")();
this.rtmidiPort=c;this.rtmidiPort.addEventListener("message",({data:d})=>{rtmidiQueue$$module$src$workers$worklet_singlethread_worker.push(d)});this.rtmidiPort.start()}}async initialize(a,b){logSinglethreadWorkletWorker$$module$src$logger("initializing worklet.singlethread.worker")();let c;const d=new Promise(e=>{c=e});$jscompDefaultExport$$module$src$module({wasmDataURI:a,withPlugins:b,messagePort:this.workerMessagePort}).then(([e,f])=>{this.wasm=e;this.wasi=f;e.wasi=f;libraryCsound$$module$src$workers$worklet_singlethread_worker=
$jscompDefaultExport$$module$src$libcsound(e);this.callUncloned=callUncloned$$module$src$workers$worklet_singlethread_worker;this.csound=libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundCreate(0);this.result=0;this.started=this.isRendering=this.running=!1;this.resetCsound(!1);e=pipe$$module$node_modules$rambda$dist$rambda_mjs(assoc$$module$node_modules$rambda$dist$rambda_mjs("csoundCreate",async g=>this.csound),assoc$$module$node_modules$rambda$dist$rambda_mjs("csoundReset",this.resetCsound.bind(this)),
assoc$$module$node_modules$rambda$dist$rambda_mjs("csoundStart",this.start.bind(this)),assoc$$module$node_modules$rambda$dist$rambda_mjs("csoundStop",this.stop.bind(this)),assoc$$module$node_modules$rambda$dist$rambda_mjs("wasm",e))(libraryCsound$$module$src$workers$worklet_singlethread_worker);combined$$module$src$workers$worklet_singlethread_worker=new Map(Object.entries(e));logSinglethreadWorkletWorker$$module$src$logger("wasm initialized and api generated")();c()});logSinglethreadWorkletWorker$$module$src$logger("waiting on wasm initialization to complete")();
await d}async resetCsound(a){if(a&&!this.workerMessagePort||a&&"realtimePerformanceEnded"!==this.workerMessagePort.workerState&&"realtimePerformanceStarted"!==this.workerMessagePort.workerState)return-1;a&&"realtimePerformanceStarted"===this.workerMessagePort.workerState&&this.workerMessagePort.broadcastPlayState("realtimePerformanceEnded");this.started=this.running=!1;this.result=0;const b=this.csound;a&&libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundReset(b);libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundSetMidiCallbacks(b);
this.sampleRate&&libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundSetOption(b,"--sample-rate="+this.sampleRate);this.nchnls_i=this.nchnls=-1;delete this.csoundOutputBuffer}stop(){this.csound&&libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundStop(this.csound);this.workerMessagePort.broadcastPlayState("realtimePerformanceEnded")}pause(){this.isPaused||(this.workerMessagePort.broadcastPlayState("realtimePerformancePaused"),this.isPaused=!0)}resume(){this.isPaused&&
(this.workerMessagePort.broadcastPlayState("realtimePerformanceResumed"),this.isPaused=!1)}process(a,b){if(!(this.isRendering||!this.isPaused&&this.csoundOutputBuffer&&this.running)){a=b[0];b=a[0].length;for(var c=0;c<b;c++)for(var d=0;d<a.numberOfChannels;d++)a[d][c]=0;return!0}this.needsStartNotification&&(this.needsStartNotification=!1,this.workerMessagePort.broadcastPlayState("realtimePerformanceStarted"));0<rtmidiQueue$$module$src$workers$worklet_singlethread_worker.length&&(rtmidiQueue$$module$src$workers$worklet_singlethread_worker.forEach(q=>
{libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundPushMidiMessage(this.csound,q[0],q[1],q[2])}),clearArray$$module$src$utils$clear_array(rtmidiQueue$$module$src$workers$worklet_singlethread_worker));a=a[0];b=b[0];c=b[0].length;d=this.csoundOutputBuffer;let e=this.csoundInputBuffer;const f=this.ksmps,g=this.zerodBFS;let h=this.cnt;const k=this.nchnls,l=this.nchnls_i;let m=this.result;for(let q=0;q<c;q++,h++){h>=f&&0===m&&(m=libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundPerformKsmps(this.csound),
h=0,0!==m&&(this.started=this.running=!1,libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundCleanup(this.csound),this.workerMessagePort.broadcastPlayState("realtimePerformanceEnded")));d&&0!==d.length||(d=this.csoundOutputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetSpout(this.csound),f*k));e&&0!==e.length||(e=this.csoundInputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetSpin(this.csound),
f*l));var n=Math.min(this.nchnls_i,a.length);for(var p=0;p<n;p++)e[h*l+p]=a[p][q]*g;if(this.nchnls===b.length)for(const [u,t]of b.entries())t[q]=0===m?d[h*k+u]/g:0;else if(2===this.nchnls&&1===b.length)b[0][q]=0===m?.5*(d[h*k]/g+d[h*k+1]/g):0;else if(1===this.nchnls&&2===b.length)if(n=b[0],p=b[1],0===m){const u=d[h*k]/g;n[q]=u;p[q]=u}else n[q]=0,p[q]=0}this.cnt=h;this.result=m;return!0}async isRequestingInput(){return(libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetInputName(this.csound)||
"").includes("adc")}async isRequestingRealtimeOutput(){return(libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetOutputName(this.csound)||"").includes("dac")}async start(){let a=-1;if(this.started)logSinglethreadWorkletWorker$$module$src$logger("worklet was asked to start but it already has!")();else{logSinglethreadWorkletWorker$$module$src$logger("worklet thread is starting..")();const b=this.csound,c=libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetKsmps(b);
this.cnt=this.ksmps=c;this.nchnls=libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetNchnls(b);this.nchnls_i=libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetNchnlsInput(b);this.zerodBFS=libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGet0dBFS(b);a=libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundStart(b);if(0!==a)return a;if(await this.isRequestingRealtimeOutput())this.csoundOutputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,
libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetSpout(b),c*this.nchnls),this.csoundInputBuffer=new Float64Array(this.wasm.wasi.memory.buffer,libraryCsound$$module$src$workers$worklet_singlethread_worker.csoundGetSpin(b),c*this.nchnls_i),logSinglethreadWorkletWorker$$module$src$logger("csoundStart called with {} return val",a)(),this.needsStartNotification=this.started=!0;else return this.workerMessagePort.broadcastPlayState("renderStarted"),this.isRendering=!0,renderFunction$$module$src$workers$common_utils({libraryCsound:libraryCsound$$module$src$workers$worklet_singlethread_worker,
workerMessagePort:this.workerMessagePort,wasi:this.wasi})({csound:b}).then(()=>{this.workerMessagePort.broadcastPlayState("renderEnded");this.isRendering=!1}).catch(()=>{this.workerMessagePort.broadcastPlayState("renderEnded");this.isRendering=!1}),0}this.running=!0;return a}}registerProcessor("csound-singlethread-worklet-processor",WorkletSinglethreadWorker$$module$src$workers$worklet_singlethread_worker);var module$src$workers$worklet_singlethread_worker={};
//# sourceURL=/dist/__compiled.worklet.singlethread.worker.js
//# sourceMappingURL=/dist/__compiled.worklet.singlethread.worker.js.map
",
+module$dist$__compiled_worklet_singlethread_worker_inline={};module$dist$__compiled_worklet_singlethread_worker_inline.default=$jscompDefaultExport$$module$dist$__compiled_worklet_singlethread_worker_inline;const initializeModule$$module$src$mains$worklet_singlethread_main=async a=>{logSinglethreadWorkletMain$$module$src$logger("Initialize Module")();try{await a.audioWorklet.addModule($jscompDefaultExport$$module$dist$__compiled_worklet_singlethread_worker_inline())}catch(b){return console.error("Error calling audioWorklet.addModule",b),!1}return!0};
+class SingleThreadAudioWorkletMainThread$$module$src$mains$worklet_singlethread_main{constructor({audioContext:a,inputChannelCount:b=1,outputChannelCount:c=2}){this.exportApi={};this.ipcMessagePorts=new IPCMessagePorts$$module$src$mains$messages_main;this.publicEvents=new PublicEventAPI$$module$src$events(this);this.eventPromises=new EventPromises$$module$src$utils$event_promises;this.audioContext=a;this.inputChannelCount=b;this.outputChannelCount=c;this.messageCallbacks=[];this.onPlayStateChange=
+this.onPlayStateChange.bind(this);this.currentPlayState=void 0}async terminateInstance(){this.node&&(this.node.disconnect(),delete this.node);this.audioContext&&("closed"!==this.audioContext.state&&await this.audioContext.close(),delete this.audioContext);this.workletProxy&&(this.workletProxy[releaseProxy$$module$node_modules$comlink$dist$esm$comlink_mjs](),delete this.workletProxy);this.publicEvents&&(this.publicEvents.terminateInstance(),delete this.publicEvents);Object.keys(this.exportApi).forEach(a=>
+delete this.exportApi[a]);Object.keys(this).forEach(a=>delete this[a])}async onPlayStateChange(a){if(this.currentPlayState!==a&&this.publicEvents)switch(this.currentPlayState=a,a){case "realtimePerformanceStarted":this.eventPromises.isWaitingToStart()&&(logSinglethreadWorkletMain$$module$src$logger("Start promise resolved")(),this.eventPromises.releaseStartPromise());this.publicEvents.triggerRealtimePerformanceStarted(this);break;case "realtimePerformanceEnded":this.midiPortStarted=!1;this.currentPlayState=
+void 0;this.publicEvents&&this.publicEvents.triggerRealtimePerformanceEnded(this);this.eventPromises&&this.eventPromises.isWaitingToStop()&&this.eventPromises.releaseStopPromise();this.eventPromises&&this.eventPromises.releaseStartPromise();break;case "realtimePerformancePaused":this.publicEvents.triggerRealtimePerformancePaused(this);break;case "realtimePerformanceResumed":this.publicEvents.triggerRealtimePerformanceResumed(this);break;case "renderStarted":this.eventPromises.isWaitingToStart()&&
+(logSinglethreadWorkletMain$$module$src$logger("Start promise resolved")(),this.publicEvents.triggerRenderStarted(this),this.eventPromises.releaseStartPromise());break;case "renderEnded":this.publicEvents.triggerRenderEnded(this),this.eventPromises&&this.eventPromises.isWaitingToStop()&&this.eventPromises.releaseStopPromise(),this.eventPromises&&this.eventPromises.releaseStartPromise()}}async csoundPause(){void 0!==this.workletProxy&&await this.workletProxy.pause()}async csoundResume(){void 0!==this.workletProxy&&
+await this.workletProxy.resume()}handleMidiInput({data:a}){this.ipcMessagePorts.csoundMainRtMidiPort.postMessage&&this.ipcMessagePorts.csoundMainRtMidiPort.postMessage(a)}async initialize({wasmDataURI:a,withPlugins:b,autoConnect:c}){b&&0<b.length&&(b=await fetchPlugins$$module$src$utils(b));await initializeModule$$module$src$mains$worklet_singlethread_main(this.audioContext);this.node=new AudioWorkletNode(this.audioContext,"csound-singlethread-worklet-processor",{inputChannelCount:this.inputChannelCount?
+[this.inputChannelCount]:0,outputChannelCount:[this.outputChannelCount||2]});c&&this.node.connect(this.audioContext.destination);try{logSinglethreadWorkletMain$$module$src$logger("wrapping Comlink proxy endpoint on the audioWorkletNode.port")(),this.workletProxy=wrap$$module$node_modules$comlink$dist$esm$comlink_mjs(this.node.port)}catch(e){console.error("COMLINK ERROR",e)}await this.workletProxy.initializeMessagePort(transfer$$module$node_modules$comlink$dist$esm$comlink_mjs({messagePort:this.ipcMessagePorts.workerMessagePort,
+rtmidiPort:this.ipcMessagePorts.csoundWorkerRtMidiPort},[this.ipcMessagePorts.workerMessagePort,this.ipcMessagePorts.csoundWorkerRtMidiPort]));this.ipcMessagePorts.mainMessagePort.addEventListener("message",messageEventHandler$$module$src$mains$messages_main(this));this.ipcMessagePorts.mainMessagePort.start();await this.workletProxy.initialize(a(),b);const d=await makeProxyCallback$$module$src$utils(this.workletProxy,void 0,"csoundCreate",this.currentPlayState)();this.csoundInstance=d;await makeProxyCallback$$module$src$utils(this.workletProxy,
+d,"csoundInitialize",this.currentPlayState)(0);this.exportApi.pause=this.csoundPause.bind(this);this.exportApi.resume=this.csoundResume.bind(this);this.exportApi.terminateInstance=this.terminateInstance.bind(this);this.exportApi.getAudioContext=async()=>this.audioContext;this.exportApi.getNode=async()=>this.node;this.exportApi.enableAudioInput=enableAudioInput$$module$src$mains$io_utils.bind(this.exportApi);this.exportApi.name="Csound: Audio Worklet, Single-threaded";this.exportApi=this.publicEvents.decorateAPI(this.exportApi);
+this.exportApi.addListener("message",console.log);for(const e of Object.keys(api$$module$src$libcsound)){const f=api$$module$src$libcsound[e],g=makeProxyCallback$$module$src$utils(this.workletProxy,d,e,this.currentPlayState);switch(e){case "csoundCreate":break;case "csoundStart":a=async function(){this.eventPromises.createStartPromise();var h=await this.workletProxy.isRequestingInput();if(await this.workletProxy.isRequestingRealtimeOutput())return h&&this.exportApi.enableAudioInput(),await this.exportApi._isRequestingRtMidiInput(d)&&
+requestMidi$$module$src$utils$request_midi({onMidiMessage:this.handleMidiInput.bind(this)}),h=await g({csound:d}),this.publicEvents.triggerOnAudioNodeCreated(this.node),await this.eventPromises.waitForStart(),h;g({csound:d});this.publicEvents.triggerOnAudioNodeCreated(this.node);await this.eventPromises.waitForStart();return 0};a.toString=()=>f.toString();this.exportApi.start=a.bind(this);break;case "csoundStop":a=async()=>{if(this.eventPromises.isWaitingToStop())return logSinglethreadWorkletMain$$module$src$logger("already waiting to stop, doing nothing")(),
+-1;this.eventPromises.createStopPromise();const h=await g();await this.eventPromises.waitForStop();return h};a.toString=()=>f.toString();this.exportApi.stop=a.bind(this);break;case "fs":this.exportApi.fs={};Object.keys(f).forEach(h=>{const k=makeProxyCallback$$module$src$utils(this.workletProxy,d,h,this.currentPlayState);k.toString=()=>f[h].toString();this.exportApi.fs[h]=k});break;default:g.toString=()=>f.toString(),this.exportApi[csoundApiRename$$module$src$utils(e)]=g}}return this.exportApi}}
+var $jscompDefaultExport$$module$src$mains$worklet_singlethread_main=SingleThreadAudioWorkletMainThread$$module$src$mains$worklet_singlethread_main,module$src$mains$worklet_singlethread_main={};module$src$mains$worklet_singlethread_main.default=$jscompDefaultExport$$module$src$mains$worklet_singlethread_main;(0,module$node_modules$unmute_ios_audio$index.default)();
+const Csound$$module$src$index=async function({audioContext:a,inputChannelCount:b,outputChannelCount:c,autoConnect:d=!0,withPlugins:e=[],useWorker:f=!1,useSAB:g=!0,useSPN:h=!1}={}){const k=a&&WebkitAudioContext$$module$src$utils()&&a instanceof WebkitAudioContext$$module$src$utils();k||(a=a||new (WebkitAudioContext$$module$src$utils())({latencyHint:"interactive"}));isSafari$$module$src$utils()&&a.resume();const n=areWorkletsSupported$$module$src$utils(),m=isScriptProcessorNodeSupported$$module$src$utils();
+if(f){n?logIndex$$module$src$logger("worklet support detected")():m?logIndex$$module$src$logger("scriptProcessorNode support detected")():console.error("No WebAudio Support detected");var l;!h&&n?l=new $jscompDefaultExport$$module$src$mains$worklet_main({audioContext:a,audioContextIsProvided:k,autoConnect:d}):m&&(l=new $jscompDefaultExport$$module$src$mains$old_spn_main({audioContext:a,audioContextIsProvided:k,autoConnect:d}));if(l)return(d=isSabSupported$$module$src$utils())?g&&logIndex$$module$src$logger("using SharedArrayBuffers")():
+logIndex$$module$src$logger("SharedArrayBuffers not found, falling back to Vanilla concurrency")(),a=d&&n&&g?new $jscompDefaultExport$$module$src$mains$sab_main({audioWorker:l,audioContext:a,audioContextIsProvided:k,inputChannelCount:b,outputChannelCount:c}):new $jscompDefaultExport$$module$src$mains$vanilla_main({audioWorker:l,audioContextIsProvided:k}),logIndex$$module$src$logger("starting Csound thread initialization via WebWorker")(),await a.initialize({wasmDataURI:$jscompDefaultExport$$module$dist$__csound_wasm_inline,
+withPlugins:e}),e=a.api}else{if(n&&!h)return logIndex$$module$src$logger("Single Thread AudioWorklet")(),(new $jscompDefaultExport$$module$src$mains$worklet_singlethread_main({audioContext:a,inputChannelCount:b||2,outputChannelCount:c||2})).initialize({wasmDataURI:$jscompDefaultExport$$module$dist$__csound_wasm_inline,withPlugins:e,autoConnect:d});if(m)return logIndex$$module$src$logger("Single Thread ScriptProcessorNode")(),await (new $jscompDefaultExport$$module$src$mains$spn_main({audioContext:a,
+inputChannelCount:b||2,outputChannelCount:c||2})).initialize({wasmDataURI:$jscompDefaultExport$$module$dist$__csound_wasm_inline,withPlugins:e,autoConnect:d})}console.error("No detectable WebAudioAPI in current environment")};goog.exportSymbol("Csound$$module$src$index",Csound$$module$src$index);var module$src$index={};module$src$index.Csound=Csound$$module$src$index;
+const Csound = Csound$$module$src$index;
+Csound.toString = () => 'async (options) => CsoundObj;';
+export { Csound }
+export default Csound
+//# sourceMappingURL=csound.js.map
author	Richard <q@1bpm.net>	2025-04-13 18:48:02 +0100
committer	Richard <q@1bpm.net>	2025-04-13 18:48:02 +0100
commit	9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22 (patch)
tree	291bd79ce340e67affa755a8a6b4f6a83cce93ea /site/code/csound.js
download	apps.csound.1bpm.net-9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22.tar.gz apps.csound.1bpm.net-9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22.tar.bz2 apps.csound.1bpm.net-9fbf91db06a6d4f4b5cd8bb45389a731bb86bf22.zip