dbxlite-ui 0.1.0

package/assets/assets/abap-CRCWOmpq.js

@@ -0,0 +1 @@
+var e={comments:{lineComment:"*"},brackets:[["[","]"],["(",")"]]},t={defaultToken:"invalid",ignoreCase:!0,tokenPostfix:".abap",keywords:["abap-source","abbreviated","abstract","accept","accepting","according","activation","actual","add","add-corresponding","adjacent","after","alias","aliases","align","all","allocate","alpha","analysis","analyzer","and","append","appendage","appending","application","archive","area","arithmetic","as","ascending","aspect","assert","assign","assigned","assigning","association","asynchronous","at","attributes","authority","authority-check","avg","back","background","backup","backward","badi","base","before","begin","between","big","binary","bintohex","bit","black","blank","blanks","blob","block","blocks","blue","bound","boundaries","bounds","boxed","break-point","buffer","by","bypassing","byte","byte-order","call","calling","case","cast","casting","catch","center","centered","chain","chain-input","chain-request","change","changing","channels","character","char-to-hex","check","checkbox","ci_","circular","class","class-coding","class-data","class-events","class-methods","class-pool","cleanup","clear","client","clob","clock","close","coalesce","code","coding","col_background","col_group","col_heading","col_key","col_negative","col_normal","col_positive","col_total","collect","color","column","columns","comment","comments","commit","common","communication","comparing","component","components","compression","compute","concat","concat_with_space","concatenate","cond","condense","condition","connect","connection","constants","context","contexts","continue","control","controls","conv","conversion","convert","copies","copy","corresponding","country","cover","cpi","create","creating","critical","currency","currency_conversion","current","cursor","cursor-selection","customer","customer-function","dangerous","data","database","datainfo","dataset","date","dats_add_days","dats_add_months","dats_days_between","dats_is_valid","daylight","dd/mm/yy","dd/mm/yyyy","ddmmyy","deallocate","decimal_shift","decimals","declarations","deep","default","deferred","define","defining","definition","delete","deleting","demand","department","descending","describe","destination","detail","dialog","directory","disconnect","display","display-mode","distinct","divide","divide-corresponding","division","do","dummy","duplicate","duplicates","duration","during","dynamic","dynpro","edit","editor-call","else","elseif","empty","enabled","enabling","encoding","end","endat","endcase","endcatch","endchain","endclass","enddo","endenhancement","end-enhancement-section","endexec","endform","endfunction","endian","endif","ending","endinterface","end-lines","endloop","endmethod","endmodule","end-of-definition","end-of-editing","end-of-file","end-of-page","end-of-selection","endon","endprovide","endselect","end-test-injection","end-test-seam","endtry","endwhile","endwith","engineering","enhancement","enhancement-point","enhancements","enhancement-section","entries","entry","enum","environment","equiv","errormessage","errors","escaping","event","events","exact","except","exception","exceptions","exception-table","exclude","excluding","exec","execute","exists","exit","exit-command","expand","expanding","expiration","explicit","exponent","export","exporting","extend","extended","extension","extract","fail","fetch","field","field-groups","fields","field-symbol","field-symbols","file","filter","filters","filter-table","final","find","first","first-line","fixed-point","fkeq","fkge","flush","font","for","form","format","forward","found","frame","frames","free","friends","from","function","functionality","function-pool","further","gaps","generate","get","giving","gkeq","gkge","global","grant","green","group","groups","handle","handler","harmless","hashed","having","hdb","header","headers","heading","head-lines","help-id","help-request","hextobin","hide","high","hint","hold","hotspot","icon","id","identification","identifier","ids","if","ignore","ignoring","immediately","implementation","implementations","implemented","implicit","import","importing","in","inactive","incl","include","includes","including","increment","index","index-line","infotypes","inheriting","init","initial","initialization","inner","inout","input","insert","instance","instances","instr","intensified","interface","interface-pool","interfaces","internal","intervals","into","inverse","inverted-date","is","iso","job","join","keep","keeping","kernel","key","keys","keywords","kind","language","last","late","layout","leading","leave","left","left-justified","leftplus","leftspace","legacy","length","let","level","levels","like","line","lines","line-count","linefeed","line-selection","line-size","list","listbox","list-processing","little","llang","load","load-of-program","lob","local","locale","locator","logfile","logical","log-point","long","loop","low","lower","lpad","lpi","ltrim","mail","main","major-id","mapping","margin","mark","mask","match","matchcode","max","maximum","medium","members","memory","mesh","message","message-id","messages","messaging","method","methods","min","minimum","minor-id","mm/dd/yy","mm/dd/yyyy","mmddyy","mode","modif","modifier","modify","module","move","move-corresponding","multiply","multiply-corresponding","name","nametab","native","nested","nesting","new","new-line","new-page","new-section","next","no","no-display","no-extension","no-gap","no-gaps","no-grouping","no-heading","no-scrolling","no-sign","no-title","no-topofpage","no-zero","node","nodes","non-unicode","non-unique","not","null","number","object","objects","obligatory","occurrence","occurrences","occurs","of","off","offset","ole","on","only","open","option","optional","options","or","order","other","others","out","outer","output","output-length","overflow","overlay","pack","package","pad","padding","page","pages","parameter","parameters","parameter-table","part","partially","pattern","percentage","perform","performing","person","pf1","pf10","pf11","pf12","pf13","pf14","pf15","pf2","pf3","pf4","pf5","pf6","pf7","pf8","pf9","pf-status","pink","places","pool","pos_high","pos_low","position","pragmas","precompiled","preferred","preserving","primary","print","print-control","priority","private","procedure","process","program","property","protected","provide","public","push","pushbutton","put","queue-only","quickinfo","radiobutton","raise","raising","range","ranges","read","reader","read-only","receive","received","receiver","receiving","red","redefinition","reduce","reduced","ref","reference","refresh","regex","reject","remote","renaming","replace","replacement","replacing","report","request","requested","reserve","reset","resolution","respecting","responsible","result","results","resumable","resume","retry","return","returncode","returning","returns","right","right-justified","rightplus","rightspace","risk","rmc_communication_failure","rmc_invalid_status","rmc_system_failure","role","rollback","rows","rpad","rtrim","run","sap","sap-spool","saving","scale_preserving","scale_preserving_scientific","scan","scientific","scientific_with_leading_zero","scroll","scroll-boundary","scrolling","search","secondary","seconds","section","select","selection","selections","selection-screen","selection-set","selection-sets","selection-table","select-options","send","separate","separated","set","shared","shift","short","shortdump-id","sign_as_postfix","single","size","skip","skipping","smart","some","sort","sortable","sorted","source","specified","split","spool","spots","sql","sqlscript","stable","stamp","standard","starting","start-of-editing","start-of-selection","state","statement","statements","static","statics","statusinfo","step-loop","stop","structure","structures","style","subkey","submatches","submit","subroutine","subscreen","subtract","subtract-corresponding","suffix","sum","summary","summing","supplied","supply","suppress","switch","switchstates","symbol","syncpoints","syntax","syntax-check","syntax-trace","system-call","system-exceptions","system-exit","tab","tabbed","table","tables","tableview","tabstrip","target","task","tasks","test","testing","test-injection","test-seam","text","textpool","then","throw","time","times","timestamp","timezone","tims_is_valid","title","titlebar","title-lines","to","tokenization","tokens","top-lines","top-of-page","trace-file","trace-table","trailing","transaction","transfer","transformation","translate","transporting","trmac","truncate","truncation","try","tstmp_add_seconds","tstmp_current_utctimestamp","tstmp_is_valid","tstmp_seconds_between","type","type-pool","type-pools","types","uline","unassign","under","unicode","union","unique","unit_conversion","unix","unpack","until","unwind","up","update","upper","user","user-command","using","utf-8","valid","value","value-request","values","vary","varying","verification-message","version","via","view","visible","wait","warning","when","whenever","where","while","width","window","windows","with","with-heading","without","with-title","word","work","write","writer","xml","xsd","yellow","yes","yymmdd","zero","zone","abap_system_timezone","abap_user_timezone","access","action","adabas","adjust_numbers","allow_precision_loss","allowed","amdp","applicationuser","as_geo_json","as400","associations","balance","behavior","breakup","bulk","cds","cds_client","check_before_save","child","clients","corr","corr_spearman","cross","cycles","datn_add_days","datn_add_months","datn_days_between","dats_from_datn","dats_tims_to_tstmp","dats_to_datn","db2","db6","ddl","dense_rank","depth","deterministic","discarding","entities","entity","error","failed","finalize","first_value","fltp_to_dec","following","fractional","full","graph","grouping","hierarchy","hierarchy_ancestors","hierarchy_ancestors_aggregate","hierarchy_descendants","hierarchy_descendants_aggregate","hierarchy_siblings","incremental","indicators","lag","last_value","lead","leaves","like_regexpr","link","locale_sap","lock","locks","many","mapped","matched","measures","median","mssqlnt","multiple","nodetype","ntile","nulls","occurrences_regexpr","one","operations","oracle","orphans","over","parent","parents","partition","pcre","period","pfcg_mapping","preceding","privileged","product","projection","rank","redirected","replace_regexpr","reported","response","responses","root","row","row_number","sap_system_date","save","schema","session","sets","shortdump","siblings","spantree","start","stddev","string_agg","subtotal","sybase","tims_from_timn","tims_to_timn","to_blob","to_clob","total","trace-entry","tstmp_to_dats","tstmp_to_dst","tstmp_to_tims","tstmpl_from_utcl","tstmpl_to_utcl","unbounded","utcl_add_seconds","utcl_current","utcl_seconds_between","uuid","var","verbatim"],builtinFunctions:["abs","acos","asin","atan","bit-set","boolc","boolx","ceil","char_off","charlen","cmax","cmin","concat_lines_of","contains","contains_any_not_of","contains_any_of","cos","cosh","count","count_any_not_of","count_any_of","dbmaxlen","distance","escape","exp","find_any_not_of","find_any_of","find_end","floor","frac","from_mixed","ipow","line_exists","line_index","log","log10","matches","nmax","nmin","numofchar","repeat","rescale","reverse","round","segment","shift_left","shift_right","sign","sin","sinh","sqrt","strlen","substring","substring_after","substring_before","substring_from","substring_to","tan","tanh","to_lower","to_mixed","to_upper","trunc","utclong_add","utclong_current","utclong_diff","xsdbool","xstrlen"],typeKeywords:["b","c","d","decfloat16","decfloat34","f","i","int8","n","p","s","string","t","utclong","x","xstring","any","clike","csequence","decfloat","numeric","simple","xsequence","accp","char","clnt","cuky","curr","datn","dats","d16d","d16n","d16r","d34d","d34n","d34r","dec","df16_dec","df16_raw","df34_dec","df34_raw","fltp","geom_ewkb","int1","int2","int4","lang","lchr","lraw","numc","quan","raw","rawstring","sstring","timn","tims","unit","utcl","df16_scl","df34_scl","prec","varc","abap_bool","abap_false","abap_true","abap_undefined","me","screen","space","super","sy","syst","table_line","*sys*"],builtinMethods:["class_constructor","constructor"],derivedTypes:["%CID","%CID_REF","%CONTROL","%DATA","%ELEMENT","%FAIL","%KEY","%MSG","%PARAM","%PID","%PID_ASSOC","%PID_PARENT","%_HINTS"],cdsLanguage:["@AbapAnnotation","@AbapCatalog","@AccessControl","@API","@ClientDependent","@ClientHandling","@CompatibilityContract","@DataAging","@EndUserText","@Environment","@LanguageDependency","@MappingRole","@Metadata","@MetadataExtension","@ObjectModel","@Scope","@Semantics","$EXTENSION","$SELF"],selectors:["->","->*","=>","~","~*"],operators:[" +"," -","/","*","**","div","mod","=","#","@","+=","-=","*=","/=","**=","&&=","?=","&","&&","bit-and","bit-not","bit-or","bit-xor","m","o","z","<"," >","<=",">=","<>","><","=<","=>","bt","byte-ca","byte-cn","byte-co","byte-cs","byte-na","byte-ns","ca","cn","co","cp","cs","eq","ge","gt","le","lt","na","nb","ne","np","ns","*/","*:","--","/*","//"],symbols:/[=><!~?&+\-*\/\^%#@]+/,tokenizer:{root:[[/[a-z_\/$%@]([\w\/$%]|-(?!>))*/,{cases:{"@typeKeywords":"type","@keywords":"keyword","@cdsLanguage":"annotation","@derivedTypes":"type","@builtinFunctions":"type","@builtinMethods":"type","@operators":"key","@default":"identifier"}}],[/<[\w]+>/,"identifier"],[/##[\w|_]+/,"comment"],{include:"@whitespace"},[/[:,.]/,"delimiter"],[/[{}()\[\]]/,"@brackets"],[/@symbols/,{cases:{"@selectors":"tag","@operators":"key","@default":""}}],[/'/,{token:"string",bracket:"@open",next:"@stringquote"}],[/`/,{token:"string",bracket:"@open",next:"@stringping"}],[/\|/,{token:"string",bracket:"@open",next:"@stringtemplate"}],[/\d+/,"number"]],stringtemplate:[[/[^\\\|]+/,"string"],[/\\\|/,"string"],[/\|/,{token:"string",bracket:"@close",next:"@pop"}]],stringping:[[/[^\\`]+/,"string"],[/`/,{token:"string",bracket:"@close",next:"@pop"}]],stringquote:[[/[^\\']+/,"string"],[/'/,{token:"string",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,""],[/^\*.*$/,"comment"],[/\".*$/,"comment"]]}};export{e as conf,t as language};

package/assets/assets/apex-DnsZk_dE.js

@@ -0,0 +1 @@
+var n={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"<",close:">"}],folding:{markers:{start:new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),end:new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")}}},s=["abstract","activate","and","any","array","as","asc","assert","autonomous","begin","bigdecimal","blob","boolean","break","bulk","by","case","cast","catch","char","class","collect","commit","const","continue","convertcurrency","decimal","default","delete","desc","do","double","else","end","enum","exception","exit","export","extends","false","final","finally","float","for","from","future","get","global","goto","group","having","hint","if","implements","import","in","inner","insert","instanceof","int","interface","into","join","last_90_days","last_month","last_n_days","last_week","like","limit","list","long","loop","map","merge","native","new","next_90_days","next_month","next_n_days","next_week","not","null","nulls","number","object","of","on","or","outer","override","package","parallel","pragma","private","protected","public","retrieve","return","returning","rollback","savepoint","search","select","set","short","sort","stat","static","strictfp","super","switch","synchronized","system","testmethod","then","this","this_month","this_week","throw","throws","today","tolabel","tomorrow","transaction","transient","trigger","true","try","type","undelete","update","upsert","using","virtual","void","volatile","webservice","when","where","while","yesterday"],o=e=>e.charAt(0).toUpperCase()+e.substr(1),t=[];s.forEach(e=>{t.push(e),t.push(e.toUpperCase()),t.push(o(e))});var i={defaultToken:"",tokenPostfix:".apex",keywords:t,operators:["=",">","<","!","~","?",":","==","<=",">=","!=","&&","||","++","--","+","-","*","/","&","|","^","%","<<",">>",">>>","+=","-=","*=","/=","&=","|=","^=","%=","<<=",">>=",">>>="],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+(_+\d+)*/,octaldigits:/[0-7]+(_+[0-7]+)*/,binarydigits:/[0-1]+(_+[0-1]+)*/,hexdigits:/[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,tokenizer:{root:[[/[a-z_$][\w$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],[/[A-Z][\w\$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"type.identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/@\s*[a-zA-Z_\$][\w\$]*/,"annotation"],[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)[fFdD]/,"number.float"],[/(@digits)[lL]?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string",'@string."'],[/'/,"string","@string.'"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@apexdoc"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],apexdoc:[[/[^\/*]+/,"comment.doc"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"']+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}]]}};export{n as conf,i as language};

package/assets/assets/argon2-CtQQN5by.js

@@ -0,0 +1,531 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./argon2-VsC-m8hX.js","./react-vendor-CJNQXC79.js"])))=>i.map(i=>d[i]);
+import { b as he, g as Pe } from "./react-vendor-CJNQXC79.js";
+import { _ as Be, __tla as __tla_0 } from "./monaco-editor-DbSHhIAW.js";
+import * as me from "a";
+let en, Ue;
+let __tla = Promise.all([
+    (()=>{
+        try {
+            return __tla_0;
+        } catch  {}
+    })()
+]).then(async ()=>{
+    function ye(A) {
+        throw new Error('Could not dynamically require "' + A + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+    }
+    var te = {
+        exports: {}
+    }, ae = {
+        exports: {}
+    };
+    const xe = {}, Ie = Object.freeze(Object.defineProperty({
+        __proto__: null,
+        default: xe
+    }, Symbol.toStringTag, {
+        value: "Module"
+    })), se = he(Ie);
+    var _e;
+    Ue = function() {
+        return _e || (_e = 1, (function(A) {
+            var e = typeof self < "u" && typeof self.Module < "u" ? self.Module : {}, c = {}, s;
+            for(s in e)e.hasOwnProperty(s) && (c[s] = e[s]);
+            var g = !1, p = !1, b = !1, J = !1;
+            g = typeof window == "object", p = typeof importScripts == "function", b = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string", J = !g && !b && !p;
+            var y = "";
+            function C(n) {
+                return e.locateFile ? e.locateFile(n, y) : y + n;
+            }
+            var T, P, N, V, k;
+            b ? (p ? y = se.dirname(y) + "/" : y = __dirname + "/", T = function(t, a) {
+                return V || (V = se), k || (k = se), t = k.normalize(t), V.readFileSync(t, a ? null : "utf8");
+            }, N = function(t) {
+                var a = T(t, !0);
+                return a.buffer || (a = new Uint8Array(a)), B(a.buffer), a;
+            }, process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2), A.exports = e, process.on("uncaughtException", function(n) {
+                if (!(n instanceof Se)) throw n;
+            }), process.on("unhandledRejection", Y), e.inspect = function() {
+                return "[Emscripten Module object]";
+            }) : J ? (typeof read < "u" && (T = function(t) {
+                return read(t);
+            }), N = function(t) {
+                var a;
+                return typeof readbuffer == "function" ? new Uint8Array(readbuffer(t)) : (a = read(t, "binary"), B(typeof a == "object"), a);
+            }, typeof scriptArgs < "u" && scriptArgs, typeof print < "u" && (typeof console > "u" && (console = {}), console.log = print, console.warn = console.error = typeof printErr < "u" ? printErr : print)) : (g || p) && (p ? y = self.location.href : typeof document < "u" && document.currentScript && (y = document.currentScript.src), y.indexOf("blob:") !== 0 ? y = y.substr(0, y.lastIndexOf("/") + 1) : y = "", T = function(n) {
+                var t = new XMLHttpRequest;
+                return t.open("GET", n, !1), t.send(null), t.responseText;
+            }, p && (N = function(n) {
+                var t = new XMLHttpRequest;
+                return t.open("GET", n, !1), t.responseType = "arraybuffer", t.send(null), new Uint8Array(t.response);
+            }), P = function(n, t, a) {
+                var l = new XMLHttpRequest;
+                l.open("GET", n, !0), l.responseType = "arraybuffer", l.onload = function() {
+                    if (l.status == 200 || l.status == 0 && l.response) {
+                        t(l.response);
+                        return;
+                    }
+                    a();
+                }, l.onerror = a, l.send(null);
+            }), e.print || console.log.bind(console);
+            var r = e.printErr || console.warn.bind(console);
+            for(s in c)c.hasOwnProperty(s) && (e[s] = c[s]);
+            c = null, e.arguments && e.arguments, e.thisProgram && e.thisProgram, e.quit && e.quit;
+            var i;
+            e.wasmBinary && (i = e.wasmBinary), e.noExitRuntime, typeof WebAssembly != "object" && Y("no native wasm support detected");
+            var o, u = !1;
+            function B(n, t) {
+                n || Y("Assertion failed: " + t);
+            }
+            var F = 0, x = 1;
+            function z(n, t) {
+                var a;
+                return t == x ? a = de(n.length) : a = le(n.length), n.subarray || n.slice ? m.set(n, a) : m.set(new Uint8Array(n), a), a;
+            }
+            var j = typeof TextDecoder < "u" ? new TextDecoder("utf8") : void 0;
+            function $(n, t, a) {
+                for(var l = t + a, v = t; n[v] && !(v >= l);)++v;
+                if (v - t > 16 && n.subarray && j) return j.decode(n.subarray(t, v));
+                for(var S = ""; t < v;){
+                    var f = n[t++];
+                    if (!(f & 128)) {
+                        S += String.fromCharCode(f);
+                        continue;
+                    }
+                    var R = n[t++] & 63;
+                    if ((f & 224) == 192) {
+                        S += String.fromCharCode((f & 31) << 6 | R);
+                        continue;
+                    }
+                    var W = n[t++] & 63;
+                    if ((f & 240) == 224 ? f = (f & 15) << 12 | R << 6 | W : f = (f & 7) << 18 | R << 12 | W << 6 | n[t++] & 63, f < 65536) S += String.fromCharCode(f);
+                    else {
+                        var pe = f - 65536;
+                        S += String.fromCharCode(55296 | pe >> 10, 56320 | pe & 1023);
+                    }
+                }
+                return S;
+            }
+            function M(n, t) {
+                return n ? $(m, n, t) : "";
+            }
+            function I(n, t) {
+                return n % t > 0 && (n += t - n % t), n;
+            }
+            var _, m;
+            function U(n) {
+                _ = n, e.HEAP8 = new Int8Array(n), e.HEAP16 = new Int16Array(n), e.HEAP32 = new Int32Array(n), e.HEAPU8 = m = new Uint8Array(n), e.HEAPU16 = new Uint16Array(n), e.HEAPU32 = new Uint32Array(n), e.HEAPF32 = new Float32Array(n), e.HEAPF64 = new Float64Array(n);
+            }
+            e.INITIAL_MEMORY;
+            var d, Q = [], D = [], X = [];
+            function Z() {
+                if (e.preRun) for(typeof e.preRun == "function" && (e.preRun = [
+                    e.preRun
+                ]); e.preRun.length;)q(e.preRun.shift());
+                oe(Q);
+            }
+            function re() {
+                oe(D);
+            }
+            function L() {
+                if (e.postRun) for(typeof e.postRun == "function" && (e.postRun = [
+                    e.postRun
+                ]); e.postRun.length;)O(e.postRun.shift());
+                oe(X);
+            }
+            function q(n) {
+                Q.unshift(n);
+            }
+            function K(n) {
+                D.unshift(n);
+            }
+            function O(n) {
+                X.unshift(n);
+            }
+            var E = 0, H = null;
+            function G(n) {
+                E++, e.monitorRunDependencies && e.monitorRunDependencies(E);
+            }
+            function ee(n) {
+                if (E--, e.monitorRunDependencies && e.monitorRunDependencies(E), E == 0 && H) {
+                    var t = H;
+                    H = null, t();
+                }
+            }
+            e.preloadedImages = {}, e.preloadedAudios = {};
+            function Y(n) {
+                e.onAbort && e.onAbort(n), n += "", r(n), u = !0, n = "abort(" + n + "). Build with -s ASSERTIONS=1 for more info.";
+                var t = new WebAssembly.RuntimeError(n);
+                throw t;
+            }
+            var Ae = "data:application/octet-stream;base64,";
+            function fe(n) {
+                return n.startsWith(Ae);
+            }
+            function ce(n) {
+                return n.startsWith("file://");
+            }
+            var h = "argon2.wasm";
+            fe(h) || (h = C(h));
+            function ue(n) {
+                try {
+                    if (n == h && i) return new Uint8Array(i);
+                    if (N) return N(n);
+                    throw "both async and sync fetching of the wasm failed";
+                } catch (t) {
+                    Y(t);
+                }
+            }
+            function ve() {
+                if (!i && (g || p)) {
+                    if (typeof fetch == "function" && !ce(h)) return fetch(h, {
+                        credentials: "same-origin"
+                    }).then(function(n) {
+                        if (!n.ok) throw "failed to load wasm binary file at '" + h + "'";
+                        return n.arrayBuffer();
+                    }).catch(function() {
+                        return ue(h);
+                    });
+                    if (P) return new Promise(function(n, t) {
+                        P(h, function(a) {
+                            n(new Uint8Array(a));
+                        }, t);
+                    });
+                }
+                return Promise.resolve().then(function() {
+                    return ue(h);
+                });
+            }
+            function we() {
+                var n = {
+                    a: Te
+                };
+                function t(f, R) {
+                    var W = f.exports;
+                    e.asm = W, o = e.asm.c, U(o.buffer), d = e.asm.k, K(e.asm.d), ee();
+                }
+                G();
+                function a(f) {
+                    t(f.instance);
+                }
+                function l(f) {
+                    return ve().then(function(R) {
+                        var W = WebAssembly.instantiate(R, n);
+                        return W;
+                    }).then(f, function(R) {
+                        r("failed to asynchronously prepare wasm: " + R), Y(R);
+                    });
+                }
+                function v() {
+                    return !i && typeof WebAssembly.instantiateStreaming == "function" && !fe(h) && !ce(h) && typeof fetch == "function" ? fetch(h, {
+                        credentials: "same-origin"
+                    }).then(function(f) {
+                        var R = WebAssembly.instantiateStreaming(f, n);
+                        return R.then(a, function(W) {
+                            return r("wasm streaming compile failed: " + W), r("falling back to ArrayBuffer instantiation"), l(a);
+                        });
+                    }) : l(a);
+                }
+                if (e.instantiateWasm) try {
+                    var S = e.instantiateWasm(n, t);
+                    return S;
+                } catch (f) {
+                    return r("Module.instantiateWasm callback failed with error: " + f), !1;
+                }
+                return v(), {};
+            }
+            function oe(n) {
+                for(; n.length > 0;){
+                    var t = n.shift();
+                    if (typeof t == "function") {
+                        t(e);
+                        continue;
+                    }
+                    var a = t.func;
+                    typeof a == "number" ? t.arg === void 0 ? d.get(a)() : d.get(a)(t.arg) : a(t.arg === void 0 ? null : t.arg);
+                }
+            }
+            function Re(n, t, a) {
+                m.copyWithin(n, t, t + a);
+            }
+            function be(n) {
+                try {
+                    return o.grow(n - _.byteLength + 65535 >>> 16), U(o.buffer), 1;
+                } catch  {}
+            }
+            function Ee(n) {
+                var t = m.length;
+                n = n >>> 0;
+                var a = 2147418112;
+                if (n > a) return !1;
+                for(var l = 1; l <= 4; l *= 2){
+                    var v = t * (1 + .2 / l);
+                    v = Math.min(v, n + 100663296);
+                    var S = Math.min(a, I(Math.max(n, v), 65536)), f = be(S);
+                    if (f) return !0;
+                }
+                return !1;
+            }
+            var Te = {
+                a: Re,
+                b: Ee
+            };
+            we(), e.___wasm_call_ctors = function() {
+                return (e.___wasm_call_ctors = e.asm.d).apply(null, arguments);
+            }, e._argon2_hash = function() {
+                return (e._argon2_hash = e.asm.e).apply(null, arguments);
+            };
+            var le = e._malloc = function() {
+                return (le = e._malloc = e.asm.f).apply(null, arguments);
+            };
+            e._free = function() {
+                return (e._free = e.asm.g).apply(null, arguments);
+            }, e._argon2_verify = function() {
+                return (e._argon2_verify = e.asm.h).apply(null, arguments);
+            }, e._argon2_error_message = function() {
+                return (e._argon2_error_message = e.asm.i).apply(null, arguments);
+            }, e._argon2_encodedlen = function() {
+                return (e._argon2_encodedlen = e.asm.j).apply(null, arguments);
+            }, e._argon2_hash_ext = function() {
+                return (e._argon2_hash_ext = e.asm.l).apply(null, arguments);
+            }, e._argon2_verify_ext = function() {
+                return (e._argon2_verify_ext = e.asm.m).apply(null, arguments);
+            };
+            var de = e.stackAlloc = function() {
+                return (de = e.stackAlloc = e.asm.n).apply(null, arguments);
+            };
+            e.allocate = z, e.UTF8ToString = M, e.ALLOC_NORMAL = F;
+            var ne;
+            function Se(n) {
+                this.name = "ExitStatus", this.message = "Program terminated with exit(" + n + ")", this.status = n;
+            }
+            H = function n() {
+                ne || ie(), ne || (H = n);
+            };
+            function ie(n) {
+                if (E > 0 || (Z(), E > 0)) return;
+                function t() {
+                    ne || (ne = !0, e.calledRun = !0, !u && (re(), e.onRuntimeInitialized && e.onRuntimeInitialized(), L()));
+                }
+                e.setStatus ? (e.setStatus("Running..."), setTimeout(function() {
+                    setTimeout(function() {
+                        e.setStatus("");
+                    }, 1), t();
+                }, 1)) : t();
+            }
+            if (e.run = ie, e.preInit) for(typeof e.preInit == "function" && (e.preInit = [
+                e.preInit
+            ]); e.preInit.length > 0;)e.preInit.pop()();
+            ie(), A.exports = e, e.unloadRuntime = function() {
+                typeof self < "u" && delete self.Module, e = o = d = _ = m = void 0, delete A.exports;
+            };
+        })(ae)), ae.exports;
+    };
+    const Le = "" + new URL("argon2-BUCifEKR.wasm", import.meta.url).href, Oe = async (A = {}, e)=>{
+        let c;
+        if (e.startsWith("data:")) {
+            const s = e.replace(/^data:.*?base64,/, "");
+            let g;
+            if (typeof Buffer == "function" && typeof Buffer.from == "function") g = Buffer.from(s, "base64");
+            else if (typeof atob == "function") {
+                const p = atob(s);
+                g = new Uint8Array(p.length);
+                for(let b = 0; b < p.length; b++)g[b] = p.charCodeAt(b);
+            } else throw new Error("Cannot decode base64-encoded data URL");
+            c = await WebAssembly.instantiate(g, A);
+        } else {
+            const s = await fetch(e), g = s.headers.get("Content-Type") || "";
+            if ("instantiateStreaming" in WebAssembly && g.startsWith("application/wasm")) c = await WebAssembly.instantiateStreaming(s, A);
+            else {
+                const p = await s.arrayBuffer();
+                c = await WebAssembly.instantiate(p, A);
+            }
+        }
+        return c.instance.exports;
+    };
+    URL = globalThis.URL;
+    const w = await Oe({
+        a: {
+            a: me.a,
+            b: me.b
+        }
+    }, Le), We = w.c, Ce = w.d, Ne = w.e, Fe = w.f, je = w.g, Me = w.h, De = w.i, He = w.j, $e = w.k, qe = w.l, Ke = w.m, Ge = w.n, Ve = Object.freeze(Object.defineProperty({
+        __proto__: null,
+        c: We,
+        d: Ce,
+        e: Ne,
+        f: Fe,
+        g: je,
+        h: Me,
+        i: De,
+        j: He,
+        k: $e,
+        l: qe,
+        m: Ke,
+        n: Ge
+    }, Symbol.toStringTag, {
+        value: "Module"
+    })), ke = he(Ve);
+    var ze = te.exports, ge;
+    function Xe() {
+        return ge || (ge = 1, (function(A) {
+            (function(e, c) {
+                A.exports ? A.exports = c() : e.argon2 = c();
+            })(typeof self < "u" ? self : ze, function() {
+                const e = typeof self < "u" ? self : this, c = {
+                    Argon2d: 0,
+                    Argon2i: 1,
+                    Argon2id: 2
+                };
+                function s(r) {
+                    if (s._promise) return s._promise;
+                    if (s._module) return Promise.resolve(s._module);
+                    let i;
+                    return e.process && e.process.versions && e.process.versions.node ? i = p().then((o)=>new Promise((u)=>{
+                            o.postRun = ()=>u(o);
+                        })) : i = b().then((o)=>{
+                        const u = r ? y(r) : void 0;
+                        return g(o, u);
+                    }), s._promise = i, i.then((o)=>(s._module = o, delete s._promise, o));
+                }
+                function g(r, i) {
+                    return new Promise((o)=>(e.Module = {
+                            wasmBinary: r,
+                            wasmMemory: i,
+                            postRun () {
+                                o(Module);
+                            }
+                        }, p()));
+                }
+                function p() {
+                    return e.loadArgon2WasmModule ? e.loadArgon2WasmModule() : typeof ye == "function" ? Promise.resolve(Ue()) : Be(()=>import("./argon2-VsC-m8hX.js").then(async (m)=>{
+                            await m.__tla;
+                            return m;
+                        }).then((r)=>r.a), __vite__mapDeps([0,1]), import.meta.url);
+                }
+                function b() {
+                    if (e.loadArgon2WasmBinary) return e.loadArgon2WasmBinary();
+                    if (typeof ye == "function") return Promise.resolve(ke).then((i)=>J(i));
+                    const r = e.argon2WasmPath || "node_modules/argon2-browser/dist/argon2.wasm";
+                    return fetch(r).then((i)=>i.arrayBuffer()).then((i)=>new Uint8Array(i));
+                }
+                function J(r) {
+                    const i = atob(r), o = new Uint8Array(new ArrayBuffer(i.length));
+                    for(let u = 0; u < i.length; u++)o[u] = i.charCodeAt(u);
+                    return o;
+                }
+                function y(r) {
+                    const x = Math.min(Math.max(Math.ceil(r * 1024 / 65536), 256) + 256, 32767);
+                    return new WebAssembly.Memory({
+                        initial: x,
+                        maximum: 32767
+                    });
+                }
+                function C(r, i) {
+                    return r.allocate(i, "i8", r.ALLOC_NORMAL);
+                }
+                function T(r, i) {
+                    const o = new Uint8Array([
+                        ...i,
+                        0
+                    ]);
+                    return C(r, o);
+                }
+                function P(r) {
+                    if (typeof r != "string") return r;
+                    if (typeof TextEncoder == "function") return new TextEncoder().encode(r);
+                    if (typeof Buffer == "function") return Buffer.from(r);
+                    throw new Error("Don't know how to encode UTF8");
+                }
+                function N(r) {
+                    const i = r.mem || 1024;
+                    return s(i).then((o)=>{
+                        const u = r.time || 1, B = r.parallelism || 1, F = P(r.pass), x = T(o, F), z = F.length, j = P(r.salt), $ = T(o, j), M = j.length, I = r.type || c.Argon2d, _ = o.allocate(new Array(r.hashLen || 24), "i8", o.ALLOC_NORMAL), m = r.secret ? C(o, r.secret) : 0, U = r.secret ? r.secret.byteLength : 0, d = r.ad ? C(o, r.ad) : 0, Q = r.ad ? r.ad.byteLength : 0, D = r.hashLen || 24, X = o._argon2_encodedlen(u, i, B, M, D, I), Z = o.allocate(new Array(X + 1), "i8", o.ALLOC_NORMAL), re = 19;
+                        let L, q;
+                        try {
+                            q = o._argon2_hash_ext(u, i, B, x, z, $, M, _, D, Z, X, I, m, U, d, Q, re);
+                        } catch (O) {
+                            L = O;
+                        }
+                        let K;
+                        if (q === 0 && !L) {
+                            let O = "";
+                            const E = new Uint8Array(D);
+                            for(let G = 0; G < D; G++){
+                                const ee = o.HEAP8[_ + G];
+                                E[G] = ee, O += ("0" + (255 & ee).toString(16)).slice(-2);
+                            }
+                            const H = o.UTF8ToString(Z);
+                            K = {
+                                hash: E,
+                                hashHex: O,
+                                encoded: H
+                            };
+                        } else {
+                            try {
+                                L || (L = o.UTF8ToString(o._argon2_error_message(q)));
+                            } catch  {}
+                            K = {
+                                message: L,
+                                code: q
+                            };
+                        }
+                        try {
+                            o._free(x), o._free($), o._free(_), o._free(Z), d && o._free(d), m && o._free(m);
+                        } catch  {}
+                        if (L) throw K;
+                        return K;
+                    });
+                }
+                function V(r) {
+                    return s().then((i)=>{
+                        const o = P(r.pass), u = T(i, o), B = o.length, F = r.secret ? C(i, r.secret) : 0, x = r.secret ? r.secret.byteLength : 0, z = r.ad ? C(i, r.ad) : 0, j = r.ad ? r.ad.byteLength : 0, $ = P(r.encoded), M = T(i, $);
+                        let I = r.type;
+                        if (I === void 0) {
+                            let d = r.encoded.split("$")[1];
+                            d && (d = d.replace("a", "A"), I = c[d] || c.Argon2d);
+                        }
+                        let _, m;
+                        try {
+                            m = i._argon2_verify_ext(M, u, B, F, x, z, j, I);
+                        } catch (d) {
+                            _ = d;
+                        }
+                        let U;
+                        if (m || _) {
+                            try {
+                                _ || (_ = i.UTF8ToString(i._argon2_error_message(m)));
+                            } catch  {}
+                            U = {
+                                message: _,
+                                code: m
+                            };
+                        }
+                        try {
+                            i._free(u), i._free(M);
+                        } catch  {}
+                        if (_) throw U;
+                        return U;
+                    });
+                }
+                function k() {
+                    s._module && (s._module.unloadRuntime(), delete s._promise, delete s._module);
+                }
+                return {
+                    ArgonType: c,
+                    hash: N,
+                    verify: V,
+                    unloadRuntime: k
+                };
+            });
+        })(te)), te.exports;
+    }
+    var Ze = Xe();
+    let Ye;
+    Ye = Pe(Ze);
+    en = Object.freeze(Object.defineProperty({
+        __proto__: null,
+        default: Ye
+    }, Symbol.toStringTag, {
+        value: "Module"
+    }));
+});
+export { en as a, Ue as r, __tla };

package/assets/assets/argon2-VsC-m8hX.js

@@ -0,0 +1,38 @@
+import { g as s } from "./react-vendor-CJNQXC79.js";
+import { r as g, __tla as __tla_0 } from "./argon2-CtQQN5by.js";
+let l;
+let __tla = Promise.all([
+    (()=>{
+        try {
+            return __tla_0;
+        } catch  {}
+    })()
+]).then(async ()=>{
+    function i(t, a) {
+        for(var o = 0; o < a.length; o++){
+            const r = a[o];
+            if (typeof r != "string" && !Array.isArray(r)) {
+                for(const e in r)if (e !== "default" && !(e in t)) {
+                    const n = Object.getOwnPropertyDescriptor(r, e);
+                    n && Object.defineProperty(t, e, n.get ? n : {
+                        enumerable: !0,
+                        get: ()=>r[e]
+                    });
+                }
+            }
+        }
+        return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, {
+            value: "Module"
+        }));
+    }
+    var f = g();
+    let c;
+    c = s(f);
+    l = i({
+        __proto__: null,
+        default: c
+    }, [
+        f
+    ]);
+});
+export { l as a, __tla };

