{"version":3,"sources":["webpack:///./node_modules/@ffmpeg/ffmpeg/src/utils/parseArgs.js","webpack:///./src/components/Toggle.vue?c1a3","webpack:///./node_modules/@ffmpeg/ffmpeg/node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/@ffmpeg/ffmpeg/src/browser/getCreateFFmpegCore.js","webpack:///./node_modules/resolve-url/resolve-url.js","webpack:///./src/assets/img/bgBluesquare.png","webpack:///./src/assets/img/bgline.png","webpack:///./node_modules/@ffmpeg/ffmpeg/src/browser/fetchFile.js","webpack:///./node_modules/@ffmpeg/ffmpeg/src/browser/defaultOptions.js","webpack:///./node_modules/@ffmpeg/ffmpeg/src/utils/log.js","webpack:///./node_modules/@ffmpeg/ffmpeg/src/index.js","webpack:///./node_modules/@ffmpeg/ffmpeg/src/createFFmpeg.js","webpack:///./src/components/Toggle.vue?dbf7","webpack:///src/components/Toggle.vue","webpack:///./src/components/Toggle.vue?da97","webpack:///./src/components/Toggle.vue","webpack:///./node_modules/@ffmpeg/ffmpeg/src/browser/index.js","webpack:///./node_modules/@ffmpeg/ffmpeg/src/config.js","webpack:///./src/assets/img/bgPurpleYellow.png","webpack:///./src/assets/img/BgPeople.png","webpack:///./src/assets/img/Map.png","webpack:///./node_modules/@ffmpeg/ffmpeg/src/utils/parseProgress.js"],"names":["module","exports","Core","args","argsPtr","_malloc","length","Uint32Array","BYTES_PER_ELEMENT","forEach","s","idx","buf","writeAsciiToMemory","setValue","runtime","undefined","Op","Object","prototype","hasOwn","hasOwnProperty","defineProperty","obj","key","desc","value","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","enumerable","configurable","writable","err","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","create","context","Context","makeInvokeMethod","tryCatch","fn","arg","type","call","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","this","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","method","_invoke","AsyncIterator","PromiseImpl","invoke","resolve","reject","record","result","__await","then","unwrapped","error","previousPromise","enqueue","callInvokeWithMethodAndArg","state","Error","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","done","methodName","TypeError","info","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","i","displayName","isGeneratorFunction","genFun","ctor","constructor","name","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","keys","val","object","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootEntry","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","globalThis","Function","resolveURL","log","toBlobURL","url","mimeType","fetch","arrayBuffer","byteLength","blob","Blob","blobURL","URL","createObjectURL","corePath","_corePath","coreRemotePath","wasmPath","replace","workerPath","createFFmpegCore","script","document","createElement","eventHandler","removeEventListener","src","addEventListener","getElementsByTagName","appendChild","root","factory","resolveUrl","numUrls","arguments","base","href","head","insertBefore","firstChild","resolved","a","index","removeChild","readFromBlobOrFile","fileReader","FileReader","onload","onerror","target","code","readAsArrayBuffer","_data","data","Uint8Array","test","atob","split","map","c","charCodeAt","res","File","devDependencies","process","FFMPEG_ENV","substring","logging","customLogger","setLogging","_logging","setCustomLogger","logger","message","console","createFFmpeg","fetchFile","defaultArgs","baseOptions","parseProgress","parseArgs","defaultOptions","getCreateFFmpegCore","version","NO_LOAD","_options","progress","optProgress","options","ffmpeg","runResolve","running","detectCompletion","parseMessage","load","mainScriptUrlOrBlob","printErr","print","locateFile","path","prefix","window","endsWith","cwrap","isLoaded","run","_args","join","filter","FS","ret","e","exit","setProgress","_progress","setLogger","_logger","render","_vm","_h","$createElement","_c","_self","staticClass","staticStyle","attrs","on","toggle","_v","_s","title","isActive","directives","rawName","expression","_t","staticRenderFns","component","duration","ratio","ts2sec","ts","h","m","parseFloat","startsWith","d","t","time"],"mappings":"mGAAAA,EAAOC,QAAU,CAACC,EAAMC,KACtB,MAAMC,EAAUF,EAAKG,QAAQF,EAAKG,OAASC,YAAYC,mBAMvD,OALAL,EAAKM,QAAQ,CAACC,EAAGC,KACf,MAAMC,EAAMV,EAAKG,QAAQK,EAAEJ,OAAS,GACpCJ,EAAKW,mBAAmBH,EAAGE,GAC3BV,EAAKY,SAASV,EAAWG,YAAYC,kBAAoBG,EAAMC,EAAK,SAE/D,CAACT,EAAKG,OAAQF,K,oCCPvB,yBAAmgB,EAAG,G,uBCOtgB,IAAIW,EAAW,SAAUd,GACvB,aAEA,IAGIe,EAHAC,EAAKC,OAAOC,UACZC,EAASH,EAAGI,eACZC,EAAiBJ,OAAOI,gBAAkB,SAAUC,EAAKC,EAAKC,GAAQF,EAAIC,GAAOC,EAAKC,OAEtFC,EAA4B,oBAAXC,OAAwBA,OAAS,GAClDC,EAAiBF,EAAQG,UAAY,aACrCC,EAAsBJ,EAAQK,eAAiB,kBAC/CC,EAAoBN,EAAQO,aAAe,gBAE/C,SAASC,EAAOZ,EAAKC,EAAKE,GAOxB,OANAR,OAAOI,eAAeC,EAAKC,EAAK,CAC9BE,MAAOA,EACPU,YAAY,EACZC,cAAc,EACdC,UAAU,IAELf,EAAIC,GAEb,IAEEW,EAAO,GAAI,IACX,MAAOI,GACPJ,EAAS,SAASZ,EAAKC,EAAKE,GAC1B,OAAOH,EAAIC,GAAOE,GAItB,SAASc,EAAKC,EAASC,EAASC,EAAMC,GAEpC,IAAIC,EAAiBH,GAAWA,EAAQvB,qBAAqB2B,EAAYJ,EAAUI,EAC/EC,EAAY7B,OAAO8B,OAAOH,EAAe1B,WACzC8B,EAAU,IAAIC,EAAQN,GAAe,IAMzC,OAFAtB,EAAeyB,EAAW,UAAW,CAAErB,MAAOyB,EAAiBV,EAASE,EAAMM,KAEvEF,EAcT,SAASK,EAASC,EAAI9B,EAAK+B,GACzB,IACE,MAAO,CAAEC,KAAM,SAAUD,IAAKD,EAAGG,KAAKjC,EAAK+B,IAC3C,MAAOf,GACP,MAAO,CAAEgB,KAAM,QAASD,IAAKf,IAhBjCtC,EAAQuC,KAAOA,EAoBf,IAAIiB,EAAyB,iBACzBC,EAAyB,iBACzBC,EAAoB,YACpBC,EAAoB,YAIpBC,EAAmB,GAMvB,SAASf,KACT,SAASgB,KACT,SAASC,KAIT,IAAIC,EAAoB,GACxB7B,EAAO6B,EAAmBnC,GAAgB,WACxC,OAAOoC,QAGT,IAAIC,EAAWhD,OAAOiD,eAClBC,EAA0BF,GAAYA,EAASA,EAASG,EAAO,MAC/DD,GACAA,IAA4BnD,GAC5BG,EAAOoC,KAAKY,EAAyBvC,KAGvCmC,EAAoBI,GAGtB,IAAIE,EAAKP,EAA2B5C,UAClC2B,EAAU3B,UAAYD,OAAO8B,OAAOgB,GAgBtC,SAASO,EAAsBpD,GAC7B,CAAC,OAAQ,QAAS,UAAUV,SAAQ,SAAS+D,GAC3CrC,EAAOhB,EAAWqD,GAAQ,SAASlB,GACjC,OAAOW,KAAKQ,QAAQD,EAAQlB,SAkClC,SAASoB,EAAc3B,EAAW4B,GAChC,SAASC,EAAOJ,EAAQlB,EAAKuB,EAASC,GACpC,IAAIC,EAAS3B,EAASL,EAAUyB,GAASzB,EAAWO,GACpD,GAAoB,UAAhByB,EAAOxB,KAEJ,CACL,IAAIyB,EAASD,EAAOzB,IAChB5B,EAAQsD,EAAOtD,MACnB,OAAIA,GACiB,kBAAVA,GACPN,EAAOoC,KAAK9B,EAAO,WACdiD,EAAYE,QAAQnD,EAAMuD,SAASC,MAAK,SAASxD,GACtDkD,EAAO,OAAQlD,EAAOmD,EAASC,MAC9B,SAASvC,GACVqC,EAAO,QAASrC,EAAKsC,EAASC,MAI3BH,EAAYE,QAAQnD,GAAOwD,MAAK,SAASC,GAI9CH,EAAOtD,MAAQyD,EACfN,EAAQG,MACP,SAASI,GAGV,OAAOR,EAAO,QAASQ,EAAOP,EAASC,MAvBzCA,EAAOC,EAAOzB,KA4BlB,IAAI+B,EAEJ,SAASC,EAAQd,EAAQlB,GACvB,SAASiC,IACP,OAAO,IAAIZ,GAAY,SAASE,EAASC,GACvCF,EAAOJ,EAAQlB,EAAKuB,EAASC,MAIjC,OAAOO,EAaLA,EAAkBA,EAAgBH,KAChCK,EAGAA,GACEA,IAKRjE,EAAe2C,KAAM,UAAW,CAAEvC,MAAO4D,IA2B3C,SAASnC,EAAiBV,EAASE,EAAMM,GACvC,IAAIuC,EAAQ/B,EAEZ,OAAO,SAAgBe,EAAQlB,GAC7B,GAAIkC,IAAU7B,EACZ,MAAM,IAAI8B,MAAM,gCAGlB,GAAID,IAAU5B,EAAmB,CAC/B,GAAe,UAAXY,EACF,MAAMlB,EAKR,OAAOoC,IAGTzC,EAAQuB,OAASA,EACjBvB,EAAQK,IAAMA,EAEd,MAAO,EAAM,CACX,IAAIqC,EAAW1C,EAAQ0C,SACvB,GAAIA,EAAU,CACZ,IAAIC,EAAiBC,EAAoBF,EAAU1C,GACnD,GAAI2C,EAAgB,CAClB,GAAIA,IAAmB/B,EAAkB,SACzC,OAAO+B,GAIX,GAAuB,SAAnB3C,EAAQuB,OAGVvB,EAAQ6C,KAAO7C,EAAQ8C,MAAQ9C,EAAQK,SAElC,GAAuB,UAAnBL,EAAQuB,OAAoB,CACrC,GAAIgB,IAAU/B,EAEZ,MADA+B,EAAQ5B,EACFX,EAAQK,IAGhBL,EAAQ+C,kBAAkB/C,EAAQK,SAEN,WAAnBL,EAAQuB,QACjBvB,EAAQgD,OAAO,SAAUhD,EAAQK,KAGnCkC,EAAQ7B,EAER,IAAIoB,EAAS3B,EAASX,EAASE,EAAMM,GACrC,GAAoB,WAAhB8B,EAAOxB,KAAmB,CAO5B,GAJAiC,EAAQvC,EAAQiD,KACZtC,EACAF,EAEAqB,EAAOzB,MAAQO,EACjB,SAGF,MAAO,CACLnC,MAAOqD,EAAOzB,IACd4C,KAAMjD,EAAQiD,MAGS,UAAhBnB,EAAOxB,OAChBiC,EAAQ5B,EAGRX,EAAQuB,OAAS,QACjBvB,EAAQK,IAAMyB,EAAOzB,OAU7B,SAASuC,EAAoBF,EAAU1C,GACrC,IAAIkD,EAAalD,EAAQuB,OACrBA,EAASmB,EAAS7D,SAASqE,GAC/B,GAAI3B,IAAWxD,EAOb,OAHAiC,EAAQ0C,SAAW,KAGA,UAAfQ,GAA0BR,EAAS7D,SAAS,YAG9CmB,EAAQuB,OAAS,SACjBvB,EAAQK,IAAMtC,EACd6E,EAAoBF,EAAU1C,GAEP,UAAnBA,EAAQuB,SAMK,WAAf2B,IACFlD,EAAQuB,OAAS,QACjBvB,EAAQK,IAAM,IAAI8C,UAChB,oCAAsCD,EAAa,aAN5CtC,EAYb,IAAIkB,EAAS3B,EAASoB,EAAQmB,EAAS7D,SAAUmB,EAAQK,KAEzD,GAAoB,UAAhByB,EAAOxB,KAIT,OAHAN,EAAQuB,OAAS,QACjBvB,EAAQK,IAAMyB,EAAOzB,IACrBL,EAAQ0C,SAAW,KACZ9B,EAGT,IAAIwC,EAAOtB,EAAOzB,IAElB,OAAM+C,EAOFA,EAAKH,MAGPjD,EAAQ0C,EAASW,YAAcD,EAAK3E,MAGpCuB,EAAQsD,KAAOZ,EAASa,QAQD,WAAnBvD,EAAQuB,SACVvB,EAAQuB,OAAS,OACjBvB,EAAQK,IAAMtC,GAUlBiC,EAAQ0C,SAAW,KACZ9B,GANEwC,GA3BPpD,EAAQuB,OAAS,QACjBvB,EAAQK,IAAM,IAAI8C,UAAU,oCAC5BnD,EAAQ0C,SAAW,KACZ9B,GAoDX,SAAS4C,EAAaC,GACpB,IAAIC,EAAQ,CAAEC,OAAQF,EAAK,IAEvB,KAAKA,IACPC,EAAME,SAAWH,EAAK,IAGpB,KAAKA,IACPC,EAAMG,WAAaJ,EAAK,GACxBC,EAAMI,SAAWL,EAAK,IAGxBzC,KAAK+C,WAAWC,KAAKN,GAGvB,SAASO,EAAcP,GACrB,IAAI5B,EAAS4B,EAAMQ,YAAc,GACjCpC,EAAOxB,KAAO,gBACPwB,EAAOzB,IACdqD,EAAMQ,WAAapC,EAGrB,SAAS7B,EAAQN,GAIfqB,KAAK+C,WAAa,CAAC,CAAEJ,OAAQ,SAC7BhE,EAAYnC,QAAQgG,EAAcxC,MAClCA,KAAKmD,OAAM,GA+Bb,SAAS/C,EAAOgD,GACd,GAAIA,EAAU,CACZ,IAAIC,EAAiBD,EAASxF,GAC9B,GAAIyF,EACF,OAAOA,EAAe9D,KAAK6D,GAG7B,GAA6B,oBAAlBA,EAASd,KAClB,OAAOc,EAGT,IAAKE,MAAMF,EAAS/G,QAAS,CAC3B,IAAIkH,GAAK,EAAGjB,EAAO,SAASA,IAC1B,QAASiB,EAAIH,EAAS/G,OACpB,GAAIc,EAAOoC,KAAK6D,EAAUG,GAGxB,OAFAjB,EAAK7E,MAAQ2F,EAASG,GACtBjB,EAAKL,MAAO,EACLK,EAOX,OAHAA,EAAK7E,MAAQV,EACbuF,EAAKL,MAAO,EAELK,GAGT,OAAOA,EAAKA,KAAOA,GAKvB,MAAO,CAAEA,KAAMb,GAIjB,SAASA,IACP,MAAO,CAAEhE,MAAOV,EAAWkF,MAAM,GA+MnC,OAnnBApC,EAAkB3C,UAAY4C,EAC9BzC,EAAegD,EAAI,cAAe,CAAE5C,MAAOqC,EAA4B1B,cAAc,IACrFf,EACEyC,EACA,cACA,CAAErC,MAAOoC,EAAmBzB,cAAc,IAE5CyB,EAAkB2D,YAActF,EAC9B4B,EACA9B,EACA,qBAaFhC,EAAQyH,oBAAsB,SAASC,GACrC,IAAIC,EAAyB,oBAAXD,GAAyBA,EAAOE,YAClD,QAAOD,IACHA,IAAS9D,GAG2B,uBAAnC8D,EAAKH,aAAeG,EAAKE,QAIhC7H,EAAQ8H,KAAO,SAASJ,GAQtB,OAPIzG,OAAO8G,eACT9G,OAAO8G,eAAeL,EAAQ5D,IAE9B4D,EAAOM,UAAYlE,EACnB5B,EAAOwF,EAAQ1F,EAAmB,sBAEpC0F,EAAOxG,UAAYD,OAAO8B,OAAOsB,GAC1BqD,GAOT1H,EAAQiI,MAAQ,SAAS5E,GACvB,MAAO,CAAE2B,QAAS3B,IAsEpBiB,EAAsBG,EAAcvD,WACpCgB,EAAOuC,EAAcvD,UAAWY,GAAqB,WACnD,OAAOkC,QAEThE,EAAQyE,cAAgBA,EAKxBzE,EAAQkI,MAAQ,SAAS1F,EAASC,EAASC,EAAMC,EAAa+B,QACxC,IAAhBA,IAAwBA,EAAcyD,SAE1C,IAAIC,EAAO,IAAI3D,EACblC,EAAKC,EAASC,EAASC,EAAMC,GAC7B+B,GAGF,OAAO1E,EAAQyH,oBAAoBhF,GAC/B2F,EACAA,EAAK9B,OAAOrB,MAAK,SAASF,GACxB,OAAOA,EAAOkB,KAAOlB,EAAOtD,MAAQ2G,EAAK9B,WAwKjDhC,EAAsBD,GAEtBnC,EAAOmC,EAAIrC,EAAmB,aAO9BE,EAAOmC,EAAIzC,GAAgB,WACzB,OAAOoC,QAGT9B,EAAOmC,EAAI,YAAY,WACrB,MAAO,wBAkCTrE,EAAQqI,KAAO,SAASC,GACtB,IAAIC,EAAStH,OAAOqH,GAChBD,EAAO,GACX,IAAK,IAAI9G,KAAOgH,EACdF,EAAKrB,KAAKzF,GAMZ,OAJA8G,EAAKG,UAIE,SAASlC,IACd,MAAO+B,EAAKhI,OAAQ,CAClB,IAAIkB,EAAM8G,EAAKI,MACf,GAAIlH,KAAOgH,EAGT,OAFAjC,EAAK7E,MAAQF,EACb+E,EAAKL,MAAO,EACLK,EAQX,OADAA,EAAKL,MAAO,EACLK,IAsCXtG,EAAQoE,OAASA,EAMjBnB,EAAQ/B,UAAY,CAClB0G,YAAa3E,EAEbkE,MAAO,SAASuB,GAcd,GAbA1E,KAAK2E,KAAO,EACZ3E,KAAKsC,KAAO,EAGZtC,KAAK6B,KAAO7B,KAAK8B,MAAQ/E,EACzBiD,KAAKiC,MAAO,EACZjC,KAAK0B,SAAW,KAEhB1B,KAAKO,OAAS,OACdP,KAAKX,IAAMtC,EAEXiD,KAAK+C,WAAWvG,QAAQyG,IAEnByB,EACH,IAAK,IAAIb,KAAQ7D,KAEQ,MAAnB6D,EAAKe,OAAO,IACZzH,EAAOoC,KAAKS,KAAM6D,KACjBP,OAAOO,EAAKgB,MAAM,MACrB7E,KAAK6D,GAAQ9G,IAMrB+H,KAAM,WACJ9E,KAAKiC,MAAO,EAEZ,IAAI8C,EAAY/E,KAAK+C,WAAW,GAC5BiC,EAAaD,EAAU7B,WAC3B,GAAwB,UAApB8B,EAAW1F,KACb,MAAM0F,EAAW3F,IAGnB,OAAOW,KAAKiF,MAGdlD,kBAAmB,SAASmD,GAC1B,GAAIlF,KAAKiC,KACP,MAAMiD,EAGR,IAAIlG,EAAUgB,KACd,SAASmF,EAAOC,EAAKC,GAYnB,OAXAvE,EAAOxB,KAAO,QACdwB,EAAOzB,IAAM6F,EACblG,EAAQsD,KAAO8C,EAEXC,IAGFrG,EAAQuB,OAAS,OACjBvB,EAAQK,IAAMtC,KAGNsI,EAGZ,IAAK,IAAI9B,EAAIvD,KAAK+C,WAAW1G,OAAS,EAAGkH,GAAK,IAAKA,EAAG,CACpD,IAAIb,EAAQ1C,KAAK+C,WAAWQ,GACxBzC,EAAS4B,EAAMQ,WAEnB,GAAqB,SAAjBR,EAAMC,OAIR,OAAOwC,EAAO,OAGhB,GAAIzC,EAAMC,QAAU3C,KAAK2E,KAAM,CAC7B,IAAIW,EAAWnI,EAAOoC,KAAKmD,EAAO,YAC9B6C,EAAapI,EAAOoC,KAAKmD,EAAO,cAEpC,GAAI4C,GAAYC,EAAY,CAC1B,GAAIvF,KAAK2E,KAAOjC,EAAME,SACpB,OAAOuC,EAAOzC,EAAME,UAAU,GACzB,GAAI5C,KAAK2E,KAAOjC,EAAMG,WAC3B,OAAOsC,EAAOzC,EAAMG,iBAGjB,GAAIyC,GACT,GAAItF,KAAK2E,KAAOjC,EAAME,SACpB,OAAOuC,EAAOzC,EAAME,UAAU,OAG3B,KAAI2C,EAMT,MAAM,IAAI/D,MAAM,0CALhB,GAAIxB,KAAK2E,KAAOjC,EAAMG,WACpB,OAAOsC,EAAOzC,EAAMG,gBAU9Bb,OAAQ,SAAS1C,EAAMD,GACrB,IAAK,IAAIkE,EAAIvD,KAAK+C,WAAW1G,OAAS,EAAGkH,GAAK,IAAKA,EAAG,CACpD,IAAIb,EAAQ1C,KAAK+C,WAAWQ,GAC5B,GAAIb,EAAMC,QAAU3C,KAAK2E,MACrBxH,EAAOoC,KAAKmD,EAAO,eACnB1C,KAAK2E,KAAOjC,EAAMG,WAAY,CAChC,IAAI2C,EAAe9C,EACnB,OAIA8C,IACU,UAATlG,GACS,aAATA,IACDkG,EAAa7C,QAAUtD,GACvBA,GAAOmG,EAAa3C,aAGtB2C,EAAe,MAGjB,IAAI1E,EAAS0E,EAAeA,EAAatC,WAAa,GAItD,OAHApC,EAAOxB,KAAOA,EACdwB,EAAOzB,IAAMA,EAETmG,GACFxF,KAAKO,OAAS,OACdP,KAAKsC,KAAOkD,EAAa3C,WAClBjD,GAGFI,KAAKyF,SAAS3E,IAGvB2E,SAAU,SAAS3E,EAAQgC,GACzB,GAAoB,UAAhBhC,EAAOxB,KACT,MAAMwB,EAAOzB,IAcf,MAXoB,UAAhByB,EAAOxB,MACS,aAAhBwB,EAAOxB,KACTU,KAAKsC,KAAOxB,EAAOzB,IACM,WAAhByB,EAAOxB,MAChBU,KAAKiF,KAAOjF,KAAKX,IAAMyB,EAAOzB,IAC9BW,KAAKO,OAAS,SACdP,KAAKsC,KAAO,OACa,WAAhBxB,EAAOxB,MAAqBwD,IACrC9C,KAAKsC,KAAOQ,GAGPlD,GAGT8F,OAAQ,SAAS7C,GACf,IAAK,IAAIU,EAAIvD,KAAK+C,WAAW1G,OAAS,EAAGkH,GAAK,IAAKA,EAAG,CACpD,IAAIb,EAAQ1C,KAAK+C,WAAWQ,GAC5B,GAAIb,EAAMG,aAAeA,EAGvB,OAFA7C,KAAKyF,SAAS/C,EAAMQ,WAAYR,EAAMI,UACtCG,EAAcP,GACP9C,IAKb,MAAS,SAAS+C,GAChB,IAAK,IAAIY,EAAIvD,KAAK+C,WAAW1G,OAAS,EAAGkH,GAAK,IAAKA,EAAG,CACpD,IAAIb,EAAQ1C,KAAK+C,WAAWQ,GAC5B,GAAIb,EAAMC,SAAWA,EAAQ,CAC3B,IAAI7B,EAAS4B,EAAMQ,WACnB,GAAoB,UAAhBpC,EAAOxB,KAAkB,CAC3B,IAAIqG,EAAS7E,EAAOzB,IACpB4D,EAAcP,GAEhB,OAAOiD,GAMX,MAAM,IAAInE,MAAM,0BAGlBoE,cAAe,SAASxC,EAAUf,EAAYE,GAa5C,OAZAvC,KAAK0B,SAAW,CACd7D,SAAUuC,EAAOgD,GACjBf,WAAYA,EACZE,QAASA,GAGS,SAAhBvC,KAAKO,SAGPP,KAAKX,IAAMtC,GAGN6C,IAQJ5D,EArtBK,CA4tBiBD,EAAOC,SAGtC,IACE6J,mBAAqB/I,EACrB,MAAOgJ,GAWmB,kBAAfC,WACTA,WAAWF,mBAAqB/I,EAEhCkJ,SAAS,IAAK,yBAAdA,CAAwClJ,K,uBCrvB5C,MAAMmJ,EAAa,EAAQ,SACrB,IAAEC,GAAQ,EAAQ,QAMlBC,EAAYjC,MAAOkC,EAAKC,KAC5BH,EAAI,OAAQ,SAASE,GACrB,MAAMzJ,cAAmB2J,MAAMF,IAAMG,cACrCL,EAAI,OAAQ,GAAGE,iBAAmBzJ,EAAI6J,oBACtC,MAAMC,EAAO,IAAIC,KAAK,CAAC/J,GAAM,CAAE2C,KAAM+G,IAC/BM,EAAUC,IAAIC,gBAAgBJ,GAEpC,OADAP,EAAI,OAAQ,GAAGE,gBAAkBO,KAC1BA,GAGT5K,EAAOC,QAAUkI,OAAS4C,SAAUC,MAClC,GAAyB,kBAAdA,EACT,MAAMvF,MAAM,gCAEd,MAAMwF,EAAiBf,EAAWc,GAC5BD,QAAiBX,EACrBa,EACA,0BAEIC,QAAiBd,EACrBa,EAAeE,QAAQ,iBAAkB,oBACzC,oBAEIC,QAAmBhB,EACvBa,EAAeE,QAAQ,iBAAkB,yBACzC,0BAEF,MAAgC,qBAArBE,iBACF,IAAIjD,QAASvD,IAClB,MAAMyG,EAASC,SAASC,cAAc,UAChCC,EAAe,KACnBH,EAAOI,oBAAoB,OAAQD,GACnCtB,EAAI,OAAQ,gCACZtF,EAAQ,CACNwG,kCACAN,WACAG,WACAE,gBAGJE,EAAOK,IAAMZ,EACbO,EAAO/H,KAAO,kBACd+H,EAAOM,iBAAiB,OAAQH,GAChCF,SAASM,qBAAqB,QAAQ,GAAGC,YAAYR,MAGzDnB,EAAI,OAAQ,2CACL/B,QAAQvD,QAAQ,CACrBwG,kCACAN,WACAG,WACAE,kB,uBC3DJ,SAGM,SAASW,EAAMC,GAEjB,IAAc,oEAFb,CAQH/H,GAAM,WAEN,SAASgI,IACP,IAAIC,EAAUC,UAAU7L,OAExB,GAAgB,IAAZ4L,EACF,MAAM,IAAIzG,MAAM,wDAGlB,IAAI2G,EAAOb,SAASC,cAAc,QAGlC,GAFAY,EAAKC,KAAOF,UAAU,GAEN,IAAZD,EACF,OAAOE,EAAKC,KAGd,IAAIC,EAAOf,SAASM,qBAAqB,QAAQ,GACjDS,EAAKC,aAAaH,EAAME,EAAKE,YAK7B,IAHA,IACIC,EADAC,EAAInB,SAASC,cAAc,KAGtBmB,EAAQ,EAAGA,EAAQT,EAASS,IACnCD,EAAEL,KAAOF,UAAUQ,GACnBF,EAAWC,EAAEL,KACbD,EAAKC,KAAOI,EAKd,OAFAH,EAAKM,YAAYR,GAEVK,EAGT,OAAOR,M,uBC5CTjM,EAAOC,QAAU,IAA0B,iC,uBCA3CD,EAAOC,QAAU,IAA0B,2B,uBCA3C,MAAMiK,EAAa,EAAQ,QAErB2C,EAAsBnC,GAAS,IAC/BtC,QAAQ,CAACvD,EAASC,KACpB,MAAMgI,EAAa,IAAIC,WACvBD,EAAWE,OAAS,KAClBnI,EAAQiI,EAAW9H,SAErB8H,EAAWG,QAAU,EAAGC,QAAU9H,OAAS+H,aACzCrI,EAAOW,MAAM,gCAAgC0H,KAE/CL,EAAWM,kBAAkB1C,KAIjC1K,EAAOC,QAAUkI,MAAOkF,IACtB,IAAIC,EAAOD,EACX,GAAqB,qBAAVA,EACT,OAAO,IAAIE,WAGb,GAAqB,kBAAVF,EAET,GAAI,yCAAyCG,KAAKH,GAChDC,EAAOG,KAAKJ,EAAMK,MAAM,KAAK,IAC1BA,MAAM,IACNC,IAAKC,GAAMA,EAAEC,WAAW,QAEtB,CACL,MAAMC,QAAYvD,MAAML,EAAWmD,IACnCC,QAAaQ,EAAItD,mBAGV6C,aAAiBU,MAAQV,aAAiB1C,QACnD2C,QAAaT,EAAmBQ,IAGlC,OAAO,IAAIE,WAAWD,K,0rFCrCxB,oBAAmB,EAAQ,SACrB,gBAAEU,GAAoB,EAAQ,QAKpChO,EAAOC,QAAU,CACf8K,SAA8B,qBAAZkD,GAAsD,gBAA3B,6CAAYC,WACrDhE,EAAW,kDACX,kCAAkC8D,EAAgB,gBAAgBG,UAAU,4B,2CCTlF,IAAIC,GAAU,EACVC,EAAe,OAEnB,MAAMC,EAAcC,IAClBH,EAAUG,GAGNC,EAAmBC,IACvBJ,EAAeI,GAGXtE,EAAM,CAAC5G,EAAMmL,KACjBL,EAAa,CAAE9K,OAAMmL,YACjBN,GACFO,QAAQxE,IAAI,IAAI5G,MAASmL,MAI7B1O,EAAOC,QAAU,CACfmO,UACAE,aACAE,kBACArE,Q,qBCtBF,EAAQ,QACR,MAAMyE,EAAe,EAAQ,SACvB,UAAEC,GAAc,EAAQ,QAE9B7O,EAAOC,QAAU,CAoBf2O,eAUAC,c,qBClCF,MAAM,YAAEC,EAAW,YAAEC,GAAgB,EAAQ,SACvC,WAAET,EAAU,gBAAEE,EAAe,IAAErE,GAAQ,EAAQ,QAC/C6E,EAAgB,EAAQ,QACxBC,EAAY,EAAQ,SACpB,eAAEC,EAAc,oBAAEC,GAAwB,EAAQ,SAClD,QAAEC,GAAY,EAAQ,QAEtBC,EAAU5J,MAAM,kEAEtBzF,EAAOC,QAAU,CAACqP,EAAW,MAC3B,MACEnF,IAAKiE,EAAO,OACZK,EACAc,SAAUC,KACPC,GACD,IACCV,KACAG,KACAI,GAEL,IAAIpP,EAAO,KACPwP,EAAS,KACTC,EAAa,KACbC,GAAU,EACVL,EAAWC,EACf,MAAMK,EAAoBnB,IACR,eAAZA,GAA2C,OAAfiB,IAC9BA,IACAA,EAAa,KACbC,GAAU,IAGRE,EAAe,EAAGvM,OAAMmL,cAC5BvE,EAAI5G,EAAMmL,GACVM,EAAcN,EAASa,GACvBM,EAAiBnB,IAcbqB,EAAO5H,UAEX,GADAgC,EAAI,OAAQ,oBACC,OAATjK,EA0CF,MAAMuF,MAAM,mGA1CK,CACjB0E,EAAI,OAAQ,uBAKZ,MAAM,iBACJkB,EAAgB,SAChBN,EAAQ,WACRK,EAAU,SACVF,SACQiE,EAAoBM,GAC9BvP,QAAamL,EAAiB,CAK5B2E,oBAAqBjF,EACrBkF,SAAWvB,GAAYoB,EAAa,CAAEvM,KAAM,QAASmL,YACrDwB,MAAQxB,GAAYoB,EAAa,CAAEvM,KAAM,QAASmL,YAMlDyB,WAAY,CAACC,EAAMC,KACjB,GAAsB,qBAAXC,OAAwB,CACjC,GAAwB,qBAAbpF,GACNkF,EAAKG,SAAS,oBACjB,OAAOrF,EAET,GAA0B,qBAAfE,GACNgF,EAAKG,SAAS,yBACjB,OAAOnF,EAGX,OAAOiF,EAASD,KAGpBV,EAASxP,EAAKsQ,MAAM,aAAc,SAAU,CAAC,SAAU,WACvDrG,EAAI,OAAQ,wBASVsG,EAAW,IAAe,OAATvQ,EAoBjBwQ,EAAM,IAAIC,KAEd,GADAxG,EAAI,OAAQ,uBAAuBwG,EAAMC,KAAK,MACjC,OAAT1Q,EACF,MAAMmP,EACD,GAAIO,EACT,MAAMnK,MAAM,kDAGZ,OADAmK,GAAU,EACH,IAAIxH,QAASvD,IAClB,MAAM1E,EAAO,IAAI2O,KAAgB6B,GAAOE,OAAQnQ,GAAmB,IAAbA,EAAEJ,QACxDqP,EAAa9K,EACb6K,KAAUT,EAAU/O,EAAMC,OAoB1B2Q,EAAK,CAACtM,KAAWrE,KAErB,GADAgK,EAAI,OAAQ,UAAU3F,KAAUrE,EAAKwN,IAAKrK,GAAwB,kBAARA,EAAmBA,EAAM,IAAIA,EAAIhD,6BAA8BsQ,KAAK,QACjH,OAAT1Q,EACF,MAAMmP,EACD,CACL,IAAI0B,EAAM,KACV,IACEA,EAAM7Q,EAAK4Q,GAAGtM,MAAWrE,GACzB,MAAO6Q,GACP,KAAe,YAAXxM,EACIiB,MAAM,yBAAyBtF,EAAK,uEACtB,aAAXqE,EACHiB,MAAM,0BAA0BtF,EAAK,wCAErCsF,MAAM,+CAGhB,OAAOsL,IAOLE,EAAO,KACX,GAAa,OAAT/Q,EACF,MAAMmP,EAENO,GAAU,EACV1P,EAAK+Q,KAAK,GACV/Q,EAAO,KACPwP,EAAS,KACTC,EAAa,MAIXuB,EAAeC,IACnB5B,EAAW4B,GAGPC,EAAaC,IACjB7C,EAAgB6C,IAQlB,OALA/C,EAAWF,GACXI,EAAgBC,GAEhBtE,EAAI,OAAQ,oBAAoBiF,GAEzB,CACL8B,cACAE,YACA9C,aACAyB,OACAU,WACAC,MACAO,OACAH,Q,kCChNJ,IAAIQ,EAAS,WAAa,IAAIC,EAAItN,KAASuN,EAAGD,EAAIE,eAAmBC,EAAGH,EAAII,MAAMD,IAAIF,EAAG,OAAOE,EAAG,QAAQ,CAACE,YAAY,YAAY,CAACF,EAAG,OAAO,CAACG,YAAY,CAAC,aAAa,SAAS,CAACH,EAAG,OAAO,CAACG,YAAY,CAAC,aAAa,QAAQC,MAAM,CAAC,GAAK,KAAK,GAAK,MAAMC,GAAG,CAAC,MAAQR,EAAIS,SAAS,CAACN,EAAG,MAAM,CAACE,YAAY,YAAYC,YAAY,CAAC,aAAa,SAAS,CAACH,EAAG,OAAO,CAACA,EAAG,OAAO,CAACI,MAAM,CAAC,GAAK,OAAO,CAACJ,EAAG,KAAK,CAACE,YAAY,mDAAmD,CAACL,EAAIU,GAAGV,EAAIW,GAAGX,EAAIY,YAAYT,EAAG,OAAO,CAACG,YAAY,CAAC,MAAQ,WAAWC,MAAM,CAAC,GAAK,MAAM,CAACP,EAAIU,GAAGV,EAAIW,GAAGX,EAAIa,SAAW,IAAM,SAAS,IAAI,KAAKV,EAAG,OAAO,CAACI,MAAM,CAAC,GAAK,KAAK,GAAK,OAAO,CAACJ,EAAG,MAAM,CAACW,WAAW,CAAC,CAACvK,KAAK,OAAOwK,QAAQ,SAAS5Q,MAAO6P,EAAY,SAAEgB,WAAW,aAAaX,YAAY,iCAAiC,CAACL,EAAIiB,GAAG,YAAY,MAAM,IAAI,IAClzBC,EAAkB,GCwBtB,GACE,KADF,WAEI,MAAJ,CACM,UAAN,IAGE,MAAF,CACI,MAAJ,QAEE,QAAF,CACI,OADJ,WAEM,KAAN,2BCpCmX,I,wBCQ/WC,EAAY,eACd,EACApB,EACAmB,GACA,EACA,KACA,WACA,MAIa,OAAAC,E,8BCnBf,MAAMxD,EAAiB,EAAQ,QACzBC,EAAsB,EAAQ,QAC9BN,EAAY,EAAQ,QAE1B7O,EAAOC,QAAU,CACfiP,iBACAC,sBACAN,c,mBCPF7O,EAAOC,QAAU,CACf6O,YAAa,CAEX,WAEA,WAEA,MAEFC,YAAa,CAEX5E,KAAK,EAiBLsE,OAAQ,OAaRc,SAAU,OAMVxE,SAAU,M,qBC/Cd/K,EAAOC,QAAU,IAA0B,mC,qBCA3CD,EAAOC,QAAU,IAA0B,6B,qBCA3CD,EAAOC,QAAU,IAA0B,wB,0CCA3C,IAAI0S,EAAW,EACXC,EAAQ,EAEZ,MAAMC,EAAUC,IACd,MAAOC,EAAGC,EAAGtS,GAAKoS,EAAGpF,MAAM,KAC3B,OAAwB,GAAhBuF,WAAWF,GAAU,GAAuB,GAAhBE,WAAWD,GAAWC,WAAWvS,IAGvEV,EAAOC,QAAU,CAACyO,EAASa,KACzB,GAAuB,kBAAZb,EACT,GAAIA,EAAQwE,WAAW,cAAe,CACpC,MAAMJ,EAAKpE,EAAQhB,MAAM,MAAM,GAAGA,MAAM,MAAM,GACxCyF,EAAIN,EAAOC,GACjBvD,EAAS,CAAEoD,SAAUQ,EAAGP,WACP,IAAbD,GAAkBA,EAAWQ,KAC/BR,EAAWQ,QAER,GAAIzE,EAAQwE,WAAW,UAAYxE,EAAQwE,WAAW,QAAS,CACpE,MAAMJ,EAAKpE,EAAQhB,MAAM,SAAS,GAAGA,MAAM,KAAK,GAC1C0F,EAAIP,EAAOC,GACjBF,EAAQQ,EAAIT,EACZpD,EAAS,CAAEqD,QAAOS,KAAMD,SACf1E,EAAQwE,WAAW,YAC5B3D,EAAS,CAAEqD,MAAO,IAClBD,EAAW","file":"js/chunk-06876972.062c5988.js","sourcesContent":["module.exports = (Core, args) => {\n  const argsPtr = Core._malloc(args.length * Uint32Array.BYTES_PER_ELEMENT);\n  args.forEach((s, idx) => {\n    const buf = Core._malloc(s.length + 1);\n    Core.writeAsciiToMemory(s, buf);\n    Core.setValue(argsPtr + (Uint32Array.BYTES_PER_ELEMENT * idx), buf, 'i32');\n  });\n  return [args.length, argsPtr];\n};\n","import mod from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--6-oneOf-1-0!../../node_modules/@vue/cli-service/node_modules/css-loader/dist/cjs.js??ref--6-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--6-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Toggle.vue?vue&type=style&index=0&id=0177c342&scoped=true&lang=css&\"; export default mod; export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--6-oneOf-1-0!../../node_modules/@vue/cli-service/node_modules/css-loader/dist/cjs.js??ref--6-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--6-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Toggle.vue?vue&type=style&index=0&id=0177c342&scoped=true&lang=css&\"","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; };\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    defineProperty(generator, \"_invoke\", { value: makeInvokeMethod(innerFn, self, context) });\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = GeneratorFunctionPrototype;\n  defineProperty(Gp, \"constructor\", { value: GeneratorFunctionPrototype, configurable: true });\n  defineProperty(\n    GeneratorFunctionPrototype,\n    \"constructor\",\n    { value: GeneratorFunction, configurable: true }\n  );\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    defineProperty(this, \"_invoke\", { value: enqueue });\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  });\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var methodName = context.method;\n    var method = delegate.iterator[methodName];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method, or a missing .next mehtod, always terminate the\n      // yield* loop.\n      context.delegate = null;\n\n      // Note: [\"return\"] must be used for ES3 parsing compatibility.\n      if (methodName === \"throw\" && delegate.iterator[\"return\"]) {\n        // If the delegate iterator has a return method, give it a\n        // chance to clean up.\n        context.method = \"return\";\n        context.arg = undefined;\n        maybeInvokeDelegate(delegate, context);\n\n        if (context.method === \"throw\") {\n          // If maybeInvokeDelegate(context) changed context.method from\n          // \"return\" to \"throw\", let that override the TypeError below.\n          return ContinueSentinel;\n        }\n      }\n      if (methodName !== \"return\") {\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a '\" + methodName + \"' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(Gp, \"toString\", function() {\n    return \"[object Generator]\";\n  });\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(val) {\n    var object = Object(val);\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, in modern engines\n  // we can explicitly access globalThis. In older engines we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","/* eslint-disable no-undef */\nconst resolveURL = require('resolve-url');\nconst { log } = require('../utils/log');\n\n/*\n * Fetch data from remote URL and convert to blob URL\n * to avoid CORS issue\n */\nconst toBlobURL = async (url, mimeType) => {\n  log('info', `fetch ${url}`);\n  const buf = await (await fetch(url)).arrayBuffer();\n  log('info', `${url} file size = ${buf.byteLength} bytes`);\n  const blob = new Blob([buf], { type: mimeType });\n  const blobURL = URL.createObjectURL(blob);\n  log('info', `${url} blob URL = ${blobURL}`);\n  return blobURL;\n};\n\nmodule.exports = async ({ corePath: _corePath }) => {\n  if (typeof _corePath !== 'string') {\n    throw Error('corePath should be a string!');\n  }\n  const coreRemotePath = resolveURL(_corePath);\n  const corePath = await toBlobURL(\n    coreRemotePath,\n    'application/javascript',\n  );\n  const wasmPath = await toBlobURL(\n    coreRemotePath.replace('ffmpeg-core.js', 'ffmpeg-core.wasm'),\n    'application/wasm',\n  );\n  const workerPath = await toBlobURL(\n    coreRemotePath.replace('ffmpeg-core.js', 'ffmpeg-core.worker.js'),\n    'application/javascript',\n  );\n  if (typeof createFFmpegCore === 'undefined') {\n    return new Promise((resolve) => {\n      const script = document.createElement('script');\n      const eventHandler = () => {\n        script.removeEventListener('load', eventHandler);\n        log('info', 'ffmpeg-core.js script loaded');\n        resolve({\n          createFFmpegCore,\n          corePath,\n          wasmPath,\n          workerPath,\n        });\n      };\n      script.src = corePath;\n      script.type = 'text/javascript';\n      script.addEventListener('load', eventHandler);\n      document.getElementsByTagName('head')[0].appendChild(script);\n    });\n  }\n  log('info', 'ffmpeg-core.js script is loaded already');\n  return Promise.resolve({\n    createFFmpegCore,\n    corePath,\n    wasmPath,\n    workerPath,\n  });\n};\n","// Copyright 2014 Simon Lydell\r\n// X11 (“MIT”) Licensed. (See LICENSE.)\r\n\r\nvoid (function(root, factory) {\r\n  if (typeof define === \"function\" && define.amd) {\r\n    define(factory)\r\n  } else if (typeof exports === \"object\") {\r\n    module.exports = factory()\r\n  } else {\r\n    root.resolveUrl = factory()\r\n  }\r\n}(this, function() {\r\n\r\n  function resolveUrl(/* ...urls */) {\r\n    var numUrls = arguments.length\r\n\r\n    if (numUrls === 0) {\r\n      throw new Error(\"resolveUrl requires at least one argument; got none.\")\r\n    }\r\n\r\n    var base = document.createElement(\"base\")\r\n    base.href = arguments[0]\r\n\r\n    if (numUrls === 1) {\r\n      return base.href\r\n    }\r\n\r\n    var head = document.getElementsByTagName(\"head\")[0]\r\n    head.insertBefore(base, head.firstChild)\r\n\r\n    var a = document.createElement(\"a\")\r\n    var resolved\r\n\r\n    for (var index = 1; index < numUrls; index++) {\r\n      a.href = arguments[index]\r\n      resolved = a.href\r\n      base.href = resolved\r\n    }\r\n\r\n    head.removeChild(base)\r\n\r\n    return resolved\r\n  }\r\n\r\n  return resolveUrl\r\n\r\n}));\r\n","module.exports = __webpack_public_path__ + \"img/bgBluesquare.97e7e132.png\";","module.exports = __webpack_public_path__ + \"img/bgline.2257b8d3.png\";","const resolveURL = require('resolve-url');\n\nconst readFromBlobOrFile = (blob) => (\n  new Promise((resolve, reject) => {\n    const fileReader = new FileReader();\n    fileReader.onload = () => {\n      resolve(fileReader.result);\n    };\n    fileReader.onerror = ({ target: { error: { code } } }) => {\n      reject(Error(`File could not be read! Code=${code}`));\n    };\n    fileReader.readAsArrayBuffer(blob);\n  })\n);\n\nmodule.exports = async (_data) => {\n  let data = _data;\n  if (typeof _data === 'undefined') {\n    return new Uint8Array();\n  }\n\n  if (typeof _data === 'string') {\n    /* From base64 format */\n    if (/data:_data\\/([a-zA-Z]*);base64,([^\"]*)/.test(_data)) {\n      data = atob(_data.split(',')[1])\n        .split('')\n        .map((c) => c.charCodeAt(0));\n    /* From remote server/URL */\n    } else {\n      const res = await fetch(resolveURL(_data));\n      data = await res.arrayBuffer();\n    }\n  /* From Blob or File */\n  } else if (_data instanceof File || _data instanceof Blob) {\n    data = await readFromBlobOrFile(_data);\n  }\n\n  return new Uint8Array(data);\n};\n","const resolveURL = require('resolve-url');\nconst { devDependencies } = require('../../package.json');\n\n/*\n * Default options for browser environment\n */\nmodule.exports = {\n  corePath: (typeof process !== 'undefined' && process.env.FFMPEG_ENV === 'development')\n    ? resolveURL('/node_modules/@ffmpeg/core/dist/ffmpeg-core.js')\n    : `https://unpkg.com/@ffmpeg/core@${devDependencies['@ffmpeg/core'].substring(1)}/dist/ffmpeg-core.js`,\n};\n","let logging = false;\nlet customLogger = () => {};\n\nconst setLogging = (_logging) => {\n  logging = _logging;\n};\n\nconst setCustomLogger = (logger) => {\n  customLogger = logger;\n};\n\nconst log = (type, message) => {\n  customLogger({ type, message });\n  if (logging) {\n    console.log(`[${type}] ${message}`);\n  }\n};\n\nmodule.exports = {\n  logging,\n  setLogging,\n  setCustomLogger,\n  log,\n};\n","require('regenerator-runtime/runtime');\nconst createFFmpeg = require('./createFFmpeg');\nconst { fetchFile } = require('./node');\n\nmodule.exports = {\n  /*\n   * Create ffmpeg instance.\n   * Each ffmpeg instance owns an isolated MEMFS and works\n   * independently.\n   *\n   * For example:\n   *\n   * ```\n   * const ffmpeg = createFFmpeg({\n   *  log: true,\n   *  logger: () => {},\n   *  progress: () => {},\n   *  corePath: '',\n   * })\n   * ```\n   *\n   * For the usage of these four arguments, check config.js\n   *\n   */\n  createFFmpeg,\n  /*\n   * Helper function for fetching files from various resource.\n   * Sometimes the video/audio file you want to process may located\n   * in a remote URL and somewhere in your local file system.\n   *\n   * This helper function helps you to fetch to file and return an\n   * Uint8Array variable for ffmpeg.wasm to consume.\n   *\n   */\n  fetchFile,\n};\n","const { defaultArgs, baseOptions } = require('./config');\nconst { setLogging, setCustomLogger, log } = require('./utils/log');\nconst parseProgress = require('./utils/parseProgress');\nconst parseArgs = require('./utils/parseArgs');\nconst { defaultOptions, getCreateFFmpegCore } = require('./node');\nconst { version } = require('../package.json');\n\nconst NO_LOAD = Error('ffmpeg.wasm is not ready, make sure you have completed load().');\n\nmodule.exports = (_options = {}) => {\n  const {\n    log: logging,\n    logger,\n    progress: optProgress,\n    ...options\n  } = {\n    ...baseOptions,\n    ...defaultOptions,\n    ..._options,\n  };\n  let Core = null;\n  let ffmpeg = null;\n  let runResolve = null;\n  let running = false;\n  let progress = optProgress;\n  const detectCompletion = (message) => {\n    if (message === 'FFMPEG_END' && runResolve !== null) {\n      runResolve();\n      runResolve = null;\n      running = false;\n    }\n  };\n  const parseMessage = ({ type, message }) => {\n    log(type, message);\n    parseProgress(message, progress);\n    detectCompletion(message);\n  };\n\n  /*\n   * Load ffmpeg.wasm-core script.\n   * In browser environment, the ffmpeg.wasm-core script is fetch from\n   * CDN and can be assign to a local path by assigning `corePath`.\n   * In node environment, we use dynamic require and the default `corePath`\n   * is `$ffmpeg/core`.\n   *\n   * Typically the load() func might take few seconds to minutes to complete,\n   * better to do it as early as possible.\n   *\n   */\n  const load = async () => {\n    log('info', 'load ffmpeg-core');\n    if (Core === null) {\n      log('info', 'loading ffmpeg-core');\n      /*\n       * In node environment, all paths are undefined as there\n       * is no need to set them.\n       */\n      const {\n        createFFmpegCore,\n        corePath,\n        workerPath,\n        wasmPath,\n      } = await getCreateFFmpegCore(options);\n      Core = await createFFmpegCore({\n        /*\n         * Assign mainScriptUrlOrBlob fixes chrome extension web worker issue\n         * as there is no document.currentScript in the context of content_scripts\n         */\n        mainScriptUrlOrBlob: corePath,\n        printErr: (message) => parseMessage({ type: 'fferr', message }),\n        print: (message) => parseMessage({ type: 'ffout', message }),\n        /*\n         * locateFile overrides paths of files that is loaded by main script (ffmpeg-core.js).\n         * It is critical for browser environment and we override both wasm and worker paths\n         * as we are using blob URL instead of original URL to avoid cross origin issues.\n         */\n        locateFile: (path, prefix) => {\n          if (typeof window !== 'undefined') {\n            if (typeof wasmPath !== 'undefined'\n              && path.endsWith('ffmpeg-core.wasm')) {\n              return wasmPath;\n            }\n            if (typeof workerPath !== 'undefined'\n              && path.endsWith('ffmpeg-core.worker.js')) {\n              return workerPath;\n            }\n          }\n          return prefix + path;\n        },\n      });\n      ffmpeg = Core.cwrap('proxy_main', 'number', ['number', 'number']);\n      log('info', 'ffmpeg-core loaded');\n    } else {\n      throw Error('ffmpeg.wasm was loaded, you should not load it again, use ffmpeg.isLoaded() to check next time.');\n    }\n  };\n\n  /*\n   * Determine whether the Core is loaded.\n   */\n  const isLoaded = () => Core !== null;\n\n  /*\n   * Run ffmpeg command.\n   * This is the major function in ffmpeg.wasm, you can just imagine it\n   * as ffmpeg native cli and what you need to pass is the same.\n   *\n   * For example, you can convert native command below:\n   *\n   * ```\n   * $ ffmpeg -i video.avi -c:v libx264 video.mp4\n   * ```\n   *\n   * To\n   *\n   * ```\n   * await ffmpeg.run('-i', 'video.avi', '-c:v', 'libx264', 'video.mp4');\n   * ```\n   *\n   */\n  const run = (..._args) => {\n    log('info', `run ffmpeg command: ${_args.join(' ')}`);\n    if (Core === null) {\n      throw NO_LOAD;\n    } else if (running) {\n      throw Error('ffmpeg.wasm can only run one command at a time');\n    } else {\n      running = true;\n      return new Promise((resolve) => {\n        const args = [...defaultArgs, ..._args].filter((s) => s.length !== 0);\n        runResolve = resolve;\n        ffmpeg(...parseArgs(Core, args));\n      });\n    }\n  };\n\n  /*\n   * Run FS operations.\n   * For input/output file of ffmpeg.wasm, it is required to save them to MEMFS\n   * first so that ffmpeg.wasm is able to consume them. Here we rely on the FS\n   * methods provided by Emscripten.\n   *\n   * Common methods to use are:\n   * ffmpeg.FS('writeFile', 'video.avi', new Uint8Array(...)): writeFile writes\n   * data to MEMFS. You need to use Uint8Array for binary data.\n   * ffmpeg.FS('readFile', 'video.mp4'): readFile from MEMFS.\n   * ffmpeg.FS('unlink', 'video.map'): delete file from MEMFS.\n   *\n   * For more info, check https://emscripten.org/docs/api_reference/Filesystem-API.html\n   *\n   */\n  const FS = (method, ...args) => {\n    log('info', `run FS.${method} ${args.map((arg) => (typeof arg === 'string' ? arg : `<${arg.length} bytes binary file>`)).join(' ')}`);\n    if (Core === null) {\n      throw NO_LOAD;\n    } else {\n      let ret = null;\n      try {\n        ret = Core.FS[method](...args);\n      } catch (e) {\n        if (method === 'readdir') {\n          throw Error(`ffmpeg.FS('readdir', '${args[0]}') error. Check if the path exists, ex: ffmpeg.FS('readdir', '/')`);\n        } else if (method === 'readFile') {\n          throw Error(`ffmpeg.FS('readFile', '${args[0]}') error. Check if the path exists`);\n        } else {\n          throw Error('Oops, something went wrong in FS operation.');\n        }\n      }\n      return ret;\n    }\n  };\n\n  /**\n   * forcibly terminate the ffmpeg program.\n   */\n  const exit = () => {\n    if (Core === null) {\n      throw NO_LOAD;\n    } else {\n      running = false;\n      Core.exit(1);\n      Core = null;\n      ffmpeg = null;\n      runResolve = null;\n    }\n  };\n\n  const setProgress = (_progress) => {\n    progress = _progress;\n  };\n\n  const setLogger = (_logger) => {\n    setCustomLogger(_logger);\n  };\n\n  setLogging(logging);\n  setCustomLogger(logger);\n\n  log('info', `use ffmpeg.wasm v${version}`);\n\n  return {\n    setProgress,\n    setLogger,\n    setLogging,\n    load,\n    isLoaded,\n    run,\n    exit,\n    FS,\n  };\n};\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('CCard',{staticClass:\"p-4 mt-3\"},[_c('CRow',{staticStyle:{\"text-align\":\"left\"}},[_c('CCol',{staticStyle:{\"text-align\":\"left\"},attrs:{\"sm\":\"12\",\"lg\":\"12\"},on:{\"click\":_vm.toggle}},[_c('div',{staticClass:\"item-text\",staticStyle:{\"text-align\":\"left\"}},[_c('CRow',[_c('CCol',{attrs:{\"sm\":\"11\"}},[_c('h4',{staticClass:\"poppin-font text-24px font-500 custom-title-faq\"},[_vm._v(_vm._s(_vm.title))])]),_c('CCol',{staticStyle:{\"color\":\"#171717\"},attrs:{\"sm\":\"1\"}},[_vm._v(_vm._s(_vm.isActive ? '-' : '+'))])],1)],1)]),_c('CCol',{attrs:{\"sm\":\"12\",\"lg\":\"12\"}},[_c('div',{directives:[{name:\"show\",rawName:\"v-show\",value:(_vm.isActive),expression:\"isActive\"}],staticClass:\"item-desc ml-3 mb-2 display-8\"},[_vm._t(\"default\")],2)])],1)],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","<!-- ToggleCard.vue -->\n<template>\n    <CCard class=\"p-4 mt-3\">\n      <CRow style=\"text-align: left;\">\n        <CCol style=\"text-align: left;\" sm=\"12\" lg=\"12\" @click=\"toggle\">\n          <div style=\"text-align: left\" class=\"item-text\">\n            <CRow>\n              <CCol sm=\"11\">\n                <h4 class=\"poppin-font text-24px font-500 custom-title-faq\">{{ title }}</h4>\n              </CCol>\n              <CCol sm=\"1\" style=\"color:#171717\">{{ isActive ? '-' : '+' }}</CCol>\n            </CRow>\n          </div>\n        </CCol>\n  \n        <CCol sm=\"12\" lg=\"12\">\n          <div v-show=\"isActive\" class=\"item-desc ml-3 mb-2 display-8\">\n            <slot class=\"custom-answer-faq font-color-171717\"></slot>\n          </div>\n        </CCol>\n      </CRow>\n    </CCard>\n  </template>\n  \n  <script>\n  export default {\n    data() {\n      return {\n        isActive: false,\n      };\n    },\n    props: {\n      title: String,\n    },\n    methods: {\n      toggle() {\n        this.isActive = !this.isActive;\n      },\n    },\n  };\n  </script>\n  \n  <style scoped>\n  /* Add any specific styles for your ToggleCard component */\n \n  </style>\n  ","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/@vue/cli-plugin-babel/node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Toggle.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/@vue/cli-plugin-babel/node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Toggle.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Toggle.vue?vue&type=template&id=0177c342&scoped=true&\"\nimport script from \"./Toggle.vue?vue&type=script&lang=js&\"\nexport * from \"./Toggle.vue?vue&type=script&lang=js&\"\nimport style0 from \"./Toggle.vue?vue&type=style&index=0&id=0177c342&scoped=true&lang=css&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"0177c342\",\n  null\n  \n)\n\nexport default component.exports","const defaultOptions = require('./defaultOptions');\nconst getCreateFFmpegCore = require('./getCreateFFmpegCore');\nconst fetchFile = require('./fetchFile');\n\nmodule.exports = {\n  defaultOptions,\n  getCreateFFmpegCore,\n  fetchFile,\n};\n","module.exports = {\n  defaultArgs: [\n    /* args[0] is always the binary path */\n    './ffmpeg',\n    /* Disable interaction mode */\n    '-nostdin',\n    /* Force to override output file */\n    '-y',\n  ],\n  baseOptions: {\n    /* Flag to turn on/off log messages in console */\n    log: false,\n    /*\n     * Custom logger to get ffmpeg.wasm output messages.\n     * a sample logger looks like this:\n     *\n     * ```\n     * logger = ({ type, message }) => {\n     *   console.log(type, message);\n     * }\n     * ```\n     *\n     * type can be one of following:\n     *\n     * info: internal workflow debug messages\n     * fferr: ffmpeg native stderr output\n     * ffout: ffmpeg native stdout output\n     */\n    logger: () => {},\n    /*\n     * Progress handler to get current progress of ffmpeg command.\n     * a sample progress handler looks like this:\n     *\n     * ```\n     * progress = ({ ratio }) => {\n     *   console.log(ratio);\n     * }\n     * ```\n     *\n     * ratio is a float number between 0 to 1.\n     */\n    progress: () => {},\n    /*\n     * Path to find/download ffmpeg.wasm-core,\n     * this value should be overwriten by `defaultOptions` in\n     * each environment.\n     */\n    corePath: '',\n  },\n};\n","module.exports = __webpack_public_path__ + \"img/bgPurpleYellow.aa8f8a0e.png\";","module.exports = __webpack_public_path__ + \"img/BgPeople.cea8ab05.png\";","module.exports = __webpack_public_path__ + \"img/Map.22cab898.png\";","let duration = 0;\nlet ratio = 0;\n\nconst ts2sec = (ts) => {\n  const [h, m, s] = ts.split(':');\n  return (parseFloat(h) * 60 * 60) + (parseFloat(m) * 60) + parseFloat(s);\n};\n\nmodule.exports = (message, progress) => {\n  if (typeof message === 'string') {\n    if (message.startsWith('  Duration')) {\n      const ts = message.split(', ')[0].split(': ')[1];\n      const d = ts2sec(ts);\n      progress({ duration: d, ratio });\n      if (duration === 0 || duration > d) {\n        duration = d;\n      }\n    } else if (message.startsWith('frame') || message.startsWith('size')) {\n      const ts = message.split('time=')[1].split(' ')[0];\n      const t = ts2sec(ts);\n      ratio = t / duration;\n      progress({ ratio, time: t });\n    } else if (message.startsWith('video:')) {\n      progress({ ratio: 1 });\n      duration = 0;\n    }\n  }\n};\n"],"sourceRoot":""}