@pathscale/ui 0.0.12 → 0.0.14

package/dist/components/polymorphic/index.js

@@ -1 +1,3031 @@
-export { Polymorphic_default as Polymorphic, PolymorphicButton_default as PolymorphicButton } from '../../chunk/SPEY5RMB.js';
+(function() {
+var __webpack_modules__ = {
+"8169": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  Polymorphic: function() { return _Polymorphic__WEBPACK_IMPORTED_MODULE_0__["default"]; },
+  PolymorphicButton: function() { return _PolymorphicButton__WEBPACK_IMPORTED_MODULE_1__["default"]; }
+});
+/* harmony import */var _Polymorphic__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Polymorphic */"5384");
+/* harmony import */var _PolymorphicButton__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./PolymorphicButton */"4719");
+
+
+
+}),
+"2173": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  chain: function() { return chain; }
+});
+/**
+ * Creates a function that calls a series of callbacks in order with the same arguments.
+ *
+ * @param callbacks An iterable of callback functions to invoke.
+ * @returns A function that will execute all callbacks with the provided arguments.
+ */ function chain(callbacks) {
+    return function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)args[_key] = arguments[_key];
+        for (const callback of callbacks)callback === null || callback === void 0 || callback(...args);
+    };
+}
+}),
+"2448": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  mergeRefs: function() { return _mergeRefs__WEBPACK_IMPORTED_MODULE_0__.mergeRefs; }
+});
+/* harmony import */var _mergeRefs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./mergeRefs */"7679");
+
+}),
+"7679": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  mergeRefs: function() { return mergeRefs; }
+});
+/* harmony import */var _src_lib_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @src/lib/iterable */"2173");
+
+/**
+ * Utility for chaining multiple `ref` assignments with `props.ref` forwarding.
+ *
+ * @param refs An array of refs to merge.
+ * @returns A function that assigns the element to all provided refs.
+ */ function mergeRefs() {
+    for(var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++)refs[_key] = arguments[_key];
+    return (0, _src_lib_iterable__WEBPACK_IMPORTED_MODULE_0__.chain)(refs);
+}
+}),
+"8762": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  createIsButton: function() { return createIsButton; }
+});
+/* harmony import */var solid_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! solid-js */"5666");
+/* harmony import */var _createTagName__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./createTagName */"1303");
+
+
+const BUTTON_INPUT_TYPES = [
+    "button",
+    "color",
+    "file",
+    "image",
+    "reset",
+    "submit"
+];
+/**
+ * Checks if the given tag name or input type represent a button.
+ *
+ * @param tagName The name of the tag to check.
+ * @param type The type attribute of the input element.
+ * @returns `true` if the tag is a button or an input of a button type; otherwise, `false`.
+ */ function isButton(tagName, type) {
+    if (tagName === "button") return true;
+    if (tagName === "input" && type !== undefined) return BUTTON_INPUT_TYPES.indexOf(type) !== -1;
+    return false;
+}
+/**
+ * Creates a memoized signal that checks if the element is a button.
+ *
+ * @param props.element The element to check.
+ * @param props.type An optional button input type to consider.
+ * @returns A memoized signal indicating if the element is a button.
+ */ function createIsButton(props) {
+    const tagName = (0, _createTagName__WEBPACK_IMPORTED_MODULE_1__.createTagName)({
+        element: props.element,
+        fallback: "button"
+    });
+    return (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createMemo)(()=>isButton(tagName(), props.type));
+}
+}),
+"1303": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  createTagName: function() { return createTagName; }
+});
+/* harmony import */var solid_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! solid-js */"5666");
+
+/**
+ * Creates a memoized signal with the lowercase tag name of the element.
+ *
+ * @param props.element The element to get the tag name of.
+ * @param props.fallback The fallback tag name to use if the element is `null`.
+ * @returns A memoized signal with the lowercase tag name of the element.
+ */ function createTagName(props) {
+    return (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createMemo)(()=>{
+        var _props_element;
+        return ((_props_element = props.element()) === null || _props_element === void 0 ? void 0 : _props_element.tagName.toLowerCase()) ?? props.fallback;
+    });
+}
+}),
+"9966": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  createIsButton: function() { return _createIsButton__WEBPACK_IMPORTED_MODULE_0__.createIsButton; }
+});
+/* harmony import */var _createIsButton__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./createIsButton */"8762");
+/* harmony import */var _createTagName__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./createTagName */"1303");
+
+
+}),
+"5384": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */var solid_js_web__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! solid-js/web */"7525");
+/* harmony import */var solid_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! solid-js */"5666");
+
+
+
+
+/**
+ * Renders as a div by default and can be overridden with the `as` property.
+ */ const Polymorphic = (props)=>{
+    const [localProps, otherProps] = (0, solid_js__WEBPACK_IMPORTED_MODULE_1__.splitProps)(props, [
+        "as"
+    ]);
+    // biome-ignore lint: types are valid
+    const cached = (0, solid_js__WEBPACK_IMPORTED_MODULE_1__.createMemo)(()=>localProps.as ?? "div");
+    return (0, solid_js__WEBPACK_IMPORTED_MODULE_1__.createMemo)(()=>{
+        const component = cached();
+        switch(typeof component){
+            case "function":
+                return (0, solid_js__WEBPACK_IMPORTED_MODULE_1__.untrack)(()=>component(otherProps));
+            case "string":
+                return (0, solid_js_web__WEBPACK_IMPORTED_MODULE_0__.createComponent)(solid_js_web__WEBPACK_IMPORTED_MODULE_0__.Dynamic, (0, solid_js_web__WEBPACK_IMPORTED_MODULE_0__.mergeProps)({
+                    component: component
+                }, otherProps));
+        }
+    });
+};
+/* harmony default export */ __webpack_exports__["default"] = (Polymorphic);
+}),
+"4719": (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */var solid_js_web__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! solid-js/web */"7525");
+/* harmony import */var _src_lib_refs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @src/lib/refs */"2448");
+/* harmony import */var _src_lib_tag__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @src/lib/tag */"9966");
+/* harmony import */var solid_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! solid-js */"5666");
+/* harmony import */var _Polymorphic__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Polymorphic */"5384");
+
+
+
+
+
+
+/**
+ * An accessible button that sets `type` and `role` properly based on
+ * if it's a native button.
+ */ const PolymorphicButton = (props)=>{
+    const [ref, setRef] = (0, solid_js__WEBPACK_IMPORTED_MODULE_3__.createSignal)(null);
+    const [localProps, otherProps] = (0, solid_js__WEBPACK_IMPORTED_MODULE_3__.splitProps)(props, [
+        "ref"
+    ]);
+    const isButton = (0, _src_lib_tag__WEBPACK_IMPORTED_MODULE_2__.createIsButton)({
+        element: ref,
+        type: props.type
+    });
+    return (0, solid_js_web__WEBPACK_IMPORTED_MODULE_0__.createComponent)(_Polymorphic__WEBPACK_IMPORTED_MODULE_4__["default"], (0, solid_js_web__WEBPACK_IMPORTED_MODULE_0__.mergeProps)({
+        as: "button",
+        ref (r$) {
+            var _ref$ = (0, _src_lib_refs__WEBPACK_IMPORTED_MODULE_1__.mergeRefs)(setRef, localProps.ref);
+            typeof _ref$ === "function" && _ref$(r$);
+        },
+        get role () {
+            return !isButton() ? "button" : undefined;
+        }
+    }, otherProps));
+};
+/* harmony default export */ __webpack_exports__["default"] = (PolymorphicButton);
+}),
+"5666": (function (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  For: function() { return For; },
+  Show: function() { return Show; },
+  children: function() { return children; },
+  createComponent: function() { return createComponent; },
+  createEffect: function() { return createEffect; },
+  createMemo: function() { return createMemo; },
+  createRenderEffect: function() { return createRenderEffect; },
+  createSignal: function() { return createSignal; },
+  getOwner: function() { return getOwner; },
+  mergeProps: function() { return mergeProps; },
+  onCleanup: function() { return onCleanup; },
+  onMount: function() { return onMount; },
+  sharedConfig: function() { return sharedConfig; },
+  splitProps: function() { return splitProps; },
+  untrack: function() { return untrack; }
+});
+let taskIdCounter = 1, isCallbackScheduled = false, isPerformingWork = false, taskQueue = [], currentTask = null, shouldYieldToHost = null, yieldInterval = 5, deadline = 0, maxYieldInterval = 300, scheduleCallback = null, scheduledCallback = null;
+const maxSigned31BitInt = 1073741823;
+function setupScheduler() {
+    const channel = new MessageChannel(), port = channel.port2;
+    scheduleCallback = ()=>port.postMessage(null);
+    channel.port1.onmessage = ()=>{
+        if (scheduledCallback !== null) {
+            const currentTime = performance.now();
+            deadline = currentTime + yieldInterval;
+            const hasTimeRemaining = true;
+            try {
+                const hasMoreWork = scheduledCallback(hasTimeRemaining, currentTime);
+                if (!hasMoreWork) scheduledCallback = null;
+                else port.postMessage(null);
+            } catch (error) {
+                port.postMessage(null);
+                throw error;
+            }
+        }
+    };
+    if (navigator && navigator.scheduling && navigator.scheduling.isInputPending) {
+        const scheduling = navigator.scheduling;
+        shouldYieldToHost = ()=>{
+            const currentTime = performance.now();
+            if (currentTime >= deadline) {
+                if (scheduling.isInputPending()) return true;
+                return currentTime >= maxYieldInterval;
+            } else return false;
+        };
+    } else shouldYieldToHost = ()=>performance.now() >= deadline;
+}
+function enqueue(taskQueue, task) {
+    function findIndex() {
+        let m = 0;
+        let n = taskQueue.length - 1;
+        while(m <= n){
+            const k = n + m >> 1;
+            const cmp = task.expirationTime - taskQueue[k].expirationTime;
+            if (cmp > 0) m = k + 1;
+            else if (cmp < 0) n = k - 1;
+            else return k;
+        }
+        return m;
+    }
+    taskQueue.splice(findIndex(), 0, task);
+}
+function requestCallback(fn, options) {
+    if (!scheduleCallback) setupScheduler();
+    let startTime = performance.now(), timeout = maxSigned31BitInt;
+    if (options && options.timeout) timeout = options.timeout;
+    const newTask = {
+        id: taskIdCounter++,
+        fn,
+        startTime,
+        expirationTime: startTime + timeout
+    };
+    enqueue(taskQueue, newTask);
+    if (!isCallbackScheduled && !isPerformingWork) {
+        isCallbackScheduled = true;
+        scheduledCallback = flushWork;
+        scheduleCallback();
+    }
+    return newTask;
+}
+function cancelCallback(task) {
+    task.fn = null;
+}
+function flushWork(hasTimeRemaining, initialTime) {
+    isCallbackScheduled = false;
+    isPerformingWork = true;
+    try {
+        return workLoop(hasTimeRemaining, initialTime);
+    } finally{
+        currentTask = null;
+        isPerformingWork = false;
+    }
+}
+function workLoop(hasTimeRemaining, initialTime) {
+    let currentTime = initialTime;
+    currentTask = taskQueue[0] || null;
+    while(currentTask !== null){
+        if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) break;
+        const callback = currentTask.fn;
+        if (callback !== null) {
+            currentTask.fn = null;
+            const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+            callback(didUserCallbackTimeout);
+            currentTime = performance.now();
+            if (currentTask === taskQueue[0]) taskQueue.shift();
+        } else taskQueue.shift();
+        currentTask = taskQueue[0] || null;
+    }
+    return currentTask !== null;
+}
+const sharedConfig = {
+    context: undefined,
+    registry: undefined,
+    effects: undefined,
+    done: false,
+    getContextId () {
+        return getContextId(this.context.count);
+    },
+    getNextContextId () {
+        return getContextId(this.context.count++);
+    }
+};
+function getContextId(count) {
+    const num = String(count), len = num.length - 1;
+    return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
+}
+function setHydrateContext(context) {
+    sharedConfig.context = context;
+}
+function nextHydrateContext() {
+    return {
+        ...sharedConfig.context,
+        id: sharedConfig.getNextContextId(),
+        count: 0
+    };
+}
+const IS_DEV = false;
+const equalFn = (a, b)=>a === b;
+const $PROXY = Symbol("solid-proxy");
+const SUPPORTS_PROXY = typeof Proxy === "function";
+const $TRACK = Symbol("solid-track");
+const $DEVCOMP = Symbol("solid-dev-component");
+const signalOptions = {
+    equals: equalFn
+};
+let ERROR = null;
+let runEffects = runQueue;
+const STALE = 1;
+const PENDING = 2;
+const UNOWNED = {
+    owned: null,
+    cleanups: null,
+    context: null,
+    owner: null
+};
+const NO_INIT = {};
+var Owner = null;
+let Transition = null;
+let Scheduler = null;
+let ExternalSourceConfig = null;
+let Listener = null;
+let Updates = null;
+let Effects = null;
+let ExecCount = 0;
+function createRoot(fn, detachedOwner) {
+    const listener = Listener, owner = Owner, unowned = fn.length === 0, current = detachedOwner === undefined ? owner : detachedOwner, root = unowned ? UNOWNED : {
+        owned: null,
+        cleanups: null,
+        context: current ? current.context : null,
+        owner: current
+    }, updateFn = unowned ? fn : ()=>fn(()=>untrack(()=>cleanNode(root)));
+    Owner = root;
+    Listener = null;
+    try {
+        return runUpdates(updateFn, true);
+    } finally{
+        Listener = listener;
+        Owner = owner;
+    }
+}
+function createSignal(value, options) {
+    options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+    const s = {
+        value,
+        observers: null,
+        observerSlots: null,
+        comparator: options.equals || undefined
+    };
+    const setter = (value)=>{
+        if (typeof value === "function") {
+            if (Transition && Transition.running && Transition.sources.has(s)) value = value(s.tValue);
+            else value = value(s.value);
+        }
+        return writeSignal(s, value);
+    };
+    return [
+        readSignal.bind(s),
+        setter
+    ];
+}
+function createComputed(fn, value, options) {
+    const c = createComputation(fn, value, true, STALE);
+    if (Scheduler && Transition && Transition.running) Updates.push(c);
+    else updateComputation(c);
+}
+function createRenderEffect(fn, value, options) {
+    const c = createComputation(fn, value, false, STALE);
+    if (Scheduler && Transition && Transition.running) Updates.push(c);
+    else updateComputation(c);
+}
+function createEffect(fn, value, options) {
+    runEffects = runUserEffects;
+    const c = createComputation(fn, value, false, STALE), s = SuspenseContext && useContext(SuspenseContext);
+    if (s) c.suspense = s;
+    if (!options || !options.render) c.user = true;
+    Effects ? Effects.push(c) : updateComputation(c);
+}
+function createReaction(onInvalidate, options) {
+    let fn;
+    const c = createComputation(()=>{
+        fn ? fn() : untrack(onInvalidate);
+        fn = undefined;
+    }, undefined, false, 0), s = SuspenseContext && useContext(SuspenseContext);
+    if (s) c.suspense = s;
+    c.user = true;
+    return (tracking)=>{
+        fn = tracking;
+        updateComputation(c);
+    };
+}
+function createMemo(fn, value, options) {
+    options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+    const c = createComputation(fn, value, true, 0);
+    c.observers = null;
+    c.observerSlots = null;
+    c.comparator = options.equals || undefined;
+    if (Scheduler && Transition && Transition.running) {
+        c.tState = STALE;
+        Updates.push(c);
+    } else updateComputation(c);
+    return readSignal.bind(c);
+}
+function isPromise(v) {
+    return v && typeof v === "object" && "then" in v;
+}
+function createResource(pSource, pFetcher, pOptions) {
+    let source;
+    let fetcher;
+    let options;
+    if (typeof pFetcher === "function") {
+        source = pSource;
+        fetcher = pFetcher;
+        options = pOptions || {};
+    } else {
+        source = true;
+        fetcher = pSource;
+        options = pFetcher || {};
+    }
+    let pr = null, initP = NO_INIT, id = null, loadedUnderTransition = false, scheduled = false, resolved = "initialValue" in options, dynamic = typeof source === "function" && createMemo(source);
+    const contexts = new Set(), [value, setValue] = (options.storage || createSignal)(options.initialValue), [error, setError] = createSignal(undefined), [track, trigger] = createSignal(undefined, {
+        equals: false
+    }), [state, setState] = createSignal(resolved ? "ready" : "unresolved");
+    if (sharedConfig.context) {
+        id = sharedConfig.getNextContextId();
+        if (options.ssrLoadFrom === "initial") initP = options.initialValue;
+        else if (sharedConfig.load && sharedConfig.has(id)) initP = sharedConfig.load(id);
+    }
+    function loadEnd(p, v, error, key) {
+        if (pr === p) {
+            pr = null;
+            key !== undefined && (resolved = true);
+            if ((p === initP || v === initP) && options.onHydrated) queueMicrotask(()=>options.onHydrated(key, {
+                    value: v
+                }));
+            initP = NO_INIT;
+            if (Transition && p && loadedUnderTransition) {
+                Transition.promises.delete(p);
+                loadedUnderTransition = false;
+                runUpdates(()=>{
+                    Transition.running = true;
+                    completeLoad(v, error);
+                }, false);
+            } else completeLoad(v, error);
+        }
+        return v;
+    }
+    function completeLoad(v, err) {
+        runUpdates(()=>{
+            if (err === undefined) setValue(()=>v);
+            setState(err !== undefined ? "errored" : resolved ? "ready" : "unresolved");
+            setError(err);
+            for (const c of contexts.keys())c.decrement();
+            contexts.clear();
+        }, false);
+    }
+    function read() {
+        const c = SuspenseContext && useContext(SuspenseContext), v = value(), err = error();
+        if (err !== undefined && !pr) throw err;
+        if (Listener && !Listener.user && c) createComputed(()=>{
+            track();
+            if (pr) {
+                if (c.resolved && Transition && loadedUnderTransition) Transition.promises.add(pr);
+                else if (!contexts.has(c)) {
+                    c.increment();
+                    contexts.add(c);
+                }
+            }
+        });
+        return v;
+    }
+    function load(refetching = true) {
+        if (refetching !== false && scheduled) return;
+        scheduled = false;
+        const lookup = dynamic ? dynamic() : source;
+        loadedUnderTransition = Transition && Transition.running;
+        if (lookup == null || lookup === false) {
+            loadEnd(pr, untrack(value));
+            return;
+        }
+        if (Transition && pr) Transition.promises.delete(pr);
+        const p = initP !== NO_INIT ? initP : untrack(()=>fetcher(lookup, {
+                value: value(),
+                refetching
+            }));
+        if (!isPromise(p)) {
+            loadEnd(pr, p, undefined, lookup);
+            return p;
+        }
+        pr = p;
+        if ("value" in p) {
+            if (p.status === "success") loadEnd(pr, p.value, undefined, lookup);
+            else loadEnd(pr, undefined, castError(p.value), lookup);
+            return p;
+        }
+        scheduled = true;
+        queueMicrotask(()=>scheduled = false);
+        runUpdates(()=>{
+            setState(resolved ? "refreshing" : "pending");
+            trigger();
+        }, false);
+        return p.then((v)=>loadEnd(p, v, undefined, lookup), (e)=>loadEnd(p, undefined, castError(e), lookup));
+    }
+    Object.defineProperties(read, {
+        state: {
+            get: ()=>state()
+        },
+        error: {
+            get: ()=>error()
+        },
+        loading: {
+            get () {
+                const s = state();
+                return s === "pending" || s === "refreshing";
+            }
+        },
+        latest: {
+            get () {
+                if (!resolved) return read();
+                const err = error();
+                if (err && !pr) throw err;
+                return value();
+            }
+        }
+    });
+    let owner = Owner;
+    if (dynamic) createComputed(()=>(owner = Owner, load(false)));
+    else load(false);
+    return [
+        read,
+        {
+            refetch: (info)=>runWithOwner(owner, ()=>load(info)),
+            mutate: setValue
+        }
+    ];
+}
+function createDeferred(source, options) {
+    let t, timeout = options ? options.timeoutMs : undefined;
+    const node = createComputation(()=>{
+        if (!t || !t.fn) t = requestCallback(()=>setDeferred(()=>node.value), timeout !== undefined ? {
+            timeout
+        } : undefined);
+        return source();
+    }, undefined, true);
+    const [deferred, setDeferred] = createSignal(Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, options);
+    updateComputation(node);
+    setDeferred(()=>Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value);
+    return deferred;
+}
+function createSelector(source, fn = equalFn, options) {
+    const subs = new Map();
+    const node = createComputation((p)=>{
+        const v = source();
+        for (const [key, val] of subs.entries())if (fn(key, v) !== fn(key, p)) for (const c of val.values()){
+            c.state = STALE;
+            if (c.pure) Updates.push(c);
+            else Effects.push(c);
+        }
+        return v;
+    }, undefined, true, STALE);
+    updateComputation(node);
+    return (key)=>{
+        const listener = Listener;
+        if (listener) {
+            let l;
+            if (l = subs.get(key)) l.add(listener);
+            else subs.set(key, l = new Set([
+                listener
+            ]));
+            onCleanup(()=>{
+                l.delete(listener);
+                !l.size && subs.delete(key);
+            });
+        }
+        return fn(key, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value);
+    };
+}
+function batch(fn) {
+    return runUpdates(fn, false);
+}
+function untrack(fn) {
+    if (!ExternalSourceConfig && Listener === null) return fn();
+    const listener = Listener;
+    Listener = null;
+    try {
+        if (ExternalSourceConfig) return ExternalSourceConfig.untrack(fn);
+        return fn();
+    } finally{
+        Listener = listener;
+    }
+}
+function on(deps, fn, options) {
+    const isArray = Array.isArray(deps);
+    let prevInput;
+    let defer = options && options.defer;
+    return (prevValue)=>{
+        let input;
+        if (isArray) {
+            input = Array(deps.length);
+            for(let i = 0; i < deps.length; i++)input[i] = deps[i]();
+        } else input = deps();
+        if (defer) {
+            defer = false;
+            return prevValue;
+        }
+        const result = untrack(()=>fn(input, prevInput, prevValue));
+        prevInput = input;
+        return result;
+    };
+}
+function onMount(fn) {
+    createEffect(()=>untrack(fn));
+}
+function onCleanup(fn) {
+    if (Owner === null) ;
+    else if (Owner.cleanups === null) Owner.cleanups = [
+        fn
+    ];
+    else Owner.cleanups.push(fn);
+    return fn;
+}
+function catchError(fn, handler) {
+    ERROR || (ERROR = Symbol("error"));
+    Owner = createComputation(undefined, undefined, true);
+    Owner.context = {
+        ...Owner.context,
+        [ERROR]: [
+            handler
+        ]
+    };
+    if (Transition && Transition.running) Transition.sources.add(Owner);
+    try {
+        return fn();
+    } catch (err) {
+        handleError(err);
+    } finally{
+        Owner = Owner.owner;
+    }
+}
+function getListener() {
+    return Listener;
+}
+function getOwner() {
+    return Owner;
+}
+function runWithOwner(o, fn) {
+    const prev = Owner;
+    const prevListener = Listener;
+    Owner = o;
+    Listener = null;
+    try {
+        return runUpdates(fn, true);
+    } catch (err) {
+        handleError(err);
+    } finally{
+        Owner = prev;
+        Listener = prevListener;
+    }
+}
+function enableScheduling(scheduler = requestCallback) {
+    Scheduler = scheduler;
+}
+function startTransition(fn) {
+    if (Transition && Transition.running) {
+        fn();
+        return Transition.done;
+    }
+    const l = Listener;
+    const o = Owner;
+    return Promise.resolve().then(()=>{
+        Listener = l;
+        Owner = o;
+        let t;
+        if (Scheduler || SuspenseContext) {
+            t = Transition || (Transition = {
+                sources: new Set(),
+                effects: [],
+                promises: new Set(),
+                disposed: new Set(),
+                queue: new Set(),
+                running: true
+            });
+            t.done || (t.done = new Promise((res)=>t.resolve = res));
+            t.running = true;
+        }
+        runUpdates(fn, false);
+        Listener = Owner = null;
+        return t ? t.done : undefined;
+    });
+}
+const [transPending, setTransPending] = /*@__PURE__*/ createSignal(false);
+function useTransition() {
+    return [
+        transPending,
+        startTransition
+    ];
+}
+function resumeEffects(e) {
+    Effects.push.apply(Effects, e);
+    e.length = 0;
+}
+function createContext(defaultValue, options) {
+    const id = Symbol("context");
+    return {
+        id,
+        Provider: createProvider(id),
+        defaultValue
+    };
+}
+function useContext(context) {
+    let value;
+    return Owner && Owner.context && (value = Owner.context[context.id]) !== undefined ? value : context.defaultValue;
+}
+function children(fn) {
+    const children = createMemo(fn);
+    const memo = createMemo(()=>resolveChildren(children()));
+    memo.toArray = ()=>{
+        const c = memo();
+        return Array.isArray(c) ? c : c != null ? [
+            c
+        ] : [];
+    };
+    return memo;
+}
+let SuspenseContext;
+function getSuspenseContext() {
+    return SuspenseContext || (SuspenseContext = createContext());
+}
+function enableExternalSource(factory, untrack = (fn)=>fn()) {
+    if (ExternalSourceConfig) {
+        const { factory: oldFactory, untrack: oldUntrack } = ExternalSourceConfig;
+        ExternalSourceConfig = {
+            factory: (fn, trigger)=>{
+                const oldSource = oldFactory(fn, trigger);
+                const source = factory((x)=>oldSource.track(x), trigger);
+                return {
+                    track: (x)=>source.track(x),
+                    dispose () {
+                        source.dispose();
+                        oldSource.dispose();
+                    }
+                };
+            },
+            untrack: (fn)=>oldUntrack(()=>untrack(fn))
+        };
+    } else ExternalSourceConfig = {
+        factory,
+        untrack
+    };
+}
+function readSignal() {
+    const runningTransition = Transition && Transition.running;
+    if (this.sources && (runningTransition ? this.tState : this.state)) {
+        if ((runningTransition ? this.tState : this.state) === STALE) updateComputation(this);
+        else {
+            const updates = Updates;
+            Updates = null;
+            runUpdates(()=>lookUpstream(this), false);
+            Updates = updates;
+        }
+    }
+    if (Listener) {
+        const sSlot = this.observers ? this.observers.length : 0;
+        if (!Listener.sources) {
+            Listener.sources = [
+                this
+            ];
+            Listener.sourceSlots = [
+                sSlot
+            ];
+        } else {
+            Listener.sources.push(this);
+            Listener.sourceSlots.push(sSlot);
+        }
+        if (!this.observers) {
+            this.observers = [
+                Listener
+            ];
+            this.observerSlots = [
+                Listener.sources.length - 1
+            ];
+        } else {
+            this.observers.push(Listener);
+            this.observerSlots.push(Listener.sources.length - 1);
+        }
+    }
+    if (runningTransition && Transition.sources.has(this)) return this.tValue;
+    return this.value;
+}
+function writeSignal(node, value, isComp) {
+    let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+    if (!node.comparator || !node.comparator(current, value)) {
+        if (Transition) {
+            const TransitionRunning = Transition.running;
+            if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+                Transition.sources.add(node);
+                node.tValue = value;
+            }
+            if (!TransitionRunning) node.value = value;
+        } else node.value = value;
+        if (node.observers && node.observers.length) runUpdates(()=>{
+            for(let i = 0; i < node.observers.length; i += 1){
+                const o = node.observers[i];
+                const TransitionRunning = Transition && Transition.running;
+                if (TransitionRunning && Transition.disposed.has(o)) continue;
+                if (TransitionRunning ? !o.tState : !o.state) {
+                    if (o.pure) Updates.push(o);
+                    else Effects.push(o);
+                    if (o.observers) markDownstream(o);
+                }
+                if (!TransitionRunning) o.state = STALE;
+                else o.tState = STALE;
+            }
+            if (Updates.length > 10e5) {
+                Updates = [];
+                IS_DEV;
+                throw new Error();
+            }
+        }, false);
+    }
+    return value;
+}
+function updateComputation(node) {
+    if (!node.fn) return;
+    cleanNode(node);
+    const time = ExecCount;
+    runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
+    if (Transition && !Transition.running && Transition.sources.has(node)) queueMicrotask(()=>{
+        runUpdates(()=>{
+            Transition && (Transition.running = true);
+            Listener = Owner = node;
+            runComputation(node, node.tValue, time);
+            Listener = Owner = null;
+        }, false);
+    });
+}
+function runComputation(node, value, time) {
+    let nextValue;
+    const owner = Owner, listener = Listener;
+    Listener = Owner = node;
+    try {
+        nextValue = node.fn(value);
+    } catch (err) {
+        if (node.pure) {
+            if (Transition && Transition.running) {
+                node.tState = STALE;
+                node.tOwned && node.tOwned.forEach(cleanNode);
+                node.tOwned = undefined;
+            } else {
+                node.state = STALE;
+                node.owned && node.owned.forEach(cleanNode);
+                node.owned = null;
+            }
+        }
+        node.updatedAt = time + 1;
+        return handleError(err);
+    } finally{
+        Listener = listener;
+        Owner = owner;
+    }
+    if (!node.updatedAt || node.updatedAt <= time) {
+        if (node.updatedAt != null && "observers" in node) writeSignal(node, nextValue, true);
+        else if (Transition && Transition.running && node.pure) {
+            Transition.sources.add(node);
+            node.tValue = nextValue;
+        } else node.value = nextValue;
+        node.updatedAt = time;
+    }
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+    const c = {
+        fn,
+        state: state,
+        updatedAt: null,
+        owned: null,
+        sources: null,
+        sourceSlots: null,
+        cleanups: null,
+        value: init,
+        owner: Owner,
+        context: Owner ? Owner.context : null,
+        pure
+    };
+    if (Transition && Transition.running) {
+        c.state = 0;
+        c.tState = state;
+    }
+    if (Owner === null) ;
+    else if (Owner !== UNOWNED) {
+        if (Transition && Transition.running && Owner.pure) {
+            if (!Owner.tOwned) Owner.tOwned = [
+                c
+            ];
+            else Owner.tOwned.push(c);
+        } else if (!Owner.owned) Owner.owned = [
+            c
+        ];
+        else Owner.owned.push(c);
+    }
+    if (ExternalSourceConfig && c.fn) {
+        const [track, trigger] = createSignal(undefined, {
+            equals: false
+        });
+        const ordinary = ExternalSourceConfig.factory(c.fn, trigger);
+        onCleanup(()=>ordinary.dispose());
+        const triggerInTransition = ()=>startTransition(trigger).then(()=>inTransition.dispose());
+        const inTransition = ExternalSourceConfig.factory(c.fn, triggerInTransition);
+        c.fn = (x)=>{
+            track();
+            return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
+        };
+    }
+    return c;
+}
+function runTop(node) {
+    const runningTransition = Transition && Transition.running;
+    if ((runningTransition ? node.tState : node.state) === 0) return;
+    if ((runningTransition ? node.tState : node.state) === PENDING) return lookUpstream(node);
+    if (node.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
+    const ancestors = [
+        node
+    ];
+    while((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)){
+        if (runningTransition && Transition.disposed.has(node)) return;
+        if (runningTransition ? node.tState : node.state) ancestors.push(node);
+    }
+    for(let i = ancestors.length - 1; i >= 0; i--){
+        node = ancestors[i];
+        if (runningTransition) {
+            let top = node, prev = ancestors[i + 1];
+            while((top = top.owner) && top !== prev){
+                if (Transition.disposed.has(top)) return;
+            }
+        }
+        if ((runningTransition ? node.tState : node.state) === STALE) updateComputation(node);
+        else if ((runningTransition ? node.tState : node.state) === PENDING) {
+            const updates = Updates;
+            Updates = null;
+            runUpdates(()=>lookUpstream(node, ancestors[0]), false);
+            Updates = updates;
+        }
+    }
+}
+function runUpdates(fn, init) {
+    if (Updates) return fn();
+    let wait = false;
+    if (!init) Updates = [];
+    if (Effects) wait = true;
+    else Effects = [];
+    ExecCount++;
+    try {
+        const res = fn();
+        completeUpdates(wait);
+        return res;
+    } catch (err) {
+        if (!wait) Effects = null;
+        Updates = null;
+        handleError(err);
+    }
+}
+function completeUpdates(wait) {
+    if (Updates) {
+        if (Scheduler && Transition && Transition.running) scheduleQueue(Updates);
+        else runQueue(Updates);
+        Updates = null;
+    }
+    if (wait) return;
+    let res;
+    if (Transition) {
+        if (!Transition.promises.size && !Transition.queue.size) {
+            const sources = Transition.sources;
+            const disposed = Transition.disposed;
+            Effects.push.apply(Effects, Transition.effects);
+            res = Transition.resolve;
+            for (const e of Effects){
+                "tState" in e && (e.state = e.tState);
+                delete e.tState;
+            }
+            Transition = null;
+            runUpdates(()=>{
+                for (const d of disposed)cleanNode(d);
+                for (const v of sources){
+                    v.value = v.tValue;
+                    if (v.owned) for(let i = 0, len = v.owned.length; i < len; i++)cleanNode(v.owned[i]);
+                    if (v.tOwned) v.owned = v.tOwned;
+                    delete v.tValue;
+                    delete v.tOwned;
+                    v.tState = 0;
+                }
+                setTransPending(false);
+            }, false);
+        } else if (Transition.running) {
+            Transition.running = false;
+            Transition.effects.push.apply(Transition.effects, Effects);
+            Effects = null;
+            setTransPending(true);
+            return;
+        }
+    }
+    const e = Effects;
+    Effects = null;
+    if (e.length) runUpdates(()=>runEffects(e), false);
+    if (res) res();
+}
+function runQueue(queue) {
+    for(let i = 0; i < queue.length; i++)runTop(queue[i]);
+}
+function scheduleQueue(queue) {
+    for(let i = 0; i < queue.length; i++){
+        const item = queue[i];
+        const tasks = Transition.queue;
+        if (!tasks.has(item)) {
+            tasks.add(item);
+            Scheduler(()=>{
+                tasks.delete(item);
+                runUpdates(()=>{
+                    Transition.running = true;
+                    runTop(item);
+                }, false);
+                Transition && (Transition.running = false);
+            });
+        }
+    }
+}
+function runUserEffects(queue) {
+    let i, userLength = 0;
+    for(i = 0; i < queue.length; i++){
+        const e = queue[i];
+        if (!e.user) runTop(e);
+        else queue[userLength++] = e;
+    }
+    if (sharedConfig.context) {
+        if (sharedConfig.count) {
+            sharedConfig.effects || (sharedConfig.effects = []);
+            sharedConfig.effects.push(...queue.slice(0, userLength));
+            return;
+        }
+        setHydrateContext();
+    }
+    if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
+        queue = [
+            ...sharedConfig.effects,
+            ...queue
+        ];
+        userLength += sharedConfig.effects.length;
+        delete sharedConfig.effects;
+    }
+    for(i = 0; i < userLength; i++)runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+    const runningTransition = Transition && Transition.running;
+    if (runningTransition) node.tState = 0;
+    else node.state = 0;
+    for(let i = 0; i < node.sources.length; i += 1){
+        const source = node.sources[i];
+        if (source.sources) {
+            const state = runningTransition ? source.tState : source.state;
+            if (state === STALE) {
+                if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount)) runTop(source);
+            } else if (state === PENDING) lookUpstream(source, ignore);
+        }
+    }
+}
+function markDownstream(node) {
+    const runningTransition = Transition && Transition.running;
+    for(let i = 0; i < node.observers.length; i += 1){
+        const o = node.observers[i];
+        if (runningTransition ? !o.tState : !o.state) {
+            if (runningTransition) o.tState = PENDING;
+            else o.state = PENDING;
+            if (o.pure) Updates.push(o);
+            else Effects.push(o);
+            o.observers && markDownstream(o);
+        }
+    }
+}
+function cleanNode(node) {
+    let i;
+    if (node.sources) while(node.sources.length){
+        const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+        if (obs && obs.length) {
+            const n = obs.pop(), s = source.observerSlots.pop();
+            if (index < obs.length) {
+                n.sourceSlots[s] = index;
+                obs[index] = n;
+                source.observerSlots[index] = s;
+            }
+        }
+    }
+    if (node.tOwned) {
+        for(i = node.tOwned.length - 1; i >= 0; i--)cleanNode(node.tOwned[i]);
+        delete node.tOwned;
+    }
+    if (Transition && Transition.running && node.pure) reset(node, true);
+    else if (node.owned) {
+        for(i = node.owned.length - 1; i >= 0; i--)cleanNode(node.owned[i]);
+        node.owned = null;
+    }
+    if (node.cleanups) {
+        for(i = node.cleanups.length - 1; i >= 0; i--)node.cleanups[i]();
+        node.cleanups = null;
+    }
+    if (Transition && Transition.running) node.tState = 0;
+    else node.state = 0;
+}
+function reset(node, top) {
+    if (!top) {
+        node.tState = 0;
+        Transition.disposed.add(node);
+    }
+    if (node.owned) for(let i = 0; i < node.owned.length; i++)reset(node.owned[i]);
+}
+function castError(err) {
+    if (err instanceof Error) return err;
+    return new Error(typeof err === "string" ? err : "Unknown error", {
+        cause: err
+    });
+}
+function runErrors(err, fns, owner) {
+    try {
+        for (const f of fns)f(err);
+    } catch (e) {
+        handleError(e, owner && owner.owner || null);
+    }
+}
+function handleError(err, owner = Owner) {
+    const fns = ERROR && owner && owner.context && owner.context[ERROR];
+    const error = castError(err);
+    if (!fns) throw error;
+    if (Effects) Effects.push({
+        fn () {
+            runErrors(error, fns, owner);
+        },
+        state: STALE
+    });
+    else runErrors(error, fns, owner);
+}
+function resolveChildren(children) {
+    if (typeof children === "function" && !children.length) return resolveChildren(children());
+    if (Array.isArray(children)) {
+        const results = [];
+        for(let i = 0; i < children.length; i++){
+            const result = resolveChildren(children[i]);
+            Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+        }
+        return results;
+    }
+    return children;
+}
+function createProvider(id, options) {
+    return function provider(props) {
+        let res;
+        createRenderEffect(()=>res = untrack(()=>{
+                Owner.context = {
+                    ...Owner.context,
+                    [id]: props.value
+                };
+                return children(()=>props.children);
+            }), undefined);
+        return res;
+    };
+}
+function onError(fn) {
+    ERROR || (ERROR = Symbol("error"));
+    if (Owner === null) ;
+    else if (Owner.context === null || !Owner.context[ERROR]) {
+        Owner.context = {
+            ...Owner.context,
+            [ERROR]: [
+                fn
+            ]
+        };
+        mutateContext(Owner, ERROR, [
+            fn
+        ]);
+    } else Owner.context[ERROR].push(fn);
+}
+function mutateContext(o, key, value) {
+    if (o.owned) for(let i = 0; i < o.owned.length; i++){
+        if (o.owned[i].context === o.context) mutateContext(o.owned[i], key, value);
+        if (!o.owned[i].context) {
+            o.owned[i].context = o.context;
+            mutateContext(o.owned[i], key, value);
+        } else if (!o.owned[i].context[key]) {
+            o.owned[i].context[key] = value;
+            mutateContext(o.owned[i], key, value);
+        }
+    }
+}
+function observable(input) {
+    return {
+        subscribe (observer) {
+            if (!(observer instanceof Object) || observer == null) throw new TypeError("Expected the observer to be an object.");
+            const handler = typeof observer === "function" ? observer : observer.next && observer.next.bind(observer);
+            if (!handler) return {
+                unsubscribe () {}
+            };
+            const dispose = createRoot((disposer)=>{
+                createEffect(()=>{
+                    const v = input();
+                    untrack(()=>handler(v));
+                });
+                return disposer;
+            });
+            if (getOwner()) onCleanup(dispose);
+            return {
+                unsubscribe () {
+                    dispose();
+                }
+            };
+        },
+        [Symbol.observable || "@@observable"] () {
+            return this;
+        }
+    };
+}
+function from(producer, initalValue) {
+    const [s, set] = createSignal(initalValue, {
+        equals: false
+    });
+    if ("subscribe" in producer) {
+        const unsub = producer.subscribe((v)=>set(()=>v));
+        onCleanup(()=>"unsubscribe" in unsub ? unsub.unsubscribe() : unsub());
+    } else {
+        const clean = producer(set);
+        onCleanup(clean);
+    }
+    return s;
+}
+const FALLBACK = Symbol("fallback");
+function dispose(d) {
+    for(let i = 0; i < d.length; i++)d[i]();
+}
+function mapArray(list, mapFn, options = {}) {
+    let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
+    onCleanup(()=>dispose(disposers));
+    return ()=>{
+        let newItems = list() || [], newLen = newItems.length, i, j;
+        newItems[$TRACK];
+        return untrack(()=>{
+            let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
+            if (newLen === 0) {
+                if (len !== 0) {
+                    dispose(disposers);
+                    disposers = [];
+                    items = [];
+                    mapped = [];
+                    len = 0;
+                    indexes && (indexes = []);
+                }
+                if (options.fallback) {
+                    items = [
+                        FALLBACK
+                    ];
+                    mapped[0] = createRoot((disposer)=>{
+                        disposers[0] = disposer;
+                        return options.fallback();
+                    });
+                    len = 1;
+                }
+            } else if (len === 0) {
+                mapped = new Array(newLen);
+                for(j = 0; j < newLen; j++){
+                    items[j] = newItems[j];
+                    mapped[j] = createRoot(mapper);
+                }
+                len = newLen;
+            } else {
+                temp = new Array(newLen);
+                tempdisposers = new Array(newLen);
+                indexes && (tempIndexes = new Array(newLen));
+                for(start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++);
+                for(end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--){
+                    temp[newEnd] = mapped[end];
+                    tempdisposers[newEnd] = disposers[end];
+                    indexes && (tempIndexes[newEnd] = indexes[end]);
+                }
+                newIndices = new Map();
+                newIndicesNext = new Array(newEnd + 1);
+                for(j = newEnd; j >= start; j--){
+                    item = newItems[j];
+                    i = newIndices.get(item);
+                    newIndicesNext[j] = i === undefined ? -1 : i;
+                    newIndices.set(item, j);
+                }
+                for(i = start; i <= end; i++){
+                    item = items[i];
+                    j = newIndices.get(item);
+                    if (j !== undefined && j !== -1) {
+                        temp[j] = mapped[i];
+                        tempdisposers[j] = disposers[i];
+                        indexes && (tempIndexes[j] = indexes[i]);
+                        j = newIndicesNext[j];
+                        newIndices.set(item, j);
+                    } else disposers[i]();
+                }
+                for(j = start; j < newLen; j++)if (j in temp) {
+                    mapped[j] = temp[j];
+                    disposers[j] = tempdisposers[j];
+                    if (indexes) {
+                        indexes[j] = tempIndexes[j];
+                        indexes[j](j);
+                    }
+                } else mapped[j] = createRoot(mapper);
+                mapped = mapped.slice(0, len = newLen);
+                items = newItems.slice(0);
+            }
+            return mapped;
+        });
+        function mapper(disposer) {
+            disposers[j] = disposer;
+            if (indexes) {
+                const [s, set] = createSignal(j);
+                indexes[j] = set;
+                return mapFn(newItems[j], s);
+            }
+            return mapFn(newItems[j]);
+        }
+    };
+}
+function indexArray(list, mapFn, options = {}) {
+    let items = [], mapped = [], disposers = [], signals = [], len = 0, i;
+    onCleanup(()=>dispose(disposers));
+    return ()=>{
+        const newItems = list() || [], newLen = newItems.length;
+        newItems[$TRACK];
+        return untrack(()=>{
+            if (newLen === 0) {
+                if (len !== 0) {
+                    dispose(disposers);
+                    disposers = [];
+                    items = [];
+                    mapped = [];
+                    len = 0;
+                    signals = [];
+                }
+                if (options.fallback) {
+                    items = [
+                        FALLBACK
+                    ];
+                    mapped[0] = createRoot((disposer)=>{
+                        disposers[0] = disposer;
+                        return options.fallback();
+                    });
+                    len = 1;
+                }
+                return mapped;
+            }
+            if (items[0] === FALLBACK) {
+                disposers[0]();
+                disposers = [];
+                items = [];
+                mapped = [];
+                len = 0;
+            }
+            for(i = 0; i < newLen; i++){
+                if (i < items.length && items[i] !== newItems[i]) signals[i](()=>newItems[i]);
+                else if (i >= items.length) mapped[i] = createRoot(mapper);
+            }
+            for(; i < items.length; i++)disposers[i]();
+            len = signals.length = disposers.length = newLen;
+            items = newItems.slice(0);
+            return mapped = mapped.slice(0, len);
+        });
+        function mapper(disposer) {
+            disposers[i] = disposer;
+            const [s, set] = createSignal(newItems[i]);
+            signals[i] = set;
+            return mapFn(s, i);
+        }
+    };
+}
+let hydrationEnabled = false;
+function enableHydration() {
+    hydrationEnabled = true;
+}
+function createComponent(Comp, props) {
+    if (hydrationEnabled) {
+        if (sharedConfig.context) {
+            const c = sharedConfig.context;
+            setHydrateContext(nextHydrateContext());
+            const r = untrack(()=>Comp(props || {}));
+            setHydrateContext(c);
+            return r;
+        }
+    }
+    return untrack(()=>Comp(props || {}));
+}
+function trueFn() {
+    return true;
+}
+const propTraps = {
+    get (_, property, receiver) {
+        if (property === $PROXY) return receiver;
+        return _.get(property);
+    },
+    has (_, property) {
+        if (property === $PROXY) return true;
+        return _.has(property);
+    },
+    set: trueFn,
+    deleteProperty: trueFn,
+    getOwnPropertyDescriptor (_, property) {
+        return {
+            configurable: true,
+            enumerable: true,
+            get () {
+                return _.get(property);
+            },
+            set: trueFn,
+            deleteProperty: trueFn
+        };
+    },
+    ownKeys (_) {
+        return _.keys();
+    }
+};
+function resolveSource(s) {
+    return !(s = typeof s === "function" ? s() : s) ? {} : s;
+}
+function resolveSources() {
+    for(let i = 0, length = this.length; i < length; ++i){
+        const v = this[i]();
+        if (v !== undefined) return v;
+    }
+}
+function mergeProps(...sources) {
+    let proxy = false;
+    for(let i = 0; i < sources.length; i++){
+        const s = sources[i];
+        proxy = proxy || !!s && $PROXY in s;
+        sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
+    }
+    if (SUPPORTS_PROXY && proxy) return new Proxy({
+        get (property) {
+            for(let i = sources.length - 1; i >= 0; i--){
+                const v = resolveSource(sources[i])[property];
+                if (v !== undefined) return v;
+            }
+        },
+        has (property) {
+            for(let i = sources.length - 1; i >= 0; i--){
+                if (property in resolveSource(sources[i])) return true;
+            }
+            return false;
+        },
+        keys () {
+            const keys = [];
+            for(let i = 0; i < sources.length; i++)keys.push(...Object.keys(resolveSource(sources[i])));
+            return [
+                ...new Set(keys)
+            ];
+        }
+    }, propTraps);
+    const sourcesMap = {};
+    const defined = Object.create(null);
+    for(let i = sources.length - 1; i >= 0; i--){
+        const source = sources[i];
+        if (!source) continue;
+        const sourceKeys = Object.getOwnPropertyNames(source);
+        for(let i = sourceKeys.length - 1; i >= 0; i--){
+            const key = sourceKeys[i];
+            if (key === "__proto__" || key === "constructor") continue;
+            const desc = Object.getOwnPropertyDescriptor(source, key);
+            if (!defined[key]) defined[key] = desc.get ? {
+                enumerable: true,
+                configurable: true,
+                get: resolveSources.bind(sourcesMap[key] = [
+                    desc.get.bind(source)
+                ])
+            } : desc.value !== undefined ? desc : undefined;
+            else {
+                const sources = sourcesMap[key];
+                if (sources) {
+                    if (desc.get) sources.push(desc.get.bind(source));
+                    else if (desc.value !== undefined) sources.push(()=>desc.value);
+                }
+            }
+        }
+    }
+    const target = {};
+    const definedKeys = Object.keys(defined);
+    for(let i = definedKeys.length - 1; i >= 0; i--){
+        const key = definedKeys[i], desc = defined[key];
+        if (desc && desc.get) Object.defineProperty(target, key, desc);
+        else target[key] = desc ? desc.value : undefined;
+    }
+    return target;
+}
+function splitProps(props, ...keys) {
+    if (SUPPORTS_PROXY && $PROXY in props) {
+        const blocked = new Set(keys.length > 1 ? keys.flat() : keys[0]);
+        const res = keys.map((k)=>{
+            return new Proxy({
+                get (property) {
+                    return k.includes(property) ? props[property] : undefined;
+                },
+                has (property) {
+                    return k.includes(property) && property in props;
+                },
+                keys () {
+                    return k.filter((property)=>property in props);
+                }
+            }, propTraps);
+        });
+        res.push(new Proxy({
+            get (property) {
+                return blocked.has(property) ? undefined : props[property];
+            },
+            has (property) {
+                return blocked.has(property) ? false : property in props;
+            },
+            keys () {
+                return Object.keys(props).filter((k)=>!blocked.has(k));
+            }
+        }, propTraps));
+        return res;
+    }
+    const otherObject = {};
+    const objects = keys.map(()=>({}));
+    for (const propName of Object.getOwnPropertyNames(props)){
+        const desc = Object.getOwnPropertyDescriptor(props, propName);
+        const isDefaultDesc = !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable;
+        let blocked = false;
+        let objectIndex = 0;
+        for (const k of keys){
+            if (k.includes(propName)) {
+                blocked = true;
+                isDefaultDesc ? objects[objectIndex][propName] = desc.value : Object.defineProperty(objects[objectIndex], propName, desc);
+            }
+            ++objectIndex;
+        }
+        if (!blocked) isDefaultDesc ? otherObject[propName] = desc.value : Object.defineProperty(otherObject, propName, desc);
+    }
+    return [
+        ...objects,
+        otherObject
+    ];
+}
+function lazy(fn) {
+    let comp;
+    let p;
+    const wrap = (props)=>{
+        const ctx = sharedConfig.context;
+        if (ctx) {
+            const [s, set] = createSignal();
+            sharedConfig.count || (sharedConfig.count = 0);
+            sharedConfig.count++;
+            (p || (p = fn())).then((mod)=>{
+                !sharedConfig.done && setHydrateContext(ctx);
+                sharedConfig.count--;
+                set(()=>mod.default);
+                setHydrateContext();
+            });
+            comp = s;
+        } else if (!comp) {
+            const [s] = createResource(()=>(p || (p = fn())).then((mod)=>mod.default));
+            comp = s;
+        }
+        let Comp;
+        return createMemo(()=>(Comp = comp()) ? untrack(()=>{
+                IS_DEV;
+                if (!ctx || sharedConfig.done) return Comp(props);
+                const c = sharedConfig.context;
+                setHydrateContext(ctx);
+                const r = Comp(props);
+                setHydrateContext(c);
+                return r;
+            }) : "");
+    };
+    wrap.preload = ()=>p || ((p = fn()).then((mod)=>comp = ()=>mod.default), p);
+    return wrap;
+}
+let counter = 0;
+function createUniqueId() {
+    const ctx = sharedConfig.context;
+    return ctx ? sharedConfig.getNextContextId() : `cl-${counter++}`;
+}
+const narrowedError = (name)=>`Stale read from <${name}>.`;
+function For(props) {
+    const fallback = "fallback" in props && {
+        fallback: ()=>props.fallback
+    };
+    return createMemo(mapArray(()=>props.each, props.children, fallback || undefined));
+}
+function Index(props) {
+    const fallback = "fallback" in props && {
+        fallback: ()=>props.fallback
+    };
+    return createMemo(indexArray(()=>props.each, props.children, fallback || undefined));
+}
+function Show(props) {
+    const keyed = props.keyed;
+    const conditionValue = createMemo(()=>props.when, undefined, undefined);
+    const condition = keyed ? conditionValue : createMemo(conditionValue, undefined, {
+        equals: (a, b)=>!a === !b
+    });
+    return createMemo(()=>{
+        const c = condition();
+        if (c) {
+            const child = props.children;
+            const fn = typeof child === "function" && child.length > 0;
+            return fn ? untrack(()=>child(keyed ? c : ()=>{
+                    if (!untrack(condition)) throw narrowedError("Show");
+                    return conditionValue();
+                })) : child;
+        }
+        return props.fallback;
+    }, undefined, undefined);
+}
+function Switch(props) {
+    const chs = children(()=>props.children);
+    const switchFunc = createMemo(()=>{
+        const ch = chs();
+        const mps = Array.isArray(ch) ? ch : [
+            ch
+        ];
+        let func = ()=>undefined;
+        for(let i = 0; i < mps.length; i++){
+            const index = i;
+            const mp = mps[i];
+            const prevFunc = func;
+            const conditionValue = createMemo(()=>prevFunc() ? undefined : mp.when, undefined, undefined);
+            const condition = mp.keyed ? conditionValue : createMemo(conditionValue, undefined, {
+                equals: (a, b)=>!a === !b
+            });
+            func = ()=>prevFunc() || (condition() ? [
+                    index,
+                    conditionValue,
+                    mp
+                ] : undefined);
+        }
+        return func;
+    });
+    return createMemo(()=>{
+        const sel = switchFunc()();
+        if (!sel) return props.fallback;
+        const [index, conditionValue, mp] = sel;
+        const child = mp.children;
+        const fn = typeof child === "function" && child.length > 0;
+        return fn ? untrack(()=>child(mp.keyed ? conditionValue() : ()=>{
+                if (untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
+                return conditionValue();
+            })) : child;
+    }, undefined, undefined);
+}
+function Match(props) {
+    return props;
+}
+let Errors;
+function resetErrorBoundaries() {
+    Errors && [
+        ...Errors
+    ].forEach((fn)=>fn());
+}
+function ErrorBoundary(props) {
+    let err;
+    if (sharedConfig.context && sharedConfig.load) err = sharedConfig.load(sharedConfig.getContextId());
+    const [errored, setErrored] = createSignal(err, undefined);
+    Errors || (Errors = new Set());
+    Errors.add(setErrored);
+    onCleanup(()=>Errors.delete(setErrored));
+    return createMemo(()=>{
+        let e;
+        if (e = errored()) {
+            const f = props.fallback;
+            return typeof f === "function" && f.length ? untrack(()=>f(e, ()=>setErrored())) : f;
+        }
+        return catchError(()=>props.children, setErrored);
+    }, undefined, undefined);
+}
+const suspenseListEquals = (a, b)=>a.showContent === b.showContent && a.showFallback === b.showFallback;
+const SuspenseListContext = /* #__PURE__ */ createContext();
+function SuspenseList(props) {
+    let [wrapper, setWrapper] = createSignal(()=>({
+            inFallback: false
+        })), show;
+    const listContext = useContext(SuspenseListContext);
+    const [registry, setRegistry] = createSignal([]);
+    if (listContext) show = listContext.register(createMemo(()=>wrapper()().inFallback));
+    const resolved = createMemo((prev)=>{
+        const reveal = props.revealOrder, tail = props.tail, { showContent = true, showFallback = true } = show ? show() : {}, reg = registry(), reverse = reveal === "backwards";
+        if (reveal === "together") {
+            const all = reg.every((inFallback)=>!inFallback());
+            const res = reg.map(()=>({
+                    showContent: all && showContent,
+                    showFallback
+                }));
+            res.inFallback = !all;
+            return res;
+        }
+        let stop = false;
+        let inFallback = prev.inFallback;
+        const res = [];
+        for(let i = 0, len = reg.length; i < len; i++){
+            const n = reverse ? len - i - 1 : i, s = reg[n]();
+            if (!stop && !s) res[n] = {
+                showContent,
+                showFallback
+            };
+            else {
+                const next = !stop;
+                if (next) inFallback = true;
+                res[n] = {
+                    showContent: next,
+                    showFallback: !tail || next && tail === "collapsed" ? showFallback : false
+                };
+                stop = true;
+            }
+        }
+        if (!stop) inFallback = false;
+        res.inFallback = inFallback;
+        return res;
+    }, {
+        inFallback: false
+    });
+    setWrapper(()=>resolved);
+    return createComponent(SuspenseListContext.Provider, {
+        value: {
+            register: (inFallback)=>{
+                let index;
+                setRegistry((registry)=>{
+                    index = registry.length;
+                    return [
+                        ...registry,
+                        inFallback
+                    ];
+                });
+                return createMemo(()=>resolved()[index], undefined, {
+                    equals: suspenseListEquals
+                });
+            }
+        },
+        get children () {
+            return props.children;
+        }
+    });
+}
+function Suspense(props) {
+    let counter = 0, show, ctx, p, flicker, error;
+    const [inFallback, setFallback] = createSignal(false), SuspenseContext = getSuspenseContext(), store = {
+        increment: ()=>{
+            if (++counter === 1) setFallback(true);
+        },
+        decrement: ()=>{
+            if (--counter === 0) setFallback(false);
+        },
+        inFallback,
+        effects: [],
+        resolved: false
+    }, owner = getOwner();
+    if (sharedConfig.context && sharedConfig.load) {
+        const key = sharedConfig.getContextId();
+        let ref = sharedConfig.load(key);
+        if (ref) {
+            if (typeof ref !== "object" || ref.status !== "success") p = ref;
+            else sharedConfig.gather(key);
+        }
+        if (p && p !== "$$f") {
+            const [s, set] = createSignal(undefined, {
+                equals: false
+            });
+            flicker = s;
+            p.then(()=>{
+                if (sharedConfig.done) return set();
+                sharedConfig.gather(key);
+                setHydrateContext(ctx);
+                set();
+                setHydrateContext();
+            }, (err)=>{
+                error = err;
+                set();
+            });
+        }
+    }
+    const listContext = useContext(SuspenseListContext);
+    if (listContext) show = listContext.register(store.inFallback);
+    let dispose;
+    onCleanup(()=>dispose && dispose());
+    return createComponent(SuspenseContext.Provider, {
+        value: store,
+        get children () {
+            return createMemo(()=>{
+                if (error) throw error;
+                ctx = sharedConfig.context;
+                if (flicker) {
+                    flicker();
+                    return flicker = undefined;
+                }
+                if (ctx && p === "$$f") setHydrateContext();
+                const rendered = createMemo(()=>props.children);
+                return createMemo((prev)=>{
+                    const inFallback = store.inFallback(), { showContent = true, showFallback = true } = show ? show() : {};
+                    if ((!inFallback || p && p !== "$$f") && showContent) {
+                        store.resolved = true;
+                        dispose && dispose();
+                        dispose = ctx = p = undefined;
+                        resumeEffects(store.effects);
+                        return rendered();
+                    }
+                    if (!showFallback) return;
+                    if (dispose) return prev;
+                    return createRoot((disposer)=>{
+                        dispose = disposer;
+                        if (ctx) {
+                            setHydrateContext({
+                                id: ctx.id + "F",
+                                count: 0
+                            });
+                            ctx = undefined;
+                        }
+                        return props.fallback;
+                    }, owner);
+                });
+            });
+        }
+    });
+}
+const DEV = undefined;
+
+}),
+"7525": (function (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  Dynamic: function() { return Dynamic; },
+  addEventListener: function() { return addEventListener; },
+  className: function() { return className; },
+  createComponent: function() { return solid_js__WEBPACK_IMPORTED_MODULE_0__.createComponent; },
+  delegateEvents: function() { return delegateEvents; },
+  effect: function() { return solid_js__WEBPACK_IMPORTED_MODULE_0__.createRenderEffect; },
+  insert: function() { return insert; },
+  memo: function() { return memo; },
+  mergeProps: function() { return solid_js__WEBPACK_IMPORTED_MODULE_0__.mergeProps; },
+  setAttribute: function() { return setAttribute; },
+  spread: function() { return spread; },
+  style: function() { return style; },
+  template: function() { return template; },
+  use: function() { return use; }
+});
+/* harmony import */var solid_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! solid-js */"5666");
+
+
+const booleans = [
+    "allowfullscreen",
+    "async",
+    "autofocus",
+    "autoplay",
+    "checked",
+    "controls",
+    "default",
+    "disabled",
+    "formnovalidate",
+    "hidden",
+    "indeterminate",
+    "inert",
+    "ismap",
+    "loop",
+    "multiple",
+    "muted",
+    "nomodule",
+    "novalidate",
+    "open",
+    "playsinline",
+    "readonly",
+    "required",
+    "reversed",
+    "seamless",
+    "selected"
+];
+const Properties = /*#__PURE__*/ new Set([
+    "className",
+    "value",
+    "readOnly",
+    "noValidate",
+    "formNoValidate",
+    "isMap",
+    "noModule",
+    "playsInline",
+    ...booleans
+]);
+const ChildProperties = /*#__PURE__*/ new Set([
+    "innerHTML",
+    "textContent",
+    "innerText",
+    "children"
+]);
+const Aliases = /*#__PURE__*/ Object.assign(Object.create(null), {
+    className: "class",
+    htmlFor: "for"
+});
+const PropAliases = /*#__PURE__*/ Object.assign(Object.create(null), {
+    class: "className",
+    novalidate: {
+        $: "noValidate",
+        FORM: 1
+    },
+    formnovalidate: {
+        $: "formNoValidate",
+        BUTTON: 1,
+        INPUT: 1
+    },
+    ismap: {
+        $: "isMap",
+        IMG: 1
+    },
+    nomodule: {
+        $: "noModule",
+        SCRIPT: 1
+    },
+    playsinline: {
+        $: "playsInline",
+        VIDEO: 1
+    },
+    readonly: {
+        $: "readOnly",
+        INPUT: 1,
+        TEXTAREA: 1
+    }
+});
+function getPropAlias(prop, tagName) {
+    const a = PropAliases[prop];
+    return typeof a === "object" ? a[tagName] ? a["$"] : undefined : a;
+}
+const DelegatedEvents = /*#__PURE__*/ new Set([
+    "beforeinput",
+    "click",
+    "dblclick",
+    "contextmenu",
+    "focusin",
+    "focusout",
+    "input",
+    "keydown",
+    "keyup",
+    "mousedown",
+    "mousemove",
+    "mouseout",
+    "mouseover",
+    "mouseup",
+    "pointerdown",
+    "pointermove",
+    "pointerout",
+    "pointerover",
+    "pointerup",
+    "touchend",
+    "touchmove",
+    "touchstart"
+]);
+const SVGElements = /*#__PURE__*/ new Set([
+    "altGlyph",
+    "altGlyphDef",
+    "altGlyphItem",
+    "animate",
+    "animateColor",
+    "animateMotion",
+    "animateTransform",
+    "circle",
+    "clipPath",
+    "color-profile",
+    "cursor",
+    "defs",
+    "desc",
+    "ellipse",
+    "feBlend",
+    "feColorMatrix",
+    "feComponentTransfer",
+    "feComposite",
+    "feConvolveMatrix",
+    "feDiffuseLighting",
+    "feDisplacementMap",
+    "feDistantLight",
+    "feDropShadow",
+    "feFlood",
+    "feFuncA",
+    "feFuncB",
+    "feFuncG",
+    "feFuncR",
+    "feGaussianBlur",
+    "feImage",
+    "feMerge",
+    "feMergeNode",
+    "feMorphology",
+    "feOffset",
+    "fePointLight",
+    "feSpecularLighting",
+    "feSpotLight",
+    "feTile",
+    "feTurbulence",
+    "filter",
+    "font",
+    "font-face",
+    "font-face-format",
+    "font-face-name",
+    "font-face-src",
+    "font-face-uri",
+    "foreignObject",
+    "g",
+    "glyph",
+    "glyphRef",
+    "hkern",
+    "image",
+    "line",
+    "linearGradient",
+    "marker",
+    "mask",
+    "metadata",
+    "missing-glyph",
+    "mpath",
+    "path",
+    "pattern",
+    "polygon",
+    "polyline",
+    "radialGradient",
+    "rect",
+    "set",
+    "stop",
+    "svg",
+    "switch",
+    "symbol",
+    "text",
+    "textPath",
+    "tref",
+    "tspan",
+    "use",
+    "view",
+    "vkern"
+]);
+const SVGNamespace = {
+    xlink: "http://www.w3.org/1999/xlink",
+    xml: "http://www.w3.org/XML/1998/namespace"
+};
+const DOMElements = /*#__PURE__*/ new Set([
+    "html",
+    "base",
+    "head",
+    "link",
+    "meta",
+    "style",
+    "title",
+    "body",
+    "address",
+    "article",
+    "aside",
+    "footer",
+    "header",
+    "main",
+    "nav",
+    "section",
+    "body",
+    "blockquote",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "figcaption",
+    "figure",
+    "hr",
+    "li",
+    "ol",
+    "p",
+    "pre",
+    "ul",
+    "a",
+    "abbr",
+    "b",
+    "bdi",
+    "bdo",
+    "br",
+    "cite",
+    "code",
+    "data",
+    "dfn",
+    "em",
+    "i",
+    "kbd",
+    "mark",
+    "q",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "time",
+    "u",
+    "var",
+    "wbr",
+    "area",
+    "audio",
+    "img",
+    "map",
+    "track",
+    "video",
+    "embed",
+    "iframe",
+    "object",
+    "param",
+    "picture",
+    "portal",
+    "source",
+    "svg",
+    "math",
+    "canvas",
+    "noscript",
+    "script",
+    "del",
+    "ins",
+    "caption",
+    "col",
+    "colgroup",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "tr",
+    "button",
+    "datalist",
+    "fieldset",
+    "form",
+    "input",
+    "label",
+    "legend",
+    "meter",
+    "optgroup",
+    "option",
+    "output",
+    "progress",
+    "select",
+    "textarea",
+    "details",
+    "dialog",
+    "menu",
+    "summary",
+    "details",
+    "slot",
+    "template",
+    "acronym",
+    "applet",
+    "basefont",
+    "bgsound",
+    "big",
+    "blink",
+    "center",
+    "content",
+    "dir",
+    "font",
+    "frame",
+    "frameset",
+    "hgroup",
+    "image",
+    "keygen",
+    "marquee",
+    "menuitem",
+    "nobr",
+    "noembed",
+    "noframes",
+    "plaintext",
+    "rb",
+    "rtc",
+    "shadow",
+    "spacer",
+    "strike",
+    "tt",
+    "xmp",
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "base",
+    "basefont",
+    "bdi",
+    "bdo",
+    "bgsound",
+    "big",
+    "blink",
+    "blockquote",
+    "body",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "cite",
+    "code",
+    "col",
+    "colgroup",
+    "content",
+    "data",
+    "datalist",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "font",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "head",
+    "header",
+    "hgroup",
+    "hr",
+    "html",
+    "i",
+    "iframe",
+    "image",
+    "img",
+    "input",
+    "ins",
+    "kbd",
+    "keygen",
+    "label",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "map",
+    "mark",
+    "marquee",
+    "menu",
+    "menuitem",
+    "meta",
+    "meter",
+    "nav",
+    "nobr",
+    "noembed",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "picture",
+    "plaintext",
+    "portal",
+    "pre",
+    "progress",
+    "q",
+    "rb",
+    "rp",
+    "rt",
+    "rtc",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "section",
+    "select",
+    "shadow",
+    "slot",
+    "small",
+    "source",
+    "spacer",
+    "span",
+    "strike",
+    "strong",
+    "style",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "title",
+    "tr",
+    "track",
+    "tt",
+    "u",
+    "ul",
+    "var",
+    "video",
+    "wbr",
+    "xmp",
+    "input",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6"
+]);
+const memo = (fn)=>(0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createMemo)(()=>fn());
+function reconcileArrays(parentNode, a, b) {
+    let bLength = b.length, aEnd = a.length, bEnd = bLength, aStart = 0, bStart = 0, after = a[aEnd - 1].nextSibling, map = null;
+    while(aStart < aEnd || bStart < bEnd){
+        if (a[aStart] === b[bStart]) {
+            aStart++;
+            bStart++;
+            continue;
+        }
+        while(a[aEnd - 1] === b[bEnd - 1]){
+            aEnd--;
+            bEnd--;
+        }
+        if (aEnd === aStart) {
+            const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] : after;
+            while(bStart < bEnd)parentNode.insertBefore(b[bStart++], node);
+        } else if (bEnd === bStart) while(aStart < aEnd){
+            if (!map || !map.has(a[aStart])) a[aStart].remove();
+            aStart++;
+        }
+        else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+            const node = a[--aEnd].nextSibling;
+            parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling);
+            parentNode.insertBefore(b[--bEnd], node);
+            a[aEnd] = b[bEnd];
+        } else {
+            if (!map) {
+                map = new Map();
+                let i = bStart;
+                while(i < bEnd)map.set(b[i], i++);
+            }
+            const index = map.get(a[aStart]);
+            if (index != null) {
+                if (bStart < index && index < bEnd) {
+                    let i = aStart, sequence = 1, t;
+                    while(++i < aEnd && i < bEnd){
+                        if ((t = map.get(a[i])) == null || t !== index + sequence) break;
+                        sequence++;
+                    }
+                    if (sequence > index - bStart) {
+                        const node = a[aStart];
+                        while(bStart < index)parentNode.insertBefore(b[bStart++], node);
+                    } else parentNode.replaceChild(b[bStart++], a[aStart++]);
+                } else aStart++;
+            } else a[aStart++].remove();
+        }
+    }
+}
+const $$EVENTS = "_$DX_DELEGATE";
+function render(code, element, init, options = {}) {
+    let disposer;
+    /* "solid-js" unused */null((dispose)=>{
+        disposer = dispose;
+        element === document ? code() : insert(element, code(), element.firstChild ? null : undefined, init);
+    }, options.owner);
+    return ()=>{
+        disposer();
+        element.textContent = "";
+    };
+}
+function template(html, isImportNode, isSVG, isMathML) {
+    let node;
+    const create = ()=>{
+        const t = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "template") : document.createElement("template");
+        t.innerHTML = html;
+        return isSVG ? t.content.firstChild.firstChild : isMathML ? t.firstChild : t.content.firstChild;
+    };
+    const fn = isImportNode ? ()=>(0, solid_js__WEBPACK_IMPORTED_MODULE_0__.untrack)(()=>document.importNode(node || (node = create()), true)) : ()=>(node || (node = create())).cloneNode(true);
+    fn.cloneNode = fn;
+    return fn;
+}
+function delegateEvents(eventNames, document1 = window.document) {
+    const e = document1[$$EVENTS] || (document1[$$EVENTS] = new Set());
+    for(let i = 0, l = eventNames.length; i < l; i++){
+        const name = eventNames[i];
+        if (!e.has(name)) {
+            e.add(name);
+            document1.addEventListener(name, eventHandler);
+        }
+    }
+}
+function clearDelegatedEvents(document1 = window.document) {
+    if (document1[$$EVENTS]) {
+        for (let name of document1[$$EVENTS].keys())document1.removeEventListener(name, eventHandler);
+        delete document1[$$EVENTS];
+    }
+}
+function setProperty(node, name, value) {
+    if (isHydrating(node)) return;
+    node[name] = value;
+}
+function setAttribute(node, name, value) {
+    if (isHydrating(node)) return;
+    if (value == null) node.removeAttribute(name);
+    else node.setAttribute(name, value);
+}
+function setAttributeNS(node, namespace, name, value) {
+    if (isHydrating(node)) return;
+    if (value == null) node.removeAttributeNS(namespace, name);
+    else node.setAttributeNS(namespace, name, value);
+}
+function setBoolAttribute(node, name, value) {
+    if (isHydrating(node)) return;
+    value ? node.setAttribute(name, "") : node.removeAttribute(name);
+}
+function className(node, value) {
+    if (isHydrating(node)) return;
+    if (value == null) node.removeAttribute("class");
+    else node.className = value;
+}
+function addEventListener(node, name, handler, delegate) {
+    if (delegate) {
+        if (Array.isArray(handler)) {
+            node[`$$${name}`] = handler[0];
+            node[`$$${name}Data`] = handler[1];
+        } else node[`$$${name}`] = handler;
+    } else if (Array.isArray(handler)) {
+        const handlerFn = handler[0];
+        node.addEventListener(name, handler[0] = (e)=>handlerFn.call(node, handler[1], e));
+    } else node.addEventListener(name, handler, typeof handler !== "function" && handler);
+}
+function classList(node, value, prev = {}) {
+    const classKeys = Object.keys(value || {}), prevKeys = Object.keys(prev);
+    let i, len;
+    for(i = 0, len = prevKeys.length; i < len; i++){
+        const key = prevKeys[i];
+        if (!key || key === "undefined" || value[key]) continue;
+        toggleClassKey(node, key, false);
+        delete prev[key];
+    }
+    for(i = 0, len = classKeys.length; i < len; i++){
+        const key = classKeys[i], classValue = !!value[key];
+        if (!key || key === "undefined" || prev[key] === classValue || !classValue) continue;
+        toggleClassKey(node, key, true);
+        prev[key] = classValue;
+    }
+    return prev;
+}
+function style(node, value, prev) {
+    if (!value) return prev ? setAttribute(node, "style") : value;
+    const nodeStyle = node.style;
+    if (typeof value === "string") return nodeStyle.cssText = value;
+    typeof prev === "string" && (nodeStyle.cssText = prev = undefined);
+    prev || (prev = {});
+    value || (value = {});
+    let v, s;
+    for(s in prev){
+        value[s] == null && nodeStyle.removeProperty(s);
+        delete prev[s];
+    }
+    for(s in value){
+        v = value[s];
+        if (v !== prev[s]) {
+            nodeStyle.setProperty(s, v);
+            prev[s] = v;
+        }
+    }
+    return prev;
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+    const prevProps = {};
+    if (!skipChildren) (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createRenderEffect)(()=>prevProps.children = insertExpression(node, props.children, prevProps.children));
+    (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createRenderEffect)(()=>typeof props.ref === "function" && use(props.ref, node));
+    (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createRenderEffect)(()=>assign(node, props, isSVG, true, prevProps, true));
+    return prevProps;
+}
+function dynamicProperty(props, key) {
+    const src = props[key];
+    Object.defineProperty(props, key, {
+        get () {
+            return src();
+        },
+        enumerable: true
+    });
+    return props;
+}
+function use(fn, element, arg) {
+    return (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.untrack)(()=>fn(element, arg));
+}
+function insert(parent, accessor, marker, initial) {
+    if (marker !== undefined && !initial) initial = [];
+    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+    (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createRenderEffect)((current)=>insertExpression(parent, accessor(), current, marker), initial);
+}
+function assign(node, props, isSVG, skipChildren, prevProps = {}, skipRef = false) {
+    props || (props = {});
+    for(const prop in prevProps)if (!(prop in props)) {
+        if (prop === "children") continue;
+        prevProps[prop] = assignProp(node, prop, null, prevProps[prop], isSVG, skipRef, props);
+    }
+    for(const prop in props){
+        if (prop === "children") {
+            if (!skipChildren) insertExpression(node, props.children);
+            continue;
+        }
+        const value = props[prop];
+        prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG, skipRef, props);
+    }
+}
+function hydrate$1(code, element, options = {}) {
+    if (globalThis._$HY.done) return render(code, element, [
+        ...element.childNodes
+    ], options);
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.completed = globalThis._$HY.completed;
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.events = globalThis._$HY.events;
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.load = (id)=>globalThis._$HY.r[id];
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.has = (id)=>id in globalThis._$HY.r;
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.gather = (root)=>gatherHydratable(element, root);
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.registry = new Map();
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.context = {
+        id: options.renderId || "",
+        count: 0
+    };
+    try {
+        gatherHydratable(element, options.renderId);
+        return render(code, element, [
+            ...element.childNodes
+        ], options);
+    } finally{
+        solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.context = null;
+    }
+}
+function getNextElement(template) {
+    let node, key, hydrating = isHydrating();
+    if (!hydrating || !(node = solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.registry.get(key = getHydrationKey()))) return template();
+    if (solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.completed) solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.completed.add(node);
+    solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.registry["delete"](key);
+    return node;
+}
+function getNextMatch(el, nodeName) {
+    while(el && el.localName !== nodeName)el = el.nextSibling;
+    return el;
+}
+function getNextMarker(start) {
+    let end = start, count = 0, current = [];
+    if (isHydrating(start)) while(end){
+        if (end.nodeType === 8) {
+            const v = end.nodeValue;
+            if (v === "$") count++;
+            else if (v === "/") {
+                if (count === 0) return [
+                    end,
+                    current
+                ];
+                count--;
+            }
+        }
+        current.push(end);
+        end = end.nextSibling;
+    }
+    return [
+        end,
+        current
+    ];
+}
+function runHydrationEvents() {
+    if (solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.events && !solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.events.queued) {
+        queueMicrotask(()=>{
+            const { completed, events } = solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig;
+            if (!events) return;
+            events.queued = false;
+            while(events.length){
+                const [el, e] = events[0];
+                if (!completed.has(el)) return;
+                events.shift();
+                eventHandler(e);
+            }
+            if (solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.done) {
+                solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.events = _$HY.events = null;
+                solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.completed = _$HY.completed = null;
+            }
+        });
+        solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.events.queued = true;
+    }
+}
+function isHydrating(node) {
+    return !!solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.context && !solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.done && (!node || node.isConnected);
+}
+function toPropertyName(name) {
+    return name.toLowerCase().replace(/-([a-z])/g, (_, w)=>w.toUpperCase());
+}
+function toggleClassKey(node, key, value) {
+    const classNames = key.trim().split(/\s+/);
+    for(let i = 0, nameLen = classNames.length; i < nameLen; i++)node.classList.toggle(classNames[i], value);
+}
+function assignProp(node, prop, value, prev, isSVG, skipRef, props) {
+    let isCE, isProp, isChildProp, propAlias, forceProp;
+    if (prop === "style") return style(node, value, prev);
+    if (prop === "classList") return classList(node, value, prev);
+    if (value === prev) return prev;
+    if (prop === "ref") {
+        if (!skipRef) value(node);
+    } else if (prop.slice(0, 3) === "on:") {
+        const e = prop.slice(3);
+        prev && node.removeEventListener(e, prev, typeof prev !== "function" && prev);
+        value && node.addEventListener(e, value, typeof value !== "function" && value);
+    } else if (prop.slice(0, 10) === "oncapture:") {
+        const e = prop.slice(10);
+        prev && node.removeEventListener(e, prev, true);
+        value && node.addEventListener(e, value, true);
+    } else if (prop.slice(0, 2) === "on") {
+        const name = prop.slice(2).toLowerCase();
+        const delegate = DelegatedEvents.has(name);
+        if (!delegate && prev) {
+            const h = Array.isArray(prev) ? prev[0] : prev;
+            node.removeEventListener(name, h);
+        }
+        if (delegate || value) {
+            addEventListener(node, name, value, delegate);
+            delegate && delegateEvents([
+                name
+            ]);
+        }
+    } else if (prop.slice(0, 5) === "attr:") setAttribute(node, prop.slice(5), value);
+    else if (prop.slice(0, 5) === "bool:") setBoolAttribute(node, prop.slice(5), value);
+    else if ((forceProp = prop.slice(0, 5) === "prop:") || (isChildProp = ChildProperties.has(prop)) || !isSVG && ((propAlias = getPropAlias(prop, node.tagName)) || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-") || "is" in props)) {
+        if (forceProp) {
+            prop = prop.slice(5);
+            isProp = true;
+        } else if (isHydrating(node)) return value;
+        if (prop === "class" || prop === "className") className(node, value);
+        else if (isCE && !isProp && !isChildProp) node[toPropertyName(prop)] = value;
+        else node[propAlias || prop] = value;
+    } else {
+        const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
+        if (ns) setAttributeNS(node, ns, prop, value);
+        else setAttribute(node, Aliases[prop] || prop, value);
+    }
+    return value;
+}
+function eventHandler(e) {
+    if (solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.registry && solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.events) {
+        if (solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.events.find(([el, ev])=>ev === e)) return;
+    }
+    let node = e.target;
+    const key = `$$${e.type}`;
+    const oriTarget = e.target;
+    const oriCurrentTarget = e.currentTarget;
+    const retarget = (value)=>Object.defineProperty(e, "target", {
+            configurable: true,
+            value
+        });
+    const handleNode = ()=>{
+        const handler = node[key];
+        if (handler && !node.disabled) {
+            const data = node[`${key}Data`];
+            data !== undefined ? handler.call(node, data, e) : handler.call(node, e);
+            if (e.cancelBubble) return;
+        }
+        node.host && typeof node.host !== "string" && !node.host._$host && node.contains(e.target) && retarget(node.host);
+        return true;
+    };
+    const walkUpTree = ()=>{
+        while(handleNode() && (node = node._$host || node.parentNode || node.host));
+    };
+    Object.defineProperty(e, "currentTarget", {
+        configurable: true,
+        get () {
+            return node || document;
+        }
+    });
+    if (solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.registry && !solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.done) solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.done = _$HY.done = true;
+    if (e.composedPath) {
+        const path = e.composedPath();
+        retarget(path[0]);
+        for(let i = 0; i < path.length - 2; i++){
+            node = path[i];
+            if (!handleNode()) break;
+            if (node._$host) {
+                node = node._$host;
+                walkUpTree();
+                break;
+            }
+            if (node.parentNode === oriCurrentTarget) break;
+        }
+    } else walkUpTree();
+    retarget(oriTarget);
+}
+function insertExpression(parent, value, current, marker, unwrapArray) {
+    const hydrating = isHydrating(parent);
+    if (hydrating) {
+        !current && (current = [
+            ...parent.childNodes
+        ]);
+        let cleaned = [];
+        for(let i = 0; i < current.length; i++){
+            const node = current[i];
+            if (node.nodeType === 8 && node.data.slice(0, 2) === "!$") node.remove();
+            else cleaned.push(node);
+        }
+        current = cleaned;
+    }
+    while(typeof current === "function")current = current();
+    if (value === current) return current;
+    const t = typeof value, multi = marker !== undefined;
+    parent = multi && current[0] && current[0].parentNode || parent;
+    if (t === "string" || t === "number") {
+        if (hydrating) return current;
+        if (t === "number") {
+            value = value.toString();
+            if (value === current) return current;
+        }
+        if (multi) {
+            let node = current[0];
+            if (node && node.nodeType === 3) node.data !== value && (node.data = value);
+            else node = document.createTextNode(value);
+            current = cleanChildren(parent, current, marker, node);
+        } else if (current !== "" && typeof current === "string") current = parent.firstChild.data = value;
+        else current = parent.textContent = value;
+    } else if (value == null || t === "boolean") {
+        if (hydrating) return current;
+        current = cleanChildren(parent, current, marker);
+    } else if (t === "function") {
+        (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createRenderEffect)(()=>{
+            let v = value();
+            while(typeof v === "function")v = v();
+            current = insertExpression(parent, v, current, marker);
+        });
+        return ()=>current;
+    } else if (Array.isArray(value)) {
+        const array = [];
+        const currentArray = current && Array.isArray(current);
+        if (normalizeIncomingArray(array, value, current, unwrapArray)) {
+            (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createRenderEffect)(()=>current = insertExpression(parent, array, current, marker, true));
+            return ()=>current;
+        }
+        if (hydrating) {
+            if (!array.length) return current;
+            if (marker === undefined) return current = [
+                ...parent.childNodes
+            ];
+            let node = array[0];
+            if (node.parentNode !== parent) return current;
+            const nodes = [
+                node
+            ];
+            while((node = node.nextSibling) !== marker)nodes.push(node);
+            return current = nodes;
+        }
+        if (array.length === 0) {
+            current = cleanChildren(parent, current, marker);
+            if (multi) return current;
+        } else if (currentArray) {
+            if (current.length === 0) appendNodes(parent, array, marker);
+            else reconcileArrays(parent, current, array);
+        } else {
+            current && cleanChildren(parent);
+            appendNodes(parent, array);
+        }
+        current = array;
+    } else if (value.nodeType) {
+        if (hydrating && value.parentNode) return current = multi ? [
+            value
+        ] : value;
+        if (Array.isArray(current)) {
+            if (multi) return current = cleanChildren(parent, current, marker, value);
+            cleanChildren(parent, current, null, value);
+        } else if (current == null || current === "" || !parent.firstChild) parent.appendChild(value);
+        else parent.replaceChild(value, parent.firstChild);
+        current = value;
+    }
+    return current;
+}
+function normalizeIncomingArray(normalized, array, current, unwrap) {
+    let dynamic = false;
+    for(let i = 0, len = array.length; i < len; i++){
+        let item = array[i], prev = current && current[normalized.length], t;
+        if (item == null || item === true || item === false) ;
+        else if ((t = typeof item) === "object" && item.nodeType) normalized.push(item);
+        else if (Array.isArray(item)) dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
+        else if (t === "function") {
+            if (unwrap) {
+                while(typeof item === "function")item = item();
+                dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [
+                    item
+                ], Array.isArray(prev) ? prev : [
+                    prev
+                ]) || dynamic;
+            } else {
+                normalized.push(item);
+                dynamic = true;
+            }
+        } else {
+            const value = String(item);
+            if (prev && prev.nodeType === 3 && prev.data === value) normalized.push(prev);
+            else normalized.push(document.createTextNode(value));
+        }
+    }
+    return dynamic;
+}
+function appendNodes(parent, array, marker = null) {
+    for(let i = 0, len = array.length; i < len; i++)parent.insertBefore(array[i], marker);
+}
+function cleanChildren(parent, current, marker, replacement) {
+    if (marker === undefined) return parent.textContent = "";
+    const node = replacement || document.createTextNode("");
+    if (current.length) {
+        let inserted = false;
+        for(let i = current.length - 1; i >= 0; i--){
+            const el = current[i];
+            if (node !== el) {
+                const isParent = el.parentNode === parent;
+                if (!inserted && !i) isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);
+                else isParent && el.remove();
+            } else inserted = true;
+        }
+    } else parent.insertBefore(node, marker);
+    return [
+        node
+    ];
+}
+function gatherHydratable(element, root) {
+    const templates = element.querySelectorAll(`*[data-hk]`);
+    for(let i = 0; i < templates.length; i++){
+        const node = templates[i];
+        const key = node.getAttribute("data-hk");
+        if ((!root || key.startsWith(root)) && !solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.registry.has(key)) solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.registry.set(key, node);
+    }
+}
+function getHydrationKey() {
+    return solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.getNextContextId();
+}
+function NoHydration(props) {
+    return solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.context ? undefined : props.children;
+}
+function Hydration(props) {
+    return props.children;
+}
+const voidFn = ()=>undefined;
+const RequestContext = Symbol();
+function innerHTML(parent, content) {
+    !solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.context && (parent.innerHTML = content);
+}
+function throwInBrowser(func) {
+    const err = new Error(`${func.name} is not supported in the browser, returning undefined`);
+    console.error(err);
+}
+function renderToString(fn, options) {
+    throwInBrowser(renderToString);
+}
+function renderToStringAsync(fn, options) {
+    throwInBrowser(renderToStringAsync);
+}
+function renderToStream(fn, options) {
+    throwInBrowser(renderToStream);
+}
+function ssr(template, ...nodes) {}
+function ssrElement(name, props, children, needsId) {}
+function ssrClassList(value) {}
+function ssrStyle(value) {}
+function ssrAttribute(key, value) {}
+function ssrHydrationKey() {}
+function resolveSSRNode(node) {}
+function escape(html) {}
+function ssrSpread(props, isSVG, skipChildren) {}
+const isServer = false;
+const isDev = false;
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function createElement(tagName, isSVG = false) {
+    return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName);
+}
+const hydrate = (...args)=>{
+    /* "solid-js" unused */null();
+    return hydrate$1(...args);
+};
+function Portal(props) {
+    const { useShadow } = props, marker = document.createTextNode(""), mount = ()=>props.mount || document.body, owner = (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.getOwner)();
+    let content;
+    let hydrating = !!solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.context;
+    (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createEffect)(()=>{
+        if (hydrating) (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.getOwner)().user = hydrating = false;
+        content || (content = /* "solid-js" unused */null(owner, ()=>(0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createMemo)(()=>props.children)));
+        const el = mount();
+        if (el instanceof HTMLHeadElement) {
+            const [clean, setClean] = (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createSignal)(false);
+            const cleanup = ()=>setClean(true);
+            /* "solid-js" unused */null((dispose)=>insert(el, ()=>!clean() ? content() : dispose(), null));
+            (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.onCleanup)(cleanup);
+        } else {
+            const container = createElement(props.isSVG ? "g" : "div", props.isSVG), renderRoot = useShadow && container.attachShadow ? container.attachShadow({
+                mode: "open"
+            }) : container;
+            Object.defineProperty(container, "_$host", {
+                get () {
+                    return marker.parentNode;
+                },
+                configurable: true
+            });
+            insert(renderRoot, content);
+            el.appendChild(container);
+            props.ref && props.ref(container);
+            (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.onCleanup)(()=>el.removeChild(container));
+        }
+    }, undefined, {
+        render: !hydrating
+    });
+    return marker;
+}
+function createDynamic(component, props) {
+    const cached = (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createMemo)(component);
+    return (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.createMemo)(()=>{
+        const component = cached();
+        switch(typeof component){
+            case "function":
+                return (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.untrack)(()=>component(props));
+            case "string":
+                const isSvg = SVGElements.has(component);
+                const el = solid_js__WEBPACK_IMPORTED_MODULE_0__.sharedConfig.context ? getNextElement() : createElement(component, isSvg);
+                spread(el, props, isSvg);
+                return el;
+        }
+    });
+}
+function Dynamic(props) {
+    const [, others] = (0, solid_js__WEBPACK_IMPORTED_MODULE_0__.splitProps)(props, [
+        "component"
+    ]);
+    return createDynamic(()=>props.component, others);
+}
+
+}),
+
+}
+// The module cache
+ var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+// Check if module is in cache
+        var cachedModule = __webpack_module_cache__[moduleId];
+        if (cachedModule !== undefined) {
+      return cachedModule.exports;
+      }
+      // Create a new module (and put it into the cache)
+      var module = (__webpack_module_cache__[moduleId] = {
+       exports: {}
+      });
+      // Execute the module function
+      __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+// Return the exports of the module
+ return module.exports;
+
+}
+// webpack/runtime/define_property_getters
+!function() {
+__webpack_require__.d = function(exports, definition) {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+}();
+// webpack/runtime/has_own_property
+!function() {
+__webpack_require__.o = function (obj, prop) {
+	return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+}();
+// webpack/runtime/make_namespace_object
+!function() {
+// define __esModule on exports
+__webpack_require__.r = function(exports) {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+
+}();
+var __webpack_exports__ = __webpack_require__("8169");
+})()