dbxlite-ui 0.2.0 → 0.3.1

package/assets/assets/argon2-Ds2nOx5S.js

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

package/assets/assets/{argon2-VsC-m8hX.js → argon2-gAk7W4yq.js}

@@ -1,5 +1,5 @@
-import { g as s } from "./react-vendor-CJNQXC79.js";
-import { r as g, __tla as __tla_0 } from "./argon2-CtQQN5by.js";
+import { g as s } from "./react-vendor-B2Ij4Vfr.js";
+import { r as g, __tla as __tla_0 } from "./argon2-Ds2nOx5S.js";
 let l;
 let __tla = Promise.all([
     (()=>{