package/assets/assets/azcli-1IWB1ccx.js

@@ -0,0 +1 @@
+var e={comments:{lineComment:"#"}},t={defaultToken:"keyword",ignoreCase:!0,tokenPostfix:".azcli",str:/[^#\s]/,tokenizer:{root:[{include:"@comment"},[/\s-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":{token:"key.identifier",next:"@type"}}}],[/^-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":{token:"key.identifier",next:"@type"}}}]],type:[{include:"@comment"},[/-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":"key.identifier"}}],[/@str+\s*/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}]],comment:[[/#.*$/,{cases:{"@eos":{token:"comment",next:"@popall"}}}]]}};export{e as conf,t as language};

package/assets/assets/bat-DPkNLes8.js

@@ -0,0 +1 @@
+var e={comments:{lineComment:"REM"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],folding:{markers:{start:new RegExp("^\\s*(::\\s*|REM\\s+)#region"),end:new RegExp("^\\s*(::\\s*|REM\\s+)#endregion")}}},s={defaultToken:"",ignoreCase:!0,tokenPostfix:".bat",brackets:[{token:"delimiter.bracket",open:"{",close:"}"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"delimiter.square",open:"[",close:"]"}],keywords:/call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,symbols:/[=><!~?&|+\-*\/\^;\.,]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/^(\s*)(rem(?:\s.*|))$/,["","comment"]],[/(\@?)(@keywords)(?!\w)/,[{token:"keyword"},{token:"keyword.$2"}]],[/[ \t\r\n]+/,""],[/setlocal(?!\w)/,"keyword.tag-setlocal"],[/endlocal(?!\w)/,"keyword.tag-setlocal"],[/[a-zA-Z_]\w*/,""],[/:\w*/,"metatag"],[/%[^%]+%/,"variable"],[/%%[\w]+(?!\w)/,"variable"],[/[{}()\[\]]/,"@brackets"],[/@symbols/,"delimiter"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/"/,"string",'@string."'],[/'/,"string","@string.'"]],string:[[/[^\\"'%]+/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/%[\w ]+%/,"variable"],[/%%[\w]+(?!\w)/,"variable"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/$/,"string","@popall"]]}};export{e as conf,s as language};