fix: 修复关闭SSH终端标签页时会话状态未更新的问题

web/node_modules/solid-js/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-2025 Ryan Carniato
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/solid-js/README.md

@@ -0,0 +1,223 @@
+<p>
+  <img src="https://assets.solidjs.com/banner?project=Library&type=core" alt="SolidJS" />
+</p>
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/solidjs/solid/main-ci.yml?branch=main&logo=github&style=for-the-badge)](https://github.com/solidjs/solid/actions/workflows/main-ci.yml)
+[![Coverage Status](https://img.shields.io/coveralls/github/solidjs/solid.svg?style=for-the-badge)](https://coveralls.io/github/solidjs/solid?branch=main)
+
+[![NPM Version](https://img.shields.io/npm/v/solid-js.svg?style=for-the-badge)](https://www.npmjs.com/package/solid-js)
+[![](https://img.shields.io/npm/dm/solid-js.svg?style=for-the-badge)](https://www.npmjs.com/package/solid-js)
+[![Discord](https://img.shields.io/discord/722131463138705510?style=for-the-badge)](https://discord.com/invite/solidjs)
+[![Subreddit subscribers](https://img.shields.io/reddit/subreddit-subscribers/solidjs?style=for-the-badge)](https://www.reddit.com/r/solidjs/)
+
+**[Website](https://www.solidjs.com/) • [API Docs](https://docs.solidjs.com/) • [Features Tutorial](https://www.solidjs.com/tutorial/introduction_basics) • [Playground](https://playground.solidjs.com/?version=1.3.13#NobwRAdghgtgpmAXGGUCWEwBowBcCeADgsrgM4Ae2YZA9gK4BOAxiWGjIbY7gAQi9GcCABM4jXgF9eAM0a0YvADo1aAGzQiAtACsyAegDucAEYqA3EogcuPfr2ZCouOAGU0Ac2hqps+YpU6DW09CysrGXoIZlw0WgheAGEGCBdGAAoASn4rXgd4sj5gZhTcLF4yOFxkqNwAXV4AXgcnF3cvKDV0gAZMywT8iELeDEc4eFSm3iymgD4KqprU9JLamYBqXgBGPvCBoVwmBPTcvN4AHhN6XFx43gJiRpUrm-iVXnjEjWYAa0aQUZCCa4SSzU5nfirZaZSTgi76F63CBgga7CCwiBWISicTpGaNebnJZpXj6WblES0Zj0YEAOg8VQAompxsJcAAhfAASREJzAUEIhBUmTRYEkdSAA) • [Discord](https://discord.com/invite/solidjs)**
+
+Solid is a declarative JavaScript library for creating user interfaces. Instead of using a Virtual DOM, it compiles its templates to real DOM nodes and updates them with fine-grained reactions. Declare your state and use it throughout your app, and when a piece of state changes, only the code that depends on it will rerun. Check out our [intro video](https://www.youtube.com/watch?v=cELFZQAMdhQ) or read on!
+
+## Key Features
+
+- Fine-grained updates to the real DOM
+- Declarative data: model your state as a system with reactive primitives
+- Render-once mental model: your components are regular JavaScript functions that run once to set up your view
+- Automatic dependency tracking: accessing your reactive state subscribes to it
+- [Small](https://dev.to/this-is-learning/javascript-framework-todomvc-size-comparison-504f) and [fast](https://krausest.github.io/js-framework-benchmark/current.html)
+- Simple: learn a few powerful concepts that can be reused, combined, and built on top of
+- Provides modern framework features like JSX, fragments, Context, Portals, Suspense, streaming SSR, progressive hydration, Error Boundaries and concurrent rendering.
+- Naturally debuggable: A `<div>` is a real div, so you can use your browser's devtools to inspect the rendering
+- [Web component friendly](https://github.com/solidjs/solid/tree/main/packages/solid-element#readme) and can author custom elements
+- Isomorphic: render your components on the client and the server
+- Universal: write [custom renderers](https://github.com/solidjs/solid/releases/tag/v1.2.0) to use Solid anywhere
+- A growing community and ecosystem with active core team support
+
+<details>
+
+<summary>Quick Start</summary>
+
+You can get started with a simple app by running the following in your terminal:
+
+```sh
+> npx degit solidjs/templates/js my-app
+> cd my-app
+> npm i # or yarn or pnpm
+> npm run dev # or yarn or pnpm
+```
+
+Or for TypeScript:
+
+```sh
+> npx degit solidjs/templates/ts my-app
+> cd my-app
+> npm i # or yarn or pnpm
+> npm run dev # or yarn or pnpm
+```
+
+This will create a minimal, client-rendered application powered by [Vite](https://vitejs.dev/).
+
+Or you can install the dependencies in your own setup. To use Solid with JSX (_recommended_), run:
+
+```sh
+> npm i -D babel-preset-solid
+> npm i solid-js
+```
+
+The easiest way to get set up is to add `babel-preset-solid` to your `.babelrc`, babel config for webpack, or rollup configuration:
+
+```js
+"presets": ["solid"]
+```
+
+For TypeScript to work, remember to set your `.tsconfig` to handle Solid's JSX:
+
+```js
+"compilerOptions": {
+  "jsx": "preserve",
+  "jsxImportSource": "solid-js",
+}
+```
+
+</details>
+
+## Why Solid?
+
+### Performant
+
+Meticulously engineered for performance and with half a decade of research behind it, Solid's performance is almost indistinguishable from optimized vanilla JavaScript (See Solid on the [JS Framework Benchmark](https://krausest.github.io/js-framework-benchmark/current.html)). Solid is [small](https://bundlephobia.com/package/solid-js@1.3.15) and completely tree-shakable, and [fast](https://levelup.gitconnected.com/how-we-wrote-the-fastest-javascript-ui-framework-again-db097ddd99b6) when rendering on the server, too. Whether you're writing a fully client-rendered SPA or a server-rendered app, your users see it faster than ever. ([Read more about Solid's performance](https://dev.to/ryansolid/thinking-granular-how-is-solidjs-so-performant-4g37) from the library's creator.)
+
+### Powerful
+
+Solid is fully-featured with everything you can expect from a modern framework. Performant state management is built-in with Context and Stores: you don't have to reach for a third party library to manage global state (if you don't want to). With Resources, you can use data loaded from the server like any other piece of state and build a responsive UI for it thanks to Suspense and concurrent rendering. And when you're ready to move to the server, Solid has full SSR and serverless support, with streaming and progressive hydration to get to interactive as quickly as possible. (Check out our full [interactive features walkthrough](https://www.solidjs.com/tutorial/introduction_basics).)
+
+### Pragmatic
+
+Do more with less: use simple, composable primitives without hidden rules and gotchas. In Solid, components are just functions - rendering is determined purely by how your state is used - so you're free to organize your code how you like and you don't have to learn a new rendering system. Solid encourages patterns like declarative code and read-write segregation that help keep your project maintainable, but isn't opinionated enough to get in your way.
+
+### Productive
+
+Solid is built on established tools like JSX and TypeScript and integrates with the Vite ecosystem. Solid's bare-metal, minimal abstractions give you direct access to the DOM, making it easy to use your favorite native JavaScript libraries like D3. And the Solid ecosystem is growing fast, with [custom primitives](https://github.com/solidjs-community/solid-primitives), [component libraries](https://github.com/hope-ui/hope-ui), and build-time utilities that let you [write Solid code in new ways](https://github.com/LXSMNSYC/solid-labels).
+
+<details>
+<summary>Show Me!</summary>
+
+```jsx
+import { render } from "solid-js/web";
+import { createSignal } from "solid-js";
+
+// A component is just a function that (optionally) accepts properties and returns a DOM node
+const Counter = props => {
+  // Create a piece of reactive state, giving us a accessor, count(), and a setter, setCount()
+  const [count, setCount] = createSignal(props.startingCount || 1);
+
+  // The increment function calls the setter
+  const increment = () => setCount(count() + 1);
+
+  console.log(
+    "The body of the function runs once, like you'd expect from calling any other function, so you only ever see this console log once."
+  );
+
+  // JSX allows us to write HTML within our JavaScript function and include dynamic expressions using the { } syntax
+  // The only part of this that will ever rerender is the count() text.
+  return (
+    <button type="button" onClick={increment}>
+      Increment {count()}
+    </button>
+  );
+};
+
+// The render function mounts a component onto your page
+render(() => <Counter startingCount={2} />, document.getElementById("app"));
+```
+
+See it in action in our interactive [Playground](https://playground.solidjs.com/?hash=-894962706&version=1.3.13)!
+
+Solid compiles our JSX down to efficient real DOM expressions updates, still using the same reactive primitives (`createSignal`) at runtime but making sure there's as little rerendering as possible. Here's what that looks like in this example:
+
+```js
+import { render, createComponent, delegateEvents, insert, template } from "solid-js/web";
+import { createSignal } from "solid-js";
+
+const _tmpl$ = /*#__PURE__*/ template(`<button type="button">Increment </button>`, 2);
+
+const Counter = props => {
+  const [count, setCount] = createSignal(props.startingCount || 1);
+  const increment = () => setCount(count() + 1);
+
+  console.log("The body of the function runs once . . .");
+
+  return (() => {
+    //_el$ is a real DOM node!
+    const _el$ = _tmpl$.cloneNode(true);
+    _el$.firstChild;
+
+    _el$.$$click = increment;
+
+    //This inserts the count as a child of the button in a way that allows count to update without rerendering the whole button
+    insert(_el$, count, null);
+
+    return _el$;
+  })();
+};
+
+render(
+  () =>
+    createComponent(Counter, {
+      startingCount: 2
+    }),
+  document.getElementById("app")
+);
+
+delegateEvents(["click"]);
+```
+
+</details>
+
+## More
+
+Check out our official [documentation](https://www.solidjs.com/guide) or browse some [examples](https://github.com/solidjs/solid/blob/main/documentation/resources/examples.md)
+
+## Browser Support
+
+SolidJS Core is committed to supporting the last 2 years of modern browsers including Firefox, Safari, Chrome and Edge (for desktop and mobile devices). We do not support IE or similar sunset browsers. For server environments, we support Node LTS and the latest Deno and Cloudflare Worker runtimes.
+
+<img src="https://saucelabs.github.io/images/opensauce/powered-by-saucelabs-badge-gray.svg?sanitize=true" alt="Testing Powered By SauceLabs" width="300"/>
+
+## Community
+
+Come chat with us on [Discord](https://discord.com/invite/solidjs)! Solid's creator and the rest of the core team are active there, and we're always looking for contributions.
+
+### Contributors
+
+<a href="https://github.com/solidjs/solid/graphs/contributors"><img src="https://opencollective.com/solid/contributors.svg?width=890&amp;button=false" style="max-width:100%;"></a>
+
+### Open Collective
+
+Support us with a donation and help us continue our activities. [[Contribute](https://opencollective.com/solid)]
+
+<a href="https://opencollective.com/solid/backer/0/website" target="_blank"><img src="https://opencollective.com/solid/backer/0/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/1/website" target="_blank"><img src="https://opencollective.com/solid/backer/1/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/2/website" target="_blank"><img src="https://opencollective.com/solid/backer/2/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/3/website" target="_blank"><img src="https://opencollective.com/solid/backer/3/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/4/website" target="_blank"><img src="https://opencollective.com/solid/backer/4/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/5/website" target="_blank"><img src="https://opencollective.com/solid/backer/5/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/6/website" target="_blank"><img src="https://opencollective.com/solid/backer/6/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/7/website" target="_blank"><img src="https://opencollective.com/solid/backer/7/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/8/website" target="_blank"><img src="https://opencollective.com/solid/backer/8/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/9/website" target="_blank"><img src="https://opencollective.com/solid/backer/9/avatar.svg"></a>
+<a href="https://opencollective.com/solid/backer/10/website" target="_blank"><img src="https://opencollective.com/solid/backer/10/avatar.svg"></a>
+
+### Sponsors
+
+Become a sponsor and get your logo on our README on GitHub with a link to your site. [[Become a sponsor](https://opencollective.com/solid#sponsor)]
+
+<a href="https://opencollective.com/solid/sponsor/0/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/1/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/2/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/3/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/4/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/5/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/6/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/7/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/8/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/9/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/9/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/10/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/10/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/11/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/11/avatar.svg"></a>
+<a href="https://opencollective.com/solid/sponsor/12/website" target="_blank"><img src="https://opencollective.com/solid/sponsor/12/avatar.svg"></a>

web/node_modules/solid-js/dist/server.cjs

@@ -0,0 +1,813 @@
+'use strict';
+
+const equalFn = (a, b) => a === b;
+const $PROXY = Symbol("solid-proxy");
+const $TRACK = Symbol("solid-track");
+const $DEVCOMP = Symbol("solid-dev-component");
+const DEV = undefined;
+const ERROR = Symbol("error");
+function castError(err) {
+  if (err instanceof Error) return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function handleError(err, owner = Owner) {
+  const fns = owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns) throw error;
+  try {
+    for (const f of fns) f(error);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+const UNOWNED = {
+  context: null,
+  owner: null,
+  owned: null,
+  cleanups: null
+};
+let Owner = null;
+function createOwner() {
+  const o = {
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    owned: null,
+    cleanups: null
+  };
+  if (Owner) {
+    if (!Owner.owned) Owner.owned = [o];else Owner.owned.push(o);
+  }
+  return o;
+}
+function createRoot(fn, detachedOwner) {
+  const owner = Owner,
+    current = detachedOwner === undefined ? owner : detachedOwner,
+    root = fn.length === 0 ? UNOWNED : {
+      context: current ? current.context : null,
+      owner: current,
+      owned: null,
+      cleanups: null
+    };
+  Owner = root;
+  let result;
+  try {
+    result = fn(fn.length === 0 ? () => {} : () => cleanNode(root));
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = owner;
+  }
+  return result;
+}
+function createSignal(value, options) {
+  return [() => value, v => {
+    return value = typeof v === "function" ? v(value) : v;
+  }];
+}
+function createComputed(fn, value) {
+  Owner = createOwner();
+  try {
+    fn(value);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = Owner.owner;
+  }
+}
+const createRenderEffect = createComputed;
+function createEffect(fn, value) {}
+function createReaction(fn) {
+  return fn => {
+    fn();
+  };
+}
+function createMemo(fn, value) {
+  Owner = createOwner();
+  let v;
+  try {
+    v = fn(value);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = Owner.owner;
+  }
+  return () => v;
+}
+function createDeferred(source) {
+  return source;
+}
+function createSelector(source, fn = equalFn) {
+  return k => fn(k, source());
+}
+function batch(fn) {
+  return fn();
+}
+const untrack = batch;
+function on(deps, fn, options = {}) {
+  const isArray = Array.isArray(deps);
+  const defer = options.defer;
+  return () => {
+    if (defer) return undefined;
+    let value;
+    if (isArray) {
+      value = [];
+      for (let i = 0; i < deps.length; i++) value.push(deps[i]());
+    } else value = deps();
+    return fn(value);
+  };
+}
+function onMount(fn) {}
+function onCleanup(fn) {
+  if (Owner) {
+    if (!Owner.cleanups) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
+  }
+  return fn;
+}
+function cleanNode(node) {
+  if (node.owned) {
+    for (let i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (let i = 0; i < node.cleanups.length; i++) node.cleanups[i]();
+    node.cleanups = null;
+  }
+}
+function catchError(fn, handler) {
+  const owner = createOwner();
+  owner.context = {
+    ...owner.context,
+    [ERROR]: [handler]
+  };
+  Owner = owner;
+  try {
+    return fn();
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = Owner.owner;
+  }
+}
+function getListener() {
+  return null;
+}
+function createContext(defaultValue) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id),
+    defaultValue
+  };
+}
+function useContext(context) {
+  return Owner && Owner.context && Owner.context[context.id] !== undefined ? Owner.context[context.id] : context.defaultValue;
+}
+function getOwner() {
+  return Owner;
+}
+function children(fn) {
+  const memo = createMemo(() => resolveChildren(fn()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+function runWithOwner(o, fn) {
+  const prev = Owner;
+  Owner = o;
+  try {
+    return fn();
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = prev;
+  }
+}
+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) {
+  return function provider(props) {
+    return createMemo(() => {
+      Owner.context = {
+        ...Owner.context,
+        [id]: props.value
+      };
+      return children(() => props.children);
+    });
+  };
+}
+function requestCallback(fn, options) {
+  return {
+    id: 0,
+    fn: () => {},
+    startTime: 0,
+    expirationTime: 0
+  };
+}
+function mapArray(list, mapFn, options = {}) {
+  const items = list();
+  let s = [];
+  if (items && items.length) {
+    for (let i = 0, len = items.length; i < len; i++) s.push(mapFn(items[i], () => i));
+  } else if (options.fallback) s = [options.fallback()];
+  return () => s;
+}
+function indexArray(list, mapFn, options = {}) {
+  const items = list();
+  let s = [];
+  if (items && items.length) {
+    for (let i = 0, len = items.length; i < len; i++) s.push(mapFn(() => items[i], i));
+  } else if (options.fallback) s = [options.fallback()];
+  return () => s;
+}
+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) {
+  const [s, set] = createSignal(undefined);
+  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;
+}
+function enableExternalSource(factory) {}
+function onError(fn) {
+  if (Owner) {
+    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 escape(s, attr) {
+  const t = typeof s;
+  if (t !== "string") {
+    if (t === "function") return escape(s());
+    if (Array.isArray(s)) {
+      for (let i = 0; i < s.length; i++) s[i] = escape(s[i]);
+      return s;
+    }
+    return s;
+  }
+  const delim = "<";
+  const escDelim = "&lt;";
+  let iDelim = s.indexOf(delim);
+  let iAmp = s.indexOf("&");
+  if (iDelim < 0 && iAmp < 0) return s;
+  let left = 0,
+    out = "";
+  while (iDelim >= 0 && iAmp >= 0) {
+    if (iDelim < iAmp) {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } else {
+      if (left < iAmp) out += s.substring(left, iAmp);
+      out += "&amp;";
+      left = iAmp + 1;
+      iAmp = s.indexOf("&", left);
+    }
+  }
+  if (iDelim >= 0) {
+    do {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } while (iDelim >= 0);
+  } else while (iAmp >= 0) {
+    if (left < iAmp) out += s.substring(left, iAmp);
+    out += "&amp;";
+    left = iAmp + 1;
+    iAmp = s.indexOf("&", left);
+  }
+  return left < s.length ? out + s.substring(left) : out;
+}
+function resolveSSRNode(node) {
+  const t = typeof node;
+  if (t === "string") return node;
+  if (node == null || t === "boolean") return "";
+  if (Array.isArray(node)) {
+    let prev = {};
+    let mapped = "";
+    for (let i = 0, len = node.length; i < len; i++) {
+      if (typeof prev !== "object" && typeof node[i] !== "object") mapped += `<!--!$-->`;
+      mapped += resolveSSRNode(prev = node[i]);
+    }
+    return mapped;
+  }
+  if (t === "object") return node.t;
+  if (t === "function") return resolveSSRNode(node());
+  return String(node);
+}
+const sharedConfig = {
+  context: undefined,
+  getContextId() {
+    if (!this.context) throw new Error(`getContextId cannot be used under non-hydrating context`);
+    return getContextId(this.context.count);
+  },
+  getNextContextId() {
+    if (!this.context) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
+    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 ? {
+    ...sharedConfig.context,
+    id: sharedConfig.getNextContextId(),
+    count: 0
+  } : undefined;
+}
+function createUniqueId() {
+  return sharedConfig.getNextContextId();
+}
+function createComponent(Comp, props) {
+  if (sharedConfig.context && !sharedConfig.context.noHydrate) {
+    const c = sharedConfig.context;
+    setHydrateContext(nextHydrateContext());
+    const r = Comp(props || {});
+    setHydrateContext(c);
+    return r;
+  }
+  return Comp(props || {});
+}
+function mergeProps(...sources) {
+  const target = {};
+  for (let i = 0; i < sources.length; i++) {
+    let source = sources[i];
+    if (typeof source === "function") source = source();
+    if (source) {
+      const descriptors = Object.getOwnPropertyDescriptors(source);
+      for (const key in descriptors) {
+        if (key in target) continue;
+        Object.defineProperty(target, key, {
+          enumerable: true,
+          get() {
+            for (let i = sources.length - 1; i >= 0; i--) {
+              let v,
+                s = sources[i];
+              if (typeof s === "function") s = s();
+              v = (s || {})[key];
+              if (v !== undefined) return v;
+            }
+          }
+        });
+      }
+    }
+  }
+  return target;
+}
+function splitProps(props, ...keys) {
+  const descriptors = Object.getOwnPropertyDescriptors(props),
+    split = k => {
+      const clone = {};
+      for (let i = 0; i < k.length; i++) {
+        const key = k[i];
+        if (descriptors[key]) {
+          Object.defineProperty(clone, key, descriptors[key]);
+          delete descriptors[key];
+        }
+      }
+      return clone;
+    };
+  return keys.map(split).concat(split(Object.keys(descriptors)));
+}
+function simpleMap(props, wrap) {
+  const list = props.each || [],
+    len = list.length,
+    fn = props.children;
+  if (len) {
+    let mapped = Array(len);
+    for (let i = 0; i < len; i++) mapped[i] = wrap(fn, list[i], i);
+    return mapped;
+  }
+  return props.fallback;
+}
+function For(props) {
+  return simpleMap(props, (fn, item, i) => fn(item, () => i));
+}
+function Index(props) {
+  return simpleMap(props, (fn, item, i) => fn(() => item, i));
+}
+function Show(props) {
+  let c;
+  return props.when ? typeof (c = props.children) === "function" ? c(props.keyed ? props.when : () => props.when) : c : props.fallback || "";
+}
+function Switch(props) {
+  let conditions = props.children;
+  Array.isArray(conditions) || (conditions = [conditions]);
+  for (let i = 0; i < conditions.length; i++) {
+    const w = conditions[i].when;
+    if (w) {
+      const c = conditions[i].children;
+      return typeof c === "function" ? c(conditions[i].keyed ? w : () => w) : c;
+    }
+  }
+  return props.fallback || "";
+}
+function Match(props) {
+  return props;
+}
+function resetErrorBoundaries() {}
+function ErrorBoundary(props) {
+  let error,
+    res,
+    clean,
+    sync = true;
+  const ctx = sharedConfig.context;
+  const id = sharedConfig.getContextId();
+  function displayFallback() {
+    cleanNode(clean);
+    ctx.serialize(id, error);
+    setHydrateContext({
+      ...ctx,
+      count: 0
+    });
+    const f = props.fallback;
+    return typeof f === "function" && f.length ? f(error, () => {}) : f;
+  }
+  createMemo(() => {
+    clean = Owner;
+    return catchError(() => res = props.children, err => {
+      error = err;
+      !sync && ctx.replace("e" + id, displayFallback);
+      sync = true;
+    });
+  });
+  if (error) return displayFallback();
+  sync = false;
+  return {
+    t: `<!--!$e${id}-->${resolveSSRNode(escape(res))}<!--!$/e${id}-->`
+  };
+}
+const SuspenseContext = createContext();
+let resourceContext = null;
+function createResource(source, fetcher, options = {}) {
+  if (typeof fetcher !== "function") {
+    options = fetcher || {};
+    fetcher = source;
+    source = true;
+  }
+  const contexts = new Set();
+  const id = sharedConfig.getNextContextId();
+  let resource = {};
+  let value = options.storage ? options.storage(options.initialValue)[0]() : options.initialValue;
+  let p;
+  let error;
+  if (sharedConfig.context.async && options.ssrLoadFrom !== "initial") {
+    resource = sharedConfig.context.resources[id] || (sharedConfig.context.resources[id] = {});
+    if (resource.ref) {
+      if (!resource.data && !resource.ref[0]._loading && !resource.ref[0].error) resource.ref[1].refetch();
+      return resource.ref;
+    }
+  }
+  const prepareResource = () => {
+    if (error) throw error;
+    const resolved = options.ssrLoadFrom !== "initial" && sharedConfig.context.async && "data" in sharedConfig.context.resources[id];
+    if (!resolved && resourceContext) resourceContext.push(id);
+    if (!resolved && read._loading) {
+      const ctx = useContext(SuspenseContext);
+      if (ctx) {
+        ctx.resources.set(id, read);
+        contexts.add(ctx);
+      }
+    }
+    return resolved;
+  };
+  const read = () => {
+    return prepareResource() ? sharedConfig.context.resources[id].data : value;
+  };
+  const loading = () => {
+    prepareResource();
+    return read._loading;
+  };
+  read._loading = false;
+  read.error = undefined;
+  read.state = "initialValue" in options ? "ready" : "unresolved";
+  Object.defineProperties(read, {
+    latest: {
+      get() {
+        return read();
+      }
+    },
+    loading: {
+      get() {
+        return loading();
+      }
+    }
+  });
+  function load() {
+    const ctx = sharedConfig.context;
+    if (!ctx.async) return read._loading = !!(typeof source === "function" ? source() : source);
+    if (ctx.resources && id in ctx.resources && "data" in ctx.resources[id]) {
+      value = ctx.resources[id].data;
+      return;
+    }
+    let lookup;
+    try {
+      resourceContext = [];
+      lookup = typeof source === "function" ? source() : source;
+      if (resourceContext.length) return;
+    } finally {
+      resourceContext = null;
+    }
+    if (!p) {
+      if (lookup == null || lookup === false) return;
+      p = fetcher(lookup, {
+        value
+      });
+    }
+    if (p != undefined && typeof p === "object" && "then" in p) {
+      read._loading = true;
+      read.state = "pending";
+      p = p.then(res => {
+        read._loading = false;
+        read.state = "ready";
+        ctx.resources[id].data = res;
+        p = null;
+        notifySuspense(contexts);
+        return res;
+      }).catch(err => {
+        read._loading = false;
+        read.state = "errored";
+        read.error = error = castError(err);
+        p = null;
+        notifySuspense(contexts);
+        throw error;
+      });
+      if (ctx.serialize) ctx.serialize(id, p, options.deferStream);
+      return p;
+    }
+    ctx.resources[id].data = p;
+    if (ctx.serialize) ctx.serialize(id, p);
+    p = null;
+    return ctx.resources[id].data;
+  }
+  if (options.ssrLoadFrom !== "initial") load();
+  const ref = [read, {
+    refetch: load,
+    mutate: v => value = v
+  }];
+  if (p) resource.ref = ref;
+  return ref;
+}
+function lazy(fn) {
+  let p;
+  let load = id => {
+    if (!p) {
+      p = fn();
+      p.then(mod => p.resolved = mod.default);
+      if (id) sharedConfig.context.lazy[id] = p;
+    }
+    return p;
+  };
+  const contexts = new Set();
+  const wrap = props => {
+    const id = sharedConfig.context.id;
+    let ref = sharedConfig.context.lazy[id];
+    if (ref) p = ref;else load(id);
+    if (p.resolved) return p.resolved(props);
+    const ctx = useContext(SuspenseContext);
+    const track = {
+      _loading: true,
+      error: undefined
+    };
+    if (ctx) {
+      ctx.resources.set(id, track);
+      contexts.add(ctx);
+    }
+    if (sharedConfig.context.async) {
+      sharedConfig.context.block(p.then(() => {
+        track._loading = false;
+        notifySuspense(contexts);
+      }));
+    }
+    return "";
+  };
+  wrap.preload = load;
+  return wrap;
+}
+function suspenseComplete(c) {
+  for (const r of c.resources.values()) {
+    if (r._loading) return false;
+  }
+  return true;
+}
+function notifySuspense(contexts) {
+  for (const c of contexts) {
+    if (!suspenseComplete(c)) {
+      continue;
+    }
+    c.completed();
+    contexts.delete(c);
+  }
+}
+function enableScheduling() {}
+function enableHydration() {}
+function startTransition(fn) {
+  fn();
+}
+function useTransition() {
+  return [() => false, fn => {
+    fn();
+  }];
+}
+function SuspenseList(props) {
+  if (sharedConfig.context && !sharedConfig.context.noHydrate) {
+    const c = sharedConfig.context;
+    setHydrateContext(nextHydrateContext());
+    const result = props.children;
+    setHydrateContext(c);
+    return result;
+  }
+  return props.children;
+}
+function Suspense(props) {
+  let done;
+  const ctx = sharedConfig.context;
+  const id = sharedConfig.getContextId();
+  const o = createOwner();
+  const value = ctx.suspense[id] || (ctx.suspense[id] = {
+    resources: new Map(),
+    completed: () => {
+      const res = runSuspense();
+      if (suspenseComplete(value)) {
+        done(resolveSSRNode(escape(res)));
+      }
+    }
+  });
+  function suspenseError(err) {
+    if (!done || !done(undefined, err)) {
+      runWithOwner(o.owner, () => {
+        throw err;
+      });
+    }
+  }
+  function runSuspense() {
+    setHydrateContext({
+      ...ctx,
+      count: 0
+    });
+    cleanNode(o);
+    return runWithOwner(o, () => createComponent(SuspenseContext.Provider, {
+      value,
+      get children() {
+        return catchError(() => props.children, suspenseError);
+      }
+    }));
+  }
+  const res = runSuspense();
+  if (suspenseComplete(value)) {
+    delete ctx.suspense[id];
+    return res;
+  }
+  done = ctx.async ? ctx.registerFragment(id) : undefined;
+  return catchError(() => {
+    if (ctx.async) {
+      setHydrateContext({
+        ...ctx,
+        count: 0,
+        id: ctx.id + "0F",
+        noHydrate: true
+      });
+      const res = {
+        t: `<template id="pl-${id}"></template>${resolveSSRNode(escape(props.fallback))}<!--pl-${id}-->`
+      };
+      setHydrateContext(ctx);
+      return res;
+    }
+    setHydrateContext({
+      ...ctx,
+      count: 0,
+      id: ctx.id + "0F"
+    });
+    ctx.serialize(id, "$$f");
+    return props.fallback;
+  }, suspenseError);
+}
+
+exports.$DEVCOMP = $DEVCOMP;
+exports.$PROXY = $PROXY;
+exports.$TRACK = $TRACK;
+exports.DEV = DEV;
+exports.ErrorBoundary = ErrorBoundary;
+exports.For = For;
+exports.Index = Index;
+exports.Match = Match;
+exports.Show = Show;
+exports.Suspense = Suspense;
+exports.SuspenseList = SuspenseList;
+exports.Switch = Switch;
+exports.batch = batch;
+exports.catchError = catchError;
+exports.children = children;
+exports.createComponent = createComponent;
+exports.createComputed = createComputed;
+exports.createContext = createContext;
+exports.createDeferred = createDeferred;
+exports.createEffect = createEffect;
+exports.createMemo = createMemo;
+exports.createReaction = createReaction;
+exports.createRenderEffect = createRenderEffect;
+exports.createResource = createResource;
+exports.createRoot = createRoot;
+exports.createSelector = createSelector;
+exports.createSignal = createSignal;
+exports.createUniqueId = createUniqueId;
+exports.enableExternalSource = enableExternalSource;
+exports.enableHydration = enableHydration;
+exports.enableScheduling = enableScheduling;
+exports.equalFn = equalFn;
+exports.from = from;
+exports.getListener = getListener;
+exports.getOwner = getOwner;
+exports.indexArray = indexArray;
+exports.lazy = lazy;
+exports.mapArray = mapArray;
+exports.mergeProps = mergeProps;
+exports.observable = observable;
+exports.on = on;
+exports.onCleanup = onCleanup;
+exports.onError = onError;
+exports.onMount = onMount;
+exports.requestCallback = requestCallback;
+exports.resetErrorBoundaries = resetErrorBoundaries;
+exports.runWithOwner = runWithOwner;
+exports.sharedConfig = sharedConfig;
+exports.splitProps = splitProps;
+exports.startTransition = startTransition;
+exports.untrack = untrack;
+exports.useContext = useContext;
+exports.useTransition = useTransition;

web/node_modules/solid-js/dist/server.js

@@ -0,0 +1,759 @@
+const equalFn = (a, b) => a === b;
+const $PROXY = Symbol("solid-proxy");
+const $TRACK = Symbol("solid-track");
+const $DEVCOMP = Symbol("solid-dev-component");
+const DEV = undefined;
+const ERROR = Symbol("error");
+function castError(err) {
+  if (err instanceof Error) return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function handleError(err, owner = Owner) {
+  const fns = owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns) throw error;
+  try {
+    for (const f of fns) f(error);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+const UNOWNED = {
+  context: null,
+  owner: null,
+  owned: null,
+  cleanups: null
+};
+let Owner = null;
+function createOwner() {
+  const o = {
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    owned: null,
+    cleanups: null
+  };
+  if (Owner) {
+    if (!Owner.owned) Owner.owned = [o];else Owner.owned.push(o);
+  }
+  return o;
+}
+function createRoot(fn, detachedOwner) {
+  const owner = Owner,
+    current = detachedOwner === undefined ? owner : detachedOwner,
+    root = fn.length === 0 ? UNOWNED : {
+      context: current ? current.context : null,
+      owner: current,
+      owned: null,
+      cleanups: null
+    };
+  Owner = root;
+  let result;
+  try {
+    result = fn(fn.length === 0 ? () => {} : () => cleanNode(root));
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = owner;
+  }
+  return result;
+}
+function createSignal(value, options) {
+  return [() => value, v => {
+    return value = typeof v === "function" ? v(value) : v;
+  }];
+}
+function createComputed(fn, value) {
+  Owner = createOwner();
+  try {
+    fn(value);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = Owner.owner;
+  }
+}
+const createRenderEffect = createComputed;
+function createEffect(fn, value) {}
+function createReaction(fn) {
+  return fn => {
+    fn();
+  };
+}
+function createMemo(fn, value) {
+  Owner = createOwner();
+  let v;
+  try {
+    v = fn(value);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = Owner.owner;
+  }
+  return () => v;
+}
+function createDeferred(source) {
+  return source;
+}
+function createSelector(source, fn = equalFn) {
+  return k => fn(k, source());
+}
+function batch(fn) {
+  return fn();
+}
+const untrack = batch;
+function on(deps, fn, options = {}) {
+  const isArray = Array.isArray(deps);
+  const defer = options.defer;
+  return () => {
+    if (defer) return undefined;
+    let value;
+    if (isArray) {
+      value = [];
+      for (let i = 0; i < deps.length; i++) value.push(deps[i]());
+    } else value = deps();
+    return fn(value);
+  };
+}
+function onMount(fn) {}
+function onCleanup(fn) {
+  if (Owner) {
+    if (!Owner.cleanups) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
+  }
+  return fn;
+}
+function cleanNode(node) {
+  if (node.owned) {
+    for (let i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (let i = 0; i < node.cleanups.length; i++) node.cleanups[i]();
+    node.cleanups = null;
+  }
+}
+function catchError(fn, handler) {
+  const owner = createOwner();
+  owner.context = {
+    ...owner.context,
+    [ERROR]: [handler]
+  };
+  Owner = owner;
+  try {
+    return fn();
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = Owner.owner;
+  }
+}
+function getListener() {
+  return null;
+}
+function createContext(defaultValue) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id),
+    defaultValue
+  };
+}
+function useContext(context) {
+  return Owner && Owner.context && Owner.context[context.id] !== undefined ? Owner.context[context.id] : context.defaultValue;
+}
+function getOwner() {
+  return Owner;
+}
+function children(fn) {
+  const memo = createMemo(() => resolveChildren(fn()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+function runWithOwner(o, fn) {
+  const prev = Owner;
+  Owner = o;
+  try {
+    return fn();
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = prev;
+  }
+}
+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) {
+  return function provider(props) {
+    return createMemo(() => {
+      Owner.context = {
+        ...Owner.context,
+        [id]: props.value
+      };
+      return children(() => props.children);
+    });
+  };
+}
+function requestCallback(fn, options) {
+  return {
+    id: 0,
+    fn: () => {},
+    startTime: 0,
+    expirationTime: 0
+  };
+}
+function mapArray(list, mapFn, options = {}) {
+  const items = list();
+  let s = [];
+  if (items && items.length) {
+    for (let i = 0, len = items.length; i < len; i++) s.push(mapFn(items[i], () => i));
+  } else if (options.fallback) s = [options.fallback()];
+  return () => s;
+}
+function indexArray(list, mapFn, options = {}) {
+  const items = list();
+  let s = [];
+  if (items && items.length) {
+    for (let i = 0, len = items.length; i < len; i++) s.push(mapFn(() => items[i], i));
+  } else if (options.fallback) s = [options.fallback()];
+  return () => s;
+}
+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) {
+  const [s, set] = createSignal(undefined);
+  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;
+}
+function enableExternalSource(factory) {}
+function onError(fn) {
+  if (Owner) {
+    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 escape(s, attr) {
+  const t = typeof s;
+  if (t !== "string") {
+    if (t === "function") return escape(s());
+    if (Array.isArray(s)) {
+      for (let i = 0; i < s.length; i++) s[i] = escape(s[i]);
+      return s;
+    }
+    return s;
+  }
+  const delim = "<";
+  const escDelim = "&lt;";
+  let iDelim = s.indexOf(delim);
+  let iAmp = s.indexOf("&");
+  if (iDelim < 0 && iAmp < 0) return s;
+  let left = 0,
+    out = "";
+  while (iDelim >= 0 && iAmp >= 0) {
+    if (iDelim < iAmp) {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } else {
+      if (left < iAmp) out += s.substring(left, iAmp);
+      out += "&amp;";
+      left = iAmp + 1;
+      iAmp = s.indexOf("&", left);
+    }
+  }
+  if (iDelim >= 0) {
+    do {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } while (iDelim >= 0);
+  } else while (iAmp >= 0) {
+    if (left < iAmp) out += s.substring(left, iAmp);
+    out += "&amp;";
+    left = iAmp + 1;
+    iAmp = s.indexOf("&", left);
+  }
+  return left < s.length ? out + s.substring(left) : out;
+}
+function resolveSSRNode(node) {
+  const t = typeof node;
+  if (t === "string") return node;
+  if (node == null || t === "boolean") return "";
+  if (Array.isArray(node)) {
+    let prev = {};
+    let mapped = "";
+    for (let i = 0, len = node.length; i < len; i++) {
+      if (typeof prev !== "object" && typeof node[i] !== "object") mapped += `<!--!$-->`;
+      mapped += resolveSSRNode(prev = node[i]);
+    }
+    return mapped;
+  }
+  if (t === "object") return node.t;
+  if (t === "function") return resolveSSRNode(node());
+  return String(node);
+}
+const sharedConfig = {
+  context: undefined,
+  getContextId() {
+    if (!this.context) throw new Error(`getContextId cannot be used under non-hydrating context`);
+    return getContextId(this.context.count);
+  },
+  getNextContextId() {
+    if (!this.context) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
+    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 ? {
+    ...sharedConfig.context,
+    id: sharedConfig.getNextContextId(),
+    count: 0
+  } : undefined;
+}
+function createUniqueId() {
+  return sharedConfig.getNextContextId();
+}
+function createComponent(Comp, props) {
+  if (sharedConfig.context && !sharedConfig.context.noHydrate) {
+    const c = sharedConfig.context;
+    setHydrateContext(nextHydrateContext());
+    const r = Comp(props || {});
+    setHydrateContext(c);
+    return r;
+  }
+  return Comp(props || {});
+}
+function mergeProps(...sources) {
+  const target = {};
+  for (let i = 0; i < sources.length; i++) {
+    let source = sources[i];
+    if (typeof source === "function") source = source();
+    if (source) {
+      const descriptors = Object.getOwnPropertyDescriptors(source);
+      for (const key in descriptors) {
+        if (key in target) continue;
+        Object.defineProperty(target, key, {
+          enumerable: true,
+          get() {
+            for (let i = sources.length - 1; i >= 0; i--) {
+              let v,
+                s = sources[i];
+              if (typeof s === "function") s = s();
+              v = (s || {})[key];
+              if (v !== undefined) return v;
+            }
+          }
+        });
+      }
+    }
+  }
+  return target;
+}
+function splitProps(props, ...keys) {
+  const descriptors = Object.getOwnPropertyDescriptors(props),
+    split = k => {
+      const clone = {};
+      for (let i = 0; i < k.length; i++) {
+        const key = k[i];
+        if (descriptors[key]) {
+          Object.defineProperty(clone, key, descriptors[key]);
+          delete descriptors[key];
+        }
+      }
+      return clone;
+    };
+  return keys.map(split).concat(split(Object.keys(descriptors)));
+}
+function simpleMap(props, wrap) {
+  const list = props.each || [],
+    len = list.length,
+    fn = props.children;
+  if (len) {
+    let mapped = Array(len);
+    for (let i = 0; i < len; i++) mapped[i] = wrap(fn, list[i], i);
+    return mapped;
+  }
+  return props.fallback;
+}
+function For(props) {
+  return simpleMap(props, (fn, item, i) => fn(item, () => i));
+}
+function Index(props) {
+  return simpleMap(props, (fn, item, i) => fn(() => item, i));
+}
+function Show(props) {
+  let c;
+  return props.when ? typeof (c = props.children) === "function" ? c(props.keyed ? props.when : () => props.when) : c : props.fallback || "";
+}
+function Switch(props) {
+  let conditions = props.children;
+  Array.isArray(conditions) || (conditions = [conditions]);
+  for (let i = 0; i < conditions.length; i++) {
+    const w = conditions[i].when;
+    if (w) {
+      const c = conditions[i].children;
+      return typeof c === "function" ? c(conditions[i].keyed ? w : () => w) : c;
+    }
+  }
+  return props.fallback || "";
+}
+function Match(props) {
+  return props;
+}
+function resetErrorBoundaries() {}
+function ErrorBoundary(props) {
+  let error,
+    res,
+    clean,
+    sync = true;
+  const ctx = sharedConfig.context;
+  const id = sharedConfig.getContextId();
+  function displayFallback() {
+    cleanNode(clean);
+    ctx.serialize(id, error);
+    setHydrateContext({
+      ...ctx,
+      count: 0
+    });
+    const f = props.fallback;
+    return typeof f === "function" && f.length ? f(error, () => {}) : f;
+  }
+  createMemo(() => {
+    clean = Owner;
+    return catchError(() => res = props.children, err => {
+      error = err;
+      !sync && ctx.replace("e" + id, displayFallback);
+      sync = true;
+    });
+  });
+  if (error) return displayFallback();
+  sync = false;
+  return {
+    t: `<!--!$e${id}-->${resolveSSRNode(escape(res))}<!--!$/e${id}-->`
+  };
+}
+const SuspenseContext = createContext();
+let resourceContext = null;
+function createResource(source, fetcher, options = {}) {
+  if (typeof fetcher !== "function") {
+    options = fetcher || {};
+    fetcher = source;
+    source = true;
+  }
+  const contexts = new Set();
+  const id = sharedConfig.getNextContextId();
+  let resource = {};
+  let value = options.storage ? options.storage(options.initialValue)[0]() : options.initialValue;
+  let p;
+  let error;
+  if (sharedConfig.context.async && options.ssrLoadFrom !== "initial") {
+    resource = sharedConfig.context.resources[id] || (sharedConfig.context.resources[id] = {});
+    if (resource.ref) {
+      if (!resource.data && !resource.ref[0]._loading && !resource.ref[0].error) resource.ref[1].refetch();
+      return resource.ref;
+    }
+  }
+  const prepareResource = () => {
+    if (error) throw error;
+    const resolved = options.ssrLoadFrom !== "initial" && sharedConfig.context.async && "data" in sharedConfig.context.resources[id];
+    if (!resolved && resourceContext) resourceContext.push(id);
+    if (!resolved && read._loading) {
+      const ctx = useContext(SuspenseContext);
+      if (ctx) {
+        ctx.resources.set(id, read);
+        contexts.add(ctx);
+      }
+    }
+    return resolved;
+  };
+  const read = () => {
+    return prepareResource() ? sharedConfig.context.resources[id].data : value;
+  };
+  const loading = () => {
+    prepareResource();
+    return read._loading;
+  };
+  read._loading = false;
+  read.error = undefined;
+  read.state = "initialValue" in options ? "ready" : "unresolved";
+  Object.defineProperties(read, {
+    latest: {
+      get() {
+        return read();
+      }
+    },
+    loading: {
+      get() {
+        return loading();
+      }
+    }
+  });
+  function load() {
+    const ctx = sharedConfig.context;
+    if (!ctx.async) return read._loading = !!(typeof source === "function" ? source() : source);
+    if (ctx.resources && id in ctx.resources && "data" in ctx.resources[id]) {
+      value = ctx.resources[id].data;
+      return;
+    }
+    let lookup;
+    try {
+      resourceContext = [];
+      lookup = typeof source === "function" ? source() : source;
+      if (resourceContext.length) return;
+    } finally {
+      resourceContext = null;
+    }
+    if (!p) {
+      if (lookup == null || lookup === false) return;
+      p = fetcher(lookup, {
+        value
+      });
+    }
+    if (p != undefined && typeof p === "object" && "then" in p) {
+      read._loading = true;
+      read.state = "pending";
+      p = p.then(res => {
+        read._loading = false;
+        read.state = "ready";
+        ctx.resources[id].data = res;
+        p = null;
+        notifySuspense(contexts);
+        return res;
+      }).catch(err => {
+        read._loading = false;
+        read.state = "errored";
+        read.error = error = castError(err);
+        p = null;
+        notifySuspense(contexts);
+        throw error;
+      });
+      if (ctx.serialize) ctx.serialize(id, p, options.deferStream);
+      return p;
+    }
+    ctx.resources[id].data = p;
+    if (ctx.serialize) ctx.serialize(id, p);
+    p = null;
+    return ctx.resources[id].data;
+  }
+  if (options.ssrLoadFrom !== "initial") load();
+  const ref = [read, {
+    refetch: load,
+    mutate: v => value = v
+  }];
+  if (p) resource.ref = ref;
+  return ref;
+}
+function lazy(fn) {
+  let p;
+  let load = id => {
+    if (!p) {
+      p = fn();
+      p.then(mod => p.resolved = mod.default);
+      if (id) sharedConfig.context.lazy[id] = p;
+    }
+    return p;
+  };
+  const contexts = new Set();
+  const wrap = props => {
+    const id = sharedConfig.context.id;
+    let ref = sharedConfig.context.lazy[id];
+    if (ref) p = ref;else load(id);
+    if (p.resolved) return p.resolved(props);
+    const ctx = useContext(SuspenseContext);
+    const track = {
+      _loading: true,
+      error: undefined
+    };
+    if (ctx) {
+      ctx.resources.set(id, track);
+      contexts.add(ctx);
+    }
+    if (sharedConfig.context.async) {
+      sharedConfig.context.block(p.then(() => {
+        track._loading = false;
+        notifySuspense(contexts);
+      }));
+    }
+    return "";
+  };
+  wrap.preload = load;
+  return wrap;
+}
+function suspenseComplete(c) {
+  for (const r of c.resources.values()) {
+    if (r._loading) return false;
+  }
+  return true;
+}
+function notifySuspense(contexts) {
+  for (const c of contexts) {
+    if (!suspenseComplete(c)) {
+      continue;
+    }
+    c.completed();
+    contexts.delete(c);
+  }
+}
+function enableScheduling() {}
+function enableHydration() {}
+function startTransition(fn) {
+  fn();
+}
+function useTransition() {
+  return [() => false, fn => {
+    fn();
+  }];
+}
+function SuspenseList(props) {
+  if (sharedConfig.context && !sharedConfig.context.noHydrate) {
+    const c = sharedConfig.context;
+    setHydrateContext(nextHydrateContext());
+    const result = props.children;
+    setHydrateContext(c);
+    return result;
+  }
+  return props.children;
+}
+function Suspense(props) {
+  let done;
+  const ctx = sharedConfig.context;
+  const id = sharedConfig.getContextId();
+  const o = createOwner();
+  const value = ctx.suspense[id] || (ctx.suspense[id] = {
+    resources: new Map(),
+    completed: () => {
+      const res = runSuspense();
+      if (suspenseComplete(value)) {
+        done(resolveSSRNode(escape(res)));
+      }
+    }
+  });
+  function suspenseError(err) {
+    if (!done || !done(undefined, err)) {
+      runWithOwner(o.owner, () => {
+        throw err;
+      });
+    }
+  }
+  function runSuspense() {
+    setHydrateContext({
+      ...ctx,
+      count: 0
+    });
+    cleanNode(o);
+    return runWithOwner(o, () => createComponent(SuspenseContext.Provider, {
+      value,
+      get children() {
+        return catchError(() => props.children, suspenseError);
+      }
+    }));
+  }
+  const res = runSuspense();
+  if (suspenseComplete(value)) {
+    delete ctx.suspense[id];
+    return res;
+  }
+  done = ctx.async ? ctx.registerFragment(id) : undefined;
+  return catchError(() => {
+    if (ctx.async) {
+      setHydrateContext({
+        ...ctx,
+        count: 0,
+        id: ctx.id + "0F",
+        noHydrate: true
+      });
+      const res = {
+        t: `<template id="pl-${id}"></template>${resolveSSRNode(escape(props.fallback))}<!--pl-${id}-->`
+      };
+      setHydrateContext(ctx);
+      return res;
+    }
+    setHydrateContext({
+      ...ctx,
+      count: 0,
+      id: ctx.id + "0F"
+    });
+    ctx.serialize(id, "$$f");
+    return props.fallback;
+  }, suspenseError);
+}
+
+export { $DEVCOMP, $PROXY, $TRACK, DEV, ErrorBoundary, For, Index, Match, Show, Suspense, SuspenseList, Switch, batch, catchError, children, createComponent, createComputed, createContext, createDeferred, createEffect, createMemo, createReaction, createRenderEffect, createResource, createRoot, createSelector, createSignal, createUniqueId, enableExternalSource, enableHydration, enableScheduling, equalFn, from, getListener, getOwner, indexArray, lazy, mapArray, mergeProps, observable, on, onCleanup, onError, onMount, requestCallback, resetErrorBoundaries, runWithOwner, sharedConfig, splitProps, startTransition, untrack, useContext, useTransition };

web/node_modules/solid-js/h/dist/h.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+var web = require('solid-js/web');
+
+const $ELEMENT = Symbol("hyper-element");
+function createHyperScript(r) {
+  function h() {
+    let args = [].slice.call(arguments),
+      e,
+      classes = [],
+      multiExpression = false;
+    while (Array.isArray(args[0])) args = args[0];
+    if (args[0][$ELEMENT]) args.unshift(h.Fragment);
+    typeof args[0] === "string" && detectMultiExpression(args);
+    const ret = () => {
+      while (args.length) item(args.shift());
+      if (e instanceof Element && classes.length) e.classList.add(...classes);
+      return e;
+    };
+    ret[$ELEMENT] = true;
+    return ret;
+    function item(l) {
+      const type = typeof l;
+      if (l == null) ;else if ("string" === type) {
+        if (!e) parseClass(l);else e.appendChild(document.createTextNode(l));
+      } else if ("number" === type || "boolean" === type || "bigint" === type || "symbol" === type || l instanceof Date || l instanceof RegExp) {
+        e.appendChild(document.createTextNode(l.toString()));
+      } else if (Array.isArray(l)) {
+        for (let i = 0; i < l.length; i++) item(l[i]);
+      } else if (l instanceof Element) {
+        r.insert(e, l, multiExpression ? null : undefined);
+      } else if ("object" === type) {
+        let dynamic = false;
+        const d = Object.getOwnPropertyDescriptors(l);
+        for (const k in d) {
+          if (k === "class" && classes.length !== 0) {
+            const fixedClasses = classes.join(" "),
+              value = typeof d["class"].value === "function" ? () => fixedClasses + " " + d["class"].value() : fixedClasses + " " + l["class"];
+            Object.defineProperty(l, "class", {
+              ...d[k],
+              value
+            });
+            classes = [];
+          }
+          if (k !== "ref" && k.slice(0, 2) !== "on" && typeof d[k].value === "function") {
+            r.dynamicProperty(l, k);
+            dynamic = true;
+          } else if (d[k].get) dynamic = true;
+        }
+        dynamic ? r.spread(e, l, e instanceof SVGElement, !!args.length) : r.assign(e, l, e instanceof SVGElement, !!args.length);
+      } else if ("function" === type) {
+        if (!e) {
+          let props,
+            next = args[0];
+          if (next == null || typeof next === "object" && !Array.isArray(next) && !(next instanceof Element)) props = args.shift();
+          props || (props = {});
+          if (args.length) {
+            props.children = args.length > 1 ? args : args[0];
+          }
+          const d = Object.getOwnPropertyDescriptors(props);
+          for (const k in d) {
+            if (Array.isArray(d[k].value)) {
+              const list = d[k].value;
+              props[k] = () => {
+                for (let i = 0; i < list.length; i++) {
+                  while (list[i][$ELEMENT]) list[i] = list[i]();
+                }
+                return list;
+              };
+              r.dynamicProperty(props, k);
+            } else if (typeof d[k].value === "function" && !d[k].value.length) r.dynamicProperty(props, k);
+          }
+          e = r.createComponent(l, props);
+          args = [];
+        } else {
+          while (l[$ELEMENT]) l = l();
+          r.insert(e, l, multiExpression ? null : undefined);
+        }
+      }
+    }
+    function parseClass(string) {
+      const m = string.split(/([\.#]?[^\s#.]+)/);
+      if (/^\.|#/.test(m[1])) e = document.createElement("div");
+      for (let i = 0; i < m.length; i++) {
+        const v = m[i],
+          s = v.substring(1, v.length);
+        if (!v) continue;
+        if (!e) e = r.SVGElements.has(v) ? document.createElementNS("http://www.w3.org/2000/svg", v) : document.createElement(v);else if (v[0] === ".") classes.push(s);else if (v[0] === "#") e.setAttribute("id", s);
+      }
+    }
+    function detectMultiExpression(list) {
+      for (let i = 1; i < list.length; i++) {
+        if (typeof list[i] === "function") {
+          multiExpression = true;
+          return;
+        } else if (Array.isArray(list[i])) {
+          detectMultiExpression(list[i]);
+        }
+      }
+    }
+  }
+  h.Fragment = props => props.children;
+  return h;
+}
+
+const h = createHyperScript({
+  spread: web.spread,
+  assign: web.assign,
+  insert: web.insert,
+  createComponent: web.createComponent,
+  dynamicProperty: web.dynamicProperty,
+  SVGElements: web.SVGElements
+});
+
+module.exports = h;

web/node_modules/solid-js/h/dist/h.js

@@ -0,0 +1,113 @@
+import { SVGElements, dynamicProperty, createComponent, insert, assign, spread } from 'solid-js/web';
+
+const $ELEMENT = Symbol("hyper-element");
+function createHyperScript(r) {
+  function h() {
+    let args = [].slice.call(arguments),
+      e,
+      classes = [],
+      multiExpression = false;
+    while (Array.isArray(args[0])) args = args[0];
+    if (args[0][$ELEMENT]) args.unshift(h.Fragment);
+    typeof args[0] === "string" && detectMultiExpression(args);
+    const ret = () => {
+      while (args.length) item(args.shift());
+      if (e instanceof Element && classes.length) e.classList.add(...classes);
+      return e;
+    };
+    ret[$ELEMENT] = true;
+    return ret;
+    function item(l) {
+      const type = typeof l;
+      if (l == null) ;else if ("string" === type) {
+        if (!e) parseClass(l);else e.appendChild(document.createTextNode(l));
+      } else if ("number" === type || "boolean" === type || "bigint" === type || "symbol" === type || l instanceof Date || l instanceof RegExp) {
+        e.appendChild(document.createTextNode(l.toString()));
+      } else if (Array.isArray(l)) {
+        for (let i = 0; i < l.length; i++) item(l[i]);
+      } else if (l instanceof Element) {
+        r.insert(e, l, multiExpression ? null : undefined);
+      } else if ("object" === type) {
+        let dynamic = false;
+        const d = Object.getOwnPropertyDescriptors(l);
+        for (const k in d) {
+          if (k === "class" && classes.length !== 0) {
+            const fixedClasses = classes.join(" "),
+              value = typeof d["class"].value === "function" ? () => fixedClasses + " " + d["class"].value() : fixedClasses + " " + l["class"];
+            Object.defineProperty(l, "class", {
+              ...d[k],
+              value
+            });
+            classes = [];
+          }
+          if (k !== "ref" && k.slice(0, 2) !== "on" && typeof d[k].value === "function") {
+            r.dynamicProperty(l, k);
+            dynamic = true;
+          } else if (d[k].get) dynamic = true;
+        }
+        dynamic ? r.spread(e, l, e instanceof SVGElement, !!args.length) : r.assign(e, l, e instanceof SVGElement, !!args.length);
+      } else if ("function" === type) {
+        if (!e) {
+          let props,
+            next = args[0];
+          if (next == null || typeof next === "object" && !Array.isArray(next) && !(next instanceof Element)) props = args.shift();
+          props || (props = {});
+          if (args.length) {
+            props.children = args.length > 1 ? args : args[0];
+          }
+          const d = Object.getOwnPropertyDescriptors(props);
+          for (const k in d) {
+            if (Array.isArray(d[k].value)) {
+              const list = d[k].value;
+              props[k] = () => {
+                for (let i = 0; i < list.length; i++) {
+                  while (list[i][$ELEMENT]) list[i] = list[i]();
+                }
+                return list;
+              };
+              r.dynamicProperty(props, k);
+            } else if (typeof d[k].value === "function" && !d[k].value.length) r.dynamicProperty(props, k);
+          }
+          e = r.createComponent(l, props);
+          args = [];
+        } else {
+          while (l[$ELEMENT]) l = l();
+          r.insert(e, l, multiExpression ? null : undefined);
+        }
+      }
+    }
+    function parseClass(string) {
+      const m = string.split(/([\.#]?[^\s#.]+)/);
+      if (/^\.|#/.test(m[1])) e = document.createElement("div");
+      for (let i = 0; i < m.length; i++) {
+        const v = m[i],
+          s = v.substring(1, v.length);
+        if (!v) continue;
+        if (!e) e = r.SVGElements.has(v) ? document.createElementNS("http://www.w3.org/2000/svg", v) : document.createElement(v);else if (v[0] === ".") classes.push(s);else if (v[0] === "#") e.setAttribute("id", s);
+      }
+    }
+    function detectMultiExpression(list) {
+      for (let i = 1; i < list.length; i++) {
+        if (typeof list[i] === "function") {
+          multiExpression = true;
+          return;
+        } else if (Array.isArray(list[i])) {
+          detectMultiExpression(list[i]);
+        }
+      }
+    }
+  }
+  h.Fragment = props => props.children;
+  return h;
+}
+
+const h = createHyperScript({
+  spread,
+  assign,
+  insert,
+  createComponent,
+  dynamicProperty,
+  SVGElements
+});
+
+export { h as default };

web/node_modules/solid-js/h/jsx-dev-runtime/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "solid-js/h/jsx-dev-runtime",
+  "main": "../jsx-runtime/dist/jsx.cjs",
+  "module": "../jsx-runtime/dist/jsx.js",
+  "types": "../jsx-runtime/types/index.d.ts",
+  "type": "module",
+  "sideEffects": false
+}

web/node_modules/solid-js/h/jsx-runtime/dist/jsx.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var h = require('solid-js/h');
+
+function Fragment(props) {
+  return props.children;
+}
+function jsx(type, props) {
+  return h(type, props);
+}
+
+exports.Fragment = Fragment;
+exports.jsx = jsx;
+exports.jsxDEV = jsx;
+exports.jsxs = jsx;

web/node_modules/solid-js/h/jsx-runtime/dist/jsx.js

@@ -0,0 +1,10 @@
+import h from 'solid-js/h';
+
+function Fragment(props) {
+  return props.children;
+}
+function jsx(type, props) {
+  return h(type, props);
+}
+
+export { Fragment, jsx, jsx as jsxDEV, jsx as jsxs };

web/node_modules/solid-js/h/jsx-runtime/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "solid-js/h/jsx-runtime",
+  "main": "./dist/jsx.cjs",
+  "module": "./dist/jsx.js",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "sideEffects": false
+}

web/node_modules/solid-js/h/jsx-runtime/types/index.d.ts

@@ -0,0 +1,11 @@
+export type { JSX } from "./jsx.d.ts";
+import type { JSX } from "./jsx.d.ts";
+declare function Fragment(props: {
+    children: JSX.Element;
+}): JSX.Element;
+declare function jsx(type: any, props: any): () => (Node & {
+    [key: string]: any;
+}) | (Node & {
+    [key: string]: any;
+})[];
+export { jsx, jsx as jsxs, jsx as jsxDEV, Fragment };

web/node_modules/solid-js/h/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "solid-js/h",
+  "main": "./dist/h.cjs",
+  "module": "./dist/h.js",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "sideEffects": false
+}

web/node_modules/solid-js/h/types/hyperscript.d.ts

@@ -0,0 +1,20 @@
+type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+interface Runtime {
+    insert(parent: MountableElement, accessor: any, marker?: Node | null, init?: any): any;
+    spread(node: Element, accessor: any, isSVG?: Boolean, skipChildren?: Boolean): void;
+    assign(node: Element, props: any, isSVG?: Boolean, skipChildren?: Boolean): void;
+    createComponent(Comp: (props: any) => any, props: any): any;
+    dynamicProperty(props: any, key: string): any;
+    SVGElements: Set<string>;
+}
+type ExpandableNode = Node & {
+    [key: string]: any;
+};
+export type HyperScript = {
+    (...args: any[]): () => ExpandableNode | ExpandableNode[];
+    Fragment: (props: {
+        children: (() => ExpandableNode) | (() => ExpandableNode)[];
+    }) => ExpandableNode[];
+};
+export declare function createHyperScript(r: Runtime): HyperScript;
+export {};

web/node_modules/solid-js/h/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { HyperScript } from "./hyperscript.js";
+declare const h: HyperScript;
+export default h;

web/node_modules/solid-js/html/dist/html.cjs

@@ -0,0 +1,583 @@
+'use strict';
+
+var web = require('solid-js/web');
+
+const tagRE = /(?:<!--[\S\s]*?-->|<(?:"[^"]*"['"]*|'[^']*'['"]*|[^'">])+>)/g;
+const attrRE = /(?:\s(?<boolean>[^/\s><=]+?)(?=[\s/>]))|(?:(?<name>\S+?)(?:\s*=\s*(?:(['"])(?<quotedValue>[\s\S]*?)\3|(?<unquotedValue>[^\s>]+))))/g;
+const lookup = {
+  area: true,
+  base: true,
+  br: true,
+  col: true,
+  embed: true,
+  hr: true,
+  img: true,
+  input: true,
+  keygen: true,
+  link: true,
+  menuitem: true,
+  meta: true,
+  param: true,
+  source: true,
+  track: true,
+  wbr: true
+};
+function parseTag(tag) {
+  const res = {
+    type: 'tag',
+    name: '',
+    voidElement: false,
+    attrs: [],
+    children: []
+  };
+  const tagMatch = tag.match(/<\/?([^\s]+?)[/\s>]/);
+  if (tagMatch) {
+    res.name = tagMatch[1];
+    if (lookup[tagMatch[1].toLowerCase()] || tag.charAt(tag.length - 2) === '/') {
+      res.voidElement = true;
+    }
+    if (res.name.startsWith('!--')) {
+      const endIndex = tag.indexOf('-->');
+      return {
+        type: 'comment',
+        comment: endIndex !== -1 ? tag.slice(4, endIndex) : ''
+      };
+    }
+  }
+  const reg = new RegExp(attrRE);
+  for (const match of tag.matchAll(reg)) {
+    if ((match[1] || match[2]).startsWith('use:')) {
+      res.attrs.push({
+        type: 'directive',
+        name: match[1] || match[2],
+        value: match[4] || match[5] || ''
+      });
+    } else {
+      res.attrs.push({
+        type: 'attr',
+        name: match[1] || match[2],
+        value: match[4] || match[5] || ''
+      });
+    }
+  }
+  return res;
+}
+function pushTextNode(list, html, start) {
+  const end = html.indexOf('<', start);
+  const content = html.slice(start, end === -1 ? void 0 : end);
+  if (!/^\s*$/.test(content)) {
+    list.push({
+      type: 'text',
+      content: content
+    });
+  }
+}
+function pushCommentNode(list, tag) {
+  const content = tag.replace('<!--', '').replace('-->', '');
+  if (!/^\s*$/.test(content)) {
+    list.push({
+      type: 'comment',
+      content: content
+    });
+  }
+}
+function parse(html) {
+  const result = [];
+  let current = void 0;
+  let level = -1;
+  const arr = [];
+  const byTag = {};
+  html.replace(tagRE, (tag, index) => {
+    const isOpen = tag.charAt(1) !== '/';
+    const isComment = tag.slice(0, 4) === '<!--';
+    const start = index + tag.length;
+    const nextChar = html.charAt(start);
+    let parent = void 0;
+    if (isOpen && !isComment) {
+      level++;
+      current = parseTag(tag);
+      if (!current.voidElement && nextChar && nextChar !== '<') {
+        pushTextNode(current.children, html, start);
+      }
+      byTag[current.tagName] = current;
+      if (level === 0) {
+        result.push(current);
+      }
+      parent = arr[level - 1];
+      if (parent) {
+        parent.children.push(current);
+      }
+      arr[level] = current;
+    }
+    if (isComment) {
+      if (level < 0) {
+        pushCommentNode(result, tag);
+      } else {
+        pushCommentNode(arr[level].children, tag);
+      }
+    }
+    if (isComment || !isOpen || current.voidElement) {
+      if (!isComment) {
+        level--;
+      }
+      if (nextChar !== '<' && nextChar) {
+        parent = level === -1 ? result : arr[level].children;
+        pushTextNode(parent, html, start);
+      }
+    }
+  });
+  return result;
+}
+function attrString(attrs) {
+  const buff = [];
+  for (const attr of attrs) {
+    buff.push(attr.name + '="' + attr.value.replace(/"/g, '&quot;') + '"');
+  }
+  if (!buff.length) {
+    return '';
+  }
+  return ' ' + buff.join(' ');
+}
+function stringifier(buff, doc) {
+  switch (doc.type) {
+    case 'text':
+      return buff + doc.content;
+    case 'tag':
+      buff += '<' + doc.name + (doc.attrs ? attrString(doc.attrs) : '') + (doc.voidElement ? '/>' : '>');
+      if (doc.voidElement) {
+        return buff;
+      }
+      return buff + doc.children.reduce(stringifier, '') + '</' + doc.name + '>';
+    case 'comment':
+      return buff += '<!--' + doc.content + '-->';
+  }
+}
+function stringify(doc) {
+  return doc.reduce(function (token, rootEl) {
+    return token + stringifier('', rootEl);
+  }, '');
+}
+const cache = new Map();
+const VOID_ELEMENTS = /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i;
+const spaces = " \\f\\n\\r\\t";
+const almostEverything = "[^" + spaces + "\\/>\"'=]+";
+const attrName = "[ " + spaces + "]+(?:use:<!--#-->|" + almostEverything + ')';
+const tagName = "<([A-Za-z$#]+[A-Za-z0-9:_-]*)((?:";
+const attrPartials = "(?:\\s*=\\s*(?:'[^']*?'|\"[^\"]*?\"|\\([^)]*?\\)|<[^>]*?>|" + almostEverything + "))?)";
+const attrSeeker = new RegExp(tagName + attrName + attrPartials + "+)([ " + spaces + "]*/?>)", "g");
+const findAttributes = new RegExp("(" + attrName + "\\s*=\\s*)(<!--#-->|['\"(]([\\w\\s]*<!--#-->[\\w\\s]*)*['\")])", "gi");
+const selfClosing = new RegExp(tagName + attrName + attrPartials + "*)([ " + spaces + "]*/>)", "g");
+const marker = "<!--#-->";
+const reservedNameSpaces = new Set(["class", "on", "oncapture", "style", "use", "prop", "attr"]);
+function attrReplacer($0, $1, $2, $3) {
+  return "<" + $1 + $2.replace(findAttributes, replaceAttributes) + $3;
+}
+function replaceAttributes($0, $1, $2) {
+  return $1.replace(/<!--#-->/g, "###") + ($2[0] === '"' || $2[0] === "'" ? $2.replace(/<!--#-->/g, "###") : '"###"');
+}
+function fullClosing($0, $1, $2) {
+  return VOID_ELEMENTS.test($1) ? $0 : "<" + $1 + $2 + "></" + $1 + ">";
+}
+function toPropertyName(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+function parseDirective(name, value, tag, options) {
+  if (name === 'use:###' && value === '###') {
+    const count = options.counter++;
+    options.exprs.push(`typeof exprs[${count}] === "function" ? r.use(exprs[${count}], ${tag}, exprs[${options.counter++}]) : (()=>{throw new Error("use:### must be a function")})()`);
+  } else {
+    throw new Error(`Not support syntax ${name} must be use:{function}`);
+  }
+}
+function createHTML(r, {
+  delegateEvents = true,
+  functionBuilder = (...args) => new Function(...args)
+} = {}) {
+  let uuid = 1;
+  r.wrapProps = props => {
+    const d = Object.getOwnPropertyDescriptors(props);
+    for (const k in d) {
+      if (typeof d[k].value === "function" && !d[k].value.length) r.dynamicProperty(props, k);
+    }
+    return props;
+  };
+  function createTemplate(statics, opt) {
+    let i = 0,
+      markup = "";
+    for (; i < statics.length - 1; i++) {
+      markup = markup + statics[i] + "<!--#-->";
+    }
+    markup = markup + statics[i];
+    const replaceList = [[selfClosing, fullClosing], [/<(<!--#-->)/g, "<###"], [/\.\.\.(<!--#-->)/g, "###"], [attrSeeker, attrReplacer], [/>\n+\s*/g, ">"], [/\n+\s*</g, "<"], [/\s+</g, " <"], [/>\s+/g, "> "]];
+    markup = replaceList.reduce((acc, x) => {
+      return acc.replace(x[0], x[1]);
+    }, markup);
+    const pars = parse(markup);
+    const [html, code] = parseTemplate(pars, opt.funcBuilder),
+      templates = [];
+    for (let i = 0; i < html.length; i++) {
+      templates.push(document.createElement("template"));
+      templates[i].innerHTML = html[i];
+      const nomarkers = templates[i].content.querySelectorAll("script,style");
+      for (let j = 0; j < nomarkers.length; j++) {
+        const d = nomarkers[j].firstChild?.data || "";
+        if (d.indexOf(marker) > -1) {
+          const parts = d.split(marker).reduce((memo, p, i) => {
+            i && memo.push("");
+            memo.push(p);
+            return memo;
+          }, []);
+          nomarkers[i].firstChild.replaceWith(...parts);
+        }
+      }
+    }
+    templates[0].create = code;
+    cache.set(statics, templates);
+    return templates;
+  }
+  function parseKeyValue(node, tag, name, value, isSVG, isCE, options) {
+    let expr = value === "###" ? `!doNotWrap ? exprs[${options.counter}]() : exprs[${options.counter++}]` : value.split("###").map((v, i) => i ? ` + (typeof exprs[${options.counter}] === "function" ? exprs[${options.counter}]() : exprs[${options.counter++}]) + "${v}"` : `"${v}"`).join(""),
+      parts,
+      namespace;
+    if ((parts = name.split(":")) && parts[1] && reservedNameSpaces.has(parts[0])) {
+      name = parts[1];
+      namespace = parts[0];
+    }
+    const isChildProp = r.ChildProperties.has(name);
+    const isProp = r.Properties.has(name);
+    if (name === "style") {
+      const prev = `_$v${uuid++}`;
+      options.decl.push(`${prev}={}`);
+      options.exprs.push(`r.style(${tag},${expr},${prev})`);
+    } else if (name === "classList") {
+      const prev = `_$v${uuid++}`;
+      options.decl.push(`${prev}={}`);
+      options.exprs.push(`r.classList(${tag},${expr},${prev})`);
+    } else if (namespace !== "attr" && (isChildProp || !isSVG && (r.getPropAlias(name, node.name.toUpperCase()) || isProp) || isCE || namespace === "prop")) {
+      if (isCE && !isChildProp && !isProp && namespace !== "prop") name = toPropertyName(name);
+      options.exprs.push(`${tag}.${r.getPropAlias(name, node.name.toUpperCase()) || name} = ${expr}`);
+    } else {
+      const ns = isSVG && name.indexOf(":") > -1 && r.SVGNamespace[name.split(":")[0]];
+      if (ns) options.exprs.push(`r.setAttributeNS(${tag},"${ns}","${name}",${expr})`);else options.exprs.push(`r.setAttribute(${tag},"${r.Aliases[name] || name}",${expr})`);
+    }
+  }
+  function parseAttribute(node, tag, name, value, isSVG, isCE, options) {
+    if (name.slice(0, 2) === "on") {
+      if (!name.includes(":")) {
+        const lc = name.slice(2).toLowerCase();
+        const delegate = delegateEvents && r.DelegatedEvents.has(lc);
+        options.exprs.push(`r.addEventListener(${tag},"${lc}",exprs[${options.counter++}],${delegate})`);
+        delegate && options.delegatedEvents.add(lc);
+      } else {
+        let capture = name.startsWith("oncapture:");
+        options.exprs.push(`${tag}.addEventListener("${name.slice(capture ? 10 : 3)}",exprs[${options.counter++}]${capture ? ",true" : ""})`);
+      }
+    } else if (name === "ref") {
+      options.exprs.push(`exprs[${options.counter++}](${tag})`);
+    } else {
+      const childOptions = Object.assign({}, options, {
+          exprs: []
+        }),
+        count = options.counter;
+      parseKeyValue(node, tag, name, value, isSVG, isCE, childOptions);
+      options.decl.push(`_fn${count} = (${value === "###" ? "doNotWrap" : ""}) => {\n${childOptions.exprs.join(";\n")};\n}`);
+      if (value === "###") {
+        options.exprs.push(`typeof exprs[${count}] === "function" ? r.effect(_fn${count}) : _fn${count}(true)`);
+      } else {
+        let check = "";
+        for (let i = count; i < childOptions.counter; i++) {
+          i !== count && (check += " || ");
+          check += `typeof exprs[${i}] === "function"`;
+        }
+        options.exprs.push(check + ` ? r.effect(_fn${count}) : _fn${count}()`);
+      }
+      options.counter = childOptions.counter;
+      options.wrap = false;
+    }
+  }
+  function processChildren(node, options) {
+    const childOptions = Object.assign({}, options, {
+      first: true,
+      multi: false,
+      parent: options.path
+    });
+    if (node.children.length > 1) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        if (child.type === "comment" && child.content === "#" || child.type === "tag" && child.name === "###") {
+          childOptions.multi = true;
+          break;
+        }
+      }
+    }
+    let i = 0;
+    while (i < node.children.length) {
+      const child = node.children[i];
+      if (child.name === "###") {
+        if (childOptions.multi) {
+          node.children[i] = {
+            type: "comment",
+            content: "#"
+          };
+          i++;
+        } else node.children.splice(i, 1);
+        processComponent(child, childOptions);
+        continue;
+      }
+      parseNode(child, childOptions);
+      if (!childOptions.multi && child.type === "comment" && child.content === "#") node.children.splice(i, 1);else i++;
+    }
+    options.counter = childOptions.counter;
+    options.templateId = childOptions.templateId;
+    options.hasCustomElement = options.hasCustomElement || childOptions.hasCustomElement;
+    options.isImportNode = options.isImportNode || childOptions.isImportNode;
+  }
+  function processComponentProps(propGroups) {
+    let result = [];
+    for (const props of propGroups) {
+      if (Array.isArray(props)) {
+        if (!props.length) continue;
+        result.push(`r.wrapProps({${props.join(",") || ""}})`);
+      } else result.push(props);
+    }
+    return result.length > 1 ? `r.mergeProps(${result.join(",")})` : result[0];
+  }
+  function processComponent(node, options) {
+    let props = [];
+    const keys = Object.keys(node.attrs),
+      propGroups = [props],
+      componentIdentifier = options.counter++;
+    for (let i = 0; i < keys.length; i++) {
+      const {
+        type,
+        name,
+        value
+      } = node.attrs[i];
+      if (type === 'attr') {
+        if (name === "###") {
+          propGroups.push(`exprs[${options.counter++}]`);
+          propGroups.push(props = []);
+        } else if (value === "###") {
+          props.push(`"${name}": exprs[${options.counter++}]`);
+        } else props.push(`"${name}": "${value}"`);
+      } else if (type === 'directive') {
+        const tag = `_$el${uuid++}`;
+        const topDecl = !options.decl.length;
+        options.decl.push(topDecl ? "" : `${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+        parseDirective(name, value, tag, options);
+      }
+    }
+    if (node.children.length === 1 && node.children[0].type === "comment" && node.children[0].content === "#") {
+      props.push(`children: () => exprs[${options.counter++}]`);
+    } else if (node.children.length) {
+      const children = {
+          type: "fragment",
+          children: node.children
+        },
+        childOptions = Object.assign({}, options, {
+          first: true,
+          decl: [],
+          exprs: [],
+          parent: false
+        });
+      parseNode(children, childOptions);
+      props.push(`children: () => { ${childOptions.exprs.join(";\n")}}`);
+      options.templateId = childOptions.templateId;
+      options.counter = childOptions.counter;
+    }
+    let tag;
+    if (options.multi) {
+      tag = `_$el${uuid++}`;
+      options.decl.push(`${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+    }
+    if (options.parent) options.exprs.push(`r.insert(${options.parent}, r.createComponent(exprs[${componentIdentifier}],${processComponentProps(propGroups)})${tag ? `, ${tag}` : ""})`);else options.exprs.push(`${options.fragment ? "" : "return "}r.createComponent(exprs[${componentIdentifier}],${processComponentProps(propGroups)})`);
+    options.path = tag;
+    options.first = false;
+  }
+  function parseNode(node, options) {
+    if (node.type === "fragment") {
+      const parts = [];
+      node.children.forEach(child => {
+        if (child.type === "tag") {
+          if (child.name === "###") {
+            const childOptions = Object.assign({}, options, {
+              first: true,
+              fragment: true,
+              decl: [],
+              exprs: []
+            });
+            processComponent(child, childOptions);
+            parts.push(childOptions.exprs[0]);
+            options.counter = childOptions.counter;
+            options.templateId = childOptions.templateId;
+            return;
+          }
+          options.templateId++;
+          const id = uuid;
+          const childOptions = Object.assign({}, options, {
+            first: true,
+            decl: [],
+            exprs: []
+          });
+          options.templateNodes.push([child]);
+          parseNode(child, childOptions);
+          parts.push(`function() { ${childOptions.decl.join(",\n") + ";\n" + childOptions.exprs.join(";\n") + `;\nreturn _$el${id};\n`}}()`);
+          options.counter = childOptions.counter;
+          options.templateId = childOptions.templateId;
+        } else if (child.type === "text") {
+          parts.push(`"${child.content}"`);
+        } else if (child.type === "comment") {
+          if (child.content === "#") parts.push(`exprs[${options.counter++}]`);else if (child.content) {
+            for (let i = 0; i < child.content.split("###").length - 1; i++) {
+              parts.push(`exprs[${options.counter++}]`);
+            }
+          }
+        }
+      });
+      options.exprs.push(`return [${parts.join(", \n")}]`);
+    } else if (node.type === "tag") {
+      const tag = `_$el${uuid++}`;
+      const topDecl = !options.decl.length;
+      const templateId = options.templateId;
+      options.decl.push(topDecl ? "" : `${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+      const isSVG = r.SVGElements.has(node.name);
+      const isCE = node.name.includes("-") || node.attrs.some(e => e.name === "is");
+      options.hasCustomElement = isCE;
+      options.isImportNode = (node.name === 'img' || node.name === 'iframe') && node.attrs.some(e => e.name === "loading" && e.value === 'lazy');
+      if (node.attrs.some(e => e.name === "###")) {
+        const spreadArgs = [];
+        let current = "";
+        const newAttrs = [];
+        for (let i = 0; i < node.attrs.length; i++) {
+          const {
+            type,
+            name,
+            value
+          } = node.attrs[i];
+          if (type === 'attr') {
+            if (value.includes("###")) {
+              let count = options.counter++;
+              current += `${name}: ${name !== "ref" ? `typeof exprs[${count}] === "function" ? exprs[${count}]() : ` : ""}exprs[${count}],`;
+            } else if (name === "###") {
+              if (current.length) {
+                spreadArgs.push(`()=>({${current}})`);
+                current = "";
+              }
+              spreadArgs.push(`exprs[${options.counter++}]`);
+            } else {
+              newAttrs.push(node.attrs[i]);
+            }
+          } else if (type === 'directive') {
+            parseDirective(name, value, tag, options);
+          }
+        }
+        node.attrs = newAttrs;
+        if (current.length) {
+          spreadArgs.push(`()=>({${current}})`);
+        }
+        options.exprs.push(`r.spread(${tag},${spreadArgs.length === 1 ? `typeof ${spreadArgs[0]} === "function" ? r.mergeProps(${spreadArgs[0]}) : ${spreadArgs[0]}` : `r.mergeProps(${spreadArgs.join(",")})`},${isSVG},${!!node.children.length})`);
+      } else {
+        for (let i = 0; i < node.attrs.length; i++) {
+          const {
+            type,
+            name,
+            value
+          } = node.attrs[i];
+          if (type === 'directive') {
+            parseDirective(name, value, tag, options);
+            node.attrs.splice(i, 1);
+            i--;
+          } else if (type === "attr") {
+            if (value.includes("###")) {
+              node.attrs.splice(i, 1);
+              i--;
+              parseAttribute(node, tag, name, value, isSVG, isCE, options);
+            }
+          }
+        }
+      }
+      options.path = tag;
+      options.first = false;
+      processChildren(node, options);
+      if (topDecl) {
+        options.decl[0] = options.hasCustomElement || options.isImportNode ? `const ${tag} = r.untrack(() => document.importNode(tmpls[${templateId}].content.firstChild, true))` : `const ${tag} = tmpls[${templateId}].content.firstChild.cloneNode(true)`;
+      }
+    } else if (node.type === "text") {
+      const tag = `_$el${uuid++}`;
+      options.decl.push(`${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+      options.path = tag;
+      options.first = false;
+    } else if (node.type === "comment") {
+      const tag = `_$el${uuid++}`;
+      options.decl.push(`${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+      if (node.content === "#") {
+        if (options.multi) {
+          options.exprs.push(`r.insert(${options.parent}, exprs[${options.counter++}], ${tag})`);
+        } else options.exprs.push(`r.insert(${options.parent}, exprs[${options.counter++}])`);
+      }
+      options.path = tag;
+      options.first = false;
+    }
+  }
+  function parseTemplate(nodes, funcBuilder) {
+    const options = {
+        path: "",
+        decl: [],
+        exprs: [],
+        delegatedEvents: new Set(),
+        counter: 0,
+        first: true,
+        multi: false,
+        templateId: 0,
+        templateNodes: []
+      },
+      id = uuid,
+      origNodes = nodes;
+    let toplevel;
+    if (nodes.length > 1) {
+      nodes = [{
+        type: "fragment",
+        children: nodes
+      }];
+    }
+    if (nodes[0].name === "###") {
+      toplevel = true;
+      processComponent(nodes[0], options);
+    } else parseNode(nodes[0], options);
+    r.delegateEvents(Array.from(options.delegatedEvents));
+    const templateNodes = [origNodes].concat(options.templateNodes);
+    return [templateNodes.map(t => stringify(t)), funcBuilder("tmpls", "exprs", "r", options.decl.join(",\n") + ";\n" + options.exprs.join(";\n") + (toplevel ? "" : `;\nreturn _$el${id};\n`))];
+  }
+  function html(statics, ...args) {
+    const templates = cache.get(statics) || createTemplate(statics, {
+      funcBuilder: functionBuilder
+    });
+    return templates[0].create(templates, args, r);
+  }
+  return html;
+}
+
+const html = createHTML({
+  effect: web.effect,
+  style: web.style,
+  insert: web.insert,
+  untrack: web.untrack,
+  spread: web.spread,
+  createComponent: web.createComponent,
+  delegateEvents: web.delegateEvents,
+  classList: web.classList,
+  mergeProps: web.mergeProps,
+  dynamicProperty: web.dynamicProperty,
+  setAttribute: web.setAttribute,
+  setAttributeNS: web.setAttributeNS,
+  addEventListener: web.addEventListener,
+  Aliases: web.Aliases,
+  getPropAlias: web.getPropAlias,
+  Properties: web.Properties,
+  ChildProperties: web.ChildProperties,
+  DelegatedEvents: web.DelegatedEvents,
+  SVGElements: web.SVGElements,
+  SVGNamespace: web.SVGNamespace
+});
+
+module.exports = html;

web/node_modules/solid-js/html/dist/html.js

@@ -0,0 +1,581 @@
+import { SVGNamespace, SVGElements, DelegatedEvents, ChildProperties, Properties, getPropAlias, Aliases, addEventListener, setAttributeNS, setAttribute, dynamicProperty, mergeProps, classList, delegateEvents, createComponent, spread, untrack, insert, style, effect } from 'solid-js/web';
+
+const tagRE = /(?:<!--[\S\s]*?-->|<(?:"[^"]*"['"]*|'[^']*'['"]*|[^'">])+>)/g;
+const attrRE = /(?:\s(?<boolean>[^/\s><=]+?)(?=[\s/>]))|(?:(?<name>\S+?)(?:\s*=\s*(?:(['"])(?<quotedValue>[\s\S]*?)\3|(?<unquotedValue>[^\s>]+))))/g;
+const lookup = {
+  area: true,
+  base: true,
+  br: true,
+  col: true,
+  embed: true,
+  hr: true,
+  img: true,
+  input: true,
+  keygen: true,
+  link: true,
+  menuitem: true,
+  meta: true,
+  param: true,
+  source: true,
+  track: true,
+  wbr: true
+};
+function parseTag(tag) {
+  const res = {
+    type: 'tag',
+    name: '',
+    voidElement: false,
+    attrs: [],
+    children: []
+  };
+  const tagMatch = tag.match(/<\/?([^\s]+?)[/\s>]/);
+  if (tagMatch) {
+    res.name = tagMatch[1];
+    if (lookup[tagMatch[1].toLowerCase()] || tag.charAt(tag.length - 2) === '/') {
+      res.voidElement = true;
+    }
+    if (res.name.startsWith('!--')) {
+      const endIndex = tag.indexOf('-->');
+      return {
+        type: 'comment',
+        comment: endIndex !== -1 ? tag.slice(4, endIndex) : ''
+      };
+    }
+  }
+  const reg = new RegExp(attrRE);
+  for (const match of tag.matchAll(reg)) {
+    if ((match[1] || match[2]).startsWith('use:')) {
+      res.attrs.push({
+        type: 'directive',
+        name: match[1] || match[2],
+        value: match[4] || match[5] || ''
+      });
+    } else {
+      res.attrs.push({
+        type: 'attr',
+        name: match[1] || match[2],
+        value: match[4] || match[5] || ''
+      });
+    }
+  }
+  return res;
+}
+function pushTextNode(list, html, start) {
+  const end = html.indexOf('<', start);
+  const content = html.slice(start, end === -1 ? void 0 : end);
+  if (!/^\s*$/.test(content)) {
+    list.push({
+      type: 'text',
+      content: content
+    });
+  }
+}
+function pushCommentNode(list, tag) {
+  const content = tag.replace('<!--', '').replace('-->', '');
+  if (!/^\s*$/.test(content)) {
+    list.push({
+      type: 'comment',
+      content: content
+    });
+  }
+}
+function parse(html) {
+  const result = [];
+  let current = void 0;
+  let level = -1;
+  const arr = [];
+  const byTag = {};
+  html.replace(tagRE, (tag, index) => {
+    const isOpen = tag.charAt(1) !== '/';
+    const isComment = tag.slice(0, 4) === '<!--';
+    const start = index + tag.length;
+    const nextChar = html.charAt(start);
+    let parent = void 0;
+    if (isOpen && !isComment) {
+      level++;
+      current = parseTag(tag);
+      if (!current.voidElement && nextChar && nextChar !== '<') {
+        pushTextNode(current.children, html, start);
+      }
+      byTag[current.tagName] = current;
+      if (level === 0) {
+        result.push(current);
+      }
+      parent = arr[level - 1];
+      if (parent) {
+        parent.children.push(current);
+      }
+      arr[level] = current;
+    }
+    if (isComment) {
+      if (level < 0) {
+        pushCommentNode(result, tag);
+      } else {
+        pushCommentNode(arr[level].children, tag);
+      }
+    }
+    if (isComment || !isOpen || current.voidElement) {
+      if (!isComment) {
+        level--;
+      }
+      if (nextChar !== '<' && nextChar) {
+        parent = level === -1 ? result : arr[level].children;
+        pushTextNode(parent, html, start);
+      }
+    }
+  });
+  return result;
+}
+function attrString(attrs) {
+  const buff = [];
+  for (const attr of attrs) {
+    buff.push(attr.name + '="' + attr.value.replace(/"/g, '&quot;') + '"');
+  }
+  if (!buff.length) {
+    return '';
+  }
+  return ' ' + buff.join(' ');
+}
+function stringifier(buff, doc) {
+  switch (doc.type) {
+    case 'text':
+      return buff + doc.content;
+    case 'tag':
+      buff += '<' + doc.name + (doc.attrs ? attrString(doc.attrs) : '') + (doc.voidElement ? '/>' : '>');
+      if (doc.voidElement) {
+        return buff;
+      }
+      return buff + doc.children.reduce(stringifier, '') + '</' + doc.name + '>';
+    case 'comment':
+      return buff += '<!--' + doc.content + '-->';
+  }
+}
+function stringify(doc) {
+  return doc.reduce(function (token, rootEl) {
+    return token + stringifier('', rootEl);
+  }, '');
+}
+const cache = new Map();
+const VOID_ELEMENTS = /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i;
+const spaces = " \\f\\n\\r\\t";
+const almostEverything = "[^" + spaces + "\\/>\"'=]+";
+const attrName = "[ " + spaces + "]+(?:use:<!--#-->|" + almostEverything + ')';
+const tagName = "<([A-Za-z$#]+[A-Za-z0-9:_-]*)((?:";
+const attrPartials = "(?:\\s*=\\s*(?:'[^']*?'|\"[^\"]*?\"|\\([^)]*?\\)|<[^>]*?>|" + almostEverything + "))?)";
+const attrSeeker = new RegExp(tagName + attrName + attrPartials + "+)([ " + spaces + "]*/?>)", "g");
+const findAttributes = new RegExp("(" + attrName + "\\s*=\\s*)(<!--#-->|['\"(]([\\w\\s]*<!--#-->[\\w\\s]*)*['\")])", "gi");
+const selfClosing = new RegExp(tagName + attrName + attrPartials + "*)([ " + spaces + "]*/>)", "g");
+const marker = "<!--#-->";
+const reservedNameSpaces = new Set(["class", "on", "oncapture", "style", "use", "prop", "attr"]);
+function attrReplacer($0, $1, $2, $3) {
+  return "<" + $1 + $2.replace(findAttributes, replaceAttributes) + $3;
+}
+function replaceAttributes($0, $1, $2) {
+  return $1.replace(/<!--#-->/g, "###") + ($2[0] === '"' || $2[0] === "'" ? $2.replace(/<!--#-->/g, "###") : '"###"');
+}
+function fullClosing($0, $1, $2) {
+  return VOID_ELEMENTS.test($1) ? $0 : "<" + $1 + $2 + "></" + $1 + ">";
+}
+function toPropertyName(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+function parseDirective(name, value, tag, options) {
+  if (name === 'use:###' && value === '###') {
+    const count = options.counter++;
+    options.exprs.push(`typeof exprs[${count}] === "function" ? r.use(exprs[${count}], ${tag}, exprs[${options.counter++}]) : (()=>{throw new Error("use:### must be a function")})()`);
+  } else {
+    throw new Error(`Not support syntax ${name} must be use:{function}`);
+  }
+}
+function createHTML(r, {
+  delegateEvents = true,
+  functionBuilder = (...args) => new Function(...args)
+} = {}) {
+  let uuid = 1;
+  r.wrapProps = props => {
+    const d = Object.getOwnPropertyDescriptors(props);
+    for (const k in d) {
+      if (typeof d[k].value === "function" && !d[k].value.length) r.dynamicProperty(props, k);
+    }
+    return props;
+  };
+  function createTemplate(statics, opt) {
+    let i = 0,
+      markup = "";
+    for (; i < statics.length - 1; i++) {
+      markup = markup + statics[i] + "<!--#-->";
+    }
+    markup = markup + statics[i];
+    const replaceList = [[selfClosing, fullClosing], [/<(<!--#-->)/g, "<###"], [/\.\.\.(<!--#-->)/g, "###"], [attrSeeker, attrReplacer], [/>\n+\s*/g, ">"], [/\n+\s*</g, "<"], [/\s+</g, " <"], [/>\s+/g, "> "]];
+    markup = replaceList.reduce((acc, x) => {
+      return acc.replace(x[0], x[1]);
+    }, markup);
+    const pars = parse(markup);
+    const [html, code] = parseTemplate(pars, opt.funcBuilder),
+      templates = [];
+    for (let i = 0; i < html.length; i++) {
+      templates.push(document.createElement("template"));
+      templates[i].innerHTML = html[i];
+      const nomarkers = templates[i].content.querySelectorAll("script,style");
+      for (let j = 0; j < nomarkers.length; j++) {
+        const d = nomarkers[j].firstChild?.data || "";
+        if (d.indexOf(marker) > -1) {
+          const parts = d.split(marker).reduce((memo, p, i) => {
+            i && memo.push("");
+            memo.push(p);
+            return memo;
+          }, []);
+          nomarkers[i].firstChild.replaceWith(...parts);
+        }
+      }
+    }
+    templates[0].create = code;
+    cache.set(statics, templates);
+    return templates;
+  }
+  function parseKeyValue(node, tag, name, value, isSVG, isCE, options) {
+    let expr = value === "###" ? `!doNotWrap ? exprs[${options.counter}]() : exprs[${options.counter++}]` : value.split("###").map((v, i) => i ? ` + (typeof exprs[${options.counter}] === "function" ? exprs[${options.counter}]() : exprs[${options.counter++}]) + "${v}"` : `"${v}"`).join(""),
+      parts,
+      namespace;
+    if ((parts = name.split(":")) && parts[1] && reservedNameSpaces.has(parts[0])) {
+      name = parts[1];
+      namespace = parts[0];
+    }
+    const isChildProp = r.ChildProperties.has(name);
+    const isProp = r.Properties.has(name);
+    if (name === "style") {
+      const prev = `_$v${uuid++}`;
+      options.decl.push(`${prev}={}`);
+      options.exprs.push(`r.style(${tag},${expr},${prev})`);
+    } else if (name === "classList") {
+      const prev = `_$v${uuid++}`;
+      options.decl.push(`${prev}={}`);
+      options.exprs.push(`r.classList(${tag},${expr},${prev})`);
+    } else if (namespace !== "attr" && (isChildProp || !isSVG && (r.getPropAlias(name, node.name.toUpperCase()) || isProp) || isCE || namespace === "prop")) {
+      if (isCE && !isChildProp && !isProp && namespace !== "prop") name = toPropertyName(name);
+      options.exprs.push(`${tag}.${r.getPropAlias(name, node.name.toUpperCase()) || name} = ${expr}`);
+    } else {
+      const ns = isSVG && name.indexOf(":") > -1 && r.SVGNamespace[name.split(":")[0]];
+      if (ns) options.exprs.push(`r.setAttributeNS(${tag},"${ns}","${name}",${expr})`);else options.exprs.push(`r.setAttribute(${tag},"${r.Aliases[name] || name}",${expr})`);
+    }
+  }
+  function parseAttribute(node, tag, name, value, isSVG, isCE, options) {
+    if (name.slice(0, 2) === "on") {
+      if (!name.includes(":")) {
+        const lc = name.slice(2).toLowerCase();
+        const delegate = delegateEvents && r.DelegatedEvents.has(lc);
+        options.exprs.push(`r.addEventListener(${tag},"${lc}",exprs[${options.counter++}],${delegate})`);
+        delegate && options.delegatedEvents.add(lc);
+      } else {
+        let capture = name.startsWith("oncapture:");
+        options.exprs.push(`${tag}.addEventListener("${name.slice(capture ? 10 : 3)}",exprs[${options.counter++}]${capture ? ",true" : ""})`);
+      }
+    } else if (name === "ref") {
+      options.exprs.push(`exprs[${options.counter++}](${tag})`);
+    } else {
+      const childOptions = Object.assign({}, options, {
+          exprs: []
+        }),
+        count = options.counter;
+      parseKeyValue(node, tag, name, value, isSVG, isCE, childOptions);
+      options.decl.push(`_fn${count} = (${value === "###" ? "doNotWrap" : ""}) => {\n${childOptions.exprs.join(";\n")};\n}`);
+      if (value === "###") {
+        options.exprs.push(`typeof exprs[${count}] === "function" ? r.effect(_fn${count}) : _fn${count}(true)`);
+      } else {
+        let check = "";
+        for (let i = count; i < childOptions.counter; i++) {
+          i !== count && (check += " || ");
+          check += `typeof exprs[${i}] === "function"`;
+        }
+        options.exprs.push(check + ` ? r.effect(_fn${count}) : _fn${count}()`);
+      }
+      options.counter = childOptions.counter;
+      options.wrap = false;
+    }
+  }
+  function processChildren(node, options) {
+    const childOptions = Object.assign({}, options, {
+      first: true,
+      multi: false,
+      parent: options.path
+    });
+    if (node.children.length > 1) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        if (child.type === "comment" && child.content === "#" || child.type === "tag" && child.name === "###") {
+          childOptions.multi = true;
+          break;
+        }
+      }
+    }
+    let i = 0;
+    while (i < node.children.length) {
+      const child = node.children[i];
+      if (child.name === "###") {
+        if (childOptions.multi) {
+          node.children[i] = {
+            type: "comment",
+            content: "#"
+          };
+          i++;
+        } else node.children.splice(i, 1);
+        processComponent(child, childOptions);
+        continue;
+      }
+      parseNode(child, childOptions);
+      if (!childOptions.multi && child.type === "comment" && child.content === "#") node.children.splice(i, 1);else i++;
+    }
+    options.counter = childOptions.counter;
+    options.templateId = childOptions.templateId;
+    options.hasCustomElement = options.hasCustomElement || childOptions.hasCustomElement;
+    options.isImportNode = options.isImportNode || childOptions.isImportNode;
+  }
+  function processComponentProps(propGroups) {
+    let result = [];
+    for (const props of propGroups) {
+      if (Array.isArray(props)) {
+        if (!props.length) continue;
+        result.push(`r.wrapProps({${props.join(",") || ""}})`);
+      } else result.push(props);
+    }
+    return result.length > 1 ? `r.mergeProps(${result.join(",")})` : result[0];
+  }
+  function processComponent(node, options) {
+    let props = [];
+    const keys = Object.keys(node.attrs),
+      propGroups = [props],
+      componentIdentifier = options.counter++;
+    for (let i = 0; i < keys.length; i++) {
+      const {
+        type,
+        name,
+        value
+      } = node.attrs[i];
+      if (type === 'attr') {
+        if (name === "###") {
+          propGroups.push(`exprs[${options.counter++}]`);
+          propGroups.push(props = []);
+        } else if (value === "###") {
+          props.push(`"${name}": exprs[${options.counter++}]`);
+        } else props.push(`"${name}": "${value}"`);
+      } else if (type === 'directive') {
+        const tag = `_$el${uuid++}`;
+        const topDecl = !options.decl.length;
+        options.decl.push(topDecl ? "" : `${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+        parseDirective(name, value, tag, options);
+      }
+    }
+    if (node.children.length === 1 && node.children[0].type === "comment" && node.children[0].content === "#") {
+      props.push(`children: () => exprs[${options.counter++}]`);
+    } else if (node.children.length) {
+      const children = {
+          type: "fragment",
+          children: node.children
+        },
+        childOptions = Object.assign({}, options, {
+          first: true,
+          decl: [],
+          exprs: [],
+          parent: false
+        });
+      parseNode(children, childOptions);
+      props.push(`children: () => { ${childOptions.exprs.join(";\n")}}`);
+      options.templateId = childOptions.templateId;
+      options.counter = childOptions.counter;
+    }
+    let tag;
+    if (options.multi) {
+      tag = `_$el${uuid++}`;
+      options.decl.push(`${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+    }
+    if (options.parent) options.exprs.push(`r.insert(${options.parent}, r.createComponent(exprs[${componentIdentifier}],${processComponentProps(propGroups)})${tag ? `, ${tag}` : ""})`);else options.exprs.push(`${options.fragment ? "" : "return "}r.createComponent(exprs[${componentIdentifier}],${processComponentProps(propGroups)})`);
+    options.path = tag;
+    options.first = false;
+  }
+  function parseNode(node, options) {
+    if (node.type === "fragment") {
+      const parts = [];
+      node.children.forEach(child => {
+        if (child.type === "tag") {
+          if (child.name === "###") {
+            const childOptions = Object.assign({}, options, {
+              first: true,
+              fragment: true,
+              decl: [],
+              exprs: []
+            });
+            processComponent(child, childOptions);
+            parts.push(childOptions.exprs[0]);
+            options.counter = childOptions.counter;
+            options.templateId = childOptions.templateId;
+            return;
+          }
+          options.templateId++;
+          const id = uuid;
+          const childOptions = Object.assign({}, options, {
+            first: true,
+            decl: [],
+            exprs: []
+          });
+          options.templateNodes.push([child]);
+          parseNode(child, childOptions);
+          parts.push(`function() { ${childOptions.decl.join(",\n") + ";\n" + childOptions.exprs.join(";\n") + `;\nreturn _$el${id};\n`}}()`);
+          options.counter = childOptions.counter;
+          options.templateId = childOptions.templateId;
+        } else if (child.type === "text") {
+          parts.push(`"${child.content}"`);
+        } else if (child.type === "comment") {
+          if (child.content === "#") parts.push(`exprs[${options.counter++}]`);else if (child.content) {
+            for (let i = 0; i < child.content.split("###").length - 1; i++) {
+              parts.push(`exprs[${options.counter++}]`);
+            }
+          }
+        }
+      });
+      options.exprs.push(`return [${parts.join(", \n")}]`);
+    } else if (node.type === "tag") {
+      const tag = `_$el${uuid++}`;
+      const topDecl = !options.decl.length;
+      const templateId = options.templateId;
+      options.decl.push(topDecl ? "" : `${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+      const isSVG = r.SVGElements.has(node.name);
+      const isCE = node.name.includes("-") || node.attrs.some(e => e.name === "is");
+      options.hasCustomElement = isCE;
+      options.isImportNode = (node.name === 'img' || node.name === 'iframe') && node.attrs.some(e => e.name === "loading" && e.value === 'lazy');
+      if (node.attrs.some(e => e.name === "###")) {
+        const spreadArgs = [];
+        let current = "";
+        const newAttrs = [];
+        for (let i = 0; i < node.attrs.length; i++) {
+          const {
+            type,
+            name,
+            value
+          } = node.attrs[i];
+          if (type === 'attr') {
+            if (value.includes("###")) {
+              let count = options.counter++;
+              current += `${name}: ${name !== "ref" ? `typeof exprs[${count}] === "function" ? exprs[${count}]() : ` : ""}exprs[${count}],`;
+            } else if (name === "###") {
+              if (current.length) {
+                spreadArgs.push(`()=>({${current}})`);
+                current = "";
+              }
+              spreadArgs.push(`exprs[${options.counter++}]`);
+            } else {
+              newAttrs.push(node.attrs[i]);
+            }
+          } else if (type === 'directive') {
+            parseDirective(name, value, tag, options);
+          }
+        }
+        node.attrs = newAttrs;
+        if (current.length) {
+          spreadArgs.push(`()=>({${current}})`);
+        }
+        options.exprs.push(`r.spread(${tag},${spreadArgs.length === 1 ? `typeof ${spreadArgs[0]} === "function" ? r.mergeProps(${spreadArgs[0]}) : ${spreadArgs[0]}` : `r.mergeProps(${spreadArgs.join(",")})`},${isSVG},${!!node.children.length})`);
+      } else {
+        for (let i = 0; i < node.attrs.length; i++) {
+          const {
+            type,
+            name,
+            value
+          } = node.attrs[i];
+          if (type === 'directive') {
+            parseDirective(name, value, tag, options);
+            node.attrs.splice(i, 1);
+            i--;
+          } else if (type === "attr") {
+            if (value.includes("###")) {
+              node.attrs.splice(i, 1);
+              i--;
+              parseAttribute(node, tag, name, value, isSVG, isCE, options);
+            }
+          }
+        }
+      }
+      options.path = tag;
+      options.first = false;
+      processChildren(node, options);
+      if (topDecl) {
+        options.decl[0] = options.hasCustomElement || options.isImportNode ? `const ${tag} = r.untrack(() => document.importNode(tmpls[${templateId}].content.firstChild, true))` : `const ${tag} = tmpls[${templateId}].content.firstChild.cloneNode(true)`;
+      }
+    } else if (node.type === "text") {
+      const tag = `_$el${uuid++}`;
+      options.decl.push(`${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+      options.path = tag;
+      options.first = false;
+    } else if (node.type === "comment") {
+      const tag = `_$el${uuid++}`;
+      options.decl.push(`${tag} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+      if (node.content === "#") {
+        if (options.multi) {
+          options.exprs.push(`r.insert(${options.parent}, exprs[${options.counter++}], ${tag})`);
+        } else options.exprs.push(`r.insert(${options.parent}, exprs[${options.counter++}])`);
+      }
+      options.path = tag;
+      options.first = false;
+    }
+  }
+  function parseTemplate(nodes, funcBuilder) {
+    const options = {
+        path: "",
+        decl: [],
+        exprs: [],
+        delegatedEvents: new Set(),
+        counter: 0,
+        first: true,
+        multi: false,
+        templateId: 0,
+        templateNodes: []
+      },
+      id = uuid,
+      origNodes = nodes;
+    let toplevel;
+    if (nodes.length > 1) {
+      nodes = [{
+        type: "fragment",
+        children: nodes
+      }];
+    }
+    if (nodes[0].name === "###") {
+      toplevel = true;
+      processComponent(nodes[0], options);
+    } else parseNode(nodes[0], options);
+    r.delegateEvents(Array.from(options.delegatedEvents));
+    const templateNodes = [origNodes].concat(options.templateNodes);
+    return [templateNodes.map(t => stringify(t)), funcBuilder("tmpls", "exprs", "r", options.decl.join(",\n") + ";\n" + options.exprs.join(";\n") + (toplevel ? "" : `;\nreturn _$el${id};\n`))];
+  }
+  function html(statics, ...args) {
+    const templates = cache.get(statics) || createTemplate(statics, {
+      funcBuilder: functionBuilder
+    });
+    return templates[0].create(templates, args, r);
+  }
+  return html;
+}
+
+const html = createHTML({
+  effect,
+  style,
+  insert,
+  untrack,
+  spread,
+  createComponent,
+  delegateEvents,
+  classList,
+  mergeProps,
+  dynamicProperty,
+  setAttribute,
+  setAttributeNS,
+  addEventListener,
+  Aliases,
+  getPropAlias,
+  Properties,
+  ChildProperties,
+  DelegatedEvents,
+  SVGElements,
+  SVGNamespace
+});
+
+export { html as default };

web/node_modules/solid-js/html/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "solid-js/html",
+  "main": "./dist/html.cjs",
+  "module": "./dist/html.js",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "sideEffects": false
+}

web/node_modules/solid-js/html/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLTag } from "./lit.js";
+declare const html: HTMLTag;
+export default html;

web/node_modules/solid-js/html/types/lit.d.ts

@@ -0,0 +1,41 @@
+type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+interface Runtime {
+    effect<T>(fn: (prev?: T) => T, init?: T): any;
+    untrack<T>(fn: () => T): T;
+    insert(parent: MountableElement, accessor: any, marker?: Node | null, init?: any): any;
+    spread<T>(node: Element, accessor: (() => T) | T, isSVG?: Boolean, skipChildren?: Boolean): void;
+    createComponent(Comp: (props: any) => any, props: any): any;
+    addEventListener(node: Element, name: string, handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions), delegate: boolean): void;
+    delegateEvents(eventNames: string[]): void;
+    classList(node: Element, value: {
+        [k: string]: boolean;
+    }, prev?: {
+        [k: string]: boolean;
+    }): {
+        [k: string]: boolean;
+    };
+    style(node: Element, value: {
+        [k: string]: string;
+    }, prev?: {
+        [k: string]: string;
+    }): void;
+    mergeProps(...sources: unknown[]): unknown;
+    dynamicProperty(props: any, key: string): any;
+    setAttribute(node: Element, name: string, value: any): void;
+    setAttributeNS(node: Element, namespace: string, name: string, value: any): void;
+    Aliases: Record<string, string>;
+    getPropAlias(prop: string, tagName: string): string | undefined;
+    Properties: Set<string>;
+    ChildProperties: Set<string>;
+    DelegatedEvents: Set<string>;
+    SVGElements: Set<string>;
+    SVGNamespace: Record<string, string>;
+}
+export type HTMLTag = {
+    (statics: TemplateStringsArray, ...args: unknown[]): Node | Node[];
+};
+export declare function createHTML(r: Runtime, { delegateEvents, functionBuilder }?: {
+    delegateEvents?: boolean;
+    functionBuilder?: (...args: string[]) => Function;
+}): HTMLTag;
+export {};

web/node_modules/solid-js/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export * from "./types/jsx";

web/node_modules/solid-js/package.json

@@ -0,0 +1,243 @@
+{
+  "name": "solid-js",
+  "description": "A declarative JavaScript library for building user interfaces.",
+  "version": "1.9.12",
+  "author": "Ryan Carniato",
+  "license": "MIT",
+  "homepage": "https://solidjs.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solidjs/solid"
+  },
+  "main": "./dist/server.cjs",
+  "module": "./dist/server.js",
+  "unpkg": "./dist/solid.cjs",
+  "types": "types/index.d.ts",
+  "sideEffects": false,
+  "type": "module",
+  "files": [
+    "dist",
+    "store/dist",
+    "store/types",
+    "store/package.json",
+    "web/dist",
+    "web/types",
+    "web/package.json",
+    "web/storage/dist",
+    "web/storage/types",
+    "web/storage/package.json",
+    "h/dist",
+    "h/types",
+    "h/package.json",
+    "h/jsx-runtime/dist",
+    "h/jsx-runtime/types",
+    "h/jsx-runtime/package.json",
+    "h/jsx-dev-runtime/package.json",
+    "html/dist",
+    "html/types",
+    "html/package.json",
+    "universal/dist",
+    "universal/types",
+    "universal/package.json",
+    "types",
+    "jsx-runtime.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "worker": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "browser": {
+        "development": {
+          "types": "./types/index.d.ts",
+          "import": "./dist/dev.js",
+          "require": "./dist/dev.cjs"
+        },
+        "types": "./types/index.d.ts",
+        "import": "./dist/solid.js",
+        "require": "./dist/solid.cjs"
+      },
+      "deno": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "node": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "development": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/dev.js",
+        "require": "./dist/dev.cjs"
+      },
+      "types": "./types/index.d.ts",
+      "import": "./dist/solid.js",
+      "require": "./dist/solid.cjs"
+    },
+    "./dist/*": "./dist/*",
+    "./types/*": "./types/*",
+    "./jsx-runtime": {
+      "types": "./types/jsx.d.ts",
+      "default": "./dist/solid.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./types/jsx.d.ts",
+      "default": "./dist/solid.js"
+    },
+    "./store": {
+      "worker": {
+        "types": "./store/types/index.d.ts",
+        "import": "./store/dist/server.js",
+        "require": "./store/dist/server.cjs"
+      },
+      "browser": {
+        "development": {
+          "types": "./store/types/index.d.ts",
+          "import": "./store/dist/dev.js",
+          "require": "./store/dist/dev.cjs"
+        },
+        "types": "./store/types/index.d.ts",
+        "import": "./store/dist/store.js",
+        "require": "./store/dist/store.cjs"
+      },
+      "deno": {
+        "types": "./store/types/index.d.ts",
+        "import": "./store/dist/server.js",
+        "require": "./store/dist/server.cjs"
+      },
+      "node": {
+        "types": "./store/types/index.d.ts",
+        "import": "./store/dist/server.js",
+        "require": "./store/dist/server.cjs"
+      },
+      "development": {
+        "types": "./store/types/index.d.ts",
+        "import": "./store/dist/dev.js",
+        "require": "./store/dist/dev.cjs"
+      },
+      "types": "./store/types/index.d.ts",
+      "import": "./store/dist/store.js",
+      "require": "./store/dist/store.cjs"
+    },
+    "./store/dist/*": "./store/dist/*",
+    "./store/types/*": "./store/types/*",
+    "./web": {
+      "worker": {
+        "types": "./web/types/index.d.ts",
+        "import": "./web/dist/server.js",
+        "require": "./web/dist/server.cjs"
+      },
+      "browser": {
+        "development": {
+          "types": "./web/types/index.d.ts",
+          "import": "./web/dist/dev.js",
+          "require": "./web/dist/dev.cjs"
+        },
+        "types": "./web/types/index.d.ts",
+        "import": "./web/dist/web.js",
+        "require": "./web/dist/web.cjs"
+      },
+      "deno": {
+        "types": "./web/types/index.d.ts",
+        "import": "./web/dist/server.js",
+        "require": "./web/dist/server.cjs"
+      },
+      "node": {
+        "types": "./web/types/index.d.ts",
+        "import": "./web/dist/server.js",
+        "require": "./web/dist/server.cjs"
+      },
+      "development": {
+        "types": "./web/types/index.d.ts",
+        "import": "./web/dist/dev.js",
+        "require": "./web/dist/dev.cjs"
+      },
+      "types": "./web/types/index.d.ts",
+      "import": "./web/dist/web.js",
+      "require": "./web/dist/web.cjs"
+    },
+    "./web/storage": {
+      "types": "./web/storage/types/index.d.ts",
+      "import": "./web/storage/dist/storage.js",
+      "require": "./web/storage/dist/storage.cjs"
+    },
+    "./web/dist/*": "./web/dist/*",
+    "./web/types/*": "./web/types/*",
+    "./universal": {
+      "development": {
+        "types": "./universal/types/index.d.ts",
+        "import": "./universal/dist/dev.js",
+        "require": "./universal/dist/dev.cjs"
+      },
+      "types": "./universal/types/index.d.ts",
+      "import": "./universal/dist/universal.js",
+      "require": "./universal/dist/universal.cjs"
+    },
+    "./universal/dist/*": "./universal/dist/*",
+    "./universal/types/*": "./universal/types/*",
+    "./h": {
+      "types": "./h/types/index.d.ts",
+      "import": "./h/dist/h.js",
+      "require": "./h/dist/h.cjs"
+    },
+    "./h/jsx-runtime": {
+      "types": "./h/jsx-runtime/types/index.d.ts",
+      "import": "./h/jsx-runtime/dist/jsx.js",
+      "require": "./h/jsx-runtime/dist/jsx.cjs"
+    },
+    "./h/jsx-dev-runtime": {
+      "types": "./h/jsx-runtime/types/index.d.ts",
+      "import": "./h/jsx-runtime/dist/jsx.js",
+      "require": "./h/jsx-runtime/dist/jsx.cjs"
+    },
+    "./h/dist/*": "./h/dist/*",
+    "./h/types/*": "./h/types/*",
+    "./html": {
+      "types": "./html/types/index.d.ts",
+      "import": "./html/dist/html.js",
+      "require": "./html/dist/html.cjs"
+    },
+    "./html/dist/*": "./html/dist/*",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "solid",
+    "solidjs",
+    "ui",
+    "reactive",
+    "components",
+    "compiler",
+    "performance"
+  ],
+  "dependencies": {
+    "csstype": "^3.1.0",
+    "seroval": "~1.5.0",
+    "seroval-plugins": "~1.5.0"
+  },
+  "scripts": {
+    "build": "npm-run-all -nl build:*",
+    "build:clean": "rimraf dist/ coverage/ store/dist/ web/dist/ web/storage/dist h/dist/ h/jsx-runtime/dist html/dist/ universal/dist/",
+    "build:js": "rollup -c",
+    "types": "npm-run-all -nl types:*",
+    "types:clean": "rimraf types/ store/types/ web/types/ web/storage/types/ h/types/ h/jsx-runtime/types html/types/ universal/types/ src/jsx.d.ts h/jsx-runtime/src/jsx.d.ts",
+    "types:copy": "ncp ../../node_modules/dom-expressions/src/jsx.d.ts ./src/jsx.d.ts && ncp ../../node_modules/dom-expressions/src/jsx-h.d.ts ./h/jsx-runtime/src/jsx.d.ts",
+    "types:src": "tsc --project ./tsconfig.build.json && ncp ../../node_modules/dom-expressions/src/jsx.d.ts ./types/jsx.d.ts",
+    "types:web": "tsc --project ./web/tsconfig.build.json",
+    "types:web-storage": "tsc --project ./web/storage/tsconfig.build.json",
+    "types:copy-web": "ncp ../../node_modules/dom-expressions/src/client.d.ts ./web/types/client.d.ts && ncp ../../node_modules/dom-expressions/src/server.d.ts ./web/types/server.d.ts",
+    "types:store": "tsc --project ./store/tsconfig.build.json",
+    "types:html": "tsc --project ./html/tsconfig.json && ncp ../../node_modules/lit-dom-expressions/types/index.d.ts ./html/types/lit.d.ts",
+    "types:h": "tsc --project ./h/tsconfig.json && ncp ../../node_modules/hyper-dom-expressions/types/index.d.ts ./h/types/hyperscript.d.ts",
+    "types:jsx": "rimraf ./h/jsx-runtime/types && tsc --project ./h/jsx-runtime/tsconfig.json && ncp ../../node_modules/dom-expressions/src/jsx-h.d.ts ./h/jsx-runtime/types/jsx.d.ts",
+    "types:universal": "tsc --project ./universal/tsconfig.json && ncp ../../node_modules/dom-expressions/src/universal.d.ts ./universal/types/universal.d.ts",
+    "bench": "node --allow-natives-syntax bench/bench.cjs",
+    "link": "symlink-dir . node_modules/solid-js",
+    "test": "vitest run",
+    "coverage": "vitest run --coverage",
+    "test-types": "tsc --project tsconfig.test.json"
+  }
+}

web/node_modules/solid-js/store/dist/dev.cjs

@@ -0,0 +1,458 @@
+'use strict';
+
+var solidJs = require('solid-js');
+
+const $RAW = Symbol("store-raw"),
+  $NODE = Symbol("store-node"),
+  $HAS = Symbol("store-has"),
+  $SELF = Symbol("store-self");
+const DevHooks = {
+  onStoreNodeUpdate: null
+};
+function wrap$1(value) {
+  let p = value[solidJs.$PROXY];
+  if (!p) {
+    Object.defineProperty(value, solidJs.$PROXY, {
+      value: p = new Proxy(value, proxyTraps$1)
+    });
+    if (!Array.isArray(value)) {
+      const keys = Object.keys(value),
+        desc = Object.getOwnPropertyDescriptors(value);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const prop = keys[i];
+        if (desc[prop].get) {
+          Object.defineProperty(value, prop, {
+            enumerable: desc[prop].enumerable,
+            get: desc[prop].get.bind(p)
+          });
+        }
+      }
+    }
+  }
+  return p;
+}
+function isWrappable(obj) {
+  let proto;
+  return obj != null && typeof obj === "object" && (obj[solidJs.$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item, set = new Set()) {
+  let result, unwrapped, v, prop;
+  if (result = item != null && item[$RAW]) return result;
+  if (!isWrappable(item) || set.has(item)) return item;
+  if (Array.isArray(item)) {
+    if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
+    for (let i = 0, l = item.length; i < l; i++) {
+      v = item[i];
+      if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
+    }
+  } else {
+    if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
+    const keys = Object.keys(item),
+      desc = Object.getOwnPropertyDescriptors(item);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      prop = keys[i];
+      if (desc[prop].get) continue;
+      v = item[prop];
+      if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
+    }
+  }
+  return item;
+}
+function getNodes(target, symbol) {
+  let nodes = target[symbol];
+  if (!nodes) Object.defineProperty(target, symbol, {
+    value: nodes = Object.create(null)
+  });
+  return nodes;
+}
+function getNode(nodes, property, value) {
+  if (nodes[property]) return nodes[property];
+  const [s, set] = solidJs.createSignal(value, {
+    equals: false,
+    internal: true
+  });
+  s.$ = set;
+  return nodes[property] = s;
+}
+function proxyDescriptor$1(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[solidJs.$PROXY][property];
+  return desc;
+}
+function trackSelf(target) {
+  solidJs.getListener() && getNode(getNodes(target, $NODE), $SELF)();
+}
+function ownKeys(target) {
+  trackSelf(target);
+  return Reflect.ownKeys(target);
+}
+const proxyTraps$1 = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === solidJs.$PROXY) return receiver;
+    if (property === solidJs.$TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      if (solidJs.getListener() && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
+    }
+    return isWrappable(value) ? wrap$1(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set() {
+    console.warn("Cannot mutate a Store directly");
+    return true;
+  },
+  deleteProperty() {
+    console.warn("Cannot mutate a Store directly");
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor$1
+};
+function setProperty(state, property, value, deleting = false) {
+  if (!deleting && state[property] === value) return;
+  const prev = state[property],
+    len = state.length;
+  DevHooks.onStoreNodeUpdate && DevHooks.onStoreNodeUpdate(state, property, value, prev);
+  if (value === undefined) {
+    delete state[property];
+    if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
+  } else {
+    state[property] = value;
+    if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
+  }
+  let nodes = getNodes(state, $NODE),
+    node;
+  if (node = getNode(nodes, property, prev)) node.$(() => value);
+  if (Array.isArray(state) && state.length !== len) {
+    for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
+    (node = getNode(nodes, "length", len)) && node.$(state.length);
+  }
+  (node = nodes[$SELF]) && node.$();
+}
+function mergeStoreNode(state, value) {
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    setProperty(state, key, value[key]);
+  }
+}
+function updateArray(current, next) {
+  if (typeof next === "function") next = next(current);
+  next = unwrap(next);
+  if (Array.isArray(next)) {
+    if (current === next) return;
+    let i = 0,
+      len = next.length;
+    for (; i < len; i++) {
+      const value = next[i];
+      if (current[i] !== value) setProperty(current, i, value);
+    }
+    setProperty(current, "length", len);
+  } else mergeStoreNode(current, next);
+}
+function updatePath(current, path, traversed = []) {
+  let part,
+    prev = current;
+  if (path.length > 1) {
+    part = path.shift();
+    const partType = typeof part,
+      isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let i = 0; i < part.length; i++) {
+        updatePath(current, [part[i]].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "function") {
+      for (let i = 0; i < current.length; i++) {
+        if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "object") {
+      const {
+        from = 0,
+        to = current.length - 1,
+        by = 1
+      } = part;
+      for (let i = from; i <= to; i += by) {
+        updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (path.length > 1) {
+      updatePath(current[part], path, [part].concat(traversed));
+      return;
+    }
+    prev = current[part];
+    traversed = [part].concat(traversed);
+  }
+  let value = path[0];
+  if (typeof value === "function") {
+    value = value(prev, traversed);
+    if (value === prev) return;
+  }
+  if (part === undefined && value == undefined) return;
+  value = unwrap(value);
+  if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
+    mergeStoreNode(prev, value);
+  } else setProperty(current, part, value);
+}
+function createStore(...[store, options]) {
+  const unwrappedStore = unwrap(store || {});
+  const isArray = Array.isArray(unwrappedStore);
+  if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createStore'. Expected an object.`);
+  const wrappedStore = wrap$1(unwrappedStore);
+  solidJs.DEV.registerGraph({
+    value: unwrappedStore,
+    name: options && options.name
+  });
+  function setStore(...args) {
+    solidJs.batch(() => {
+      isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
+    });
+  }
+  return [wrappedStore, setStore];
+}
+
+function proxyDescriptor(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || desc.set || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[solidJs.$PROXY][property];
+  desc.set = v => target[solidJs.$PROXY][property] = v;
+  return desc;
+}
+const proxyTraps = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === solidJs.$PROXY) return receiver;
+    if (property === solidJs.$TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      const isFunction = typeof value === "function";
+      if (solidJs.getListener() && (!isFunction || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
+        return (...args) => solidJs.batch(() => Array.prototype[property].apply(receiver, args));
+      }
+    }
+    return isWrappable(value) ? wrap(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set(target, property, value) {
+    solidJs.batch(() => setProperty(target, property, unwrap(value)));
+    return true;
+  },
+  deleteProperty(target, property) {
+    solidJs.batch(() => setProperty(target, property, undefined, true));
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor
+};
+function wrap(value) {
+  let p = value[solidJs.$PROXY];
+  if (!p) {
+    Object.defineProperty(value, solidJs.$PROXY, {
+      value: p = new Proxy(value, proxyTraps)
+    });
+    const keys = Object.keys(value),
+      desc = Object.getOwnPropertyDescriptors(value);
+    const proto = Object.getPrototypeOf(value);
+    const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
+    if (isClass) {
+      let curProto = proto;
+      while (curProto != null) {
+        const descriptors = Object.getOwnPropertyDescriptors(curProto);
+        keys.push(...Object.keys(descriptors));
+        Object.assign(desc, descriptors);
+        curProto = Object.getPrototypeOf(curProto);
+      }
+    }
+    for (let i = 0, l = keys.length; i < l; i++) {
+      const prop = keys[i];
+      if (isClass && prop === "constructor") continue;
+      if (desc[prop].get) {
+        const get = desc[prop].get.bind(p);
+        Object.defineProperty(value, prop, {
+          get,
+          configurable: true
+        });
+      }
+      if (desc[prop].set) {
+        const og = desc[prop].set,
+          set = v => solidJs.batch(() => og.call(p, v));
+        Object.defineProperty(value, prop, {
+          set,
+          configurable: true
+        });
+      }
+    }
+  }
+  return p;
+}
+function createMutable(state, options) {
+  const unwrappedStore = unwrap(state || {});
+  if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createMutable'. Expected an object.`);
+  const wrappedStore = wrap(unwrappedStore);
+  solidJs.DEV.registerGraph({
+    value: unwrappedStore,
+    name: options && options.name
+  });
+  return wrappedStore;
+}
+function modifyMutable(state, modifier) {
+  solidJs.batch(() => modifier(unwrap(state)));
+}
+
+const $ROOT = Symbol("store-root");
+function applyState(target, parent, property, merge, key) {
+  const previous = parent[property];
+  if (target === previous) return;
+  const isArray = Array.isArray(target);
+  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
+    setProperty(parent, property, target);
+    return;
+  }
+  if (isArray) {
+    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
+        applyState(target[start], previous, start, merge, key);
+      }
+      const temp = new Array(target.length),
+        newIndices = new Map();
+      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+        temp[newEnd] = previous[end];
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
+        for (; j < target.length; j++) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        }
+        if (previous.length > target.length) setProperty(previous, "length", target.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = target[j];
+        keyVal = key && item ? item[key] : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === undefined ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = key && item ? item[key] : item;
+        j = newIndices.get(keyVal);
+        if (j !== undefined && j !== -1) {
+          temp[j] = previous[i];
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < target.length; j++) {
+        if (j in temp) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        } else setProperty(previous, j, target[j]);
+      }
+    } else {
+      for (let i = 0, len = target.length; i < len; i++) {
+        applyState(target[i], previous, i, merge, key);
+      }
+    }
+    if (previous.length > target.length) setProperty(previous, "length", target.length);
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  for (let i = 0, len = targetKeys.length; i < len; i++) {
+    applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+  }
+  const previousKeys = Object.keys(previous);
+  for (let i = 0, len = previousKeys.length; i < len; i++) {
+    if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
+  }
+}
+function reconcile(value, options = {}) {
+  const {
+      merge,
+      key = "id"
+    } = options,
+    v = unwrap(value);
+  return state => {
+    if (!isWrappable(state) || !isWrappable(v)) return v;
+    const res = applyState(v, {
+      [$ROOT]: state
+    }, $ROOT, merge, key);
+    return res === undefined ? state : res;
+  };
+}
+const producers = new WeakMap();
+const setterTraps = {
+  get(target, property) {
+    if (property === $RAW) return target;
+    const value = target[property];
+    let proxy;
+    return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
+  },
+  set(target, property, value) {
+    setProperty(target, property, unwrap(value));
+    return true;
+  },
+  deleteProperty(target, property) {
+    setProperty(target, property, undefined, true);
+    return true;
+  }
+};
+function produce(fn) {
+  return state => {
+    if (isWrappable(state)) {
+      let proxy;
+      if (!(proxy = producers.get(state))) {
+        producers.set(state, proxy = new Proxy(state, setterTraps));
+      }
+      fn(proxy);
+    }
+    return state;
+  };
+}
+
+const DEV = {
+  $NODE,
+  isWrappable,
+  hooks: DevHooks
+} ;
+
+exports.$RAW = $RAW;
+exports.DEV = DEV;
+exports.createMutable = createMutable;
+exports.createStore = createStore;
+exports.modifyMutable = modifyMutable;
+exports.produce = produce;
+exports.reconcile = reconcile;
+exports.unwrap = unwrap;

web/node_modules/solid-js/store/dist/dev.js

@@ -0,0 +1,449 @@
+import { $PROXY, DEV as DEV$1, batch, $TRACK, getListener, createSignal } from 'solid-js';
+
+const $RAW = Symbol("store-raw"),
+  $NODE = Symbol("store-node"),
+  $HAS = Symbol("store-has"),
+  $SELF = Symbol("store-self");
+const DevHooks = {
+  onStoreNodeUpdate: null
+};
+function wrap$1(value) {
+  let p = value[$PROXY];
+  if (!p) {
+    Object.defineProperty(value, $PROXY, {
+      value: p = new Proxy(value, proxyTraps$1)
+    });
+    if (!Array.isArray(value)) {
+      const keys = Object.keys(value),
+        desc = Object.getOwnPropertyDescriptors(value);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const prop = keys[i];
+        if (desc[prop].get) {
+          Object.defineProperty(value, prop, {
+            enumerable: desc[prop].enumerable,
+            get: desc[prop].get.bind(p)
+          });
+        }
+      }
+    }
+  }
+  return p;
+}
+function isWrappable(obj) {
+  let proto;
+  return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item, set = new Set()) {
+  let result, unwrapped, v, prop;
+  if (result = item != null && item[$RAW]) return result;
+  if (!isWrappable(item) || set.has(item)) return item;
+  if (Array.isArray(item)) {
+    if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
+    for (let i = 0, l = item.length; i < l; i++) {
+      v = item[i];
+      if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
+    }
+  } else {
+    if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
+    const keys = Object.keys(item),
+      desc = Object.getOwnPropertyDescriptors(item);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      prop = keys[i];
+      if (desc[prop].get) continue;
+      v = item[prop];
+      if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
+    }
+  }
+  return item;
+}
+function getNodes(target, symbol) {
+  let nodes = target[symbol];
+  if (!nodes) Object.defineProperty(target, symbol, {
+    value: nodes = Object.create(null)
+  });
+  return nodes;
+}
+function getNode(nodes, property, value) {
+  if (nodes[property]) return nodes[property];
+  const [s, set] = createSignal(value, {
+    equals: false,
+    internal: true
+  });
+  s.$ = set;
+  return nodes[property] = s;
+}
+function proxyDescriptor$1(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[$PROXY][property];
+  return desc;
+}
+function trackSelf(target) {
+  getListener() && getNode(getNodes(target, $NODE), $SELF)();
+}
+function ownKeys(target) {
+  trackSelf(target);
+  return Reflect.ownKeys(target);
+}
+const proxyTraps$1 = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === $PROXY) return receiver;
+    if (property === $TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      if (getListener() && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
+    }
+    return isWrappable(value) ? wrap$1(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set() {
+    console.warn("Cannot mutate a Store directly");
+    return true;
+  },
+  deleteProperty() {
+    console.warn("Cannot mutate a Store directly");
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor$1
+};
+function setProperty(state, property, value, deleting = false) {
+  if (!deleting && state[property] === value) return;
+  const prev = state[property],
+    len = state.length;
+  DevHooks.onStoreNodeUpdate && DevHooks.onStoreNodeUpdate(state, property, value, prev);
+  if (value === undefined) {
+    delete state[property];
+    if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
+  } else {
+    state[property] = value;
+    if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
+  }
+  let nodes = getNodes(state, $NODE),
+    node;
+  if (node = getNode(nodes, property, prev)) node.$(() => value);
+  if (Array.isArray(state) && state.length !== len) {
+    for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
+    (node = getNode(nodes, "length", len)) && node.$(state.length);
+  }
+  (node = nodes[$SELF]) && node.$();
+}
+function mergeStoreNode(state, value) {
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    setProperty(state, key, value[key]);
+  }
+}
+function updateArray(current, next) {
+  if (typeof next === "function") next = next(current);
+  next = unwrap(next);
+  if (Array.isArray(next)) {
+    if (current === next) return;
+    let i = 0,
+      len = next.length;
+    for (; i < len; i++) {
+      const value = next[i];
+      if (current[i] !== value) setProperty(current, i, value);
+    }
+    setProperty(current, "length", len);
+  } else mergeStoreNode(current, next);
+}
+function updatePath(current, path, traversed = []) {
+  let part,
+    prev = current;
+  if (path.length > 1) {
+    part = path.shift();
+    const partType = typeof part,
+      isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let i = 0; i < part.length; i++) {
+        updatePath(current, [part[i]].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "function") {
+      for (let i = 0; i < current.length; i++) {
+        if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "object") {
+      const {
+        from = 0,
+        to = current.length - 1,
+        by = 1
+      } = part;
+      for (let i = from; i <= to; i += by) {
+        updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (path.length > 1) {
+      updatePath(current[part], path, [part].concat(traversed));
+      return;
+    }
+    prev = current[part];
+    traversed = [part].concat(traversed);
+  }
+  let value = path[0];
+  if (typeof value === "function") {
+    value = value(prev, traversed);
+    if (value === prev) return;
+  }
+  if (part === undefined && value == undefined) return;
+  value = unwrap(value);
+  if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
+    mergeStoreNode(prev, value);
+  } else setProperty(current, part, value);
+}
+function createStore(...[store, options]) {
+  const unwrappedStore = unwrap(store || {});
+  const isArray = Array.isArray(unwrappedStore);
+  if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createStore'. Expected an object.`);
+  const wrappedStore = wrap$1(unwrappedStore);
+  DEV$1.registerGraph({
+    value: unwrappedStore,
+    name: options && options.name
+  });
+  function setStore(...args) {
+    batch(() => {
+      isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
+    });
+  }
+  return [wrappedStore, setStore];
+}
+
+function proxyDescriptor(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || desc.set || !desc.configurable || property === $PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[$PROXY][property];
+  desc.set = v => target[$PROXY][property] = v;
+  return desc;
+}
+const proxyTraps = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === $PROXY) return receiver;
+    if (property === $TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      const isFunction = typeof value === "function";
+      if (getListener() && (!isFunction || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
+        return (...args) => batch(() => Array.prototype[property].apply(receiver, args));
+      }
+    }
+    return isWrappable(value) ? wrap(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set(target, property, value) {
+    batch(() => setProperty(target, property, unwrap(value)));
+    return true;
+  },
+  deleteProperty(target, property) {
+    batch(() => setProperty(target, property, undefined, true));
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor
+};
+function wrap(value) {
+  let p = value[$PROXY];
+  if (!p) {
+    Object.defineProperty(value, $PROXY, {
+      value: p = new Proxy(value, proxyTraps)
+    });
+    const keys = Object.keys(value),
+      desc = Object.getOwnPropertyDescriptors(value);
+    const proto = Object.getPrototypeOf(value);
+    const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
+    if (isClass) {
+      let curProto = proto;
+      while (curProto != null) {
+        const descriptors = Object.getOwnPropertyDescriptors(curProto);
+        keys.push(...Object.keys(descriptors));
+        Object.assign(desc, descriptors);
+        curProto = Object.getPrototypeOf(curProto);
+      }
+    }
+    for (let i = 0, l = keys.length; i < l; i++) {
+      const prop = keys[i];
+      if (isClass && prop === "constructor") continue;
+      if (desc[prop].get) {
+        const get = desc[prop].get.bind(p);
+        Object.defineProperty(value, prop, {
+          get,
+          configurable: true
+        });
+      }
+      if (desc[prop].set) {
+        const og = desc[prop].set,
+          set = v => batch(() => og.call(p, v));
+        Object.defineProperty(value, prop, {
+          set,
+          configurable: true
+        });
+      }
+    }
+  }
+  return p;
+}
+function createMutable(state, options) {
+  const unwrappedStore = unwrap(state || {});
+  if (typeof unwrappedStore !== "object" && typeof unwrappedStore !== "function") throw new Error(`Unexpected type ${typeof unwrappedStore} received when initializing 'createMutable'. Expected an object.`);
+  const wrappedStore = wrap(unwrappedStore);
+  DEV$1.registerGraph({
+    value: unwrappedStore,
+    name: options && options.name
+  });
+  return wrappedStore;
+}
+function modifyMutable(state, modifier) {
+  batch(() => modifier(unwrap(state)));
+}
+
+const $ROOT = Symbol("store-root");
+function applyState(target, parent, property, merge, key) {
+  const previous = parent[property];
+  if (target === previous) return;
+  const isArray = Array.isArray(target);
+  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
+    setProperty(parent, property, target);
+    return;
+  }
+  if (isArray) {
+    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
+        applyState(target[start], previous, start, merge, key);
+      }
+      const temp = new Array(target.length),
+        newIndices = new Map();
+      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+        temp[newEnd] = previous[end];
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
+        for (; j < target.length; j++) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        }
+        if (previous.length > target.length) setProperty(previous, "length", target.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = target[j];
+        keyVal = key && item ? item[key] : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === undefined ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = key && item ? item[key] : item;
+        j = newIndices.get(keyVal);
+        if (j !== undefined && j !== -1) {
+          temp[j] = previous[i];
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < target.length; j++) {
+        if (j in temp) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        } else setProperty(previous, j, target[j]);
+      }
+    } else {
+      for (let i = 0, len = target.length; i < len; i++) {
+        applyState(target[i], previous, i, merge, key);
+      }
+    }
+    if (previous.length > target.length) setProperty(previous, "length", target.length);
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  for (let i = 0, len = targetKeys.length; i < len; i++) {
+    applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+  }
+  const previousKeys = Object.keys(previous);
+  for (let i = 0, len = previousKeys.length; i < len; i++) {
+    if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
+  }
+}
+function reconcile(value, options = {}) {
+  const {
+      merge,
+      key = "id"
+    } = options,
+    v = unwrap(value);
+  return state => {
+    if (!isWrappable(state) || !isWrappable(v)) return v;
+    const res = applyState(v, {
+      [$ROOT]: state
+    }, $ROOT, merge, key);
+    return res === undefined ? state : res;
+  };
+}
+const producers = new WeakMap();
+const setterTraps = {
+  get(target, property) {
+    if (property === $RAW) return target;
+    const value = target[property];
+    let proxy;
+    return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
+  },
+  set(target, property, value) {
+    setProperty(target, property, unwrap(value));
+    return true;
+  },
+  deleteProperty(target, property) {
+    setProperty(target, property, undefined, true);
+    return true;
+  }
+};
+function produce(fn) {
+  return state => {
+    if (isWrappable(state)) {
+      let proxy;
+      if (!(proxy = producers.get(state))) {
+        producers.set(state, proxy = new Proxy(state, setterTraps));
+      }
+      fn(proxy);
+    }
+    return state;
+  };
+}
+
+const DEV = {
+  $NODE,
+  isWrappable,
+  hooks: DevHooks
+} ;
+
+export { $RAW, DEV, createMutable, createStore, modifyMutable, produce, reconcile, unwrap };

web/node_modules/solid-js/store/dist/server.cjs

@@ -0,0 +1,126 @@
+'use strict';
+
+const $RAW = Symbol("state-raw");
+function isWrappable(obj) {
+  return obj != null && typeof obj === "object" && (Object.getPrototypeOf(obj) === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item) {
+  return item;
+}
+function setProperty(state, property, value, force) {
+  if (!force && state[property] === value) return;
+  if (value === undefined) {
+    delete state[property];
+  } else state[property] = value;
+}
+function mergeStoreNode(state, value, force) {
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    setProperty(state, key, value[key], force);
+  }
+}
+function updateArray(current, next) {
+  if (typeof next === "function") next = next(current);
+  if (Array.isArray(next)) {
+    if (current === next) return;
+    let i = 0,
+      len = next.length;
+    for (; i < len; i++) {
+      const value = next[i];
+      if (current[i] !== value) setProperty(current, i, value);
+    }
+    setProperty(current, "length", len);
+  } else mergeStoreNode(current, next);
+}
+function updatePath(current, path, traversed = []) {
+  let part,
+    next = current;
+  if (path.length > 1) {
+    part = path.shift();
+    const partType = typeof part,
+      isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let i = 0; i < part.length; i++) {
+        updatePath(current, [part[i]].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "function") {
+      for (let i = 0; i < current.length; i++) {
+        if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "object") {
+      const {
+        from = 0,
+        to = current.length - 1,
+        by = 1
+      } = part;
+      for (let i = from; i <= to; i += by) {
+        updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (path.length > 1) {
+      updatePath(current[part], path, [part].concat(traversed));
+      return;
+    }
+    next = current[part];
+    traversed = [part].concat(traversed);
+  }
+  let value = path[0];
+  if (typeof value === "function") {
+    value = value(next, traversed);
+    if (value === next) return;
+  }
+  if (part === undefined && value == undefined) return;
+  if (part === undefined || isWrappable(next) && isWrappable(value) && !Array.isArray(value)) {
+    mergeStoreNode(next, value);
+  } else setProperty(current, part, value);
+}
+function createStore(state) {
+  const isArray = Array.isArray(state);
+  function setStore(...args) {
+    isArray && args.length === 1 ? updateArray(state, args[0]) : updatePath(state, args);
+  }
+  return [state, setStore];
+}
+function createMutable(state) {
+  return state;
+}
+function modifyMutable(state, modifier) {
+  modifier(state);
+}
+function reconcile(value, options = {}) {
+  return state => {
+    if (!isWrappable(state) || !isWrappable(value)) return value;
+    const targetKeys = Object.keys(value);
+    for (let i = 0, len = targetKeys.length; i < len; i++) {
+      const key = targetKeys[i];
+      setProperty(state, key, value[key]);
+    }
+    const previousKeys = Object.keys(state);
+    for (let i = 0, len = previousKeys.length; i < len; i++) {
+      if (value[previousKeys[i]] === undefined) setProperty(state, previousKeys[i], undefined);
+    }
+    return state;
+  };
+}
+function produce(fn) {
+  return state => {
+    if (isWrappable(state)) fn(state);
+    return state;
+  };
+}
+const DEV = undefined;
+
+exports.$RAW = $RAW;
+exports.DEV = DEV;
+exports.createMutable = createMutable;
+exports.createStore = createStore;
+exports.isWrappable = isWrappable;
+exports.modifyMutable = modifyMutable;
+exports.produce = produce;
+exports.reconcile = reconcile;
+exports.setProperty = setProperty;
+exports.unwrap = unwrap;
+exports.updatePath = updatePath;

web/node_modules/solid-js/store/dist/server.js

@@ -0,0 +1,114 @@
+const $RAW = Symbol("state-raw");
+function isWrappable(obj) {
+  return obj != null && typeof obj === "object" && (Object.getPrototypeOf(obj) === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item) {
+  return item;
+}
+function setProperty(state, property, value, force) {
+  if (!force && state[property] === value) return;
+  if (value === undefined) {
+    delete state[property];
+  } else state[property] = value;
+}
+function mergeStoreNode(state, value, force) {
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    setProperty(state, key, value[key], force);
+  }
+}
+function updateArray(current, next) {
+  if (typeof next === "function") next = next(current);
+  if (Array.isArray(next)) {
+    if (current === next) return;
+    let i = 0,
+      len = next.length;
+    for (; i < len; i++) {
+      const value = next[i];
+      if (current[i] !== value) setProperty(current, i, value);
+    }
+    setProperty(current, "length", len);
+  } else mergeStoreNode(current, next);
+}
+function updatePath(current, path, traversed = []) {
+  let part,
+    next = current;
+  if (path.length > 1) {
+    part = path.shift();
+    const partType = typeof part,
+      isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let i = 0; i < part.length; i++) {
+        updatePath(current, [part[i]].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "function") {
+      for (let i = 0; i < current.length; i++) {
+        if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "object") {
+      const {
+        from = 0,
+        to = current.length - 1,
+        by = 1
+      } = part;
+      for (let i = from; i <= to; i += by) {
+        updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (path.length > 1) {
+      updatePath(current[part], path, [part].concat(traversed));
+      return;
+    }
+    next = current[part];
+    traversed = [part].concat(traversed);
+  }
+  let value = path[0];
+  if (typeof value === "function") {
+    value = value(next, traversed);
+    if (value === next) return;
+  }
+  if (part === undefined && value == undefined) return;
+  if (part === undefined || isWrappable(next) && isWrappable(value) && !Array.isArray(value)) {
+    mergeStoreNode(next, value);
+  } else setProperty(current, part, value);
+}
+function createStore(state) {
+  const isArray = Array.isArray(state);
+  function setStore(...args) {
+    isArray && args.length === 1 ? updateArray(state, args[0]) : updatePath(state, args);
+  }
+  return [state, setStore];
+}
+function createMutable(state) {
+  return state;
+}
+function modifyMutable(state, modifier) {
+  modifier(state);
+}
+function reconcile(value, options = {}) {
+  return state => {
+    if (!isWrappable(state) || !isWrappable(value)) return value;
+    const targetKeys = Object.keys(value);
+    for (let i = 0, len = targetKeys.length; i < len; i++) {
+      const key = targetKeys[i];
+      setProperty(state, key, value[key]);
+    }
+    const previousKeys = Object.keys(state);
+    for (let i = 0, len = previousKeys.length; i < len; i++) {
+      if (value[previousKeys[i]] === undefined) setProperty(state, previousKeys[i], undefined);
+    }
+    return state;
+  };
+}
+function produce(fn) {
+  return state => {
+    if (isWrappable(state)) fn(state);
+    return state;
+  };
+}
+const DEV = undefined;
+
+export { $RAW, DEV, createMutable, createStore, isWrappable, modifyMutable, produce, reconcile, setProperty, unwrap, updatePath };

web/node_modules/solid-js/store/dist/store.cjs

@@ -0,0 +1,438 @@
+'use strict';
+
+var solidJs = require('solid-js');
+
+const $RAW = Symbol("store-raw"),
+  $NODE = Symbol("store-node"),
+  $HAS = Symbol("store-has"),
+  $SELF = Symbol("store-self");
+function wrap$1(value) {
+  let p = value[solidJs.$PROXY];
+  if (!p) {
+    Object.defineProperty(value, solidJs.$PROXY, {
+      value: p = new Proxy(value, proxyTraps$1)
+    });
+    if (!Array.isArray(value)) {
+      const keys = Object.keys(value),
+        desc = Object.getOwnPropertyDescriptors(value);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const prop = keys[i];
+        if (desc[prop].get) {
+          Object.defineProperty(value, prop, {
+            enumerable: desc[prop].enumerable,
+            get: desc[prop].get.bind(p)
+          });
+        }
+      }
+    }
+  }
+  return p;
+}
+function isWrappable(obj) {
+  let proto;
+  return obj != null && typeof obj === "object" && (obj[solidJs.$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item, set = new Set()) {
+  let result, unwrapped, v, prop;
+  if (result = item != null && item[$RAW]) return result;
+  if (!isWrappable(item) || set.has(item)) return item;
+  if (Array.isArray(item)) {
+    if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
+    for (let i = 0, l = item.length; i < l; i++) {
+      v = item[i];
+      if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
+    }
+  } else {
+    if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
+    const keys = Object.keys(item),
+      desc = Object.getOwnPropertyDescriptors(item);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      prop = keys[i];
+      if (desc[prop].get) continue;
+      v = item[prop];
+      if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
+    }
+  }
+  return item;
+}
+function getNodes(target, symbol) {
+  let nodes = target[symbol];
+  if (!nodes) Object.defineProperty(target, symbol, {
+    value: nodes = Object.create(null)
+  });
+  return nodes;
+}
+function getNode(nodes, property, value) {
+  if (nodes[property]) return nodes[property];
+  const [s, set] = solidJs.createSignal(value, {
+    equals: false,
+    internal: true
+  });
+  s.$ = set;
+  return nodes[property] = s;
+}
+function proxyDescriptor$1(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[solidJs.$PROXY][property];
+  return desc;
+}
+function trackSelf(target) {
+  solidJs.getListener() && getNode(getNodes(target, $NODE), $SELF)();
+}
+function ownKeys(target) {
+  trackSelf(target);
+  return Reflect.ownKeys(target);
+}
+const proxyTraps$1 = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === solidJs.$PROXY) return receiver;
+    if (property === solidJs.$TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      if (solidJs.getListener() && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
+    }
+    return isWrappable(value) ? wrap$1(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set() {
+    return true;
+  },
+  deleteProperty() {
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor$1
+};
+function setProperty(state, property, value, deleting = false) {
+  if (!deleting && state[property] === value) return;
+  const prev = state[property],
+    len = state.length;
+  if (value === undefined) {
+    delete state[property];
+    if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
+  } else {
+    state[property] = value;
+    if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
+  }
+  let nodes = getNodes(state, $NODE),
+    node;
+  if (node = getNode(nodes, property, prev)) node.$(() => value);
+  if (Array.isArray(state) && state.length !== len) {
+    for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
+    (node = getNode(nodes, "length", len)) && node.$(state.length);
+  }
+  (node = nodes[$SELF]) && node.$();
+}
+function mergeStoreNode(state, value) {
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    setProperty(state, key, value[key]);
+  }
+}
+function updateArray(current, next) {
+  if (typeof next === "function") next = next(current);
+  next = unwrap(next);
+  if (Array.isArray(next)) {
+    if (current === next) return;
+    let i = 0,
+      len = next.length;
+    for (; i < len; i++) {
+      const value = next[i];
+      if (current[i] !== value) setProperty(current, i, value);
+    }
+    setProperty(current, "length", len);
+  } else mergeStoreNode(current, next);
+}
+function updatePath(current, path, traversed = []) {
+  let part,
+    prev = current;
+  if (path.length > 1) {
+    part = path.shift();
+    const partType = typeof part,
+      isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let i = 0; i < part.length; i++) {
+        updatePath(current, [part[i]].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "function") {
+      for (let i = 0; i < current.length; i++) {
+        if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "object") {
+      const {
+        from = 0,
+        to = current.length - 1,
+        by = 1
+      } = part;
+      for (let i = from; i <= to; i += by) {
+        updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (path.length > 1) {
+      updatePath(current[part], path, [part].concat(traversed));
+      return;
+    }
+    prev = current[part];
+    traversed = [part].concat(traversed);
+  }
+  let value = path[0];
+  if (typeof value === "function") {
+    value = value(prev, traversed);
+    if (value === prev) return;
+  }
+  if (part === undefined && value == undefined) return;
+  value = unwrap(value);
+  if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
+    mergeStoreNode(prev, value);
+  } else setProperty(current, part, value);
+}
+function createStore(...[store, options]) {
+  const unwrappedStore = unwrap(store || {});
+  const isArray = Array.isArray(unwrappedStore);
+  const wrappedStore = wrap$1(unwrappedStore);
+  function setStore(...args) {
+    solidJs.batch(() => {
+      isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
+    });
+  }
+  return [wrappedStore, setStore];
+}
+
+function proxyDescriptor(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || desc.set || !desc.configurable || property === solidJs.$PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[solidJs.$PROXY][property];
+  desc.set = v => target[solidJs.$PROXY][property] = v;
+  return desc;
+}
+const proxyTraps = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === solidJs.$PROXY) return receiver;
+    if (property === solidJs.$TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      const isFunction = typeof value === "function";
+      if (solidJs.getListener() && (!isFunction || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
+        return (...args) => solidJs.batch(() => Array.prototype[property].apply(receiver, args));
+      }
+    }
+    return isWrappable(value) ? wrap(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === solidJs.$PROXY || property === solidJs.$TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    solidJs.getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set(target, property, value) {
+    solidJs.batch(() => setProperty(target, property, unwrap(value)));
+    return true;
+  },
+  deleteProperty(target, property) {
+    solidJs.batch(() => setProperty(target, property, undefined, true));
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor
+};
+function wrap(value) {
+  let p = value[solidJs.$PROXY];
+  if (!p) {
+    Object.defineProperty(value, solidJs.$PROXY, {
+      value: p = new Proxy(value, proxyTraps)
+    });
+    const keys = Object.keys(value),
+      desc = Object.getOwnPropertyDescriptors(value);
+    const proto = Object.getPrototypeOf(value);
+    const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
+    if (isClass) {
+      let curProto = proto;
+      while (curProto != null) {
+        const descriptors = Object.getOwnPropertyDescriptors(curProto);
+        keys.push(...Object.keys(descriptors));
+        Object.assign(desc, descriptors);
+        curProto = Object.getPrototypeOf(curProto);
+      }
+    }
+    for (let i = 0, l = keys.length; i < l; i++) {
+      const prop = keys[i];
+      if (isClass && prop === "constructor") continue;
+      if (desc[prop].get) {
+        const get = desc[prop].get.bind(p);
+        Object.defineProperty(value, prop, {
+          get,
+          configurable: true
+        });
+      }
+      if (desc[prop].set) {
+        const og = desc[prop].set,
+          set = v => solidJs.batch(() => og.call(p, v));
+        Object.defineProperty(value, prop, {
+          set,
+          configurable: true
+        });
+      }
+    }
+  }
+  return p;
+}
+function createMutable(state, options) {
+  const unwrappedStore = unwrap(state || {});
+  const wrappedStore = wrap(unwrappedStore);
+  return wrappedStore;
+}
+function modifyMutable(state, modifier) {
+  solidJs.batch(() => modifier(unwrap(state)));
+}
+
+const $ROOT = Symbol("store-root");
+function applyState(target, parent, property, merge, key) {
+  const previous = parent[property];
+  if (target === previous) return;
+  const isArray = Array.isArray(target);
+  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
+    setProperty(parent, property, target);
+    return;
+  }
+  if (isArray) {
+    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
+        applyState(target[start], previous, start, merge, key);
+      }
+      const temp = new Array(target.length),
+        newIndices = new Map();
+      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+        temp[newEnd] = previous[end];
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
+        for (; j < target.length; j++) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        }
+        if (previous.length > target.length) setProperty(previous, "length", target.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = target[j];
+        keyVal = key && item ? item[key] : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === undefined ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = key && item ? item[key] : item;
+        j = newIndices.get(keyVal);
+        if (j !== undefined && j !== -1) {
+          temp[j] = previous[i];
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < target.length; j++) {
+        if (j in temp) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        } else setProperty(previous, j, target[j]);
+      }
+    } else {
+      for (let i = 0, len = target.length; i < len; i++) {
+        applyState(target[i], previous, i, merge, key);
+      }
+    }
+    if (previous.length > target.length) setProperty(previous, "length", target.length);
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  for (let i = 0, len = targetKeys.length; i < len; i++) {
+    applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+  }
+  const previousKeys = Object.keys(previous);
+  for (let i = 0, len = previousKeys.length; i < len; i++) {
+    if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
+  }
+}
+function reconcile(value, options = {}) {
+  const {
+      merge,
+      key = "id"
+    } = options,
+    v = unwrap(value);
+  return state => {
+    if (!isWrappable(state) || !isWrappable(v)) return v;
+    const res = applyState(v, {
+      [$ROOT]: state
+    }, $ROOT, merge, key);
+    return res === undefined ? state : res;
+  };
+}
+const producers = new WeakMap();
+const setterTraps = {
+  get(target, property) {
+    if (property === $RAW) return target;
+    const value = target[property];
+    let proxy;
+    return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
+  },
+  set(target, property, value) {
+    setProperty(target, property, unwrap(value));
+    return true;
+  },
+  deleteProperty(target, property) {
+    setProperty(target, property, undefined, true);
+    return true;
+  }
+};
+function produce(fn) {
+  return state => {
+    if (isWrappable(state)) {
+      let proxy;
+      if (!(proxy = producers.get(state))) {
+        producers.set(state, proxy = new Proxy(state, setterTraps));
+      }
+      fn(proxy);
+    }
+    return state;
+  };
+}
+
+const DEV = undefined;
+
+exports.$RAW = $RAW;
+exports.DEV = DEV;
+exports.createMutable = createMutable;
+exports.createStore = createStore;
+exports.modifyMutable = modifyMutable;
+exports.produce = produce;
+exports.reconcile = reconcile;
+exports.unwrap = unwrap;

web/node_modules/solid-js/store/dist/store.js

@@ -0,0 +1,429 @@
+import { batch, $PROXY, $TRACK, getListener, createSignal } from 'solid-js';
+
+const $RAW = Symbol("store-raw"),
+  $NODE = Symbol("store-node"),
+  $HAS = Symbol("store-has"),
+  $SELF = Symbol("store-self");
+function wrap$1(value) {
+  let p = value[$PROXY];
+  if (!p) {
+    Object.defineProperty(value, $PROXY, {
+      value: p = new Proxy(value, proxyTraps$1)
+    });
+    if (!Array.isArray(value)) {
+      const keys = Object.keys(value),
+        desc = Object.getOwnPropertyDescriptors(value);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const prop = keys[i];
+        if (desc[prop].get) {
+          Object.defineProperty(value, prop, {
+            enumerable: desc[prop].enumerable,
+            get: desc[prop].get.bind(p)
+          });
+        }
+      }
+    }
+  }
+  return p;
+}
+function isWrappable(obj) {
+  let proto;
+  return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item, set = new Set()) {
+  let result, unwrapped, v, prop;
+  if (result = item != null && item[$RAW]) return result;
+  if (!isWrappable(item) || set.has(item)) return item;
+  if (Array.isArray(item)) {
+    if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
+    for (let i = 0, l = item.length; i < l; i++) {
+      v = item[i];
+      if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
+    }
+  } else {
+    if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
+    const keys = Object.keys(item),
+      desc = Object.getOwnPropertyDescriptors(item);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      prop = keys[i];
+      if (desc[prop].get) continue;
+      v = item[prop];
+      if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
+    }
+  }
+  return item;
+}
+function getNodes(target, symbol) {
+  let nodes = target[symbol];
+  if (!nodes) Object.defineProperty(target, symbol, {
+    value: nodes = Object.create(null)
+  });
+  return nodes;
+}
+function getNode(nodes, property, value) {
+  if (nodes[property]) return nodes[property];
+  const [s, set] = createSignal(value, {
+    equals: false,
+    internal: true
+  });
+  s.$ = set;
+  return nodes[property] = s;
+}
+function proxyDescriptor$1(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[$PROXY][property];
+  return desc;
+}
+function trackSelf(target) {
+  getListener() && getNode(getNodes(target, $NODE), $SELF)();
+}
+function ownKeys(target) {
+  trackSelf(target);
+  return Reflect.ownKeys(target);
+}
+const proxyTraps$1 = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === $PROXY) return receiver;
+    if (property === $TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      if (getListener() && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
+    }
+    return isWrappable(value) ? wrap$1(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set() {
+    return true;
+  },
+  deleteProperty() {
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor$1
+};
+function setProperty(state, property, value, deleting = false) {
+  if (!deleting && state[property] === value) return;
+  const prev = state[property],
+    len = state.length;
+  if (value === undefined) {
+    delete state[property];
+    if (state[$HAS] && state[$HAS][property] && prev !== undefined) state[$HAS][property].$();
+  } else {
+    state[property] = value;
+    if (state[$HAS] && state[$HAS][property] && prev === undefined) state[$HAS][property].$();
+  }
+  let nodes = getNodes(state, $NODE),
+    node;
+  if (node = getNode(nodes, property, prev)) node.$(() => value);
+  if (Array.isArray(state) && state.length !== len) {
+    for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
+    (node = getNode(nodes, "length", len)) && node.$(state.length);
+  }
+  (node = nodes[$SELF]) && node.$();
+}
+function mergeStoreNode(state, value) {
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    setProperty(state, key, value[key]);
+  }
+}
+function updateArray(current, next) {
+  if (typeof next === "function") next = next(current);
+  next = unwrap(next);
+  if (Array.isArray(next)) {
+    if (current === next) return;
+    let i = 0,
+      len = next.length;
+    for (; i < len; i++) {
+      const value = next[i];
+      if (current[i] !== value) setProperty(current, i, value);
+    }
+    setProperty(current, "length", len);
+  } else mergeStoreNode(current, next);
+}
+function updatePath(current, path, traversed = []) {
+  let part,
+    prev = current;
+  if (path.length > 1) {
+    part = path.shift();
+    const partType = typeof part,
+      isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let i = 0; i < part.length; i++) {
+        updatePath(current, [part[i]].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "function") {
+      for (let i = 0; i < current.length; i++) {
+        if (part(current[i], i)) updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "object") {
+      const {
+        from = 0,
+        to = current.length - 1,
+        by = 1
+      } = part;
+      for (let i = from; i <= to; i += by) {
+        updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (path.length > 1) {
+      updatePath(current[part], path, [part].concat(traversed));
+      return;
+    }
+    prev = current[part];
+    traversed = [part].concat(traversed);
+  }
+  let value = path[0];
+  if (typeof value === "function") {
+    value = value(prev, traversed);
+    if (value === prev) return;
+  }
+  if (part === undefined && value == undefined) return;
+  value = unwrap(value);
+  if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
+    mergeStoreNode(prev, value);
+  } else setProperty(current, part, value);
+}
+function createStore(...[store, options]) {
+  const unwrappedStore = unwrap(store || {});
+  const isArray = Array.isArray(unwrappedStore);
+  const wrappedStore = wrap$1(unwrappedStore);
+  function setStore(...args) {
+    batch(() => {
+      isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
+    });
+  }
+  return [wrappedStore, setStore];
+}
+
+function proxyDescriptor(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || desc.set || !desc.configurable || property === $PROXY || property === $NODE) return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[$PROXY][property];
+  desc.set = v => target[$PROXY][property] = v;
+  return desc;
+}
+const proxyTraps = {
+  get(target, property, receiver) {
+    if (property === $RAW) return target;
+    if (property === $PROXY) return receiver;
+    if (property === $TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__") return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      const isFunction = typeof value === "function";
+      if (getListener() && (!isFunction || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
+        return (...args) => batch(() => Array.prototype[property].apply(receiver, args));
+      }
+    }
+    return isWrappable(value) ? wrap(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
+    getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set(target, property, value) {
+    batch(() => setProperty(target, property, unwrap(value)));
+    return true;
+  },
+  deleteProperty(target, property) {
+    batch(() => setProperty(target, property, undefined, true));
+    return true;
+  },
+  ownKeys: ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor
+};
+function wrap(value) {
+  let p = value[$PROXY];
+  if (!p) {
+    Object.defineProperty(value, $PROXY, {
+      value: p = new Proxy(value, proxyTraps)
+    });
+    const keys = Object.keys(value),
+      desc = Object.getOwnPropertyDescriptors(value);
+    const proto = Object.getPrototypeOf(value);
+    const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
+    if (isClass) {
+      let curProto = proto;
+      while (curProto != null) {
+        const descriptors = Object.getOwnPropertyDescriptors(curProto);
+        keys.push(...Object.keys(descriptors));
+        Object.assign(desc, descriptors);
+        curProto = Object.getPrototypeOf(curProto);
+      }
+    }
+    for (let i = 0, l = keys.length; i < l; i++) {
+      const prop = keys[i];
+      if (isClass && prop === "constructor") continue;
+      if (desc[prop].get) {
+        const get = desc[prop].get.bind(p);
+        Object.defineProperty(value, prop, {
+          get,
+          configurable: true
+        });
+      }
+      if (desc[prop].set) {
+        const og = desc[prop].set,
+          set = v => batch(() => og.call(p, v));
+        Object.defineProperty(value, prop, {
+          set,
+          configurable: true
+        });
+      }
+    }
+  }
+  return p;
+}
+function createMutable(state, options) {
+  const unwrappedStore = unwrap(state || {});
+  const wrappedStore = wrap(unwrappedStore);
+  return wrappedStore;
+}
+function modifyMutable(state, modifier) {
+  batch(() => modifier(unwrap(state)));
+}
+
+const $ROOT = Symbol("store-root");
+function applyState(target, parent, property, merge, key) {
+  const previous = parent[property];
+  if (target === previous) return;
+  const isArray = Array.isArray(target);
+  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
+    setProperty(parent, property, target);
+    return;
+  }
+  if (isArray) {
+    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
+        applyState(target[start], previous, start, merge, key);
+      }
+      const temp = new Array(target.length),
+        newIndices = new Map();
+      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+        temp[newEnd] = previous[end];
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
+        for (; j < target.length; j++) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        }
+        if (previous.length > target.length) setProperty(previous, "length", target.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = target[j];
+        keyVal = key && item ? item[key] : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === undefined ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = key && item ? item[key] : item;
+        j = newIndices.get(keyVal);
+        if (j !== undefined && j !== -1) {
+          temp[j] = previous[i];
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < target.length; j++) {
+        if (j in temp) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        } else setProperty(previous, j, target[j]);
+      }
+    } else {
+      for (let i = 0, len = target.length; i < len; i++) {
+        applyState(target[i], previous, i, merge, key);
+      }
+    }
+    if (previous.length > target.length) setProperty(previous, "length", target.length);
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  for (let i = 0, len = targetKeys.length; i < len; i++) {
+    applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+  }
+  const previousKeys = Object.keys(previous);
+  for (let i = 0, len = previousKeys.length; i < len; i++) {
+    if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
+  }
+}
+function reconcile(value, options = {}) {
+  const {
+      merge,
+      key = "id"
+    } = options,
+    v = unwrap(value);
+  return state => {
+    if (!isWrappable(state) || !isWrappable(v)) return v;
+    const res = applyState(v, {
+      [$ROOT]: state
+    }, $ROOT, merge, key);
+    return res === undefined ? state : res;
+  };
+}
+const producers = new WeakMap();
+const setterTraps = {
+  get(target, property) {
+    if (property === $RAW) return target;
+    const value = target[property];
+    let proxy;
+    return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
+  },
+  set(target, property, value) {
+    setProperty(target, property, unwrap(value));
+    return true;
+  },
+  deleteProperty(target, property) {
+    setProperty(target, property, undefined, true);
+    return true;
+  }
+};
+function produce(fn) {
+  return state => {
+    if (isWrappable(state)) {
+      let proxy;
+      if (!(proxy = producers.get(state))) {
+        producers.set(state, proxy = new Proxy(state, setterTraps));
+      }
+      fn(proxy);
+    }
+    return state;
+  };
+}
+
+const DEV = undefined;
+
+export { $RAW, DEV, createMutable, createStore, modifyMutable, produce, reconcile, unwrap };

web/node_modules/solid-js/store/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "solid-js/store",
+  "main": "./dist/server.cjs",
+  "module": "./dist/server.js",
+  "unpkg": "./dist/store.cjs",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "worker": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "browser": {
+        "development": {
+          "types": "./types/index.d.ts",
+          "import": "./dist/dev.js",
+          "require": "./dist/dev.cjs"
+        },
+        "types": "./types/index.d.ts",
+        "import": "./dist/store.js",
+        "require": "./dist/store.cjs"
+      },
+      "deno": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "node": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "development": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/dev.js",
+        "require": "./dist/dev.cjs"
+      },
+      "types": "./types/index.d.ts",
+      "import": "./dist/store.js",
+      "require": "./dist/store.cjs"
+    }
+  }
+}

web/node_modules/solid-js/store/types/index.d.ts

@@ -0,0 +1,12 @@
+export { $RAW, createStore, unwrap } from "./store.js";
+export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StorePathRange, StoreSetter } from "./store.js";
+export * from "./mutable.js";
+export * from "./modifiers.js";
+import { $NODE, isWrappable } from "./store.js";
+export declare const DEV: {
+    readonly $NODE: typeof $NODE;
+    readonly isWrappable: typeof isWrappable;
+    readonly hooks: {
+        onStoreNodeUpdate: import("./store.js").OnStoreNodeUpdate | null;
+    };
+} | undefined;

web/node_modules/solid-js/store/types/modifiers.d.ts

@@ -0,0 +1,6 @@
+export type ReconcileOptions = {
+    key?: string | null;
+    merge?: boolean;
+};
+export declare function reconcile<T extends U, U>(value: T, options?: ReconcileOptions): (state: U) => T;
+export declare function produce<T>(fn: (state: T) => void): (state: T) => T;

web/node_modules/solid-js/store/types/mutable.d.ts

@@ -0,0 +1,5 @@
+import { StoreNode } from "./store.js";
+export declare function createMutable<T extends StoreNode>(state: T, options?: {
+    name?: string;
+}): T;
+export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;

web/node_modules/solid-js/store/types/server.d.ts

@@ -0,0 +1,17 @@
+import type { SetStoreFunction, Store } from "./store.js";
+export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StorePathRange, StoreSetter } from "./store.js";
+export declare const $RAW: unique symbol;
+export declare function isWrappable(obj: any): boolean;
+export declare function unwrap<T>(item: T): T;
+export declare function setProperty(state: any, property: PropertyKey, value: any, force?: boolean): void;
+export declare function updatePath(current: any, path: any[], traversed?: PropertyKey[]): void;
+export declare function createStore<T>(state: T | Store<T>): [Store<T>, SetStoreFunction<T>];
+export declare function createMutable<T>(state: T | Store<T>): T;
+export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;
+type ReconcileOptions = {
+    key?: string | null;
+    merge?: boolean;
+};
+export declare function reconcile<T extends U, U extends object>(value: T, options?: ReconcileOptions): (state: U) => T;
+export declare function produce<T>(fn: (state: T) => void): (state: T) => T;
+export declare const DEV: undefined;

web/node_modules/solid-js/store/types/store.d.ts

@@ -0,0 +1,107 @@
+export declare const IS_DEV: string | boolean;
+export declare const $RAW: unique symbol, $NODE: unique symbol, $HAS: unique symbol, $SELF: unique symbol;
+export declare const DevHooks: {
+    onStoreNodeUpdate: OnStoreNodeUpdate | null;
+};
+type DataNode = {
+    (): any;
+    $(value?: any): void;
+};
+export type DataNodes = Record<PropertyKey, DataNode | undefined>;
+export type OnStoreNodeUpdate = (state: StoreNode, property: PropertyKey, value: StoreNode | NotWrappable, prev: StoreNode | NotWrappable) => void;
+export interface StoreNode {
+    [$NODE]?: DataNodes;
+    [key: PropertyKey]: any;
+}
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
+export type Store<T> = T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+/**
+ * Returns the underlying data in the store without a proxy.
+ * @param item store proxy object
+ * @example
+ * ```js
+ * const initial = {z...};
+ * const [state, setState] = createStore(initial);
+ * initial === state; // => false
+ * initial === unwrap(state); // => true
+ * ```
+ */
+export declare function unwrap<T>(item: T, set?: Set<unknown>): T;
+export declare function getNodes(target: StoreNode, symbol: typeof $NODE | typeof $HAS): DataNodes;
+export declare function getNode(nodes: DataNodes, property: PropertyKey, value?: any): DataNode;
+export declare function proxyDescriptor(target: StoreNode, property: PropertyKey): TypedPropertyDescriptor<any> | undefined;
+export declare function trackSelf(target: StoreNode): void;
+export declare function ownKeys(target: StoreNode): (string | symbol)[];
+export declare function setProperty(state: StoreNode, property: PropertyKey, value: any, deleting?: boolean): void;
+export declare function updatePath(current: StoreNode, path: any[], traversed?: PropertyKey[]): void;
+/** @deprecated */
+export type DeepReadonly<T> = 0 extends 1 & T ? T : T extends NotWrappable ? T : {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+/** @deprecated */
+export type DeepMutable<T> = 0 extends 1 & T ? T : T extends NotWrappable ? T : {
+    -readonly [K in keyof T]: DeepMutable<T[K]>;
+};
+export type CustomPartial<T> = T extends readonly unknown[] ? "0" extends keyof T ? {
+    [K in Extract<keyof T, `${number}`>]?: T[K];
+} : {
+    [x: number]: T[number];
+} : Partial<T>;
+export type PickMutable<T> = {
+    [K in keyof T as (<U>() => U extends {
+        [V in K]: T[V];
+    } ? 1 : 2) extends <U>() => U extends {
+        -readonly [V in K]: T[V];
+    } ? 1 : 2 ? K : never]: T[K];
+};
+export type StorePathRange = {
+    from?: number;
+    to?: number;
+    by?: number;
+};
+export type ArrayFilterFn<T> = (item: T, index: number) => boolean;
+export type StoreSetter<T, U extends PropertyKey[] = []> = T | CustomPartial<T> | ((prevState: T, traversed: U) => T | CustomPartial<T>);
+export type Part<T, K extends KeyOf<T> = KeyOf<T>> = K | ([K] extends [never] ? never : readonly K[]) | ([T] extends [readonly unknown[]] ? ArrayFilterFn<T[number]> | StorePathRange : never);
+type W<T> = Exclude<T, NotWrappable>;
+type KeyOf<T> = number extends keyof T ? 0 extends 1 & T ? keyof T : [T] extends [never] ? never : [
+    T
+] extends [readonly unknown[]] ? number : keyof T : keyof T;
+type MutableKeyOf<T> = KeyOf<T> & keyof PickMutable<T>;
+type Rest<T, U extends PropertyKey[], K extends KeyOf<T> = KeyOf<T>> = [T] extends [never] ? never : K extends MutableKeyOf<T> ? [Part<T, K>, ...RestSetterOrContinue<T[K], [K, ...U]>] : K extends KeyOf<T> ? [Part<T, K>, ...RestContinue<T[K], [K, ...U]>] : never;
+type RestContinue<T, U extends PropertyKey[]> = 0 extends 1 & T ? [...Part<any>[], StoreSetter<any, PropertyKey[]>] : Rest<W<T>, U>;
+type RestSetterOrContinue<T, U extends PropertyKey[]> = [StoreSetter<T, U>] | RestContinue<T, U>;
+export interface SetStoreFunction<T> {
+    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends MutableKeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, setter: StoreSetter<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7], [
+        K7,
+        K6,
+        K5,
+        K4,
+        K3,
+        K2,
+        K1
+    ]>): void;
+    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends MutableKeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, setter: StoreSetter<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6], [K6, K5, K4, K3, K2, K1]>): void;
+    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends MutableKeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, setter: StoreSetter<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5], [K5, K4, K3, K2, K1]>): void;
+    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends MutableKeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, setter: StoreSetter<W<W<W<W<T>[K1]>[K2]>[K3]>[K4], [K4, K3, K2, K1]>): void;
+    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends MutableKeyOf<W<W<W<T>[K1]>[K2]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, setter: StoreSetter<W<W<W<T>[K1]>[K2]>[K3], [K3, K2, K1]>): void;
+    <K1 extends KeyOf<W<T>>, K2 extends MutableKeyOf<W<W<T>[K1]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, setter: StoreSetter<W<W<T>[K1]>[K2], [K2, K1]>): void;
+    <K1 extends MutableKeyOf<W<T>>>(k1: Part<W<T>, K1>, setter: StoreSetter<W<T>[K1], [K1]>): void;
+    (setter: StoreSetter<T, []>): void;
+    <K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends KeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, ...rest: Rest<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7], [K7, K6, K5, K4, K3, K2, K1]>): void;
+}
+/**
+ * Creates a reactive store that can be read through a proxy object and written with a setter function
+ *
+ * @description https://docs.solidjs.com/reference/store-utilities/create-store
+ */
+export declare function createStore<T extends object = {}>(...[store, options]: {} extends T ? [store?: T | Store<T>, options?: {
+    name?: string;
+}] : [store: T | Store<T>, options?: {
+    name?: string;
+}]): [get: Store<T>, set: SetStoreFunction<T>];
+export {};

web/node_modules/solid-js/types/index.d.ts

@@ -0,0 +1,23 @@
+export { $DEVCOMP, $PROXY, $TRACK, batch, catchError, children, createComputed, createContext, createDeferred, createEffect, createMemo, createReaction, createRenderEffect, createResource, createRoot, createSelector, createSignal, enableExternalSource, enableScheduling, equalFn, getListener, getOwner, on, onCleanup, onError, onMount, runWithOwner, startTransition, untrack, useContext, useTransition } from "./reactive/signal.js";
+export type { Accessor, AccessorArray, ChildrenReturn, Context, ContextProviderComponent, EffectFunction, EffectOptions, InitializedResource, InitializedResourceOptions, InitializedResourceReturn, MemoOptions, NoInfer, OnEffectFunction, OnOptions, Owner, ResolvedChildren, ResolvedJSXElement, Resource, ResourceActions, ResourceFetcher, ResourceFetcherInfo, ResourceOptions, ResourceReturn, ResourceSource, ReturnTypes, Setter, Signal, SignalOptions, Transition } from "./reactive/signal.js";
+export * from "./reactive/observable.js";
+export * from "./reactive/scheduler.js";
+export * from "./reactive/array.js";
+export * from "./render/index.js";
+import type { JSX } from "./jsx.js";
+type JSXElement = JSX.Element;
+export type { JSXElement, JSX };
+import { registerGraph, writeSignal } from "./reactive/signal.js";
+export declare const DEV: {
+    readonly hooks: {
+        afterUpdate: (() => void) | null;
+        afterCreateOwner: ((owner: import("./reactive/signal.js").Owner) => void) | null;
+        afterCreateSignal: ((signal: import("./reactive/signal.js").SignalState<any>) => void) | null;
+        afterRegisterGraph: ((sourceMapValue: import("./reactive/signal.js").SourceMapValue) => void) | null;
+    };
+    readonly writeSignal: typeof writeSignal;
+    readonly registerGraph: typeof registerGraph;
+} | undefined;
+declare global {
+    var Solid$$: boolean;
+}

web/node_modules/solid-js/types/reactive/array.d.ts

@@ -0,0 +1,44 @@
+import { Accessor } from "./signal.js";
+/**
+The MIT License (MIT)
+
+Copyright (c) 2017 Adam Haile
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+/**
+ * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ *
+ * similar to `Array.prototype.map`, but gets the index as accessor, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
+ */
+export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: T, i: Accessor<number>) => U, options?: {
+    fallback?: Accessor<any>;
+}): () => U[];
+/**
+ * Reactively maps arrays by index instead of value - underlying helper for the `<Index>` control flow
+ *
+ * similar to `Array.prototype.map`, but gets the value as an accessor, transforms only changed items of the original arrays anew and returns an accessor.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/index-array
+ */
+export declare function indexArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: number) => U, options?: {
+    fallback?: Accessor<any>;
+}): () => U[];

web/node_modules/solid-js/types/reactive/observable.d.ts

@@ -0,0 +1,36 @@
+import { Accessor, Setter } from "./signal.js";
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+interface Observable<T> {
+    subscribe(observer: ObservableObserver<T>): {
+        unsubscribe(): void;
+    };
+    [Symbol.observable](): Observable<T>;
+}
+export type ObservableObserver<T> = ((v: T) => void) | {
+    next?: (v: T) => void;
+    error?: (v: any) => void;
+    complete?: (v: boolean) => void;
+};
+/**
+ * Creates a simple observable from a signal's accessor to be used with the `from` operator of observable libraries like e.g. rxjs
+ * ```typescript
+ * import { from } from "rxjs";
+ * const [s, set] = createSignal(0);
+ * const obsv$ = from(observable(s));
+ * obsv$.subscribe((v) => console.log(v));
+ * ```
+ * description https://docs.solidjs.com/reference/reactive-utilities/observable
+ */
+export declare function observable<T>(input: Accessor<T>): Observable<T>;
+type Producer<T> = ((setter: Setter<T>) => () => void) | {
+    subscribe: (fn: (v: T) => void) => (() => void) | {
+        unsubscribe: () => void;
+    };
+};
+export declare function from<T>(producer: Producer<T>, initalValue: T): Accessor<T>;
+export declare function from<T>(producer: Producer<T | undefined>): Accessor<T | undefined>;
+export {};

web/node_modules/solid-js/types/reactive/scheduler.d.ts

@@ -0,0 +1,10 @@
+export interface Task {
+    id: number;
+    fn: ((didTimeout: boolean) => void) | null;
+    startTime: number;
+    expirationTime: number;
+}
+export declare function requestCallback(fn: () => void, options?: {
+    timeout: number;
+}): Task;
+export declare function cancelCallback(task: Task): void;

web/node_modules/solid-js/types/reactive/signal.d.ts

@@ -0,0 +1,577 @@
+/**
+The MIT License (MIT)
+
+Copyright (c) 2017 Adam Haile
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+import { requestCallback } from "./scheduler.js";
+import type { JSX } from "../jsx.js";
+import type { FlowComponent } from "../render/index.js";
+export declare const IS_DEV: string | boolean;
+export declare const equalFn: <T>(a: T, b: T) => boolean;
+export declare const $PROXY: unique symbol;
+export declare const SUPPORTS_PROXY: boolean;
+export declare const $TRACK: unique symbol;
+export declare const $DEVCOMP: unique symbol;
+export declare var Owner: Owner | null;
+export declare let Transition: TransitionState | null;
+/** Object storing callbacks for debugging during development */
+export declare const DevHooks: {
+    afterUpdate: (() => void) | null;
+    afterCreateOwner: ((owner: Owner) => void) | null;
+    /** @deprecated use `afterRegisterGraph` */
+    afterCreateSignal: ((signal: SignalState<any>) => void) | null;
+    afterRegisterGraph: ((sourceMapValue: SourceMapValue) => void) | null;
+};
+export type ComputationState = 0 | 1 | 2;
+export interface SourceMapValue {
+    value: unknown;
+    name?: string;
+    graph?: Owner;
+}
+export interface SignalState<T> extends SourceMapValue {
+    value: T;
+    observers: Computation<any>[] | null;
+    observerSlots: number[] | null;
+    tValue?: T;
+    comparator?: (prev: T, next: T) => boolean;
+    internal?: true;
+}
+export interface Owner {
+    owned: Computation<any>[] | null;
+    cleanups: (() => void)[] | null;
+    owner: Owner | null;
+    context: any | null;
+    sourceMap?: SourceMapValue[];
+    name?: string;
+}
+export interface Computation<Init, Next extends Init = Init> extends Owner {
+    fn: EffectFunction<Init, Next>;
+    state: ComputationState;
+    tState?: ComputationState;
+    sources: SignalState<Next>[] | null;
+    sourceSlots: number[] | null;
+    value?: Init;
+    updatedAt: number | null;
+    pure: boolean;
+    user?: boolean;
+    suspense?: SuspenseContextType;
+}
+export interface TransitionState {
+    sources: Set<SignalState<any>>;
+    effects: Computation<any>[];
+    promises: Set<Promise<any>>;
+    disposed: Set<Computation<any>>;
+    queue: Set<Computation<any>>;
+    scheduler?: (fn: () => void) => unknown;
+    running: boolean;
+    done?: Promise<void>;
+    resolve?: () => void;
+}
+type ExternalSourceFactory = <Prev, Next extends Prev = Prev>(fn: EffectFunction<Prev, Next>, trigger: () => void) => ExternalSource;
+export interface ExternalSource {
+    track: EffectFunction<any, any>;
+    dispose: () => void;
+}
+export type RootFunction<T> = (dispose: () => void) => T;
+/**
+ * Creates a new non-tracked reactive context that doesn't auto-dispose
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @param detachedOwner optional reactive context to bind the root to
+ * @returns the output of `fn`.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ */
+export declare function createRoot<T>(fn: RootFunction<T>, detachedOwner?: typeof Owner): T;
+export type Accessor<T> = () => T;
+export type Setter<in out T> = {
+    <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
+    <U extends T>(value: (prev: T) => U): U;
+    <U extends T>(value: Exclude<U, Function>): U;
+    <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
+};
+export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+export interface SignalOptions<T> extends MemoOptions<T> {
+    internal?: boolean;
+}
+/**
+ * Creates a simple reactive state with a getter and setter
+ * ```typescript
+ * const [state: Accessor<T>, setState: Setter<T>] = createSignal<T>(
+ *  value: T,
+ *  options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * )
+ * ```
+ * @param value initial value of the state; if empty, the state's type will automatically extended with undefined; otherwise you need to extend the type manually if you want setting to undefined not be an error
+ * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
+ *
+ * @returns ```typescript
+ * [state: Accessor<T>, setState: Setter<T>]
+ * ```
+ * * the Accessor is merely a function that returns the current value and registers each call to the reactive root
+ * * the Setter is a function that allows directly setting or mutating the value:
+ * ```typescript
+ * const [count, setCount] = createSignal(0);
+ * setCount(count => count + 1);
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
+ */
+export declare function createSignal<T>(): Signal<T | undefined>;
+export declare function createSignal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
+export interface BaseOptions {
+    name?: string;
+}
+export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+export interface EffectOptions extends BaseOptions {
+}
+export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
+/**
+ * Creates a reactive computation that runs immediately before render, mainly used to write to other reactive primitives
+ * ```typescript
+ * export function createComputed<Next, Init = Next>(
+ *   fn: (v: Init | Next) => Next,
+ *   value?: Init,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-computed
+ */
+export declare function createComputed<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
+export declare function createComputed<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+/**
+ * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
+ * ```typescript
+ * export function createRenderEffect<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ */
+export declare function createRenderEffect<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
+export declare function createRenderEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+/**
+ * Creates a reactive computation that runs after the render phase
+ * ```typescript
+ * export function createEffect<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ */
+export declare function createEffect<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
+export declare function createEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions & {
+    render?: boolean;
+}): void;
+/**
+ * Creates a reactive computation that runs after the render phase with flexible tracking
+ * ```typescript
+ * export function createReaction(
+ *   onInvalidate: () => void,
+ *   options?: { name?: string }
+ * ): (fn: () => void) => void;
+ * ```
+ * @param invalidated a function that is called when tracked function is invalidated.
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ */
+export declare function createReaction(onInvalidate: () => void, options?: EffectOptions): (tracking: () => void) => void;
+export interface Memo<Prev, Next = Prev> extends SignalState<Next>, Computation<Next> {
+    value: Next;
+    tOwned?: Computation<Prev | Next, Next>[];
+}
+export interface MemoOptions<T> extends EffectOptions {
+    equals?: false | ((prev: T, next: T) => boolean);
+}
+/**
+ * Creates a readonly derived reactive memoized signal
+ * ```typescript
+ * export function createMemo<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): () => T;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
+ */
+export declare function createMemo<Next extends Prev, Prev = Next>(fn: EffectFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(fn: EffectFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+interface Unresolved {
+    state: "unresolved";
+    loading: false;
+    error: undefined;
+    latest: undefined;
+    (): undefined;
+}
+interface Pending {
+    state: "pending";
+    loading: true;
+    error: undefined;
+    latest: undefined;
+    (): undefined;
+}
+interface Ready<T> {
+    state: "ready";
+    loading: false;
+    error: undefined;
+    latest: T;
+    (): T;
+}
+interface Refreshing<T> {
+    state: "refreshing";
+    loading: true;
+    error: undefined;
+    latest: T;
+    (): T;
+}
+interface Errored {
+    state: "errored";
+    loading: false;
+    error: any;
+    latest: never;
+    (): never;
+}
+export type Resource<T> = Unresolved | Pending | Ready<T> | Refreshing<T> | Errored;
+export type InitializedResource<T> = Ready<T> | Refreshing<T> | Errored;
+export type ResourceActions<T, R = unknown> = {
+    mutate: Setter<T>;
+    refetch: (info?: R) => T | Promise<T> | undefined | null;
+};
+export type ResourceSource<S> = S | false | null | undefined | (() => S | false | null | undefined);
+export type ResourceFetcher<S, T, R = unknown> = (k: S, info: ResourceFetcherInfo<T, R>) => T | Promise<T>;
+export type ResourceFetcherInfo<T, R = unknown> = {
+    value: T | undefined;
+    refetching: R | boolean;
+};
+export type ResourceOptions<T, S = unknown> = {
+    initialValue?: T;
+    name?: string;
+    deferStream?: boolean;
+    ssrLoadFrom?: "initial" | "server";
+    storage?: (init: T | undefined) => [Accessor<T | undefined>, Setter<T | undefined>];
+    onHydrated?: (k: S | undefined, info: {
+        value: T | undefined;
+    }) => void;
+};
+export type InitializedResourceOptions<T, S = unknown> = ResourceOptions<T, S> & {
+    initialValue: T;
+};
+export type ResourceReturn<T, R = unknown> = [Resource<T>, ResourceActions<T | undefined, R>];
+export type InitializedResourceReturn<T, R = unknown> = [
+    InitializedResource<T>,
+    ResourceActions<T, R>
+];
+/**
+ * Creates a resource that wraps a repeated promise in a reactive pattern:
+ * ```typescript
+ * // Without source
+ * const [resource, { mutate, refetch }] = createResource(fetcher, options);
+ * // With source
+ * const [resource, { mutate, refetch }] = createResource(source, fetcher, options);
+ * ```
+ * @param source - reactive data function which has its non-nullish and non-false values passed to the fetcher, optional
+ * @param fetcher - function that receives the source (true if source not provided), the last or initial value, and whether the resource is being refetched, and returns a value or a Promise:
+ * ```typescript
+ * const fetcher: ResourceFetcher<S, T, R> = (
+ *   sourceOutput: S,
+ *   info: { value: T | undefined, refetching: R | boolean }
+ * ) => T | Promise<T>;
+ * ```
+ * @param options - an optional object with the initialValue and the name (for debugging purposes); see {@link ResourceOptions}
+ *
+ * @returns ```typescript
+ * [Resource<T>, { mutate: Setter<T>, refetch: () => void }]
+ * ```
+ *
+ * * Setting an `initialValue` in the options will mean that both the prev() accessor and the resource should never return undefined (if that is wanted, you need to extend the type with undefined)
+ * * `mutate` allows to manually overwrite the resource without calling the fetcher
+ * * `refetch` will re-run the fetcher without changing the source, and if called with a value, that value will be passed to the fetcher via the `refetching` property on the fetcher's second parameter
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-resource
+ */
+export declare function createResource<T, R = unknown>(fetcher: ResourceFetcher<true, T, R>, options: InitializedResourceOptions<NoInfer<T>, true>): InitializedResourceReturn<T, R>;
+export declare function createResource<T, R = unknown>(fetcher: ResourceFetcher<true, T, R>, options?: ResourceOptions<NoInfer<T>, true>): ResourceReturn<T, R>;
+export declare function createResource<T, S, R = unknown>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T, R>, options: InitializedResourceOptions<NoInfer<T>, S>): InitializedResourceReturn<T, R>;
+export declare function createResource<T, S, R = unknown>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T, R>, options?: ResourceOptions<NoInfer<T>, S>): ResourceReturn<T, R>;
+export interface DeferredOptions<T> {
+    equals?: false | ((prev: T, next: T) => boolean);
+    name?: string;
+    timeoutMs?: number;
+}
+/**
+ * Creates a reactive computation that only runs and notifies the reactive context when the browser is idle
+ * ```typescript
+ * export function createDeferred<T>(
+ *   fn: (v: T) => T,
+ *   options?: { timeoutMs?: number, name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): () => T);
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param options allows to set the timeout in milliseconds, use a custom comparison function and set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-deferred
+ */
+export declare function createDeferred<T>(source: Accessor<T>, options?: DeferredOptions<T>): Accessor<T>;
+export type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
+/**
+ * Creates a conditional signal that only notifies subscribers when entering or exiting their key matching the value
+ * ```typescript
+ * export function createSelector<T, U>(
+ *   source: () => T
+ *   fn: (a: U, b: T) => boolean,
+ *   options?: { name?: string }
+ * ): (k: U) => boolean;
+ * ```
+ * @param source
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param options allows to set a name in dev mode for debugging purposes, optional
+ *
+ * ```typescript
+ * const isSelected = createSelector(selectedId);
+ * <For each={list()}>
+ *   {(item) => <li classList={{ active: isSelected(item.id) }}>{item.name}</li>}
+ * </For>
+ * ```
+ *
+ * This makes the operation O(2) instead of O(n).
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-selector
+ */
+export declare function createSelector<T, U = T>(source: Accessor<T>, fn?: EqualityCheckerFunction<T, U>, options?: BaseOptions): (key: U) => boolean;
+/**
+ * Holds changes inside the block before the reactive context is updated
+ * @param fn wraps the reactive updates that should be batched
+ * @returns the return value from `fn`
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/batch
+ */
+export declare function batch<T>(fn: Accessor<T>): T;
+/**
+ * Ignores tracking context inside its scope
+ * @param fn the scope that is out of the tracking context
+ * @returns the return value of `fn`
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/untrack
+ */
+export declare function untrack<T>(fn: Accessor<T>): T;
+/** @deprecated */
+export type ReturnTypes<T> = T extends readonly Accessor<unknown>[] ? {
+    [K in keyof T]: T[K] extends Accessor<infer I> ? I : never;
+} : T extends Accessor<infer I> ? I : never;
+export type AccessorArray<T> = [...Extract<{
+    [K in keyof T]: Accessor<T[K]>;
+}, readonly unknown[]>];
+export type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (input: S, prevInput: S | undefined, prev: Prev) => Next;
+export interface OnOptions {
+    defer?: boolean;
+}
+/**
+ * Makes dependencies of a computation explicit
+ * ```typescript
+ * export function on<S, U>(
+ *   deps: Accessor<S> | AccessorArray<S>,
+ *   fn: (input: S, prevInput: S | undefined, prevValue: U | undefined) => U,
+ *   options?: { defer?: boolean } = {}
+ * ): (prevValue: U | undefined) => U;
+ * ```
+ * @param deps list of reactive dependencies or a single reactive dependency
+ * @param fn computation on input; the current previous content(s) of input and the previous value are given as arguments and it returns a new value
+ * @param options optional, allows deferred computation until at the end of the next change
+ * @returns an effect function that is passed into createEffect. For example:
+ *
+ * ```typescript
+ * createEffect(on(a, (v) => console.log(v, b())));
+ *
+ * // is equivalent to:
+ * createEffect(() => {
+ *   const v = a();
+ *   untrack(() => console.log(v, b()));
+ * });
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/on-util
+ */
+export declare function on<S, Next extends Prev, Prev = Next>(deps: AccessorArray<S> | Accessor<S>, fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>, options?: OnOptions & {
+    defer?: false;
+}): EffectFunction<undefined | NoInfer<Next>, NoInfer<Next>>;
+export declare function on<S, Next extends Prev, Prev = Next>(deps: AccessorArray<S> | Accessor<S>, fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>, options: OnOptions | {
+    defer: true;
+}): EffectFunction<undefined | NoInfer<Next>>;
+/**
+ * Runs an effect only after initial render on mount
+ * @param fn an effect that should run only once on mount
+ *
+ * @description https://docs.solidjs.com/reference/lifecycle/on-mount
+ */
+export declare function onMount(fn: () => void): void;
+/**
+ * Runs an effect once before the reactive scope is disposed
+ * @param fn an effect that should run only once on cleanup
+ *
+ * @returns the same {@link fn} function that was passed in
+ *
+ * @description https://docs.solidjs.com/reference/lifecycle/on-cleanup
+ */
+export declare function onCleanup<T extends () => any>(fn: T): T;
+/**
+ * Runs an effect whenever an error is thrown within the context of the child scopes
+ * @param fn boundary for the error
+ * @param handler an error handler that receives the error
+ *
+ * * If the error is thrown again inside the error handler, it will trigger the next available parent handler
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/catch-error
+ */
+export declare function catchError<T>(fn: () => T, handler: (err: Error) => void): T | undefined;
+export declare function getListener(): Computation<any, any> | null;
+export declare function getOwner(): Owner | null;
+export declare function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined;
+export declare function enableScheduling(scheduler?: typeof requestCallback): void;
+/**
+ * ```typescript
+ * export function startTransition(fn: () => void) => Promise<void>
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/start-transition
+ */
+export declare function startTransition(fn: () => unknown): Promise<void>;
+export type Transition = [Accessor<boolean>, (fn: () => void) => Promise<void>];
+/**
+ * ```typescript
+ * export function useTransition(): [
+ *   () => boolean,
+ *   (fn: () => void, cb?: () => void) => void
+ * ];
+ * ```
+ * @returns a tuple; first value is an accessor if the transition is pending and a callback to start the transition
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/use-transition
+ */
+export declare function useTransition(): Transition;
+export declare function resumeEffects(e: Computation<any>[]): void;
+export interface DevComponent<T> extends Memo<unknown> {
+    props: T;
+    name: string;
+    component: (props: T) => unknown;
+}
+export declare function devComponent<P, V>(Comp: (props: P) => V, props: P): V;
+export declare function registerGraph(value: SourceMapValue): void;
+export type ContextProviderComponent<T> = FlowComponent<{
+    value: T;
+}>;
+export interface Context<T> {
+    id: symbol;
+    Provider: ContextProviderComponent<T>;
+    defaultValue: T;
+}
+/**
+ * Creates a Context to handle a state scoped for the children of a component
+ * ```typescript
+ * interface Context<T> {
+ *   id: symbol;
+ *   Provider: FlowComponent<{ value: T }>;
+ *   defaultValue: T;
+ * }
+ * export function createContext<T>(
+ *   defaultValue?: T,
+ *   options?: { name?: string }
+ * ): Context<T | undefined>;
+ * ```
+ * @param defaultValue optional default to inject into context
+ * @param options allows to set a name in dev mode for debugging purposes
+ * @returns The context that contains the Provider Component and that can be used with `useContext`
+ *
+ * @description https://docs.solidjs.com/reference/component-apis/create-context
+ */
+export declare function createContext<T>(defaultValue?: undefined, options?: EffectOptions): Context<T | undefined>;
+export declare function createContext<T>(defaultValue: T, options?: EffectOptions): Context<T>;
+/**
+ * Uses a context to receive a scoped state from a parent's Context.Provider
+ *
+ * @param context Context object made by `createContext`
+ * @returns the current or `defaultValue`, if present
+ *
+ * @description https://docs.solidjs.com/reference/component-apis/use-context
+ */
+export declare function useContext<T>(context: Context<T>): T;
+export type ResolvedJSXElement = Exclude<JSX.Element, JSX.ArrayElement>;
+export type ResolvedChildren = ResolvedJSXElement | ResolvedJSXElement[];
+export type ChildrenReturn = Accessor<ResolvedChildren> & {
+    toArray: () => ResolvedJSXElement[];
+};
+/**
+ * Resolves child elements to help interact with children
+ *
+ * @param fn an accessor for the children
+ * @returns a accessor of the same children, but resolved
+ *
+ * @description https://docs.solidjs.com/reference/component-apis/children
+ */
+export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
+export type SuspenseContextType = {
+    increment?: () => void;
+    decrement?: () => void;
+    inFallback?: () => boolean;
+    effects?: Computation<any>[];
+    resolved?: boolean;
+};
+type SuspenseContext = Context<SuspenseContextType | undefined> & {
+    active?(): boolean;
+    increment?(): void;
+    decrement?(): void;
+};
+declare let SuspenseContext: SuspenseContext;
+export declare function getSuspenseContext(): SuspenseContext;
+export declare function enableExternalSource(factory: ExternalSourceFactory, untrack?: <V>(fn: () => V) => V): void;
+export declare function readSignal(this: SignalState<any> | Memo<any>): any;
+export declare function writeSignal(node: SignalState<any> | Memo<any>, value: any, isComp?: boolean): any;
+/**
+ * @deprecated since version 1.7.0 and will be removed in next major - use catchError instead
+ * onError - run an effect whenever an error is thrown within the context of the child scopes
+ * @param fn an error handler that receives the error
+ *
+ * * If the error is thrown again inside the error handler, it will trigger the next available parent handler
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/catch-error
+ */
+export declare function onError(fn: (err: Error) => void): void;
+export {};

web/node_modules/solid-js/types/render/Suspense.d.ts

@@ -0,0 +1,26 @@
+import type { JSX } from "../jsx.js";
+/**
+ * **[experimental]** Controls the order in which suspended content is rendered
+ *
+ * @description https://docs.solidjs.com/reference/components/suspense-list
+ */
+export declare function SuspenseList(props: {
+    children: JSX.Element;
+    revealOrder: "forwards" | "backwards" | "together";
+    tail?: "collapsed" | "hidden";
+}): JSX.Element;
+/**
+ * Tracks all resources inside a component and renders a fallback until they are all resolved
+ * ```typescript
+ * const AsyncComponent = lazy(() => import('./component'));
+ *
+ * <Suspense fallback={<LoadingIndicator />}>
+ *   <AsyncComponent />
+ * </Suspense>
+ * ```
+ * @description https://docs.solidjs.com/reference/components/suspense
+ */
+export declare function Suspense(props: {
+    fallback?: JSX.Element;
+    children: JSX.Element;
+}): JSX.Element;

web/node_modules/solid-js/types/render/component.d.ts

@@ -0,0 +1,111 @@
+import type { JSX } from "../jsx.js";
+export declare function enableHydration(): void;
+/**
+ * A general `Component` has no implicit `children` prop.  If desired, you can
+ * specify one as in `Component<{name: String, children: JSX.Element}>`.
+ */
+export type Component<P extends Record<string, any> = {}> = (props: P) => JSX.Element;
+/**
+ * Extend props to forbid the `children` prop.
+ * Use this to prevent accidentally passing `children` to components that
+ * would silently throw them away.
+ */
+export type VoidProps<P extends Record<string, any> = {}> = P & {
+    children?: never;
+};
+/**
+ * `VoidComponent` forbids the `children` prop.
+ * Use this to prevent accidentally passing `children` to components that
+ * would silently throw them away.
+ */
+export type VoidComponent<P extends Record<string, any> = {}> = Component<VoidProps<P>>;
+/**
+ * Extend props to allow an optional `children` prop with the usual
+ * type in JSX, `JSX.Element` (which allows elements, arrays, strings, etc.).
+ * Use this for components that you want to accept children.
+ */
+export type ParentProps<P extends Record<string, any> = {}> = P & {
+    children?: JSX.Element;
+};
+/**
+ * `ParentComponent` allows an optional `children` prop with the usual
+ * type in JSX, `JSX.Element` (which allows elements, arrays, strings, etc.).
+ * Use this for components that you want to accept children.
+ */
+export type ParentComponent<P extends Record<string, any> = {}> = Component<ParentProps<P>>;
+/**
+ * Extend props to require a `children` prop with the specified type.
+ * Use this for components where you need a specific child type,
+ * typically a function that receives specific argument types.
+ * Note that all JSX <Elements> are of the type `JSX.Element`.
+ */
+export type FlowProps<P extends Record<string, any> = {}, C = JSX.Element> = P & {
+    children: C;
+};
+/**
+ * `FlowComponent` requires a `children` prop with the specified type.
+ * Use this for components where you need a specific child type,
+ * typically a function that receives specific argument types.
+ * Note that all JSX <Elements> are of the type `JSX.Element`.
+ */
+export type FlowComponent<P extends Record<string, any> = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
+/** @deprecated: use `ParentProps` instead */
+export type PropsWithChildren<P extends Record<string, any> = {}> = ParentProps<P>;
+export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
+/**
+ * Takes the props of the passed component and returns its type
+ *
+ * @example
+ * ComponentProps<typeof Portal> // { mount?: Node; useShadow?: boolean; children: JSX.Element }
+ * ComponentProps<'div'> // JSX.HTMLAttributes<HTMLDivElement>
+ */
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
+/**
+ * Type of `props.ref`, for use in `Component` or `props` typing.
+ *
+ * @example Component<{ref: Ref<Element>}>
+ */
+export type Ref<T> = T | ((val: T) => void);
+export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): JSX.Element;
+type DistributeOverride<T, F> = T extends undefined ? F : T;
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
+        [K in keyof T]: any;
+    } & {
+        [K in keyof U]?: any;
+    } & {
+        [K in U extends any ? keyof U : keyof U]?: any;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+type _MergeProps<T extends unknown[], Curr = {}> = T extends [
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _MergeProps<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_MergeProps<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
+export type MergeProps<T extends unknown[]> = Simplify<_MergeProps<T>>;
+export declare function mergeProps<T extends unknown[]>(...sources: T): MergeProps<T>;
+export type SplitProps<T, K extends (readonly (keyof T)[])[]> = [
+    ...{
+        [P in keyof K]: P extends `${number}` ? Pick<T, Extract<K[P], readonly (keyof T)[]>[number]> : never;
+    },
+    {
+        [P in keyof T as Exclude<P, K[number][number]>]: T[P];
+    }
+];
+export declare function splitProps<T extends Record<any, any>, K extends [readonly (keyof T)[], ...(readonly (keyof T)[])[]]>(props: T, ...keys: K): SplitProps<T, K>;
+export declare function lazy<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>): T & {
+    preload: () => Promise<{
+        default: T;
+    }>;
+};
+export declare function createUniqueId(): string;
+export {};

web/node_modules/solid-js/types/render/flow.d.ts

@@ -0,0 +1,118 @@
+import { Accessor } from "../reactive/signal.js";
+import type { JSX } from "../jsx.js";
+/**
+ * Creates a list elements from a list
+ *
+ * it receives a map function as its child that receives a list element and an accessor with the index and returns a JSX-Element; if the list is empty, an optional fallback is returned:
+ * ```typescript
+ * <For each={items} fallback={<div>No items</div>}>
+ *   {(item, index) => <div data-index={index()}>{item}</div>}
+ * </For>
+ * ```
+ * If you have a list with fixed indices and changing values, consider using `<Index>` instead.
+ *
+ * @description https://docs.solidjs.com/reference/components/for
+ */
+export declare function For<T extends readonly any[], U extends JSX.Element>(props: {
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    children: (item: T[number], index: Accessor<number>) => U;
+}): JSX.Element;
+/**
+ * Non-keyed iteration over a list creating elements from its items
+ *
+ * To be used if you have a list with fixed indices, but changing values.
+ * ```typescript
+ * <Index each={items} fallback={<div>No items</div>}>
+ *   {(item, index) => <div data-index={index}>{item()}</div>}
+ * </Index>
+ * ```
+ * If you have a list with changing indices, better use `<For>`.
+ *
+ * @description https://docs.solidjs.com/reference/components/index-component
+ */
+export declare function Index<T extends readonly any[], U extends JSX.Element>(props: {
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    children: (item: Accessor<T[number]>, index: number) => U;
+}): JSX.Element;
+type RequiredParameter<T> = T extends () => unknown ? never : T;
+/**
+ * Conditionally render its children or an optional fallback component
+ * @description https://docs.solidjs.com/reference/components/show
+ */
+export declare function Show<T, TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    fallback?: JSX.Element;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
+}): JSX.Element;
+export declare function Show<T, TRenderFunction extends (item: NonNullable<T>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: JSX.Element;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
+}): JSX.Element;
+/**
+ * Switches between content based on mutually exclusive conditions
+ * ```typescript
+ * <Switch fallback={<FourOhFour />}>
+ *   <Match when={state.route === 'home'}>
+ *     <Home />
+ *   </Match>
+ *   <Match when={state.route === 'settings'}>
+ *     <Settings />
+ *   </Match>
+ * </Switch>
+ * ```
+ * @description https://docs.solidjs.com/reference/components/switch-and-match
+ */
+export declare function Switch(props: {
+    fallback?: JSX.Element;
+    children: JSX.Element;
+}): JSX.Element;
+export type MatchProps<T> = {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: JSX.Element | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => JSX.Element);
+};
+/**
+ * Selects a content based on condition when inside a `<Switch>` control flow
+ * ```typescript
+ * <Match when={condition()}>
+ *   <Content/>
+ * </Match>
+ * ```
+ * @description https://docs.solidjs.com/reference/components/switch-and-match
+ */
+export declare function Match<T, TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
+}): JSX.Element;
+export declare function Match<T, TRenderFunction extends (item: NonNullable<T>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
+}): JSX.Element;
+export declare function resetErrorBoundaries(): void;
+/**
+ * Catches uncaught errors inside components and renders a fallback content
+ *
+ * Also supports a callback form that passes the error and a reset function:
+ * ```typescript
+ * <ErrorBoundary fallback={
+ *   (err, reset) => <div onClick={reset}>Error: {err.toString()}</div>
+ * }>
+ *   <MyComp />
+ * </ErrorBoundary>
+ * ```
+ * Errors thrown from the fallback can be caught by a parent ErrorBoundary
+ *
+ * @description https://docs.solidjs.com/reference/components/error-boundary
+ */
+export declare function ErrorBoundary(props: {
+    fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
+    children: JSX.Element;
+}): JSX.Element;
+export {};

web/node_modules/solid-js/types/render/hydration.d.ts

@@ -0,0 +1,24 @@
+import { Computation } from "../reactive/signal.js";
+export type HydrationContext = {
+    id: string;
+    count: number;
+};
+type SharedConfig = {
+    context?: HydrationContext;
+    resources?: {
+        [key: string]: any;
+    };
+    load?: (id: string) => Promise<any> | any;
+    has?: (id: string) => boolean;
+    gather?: (key: string) => void;
+    registry?: Map<string, Element>;
+    done?: boolean;
+    count?: number;
+    effects?: Computation<any, any>[];
+    getContextId(): string;
+    getNextContextId(): string;
+};
+export declare const sharedConfig: SharedConfig;
+export declare function setHydrateContext(context?: HydrationContext): void;
+export declare function nextHydrateContext(): HydrationContext | undefined;
+export {};

web/node_modules/solid-js/types/render/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./component.js";
+export * from "./flow.js";
+export * from "./Suspense.js";
+export { sharedConfig } from "./hydration.js";

web/node_modules/solid-js/types/server/index.d.ts

@@ -0,0 +1,3 @@
+export { catchError, createRoot, createSignal, createComputed, createRenderEffect, createEffect, createReaction, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, indexArray, observable, from, $PROXY, $DEVCOMP, $TRACK, DEV, enableExternalSource } from "./reactive.js";
+export { mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, resetErrorBoundaries, enableScheduling, enableHydration, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering.js";
+export type { Component, Resource } from "./rendering.js";

web/node_modules/solid-js/types/server/reactive.d.ts

@@ -0,0 +1,98 @@
+export declare const equalFn: <T>(a: T, b: T) => boolean;
+export declare const $PROXY: unique symbol;
+export declare const $TRACK: unique symbol;
+export declare const $DEVCOMP: unique symbol;
+export declare const DEV: undefined;
+export type Accessor<T> = () => T;
+export type Setter<T> = undefined extends T ? <U extends T>(value?: (U extends Function ? never : U) | ((prev?: T) => U)) => U : <U extends T>(value: (U extends Function ? never : U) | ((prev: T) => U)) => U;
+export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+export declare function castError(err: unknown): Error;
+export declare let Owner: Owner | null;
+interface Owner {
+    owner: Owner | null;
+    context: any | null;
+    owned: Owner[] | null;
+    cleanups: (() => void)[] | null;
+}
+export declare function createOwner(): Owner;
+export declare function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: typeof Owner): T;
+export declare function createSignal<T>(value: T, options?: {
+    equals?: false | ((prev: T, next: T) => boolean);
+    name?: string;
+}): [get: () => T, set: (v: (T extends Function ? never : T) | ((prev: T) => T)) => T];
+export declare function createComputed<T>(fn: (v?: T) => T, value?: T): void;
+export declare const createRenderEffect: typeof createComputed;
+export declare function createEffect<T>(fn: (v?: T) => T, value?: T): void;
+export declare function createReaction(fn: () => void): (fn: () => void) => void;
+export declare function createMemo<T>(fn: (v?: T) => T, value?: T): () => T;
+export declare function createDeferred<T>(source: () => T): () => T;
+export declare function createSelector<T>(source: () => T, fn?: (k: T, value: T) => boolean): (k: T) => boolean;
+export declare function batch<T>(fn: () => T): T;
+export declare const untrack: typeof batch;
+export declare function on<T, U>(deps: Array<() => T> | (() => T), fn: (value: Array<T> | T, prev?: Array<T> | T, prevResults?: U) => U, options?: {
+    defer?: boolean;
+}): (prev?: U) => U | undefined;
+export declare function onMount(fn: () => void): void;
+export declare function onCleanup(fn: () => void): () => void;
+export declare function cleanNode(node: Owner): void;
+export declare function catchError<T>(fn: () => T, handler: (err: Error) => void): T | undefined;
+export declare function getListener(): null;
+export interface Context<T> {
+    id: symbol;
+    Provider: (props: {
+        value: T;
+        children: any;
+    }) => any;
+    defaultValue?: T;
+}
+export declare function createContext<T>(defaultValue?: T): Context<T>;
+export declare function useContext<T>(context: Context<T>): T;
+export declare function getOwner(): Owner | null;
+type ChildrenReturn = Accessor<any> & {
+    toArray: () => any[];
+};
+export declare function children(fn: () => any): ChildrenReturn;
+export declare function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined;
+export interface Task {
+    id: number;
+    fn: ((didTimeout: boolean) => void) | null;
+    startTime: number;
+    expirationTime: number;
+}
+export declare function requestCallback(fn: () => void, options?: {
+    timeout: number;
+}): Task;
+export declare function cancelCallback(task: Task): void;
+export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: T, i: Accessor<number>) => U, options?: {
+    fallback?: Accessor<any>;
+}): () => U[];
+export declare function indexArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: number) => U, options?: {
+    fallback?: Accessor<any>;
+}): () => U[];
+export type ObservableObserver<T> = ((v: T) => void) | {
+    next: (v: T) => void;
+    error?: (v: any) => void;
+    complete?: (v: boolean) => void;
+};
+export declare function observable<T>(input: Accessor<T>): {
+    subscribe(observer: ObservableObserver<T>): {
+        unsubscribe(): void;
+    };
+    [Symbol.observable](): {
+        subscribe(observer: ObservableObserver<T>): {
+            unsubscribe(): void;
+        };
+        [Symbol.observable](): /*elided*/ any;
+    };
+};
+export declare function from<T>(producer: ((setter: Setter<T>) => () => void) | {
+    subscribe: (fn: (v: T) => void) => (() => void) | {
+        unsubscribe: () => void;
+    };
+}): Accessor<T>;
+export declare function enableExternalSource(factory: any): void;
+/**
+ * @deprecated since version 1.7.0 and will be removed in next major - use catchError instead
+ */
+export declare function onError(fn: (err: Error) => void): void;
+export {};

web/node_modules/solid-js/types/server/rendering.d.ts

@@ -0,0 +1,159 @@
+import { Accessor, Setter, Signal } from "./reactive.js";
+import type { JSX } from "../jsx.js";
+export type Component<P = {}> = (props: P) => JSX.Element;
+export type VoidProps<P = {}> = P & {
+    children?: never;
+};
+export type VoidComponent<P = {}> = Component<VoidProps<P>>;
+export type ParentProps<P = {}> = P & {
+    children?: JSX.Element;
+};
+export type ParentComponent<P = {}> = Component<ParentProps<P>>;
+export type FlowProps<P = {}, C = JSX.Element> = P & {
+    children: C;
+};
+export type FlowComponent<P = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
+export type Ref<T> = T | ((val: T) => void);
+export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
+type SharedConfig = {
+    context?: HydrationContext;
+    getContextId(): string;
+    getNextContextId(): string;
+};
+export declare const sharedConfig: SharedConfig;
+export declare function createUniqueId(): string;
+export declare function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+export declare function mergeProps<T, U>(source: T, source1: U): T & U;
+export declare function mergeProps<T, U, V>(source: T, source1: U, source2: V): T & U & V;
+export declare function mergeProps<T, U, V, W>(source: T, source1: U, source2: V, source3: W): T & U & V & W;
+export declare function splitProps<T extends object, K1 extends keyof T>(props: T, ...keys: [K1[]]): [Pick<T, K1>, Omit<T, K1>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T>(props: T, ...keys: [K1[], K2[]]): [Pick<T, K1>, Pick<T, K2>, Omit<T, K1 | K2>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Omit<T, K1 | K2 | K3>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T, K4 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[], K4[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Pick<T, K4>, Omit<T, K1 | K2 | K3 | K4>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T, K4 extends keyof T, K5 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[], K4[], K5[]]): [
+    Pick<T, K1>,
+    Pick<T, K2>,
+    Pick<T, K3>,
+    Pick<T, K4>,
+    Pick<T, K5>,
+    Omit<T, K1 | K2 | K3 | K4 | K5>
+];
+export declare function For<T>(props: {
+    each: T[];
+    fallback?: string;
+    children: (item: T, index: () => number) => string;
+}): string | any[] | undefined;
+export declare function Index<T>(props: {
+    each: T[];
+    fallback?: string;
+    children: (item: () => T, index: number) => string;
+}): string | any[] | undefined;
+/**
+ * Conditionally render its children or an optional fallback component
+ * @description https://docs.solidjs.com/reference/components/show
+ */
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    fallback?: string;
+    children: string | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => string);
+}): string;
+export declare function Switch(props: {
+    fallback?: string;
+    children: MatchProps<unknown> | MatchProps<unknown>[];
+}): string;
+type MatchProps<T> = {
+    when: T | false;
+    keyed?: boolean;
+    children: string | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => string);
+};
+export declare function Match<T>(props: MatchProps<T>): MatchProps<T>;
+export declare function resetErrorBoundaries(): void;
+export declare function ErrorBoundary(props: {
+    fallback: string | ((err: any, reset: () => void) => string);
+    children: string;
+}): string | ((err: any, reset: () => void) => string) | {
+    t: string;
+};
+export interface Resource<T> {
+    (): T | undefined;
+    state: "unresolved" | "pending" | "ready" | "refreshing" | "errored";
+    loading: boolean;
+    error: any;
+    latest: T | undefined;
+}
+type SuspenseContextType = {
+    resources: Map<string, {
+        _loading: boolean;
+        error: any;
+    }>;
+    completed: () => void;
+};
+export type ResourceActions<T> = {
+    mutate: Setter<T>;
+    refetch: (info?: unknown) => void;
+};
+export type ResourceReturn<T> = [Resource<T>, ResourceActions<T>];
+export type ResourceSource<S> = S | false | null | undefined | (() => S | false | null | undefined);
+export type ResourceFetcher<S, T> = (k: S, info: ResourceFetcherInfo<T>) => T | Promise<T>;
+export type ResourceFetcherInfo<T> = {
+    value: T | undefined;
+    refetching?: unknown;
+};
+export type ResourceOptions<T> = undefined extends T ? {
+    initialValue?: T;
+    name?: string;
+    deferStream?: boolean;
+    ssrLoadFrom?: "initial" | "server";
+    storage?: () => Signal<T | undefined>;
+    onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
+} : {
+    initialValue: T;
+    name?: string;
+    deferStream?: boolean;
+    ssrLoadFrom?: "initial" | "server";
+    storage?: (v?: T) => Signal<T | undefined>;
+    onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
+};
+export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined>;
+export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T>;
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined>;
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T>;
+export declare function lazy<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>): T & {
+    preload: () => Promise<{
+        default: T;
+    }>;
+};
+export declare function enableScheduling(): void;
+export declare function enableHydration(): void;
+export declare function startTransition(fn: () => any): void;
+export declare function useTransition(): [() => boolean, (fn: () => any) => void];
+type HydrationContext = {
+    id: string;
+    count: number;
+    serialize: (id: string, v: Promise<any> | any, deferStream?: boolean) => void;
+    nextRoot: (v: any) => string;
+    replace: (id: string, replacement: () => any) => void;
+    block: (p: Promise<any>) => void;
+    resources: Record<string, any>;
+    suspense: Record<string, SuspenseContextType>;
+    registerFragment: (v: string) => (v?: string, err?: any) => boolean;
+    lazy: Record<string, Promise<any>>;
+    async?: boolean;
+    noHydrate: boolean;
+};
+export declare function SuspenseList(props: {
+    children: string;
+    revealOrder: "forwards" | "backwards" | "together";
+    tail?: "collapsed" | "hidden";
+}): string;
+export declare function Suspense(props: {
+    fallback?: string;
+    children: string;
+}): string | number | boolean | Node | JSX.ArrayElement | {
+    t: string;
+} | null | undefined;
+export {};

web/node_modules/solid-js/universal/dist/dev.cjs

@@ -0,0 +1,245 @@
+'use strict';
+
+var solidJs = require('solid-js');
+
+const memo = fn => solidJs.createMemo(() => fn());
+
+function createRenderer$1({
+  createElement,
+  createTextNode,
+  isTextNode,
+  replaceText,
+  insertNode,
+  removeNode,
+  setProperty,
+  getParentNode,
+  getFirstChild,
+  getNextSibling
+}) {
+  function insert(parent, accessor, marker, initial) {
+    if (marker !== undefined && !initial) initial = [];
+    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+    solidJs.createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
+  }
+  function insertExpression(parent, value, current, marker, unwrapArray) {
+    while (typeof current === "function") current = current();
+    if (value === current) return current;
+    const t = typeof value,
+      multi = marker !== undefined;
+    if (t === "string" || t === "number") {
+      if (t === "number") value = value.toString();
+      if (multi) {
+        let node = current[0];
+        if (node && isTextNode(node)) {
+          replaceText(node, value);
+        } else node = createTextNode(value);
+        current = cleanChildren(parent, current, marker, node);
+      } else {
+        if (current !== "" && typeof current === "string") {
+          replaceText(getFirstChild(parent), current = value);
+        } else {
+          cleanChildren(parent, current, marker, createTextNode(value));
+          current = value;
+        }
+      }
+    } else if (value == null || t === "boolean") {
+      current = cleanChildren(parent, current, marker);
+    } else if (t === "function") {
+      solidJs.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 = [];
+      if (normalizeIncomingArray(array, value, unwrapArray)) {
+        solidJs.createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+        return () => current;
+      }
+      if (array.length === 0) {
+        const replacement = cleanChildren(parent, current, marker);
+        if (multi) return current = replacement;
+      } else {
+        if (Array.isArray(current)) {
+          if (current.length === 0) {
+            appendNodes(parent, array, marker);
+          } else reconcileArrays(parent, current, array);
+        } else if (current == null || current === "") {
+          appendNodes(parent, array);
+        } else {
+          reconcileArrays(parent, multi && current || [getFirstChild(parent)], array);
+        }
+      }
+      current = array;
+    } else {
+      if (Array.isArray(current)) {
+        if (multi) return current = cleanChildren(parent, current, marker, value);
+        cleanChildren(parent, current, null, value);
+      } else if (current == null || current === "" || !getFirstChild(parent)) {
+        insertNode(parent, value);
+      } else replaceNode(parent, value, getFirstChild(parent));
+      current = value;
+    }
+    return current;
+  }
+  function normalizeIncomingArray(normalized, array, unwrap) {
+    let dynamic = false;
+    for (let i = 0, len = array.length; i < len; i++) {
+      let item = array[i],
+        t;
+      if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
+        dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+      } else if ((t = typeof item) === "string" || t === "number") {
+        normalized.push(createTextNode(item));
+      } else if (t === "function") {
+        if (unwrap) {
+          while (typeof item === "function") item = item();
+          dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
+        } else {
+          normalized.push(item);
+          dynamic = true;
+        }
+      } else normalized.push(item);
+    }
+    return dynamic;
+  }
+  function reconcileArrays(parentNode, a, b) {
+    let bLength = b.length,
+      aEnd = a.length,
+      bEnd = bLength,
+      aStart = 0,
+      bStart = 0,
+      after = getNextSibling(a[aEnd - 1]),
+      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 ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
+        while (bStart < bEnd) insertNode(parentNode, b[bStart++], node);
+      } else if (bEnd === bStart) {
+        while (aStart < aEnd) {
+          if (!map || !map.has(a[aStart])) removeNode(parentNode, a[aStart]);
+          aStart++;
+        }
+      } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+        const node = getNextSibling(a[--aEnd]);
+        insertNode(parentNode, b[bStart++], getNextSibling(a[aStart++]));
+        insertNode(parentNode, 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) insertNode(parentNode, b[bStart++], node);
+            } else replaceNode(parentNode, b[bStart++], a[aStart++]);
+          } else aStart++;
+        } else removeNode(parentNode, a[aStart++]);
+      }
+    }
+  }
+  function cleanChildren(parent, current, marker, replacement) {
+    if (marker === undefined) {
+      let removed;
+      while (removed = getFirstChild(parent)) removeNode(parent, removed);
+      replacement && insertNode(parent, replacement);
+      return "";
+    }
+    const node = replacement || 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 = getParentNode(el) === parent;
+          if (!inserted && !i) isParent ? replaceNode(parent, node, el) : insertNode(parent, node, marker);else isParent && removeNode(parent, el);
+        } else inserted = true;
+      }
+    } else insertNode(parent, node, marker);
+    return [node];
+  }
+  function appendNodes(parent, array, marker) {
+    for (let i = 0, len = array.length; i < len; i++) insertNode(parent, array[i], marker);
+  }
+  function replaceNode(parent, newNode, oldNode) {
+    insertNode(parent, newNode, oldNode);
+    removeNode(parent, oldNode);
+  }
+  function spreadExpression(node, props, prevProps = {}, skipChildren) {
+    props || (props = {});
+    if (!skipChildren) {
+      solidJs.createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+    }
+    solidJs.createRenderEffect(() => props.ref && props.ref(node));
+    solidJs.createRenderEffect(() => {
+      for (const prop in props) {
+        if (prop === "children" || prop === "ref") continue;
+        const value = props[prop];
+        if (value === prevProps[prop]) continue;
+        setProperty(node, prop, value, prevProps[prop]);
+        prevProps[prop] = value;
+      }
+    });
+    return prevProps;
+  }
+  return {
+    render(code, element) {
+      let disposer;
+      solidJs.createRoot(dispose => {
+        disposer = dispose;
+        insert(element, code());
+      });
+      return disposer;
+    },
+    insert,
+    spread(node, accessor, skipChildren) {
+      if (typeof accessor === "function") {
+        solidJs.createRenderEffect(current => spreadExpression(node, accessor(), current, skipChildren));
+      } else spreadExpression(node, accessor, undefined, skipChildren);
+    },
+    createElement,
+    createTextNode,
+    insertNode,
+    setProp(node, name, value, prev) {
+      setProperty(node, name, value, prev);
+      return value;
+    },
+    mergeProps: solidJs.mergeProps,
+    effect: solidJs.createRenderEffect,
+    memo,
+    createComponent: solidJs.createComponent,
+    use(fn, element, arg) {
+      return solidJs.untrack(() => fn(element, arg));
+    }
+  };
+}
+
+function createRenderer(options) {
+  const renderer = createRenderer$1(options);
+  renderer.mergeProps = solidJs.mergeProps;
+  return renderer;
+}
+
+exports.createRenderer = createRenderer;

web/node_modules/solid-js/universal/dist/dev.js

@@ -0,0 +1,243 @@
+import { createMemo, createComponent, createRenderEffect, mergeProps, untrack, createRoot } from 'solid-js';
+
+const memo = fn => createMemo(() => fn());
+
+function createRenderer$1({
+  createElement,
+  createTextNode,
+  isTextNode,
+  replaceText,
+  insertNode,
+  removeNode,
+  setProperty,
+  getParentNode,
+  getFirstChild,
+  getNextSibling
+}) {
+  function insert(parent, accessor, marker, initial) {
+    if (marker !== undefined && !initial) initial = [];
+    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+    createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
+  }
+  function insertExpression(parent, value, current, marker, unwrapArray) {
+    while (typeof current === "function") current = current();
+    if (value === current) return current;
+    const t = typeof value,
+      multi = marker !== undefined;
+    if (t === "string" || t === "number") {
+      if (t === "number") value = value.toString();
+      if (multi) {
+        let node = current[0];
+        if (node && isTextNode(node)) {
+          replaceText(node, value);
+        } else node = createTextNode(value);
+        current = cleanChildren(parent, current, marker, node);
+      } else {
+        if (current !== "" && typeof current === "string") {
+          replaceText(getFirstChild(parent), current = value);
+        } else {
+          cleanChildren(parent, current, marker, createTextNode(value));
+          current = value;
+        }
+      }
+    } else if (value == null || t === "boolean") {
+      current = cleanChildren(parent, current, marker);
+    } else if (t === "function") {
+      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 = [];
+      if (normalizeIncomingArray(array, value, unwrapArray)) {
+        createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+        return () => current;
+      }
+      if (array.length === 0) {
+        const replacement = cleanChildren(parent, current, marker);
+        if (multi) return current = replacement;
+      } else {
+        if (Array.isArray(current)) {
+          if (current.length === 0) {
+            appendNodes(parent, array, marker);
+          } else reconcileArrays(parent, current, array);
+        } else if (current == null || current === "") {
+          appendNodes(parent, array);
+        } else {
+          reconcileArrays(parent, multi && current || [getFirstChild(parent)], array);
+        }
+      }
+      current = array;
+    } else {
+      if (Array.isArray(current)) {
+        if (multi) return current = cleanChildren(parent, current, marker, value);
+        cleanChildren(parent, current, null, value);
+      } else if (current == null || current === "" || !getFirstChild(parent)) {
+        insertNode(parent, value);
+      } else replaceNode(parent, value, getFirstChild(parent));
+      current = value;
+    }
+    return current;
+  }
+  function normalizeIncomingArray(normalized, array, unwrap) {
+    let dynamic = false;
+    for (let i = 0, len = array.length; i < len; i++) {
+      let item = array[i],
+        t;
+      if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
+        dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+      } else if ((t = typeof item) === "string" || t === "number") {
+        normalized.push(createTextNode(item));
+      } else if (t === "function") {
+        if (unwrap) {
+          while (typeof item === "function") item = item();
+          dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
+        } else {
+          normalized.push(item);
+          dynamic = true;
+        }
+      } else normalized.push(item);
+    }
+    return dynamic;
+  }
+  function reconcileArrays(parentNode, a, b) {
+    let bLength = b.length,
+      aEnd = a.length,
+      bEnd = bLength,
+      aStart = 0,
+      bStart = 0,
+      after = getNextSibling(a[aEnd - 1]),
+      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 ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
+        while (bStart < bEnd) insertNode(parentNode, b[bStart++], node);
+      } else if (bEnd === bStart) {
+        while (aStart < aEnd) {
+          if (!map || !map.has(a[aStart])) removeNode(parentNode, a[aStart]);
+          aStart++;
+        }
+      } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+        const node = getNextSibling(a[--aEnd]);
+        insertNode(parentNode, b[bStart++], getNextSibling(a[aStart++]));
+        insertNode(parentNode, 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) insertNode(parentNode, b[bStart++], node);
+            } else replaceNode(parentNode, b[bStart++], a[aStart++]);
+          } else aStart++;
+        } else removeNode(parentNode, a[aStart++]);
+      }
+    }
+  }
+  function cleanChildren(parent, current, marker, replacement) {
+    if (marker === undefined) {
+      let removed;
+      while (removed = getFirstChild(parent)) removeNode(parent, removed);
+      replacement && insertNode(parent, replacement);
+      return "";
+    }
+    const node = replacement || 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 = getParentNode(el) === parent;
+          if (!inserted && !i) isParent ? replaceNode(parent, node, el) : insertNode(parent, node, marker);else isParent && removeNode(parent, el);
+        } else inserted = true;
+      }
+    } else insertNode(parent, node, marker);
+    return [node];
+  }
+  function appendNodes(parent, array, marker) {
+    for (let i = 0, len = array.length; i < len; i++) insertNode(parent, array[i], marker);
+  }
+  function replaceNode(parent, newNode, oldNode) {
+    insertNode(parent, newNode, oldNode);
+    removeNode(parent, oldNode);
+  }
+  function spreadExpression(node, props, prevProps = {}, skipChildren) {
+    props || (props = {});
+    if (!skipChildren) {
+      createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+    }
+    createRenderEffect(() => props.ref && props.ref(node));
+    createRenderEffect(() => {
+      for (const prop in props) {
+        if (prop === "children" || prop === "ref") continue;
+        const value = props[prop];
+        if (value === prevProps[prop]) continue;
+        setProperty(node, prop, value, prevProps[prop]);
+        prevProps[prop] = value;
+      }
+    });
+    return prevProps;
+  }
+  return {
+    render(code, element) {
+      let disposer;
+      createRoot(dispose => {
+        disposer = dispose;
+        insert(element, code());
+      });
+      return disposer;
+    },
+    insert,
+    spread(node, accessor, skipChildren) {
+      if (typeof accessor === "function") {
+        createRenderEffect(current => spreadExpression(node, accessor(), current, skipChildren));
+      } else spreadExpression(node, accessor, undefined, skipChildren);
+    },
+    createElement,
+    createTextNode,
+    insertNode,
+    setProp(node, name, value, prev) {
+      setProperty(node, name, value, prev);
+      return value;
+    },
+    mergeProps,
+    effect: createRenderEffect,
+    memo,
+    createComponent,
+    use(fn, element, arg) {
+      return untrack(() => fn(element, arg));
+    }
+  };
+}
+
+function createRenderer(options) {
+  const renderer = createRenderer$1(options);
+  renderer.mergeProps = mergeProps;
+  return renderer;
+}
+
+export { createRenderer };

web/node_modules/solid-js/universal/dist/universal.cjs

@@ -0,0 +1,245 @@
+'use strict';
+
+var solidJs = require('solid-js');
+
+const memo = fn => solidJs.createMemo(() => fn());
+
+function createRenderer$1({
+  createElement,
+  createTextNode,
+  isTextNode,
+  replaceText,
+  insertNode,
+  removeNode,
+  setProperty,
+  getParentNode,
+  getFirstChild,
+  getNextSibling
+}) {
+  function insert(parent, accessor, marker, initial) {
+    if (marker !== undefined && !initial) initial = [];
+    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+    solidJs.createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
+  }
+  function insertExpression(parent, value, current, marker, unwrapArray) {
+    while (typeof current === "function") current = current();
+    if (value === current) return current;
+    const t = typeof value,
+      multi = marker !== undefined;
+    if (t === "string" || t === "number") {
+      if (t === "number") value = value.toString();
+      if (multi) {
+        let node = current[0];
+        if (node && isTextNode(node)) {
+          replaceText(node, value);
+        } else node = createTextNode(value);
+        current = cleanChildren(parent, current, marker, node);
+      } else {
+        if (current !== "" && typeof current === "string") {
+          replaceText(getFirstChild(parent), current = value);
+        } else {
+          cleanChildren(parent, current, marker, createTextNode(value));
+          current = value;
+        }
+      }
+    } else if (value == null || t === "boolean") {
+      current = cleanChildren(parent, current, marker);
+    } else if (t === "function") {
+      solidJs.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 = [];
+      if (normalizeIncomingArray(array, value, unwrapArray)) {
+        solidJs.createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+        return () => current;
+      }
+      if (array.length === 0) {
+        const replacement = cleanChildren(parent, current, marker);
+        if (multi) return current = replacement;
+      } else {
+        if (Array.isArray(current)) {
+          if (current.length === 0) {
+            appendNodes(parent, array, marker);
+          } else reconcileArrays(parent, current, array);
+        } else if (current == null || current === "") {
+          appendNodes(parent, array);
+        } else {
+          reconcileArrays(parent, multi && current || [getFirstChild(parent)], array);
+        }
+      }
+      current = array;
+    } else {
+      if (Array.isArray(current)) {
+        if (multi) return current = cleanChildren(parent, current, marker, value);
+        cleanChildren(parent, current, null, value);
+      } else if (current == null || current === "" || !getFirstChild(parent)) {
+        insertNode(parent, value);
+      } else replaceNode(parent, value, getFirstChild(parent));
+      current = value;
+    }
+    return current;
+  }
+  function normalizeIncomingArray(normalized, array, unwrap) {
+    let dynamic = false;
+    for (let i = 0, len = array.length; i < len; i++) {
+      let item = array[i],
+        t;
+      if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
+        dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+      } else if ((t = typeof item) === "string" || t === "number") {
+        normalized.push(createTextNode(item));
+      } else if (t === "function") {
+        if (unwrap) {
+          while (typeof item === "function") item = item();
+          dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
+        } else {
+          normalized.push(item);
+          dynamic = true;
+        }
+      } else normalized.push(item);
+    }
+    return dynamic;
+  }
+  function reconcileArrays(parentNode, a, b) {
+    let bLength = b.length,
+      aEnd = a.length,
+      bEnd = bLength,
+      aStart = 0,
+      bStart = 0,
+      after = getNextSibling(a[aEnd - 1]),
+      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 ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
+        while (bStart < bEnd) insertNode(parentNode, b[bStart++], node);
+      } else if (bEnd === bStart) {
+        while (aStart < aEnd) {
+          if (!map || !map.has(a[aStart])) removeNode(parentNode, a[aStart]);
+          aStart++;
+        }
+      } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+        const node = getNextSibling(a[--aEnd]);
+        insertNode(parentNode, b[bStart++], getNextSibling(a[aStart++]));
+        insertNode(parentNode, 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) insertNode(parentNode, b[bStart++], node);
+            } else replaceNode(parentNode, b[bStart++], a[aStart++]);
+          } else aStart++;
+        } else removeNode(parentNode, a[aStart++]);
+      }
+    }
+  }
+  function cleanChildren(parent, current, marker, replacement) {
+    if (marker === undefined) {
+      let removed;
+      while (removed = getFirstChild(parent)) removeNode(parent, removed);
+      replacement && insertNode(parent, replacement);
+      return "";
+    }
+    const node = replacement || 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 = getParentNode(el) === parent;
+          if (!inserted && !i) isParent ? replaceNode(parent, node, el) : insertNode(parent, node, marker);else isParent && removeNode(parent, el);
+        } else inserted = true;
+      }
+    } else insertNode(parent, node, marker);
+    return [node];
+  }
+  function appendNodes(parent, array, marker) {
+    for (let i = 0, len = array.length; i < len; i++) insertNode(parent, array[i], marker);
+  }
+  function replaceNode(parent, newNode, oldNode) {
+    insertNode(parent, newNode, oldNode);
+    removeNode(parent, oldNode);
+  }
+  function spreadExpression(node, props, prevProps = {}, skipChildren) {
+    props || (props = {});
+    if (!skipChildren) {
+      solidJs.createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+    }
+    solidJs.createRenderEffect(() => props.ref && props.ref(node));
+    solidJs.createRenderEffect(() => {
+      for (const prop in props) {
+        if (prop === "children" || prop === "ref") continue;
+        const value = props[prop];
+        if (value === prevProps[prop]) continue;
+        setProperty(node, prop, value, prevProps[prop]);
+        prevProps[prop] = value;
+      }
+    });
+    return prevProps;
+  }
+  return {
+    render(code, element) {
+      let disposer;
+      solidJs.createRoot(dispose => {
+        disposer = dispose;
+        insert(element, code());
+      });
+      return disposer;
+    },
+    insert,
+    spread(node, accessor, skipChildren) {
+      if (typeof accessor === "function") {
+        solidJs.createRenderEffect(current => spreadExpression(node, accessor(), current, skipChildren));
+      } else spreadExpression(node, accessor, undefined, skipChildren);
+    },
+    createElement,
+    createTextNode,
+    insertNode,
+    setProp(node, name, value, prev) {
+      setProperty(node, name, value, prev);
+      return value;
+    },
+    mergeProps: solidJs.mergeProps,
+    effect: solidJs.createRenderEffect,
+    memo,
+    createComponent: solidJs.createComponent,
+    use(fn, element, arg) {
+      return solidJs.untrack(() => fn(element, arg));
+    }
+  };
+}
+
+function createRenderer(options) {
+  const renderer = createRenderer$1(options);
+  renderer.mergeProps = solidJs.mergeProps;
+  return renderer;
+}
+
+exports.createRenderer = createRenderer;

web/node_modules/solid-js/universal/dist/universal.js

@@ -0,0 +1,243 @@
+import { createMemo, createComponent, createRenderEffect, mergeProps, untrack, createRoot } from 'solid-js';
+
+const memo = fn => createMemo(() => fn());
+
+function createRenderer$1({
+  createElement,
+  createTextNode,
+  isTextNode,
+  replaceText,
+  insertNode,
+  removeNode,
+  setProperty,
+  getParentNode,
+  getFirstChild,
+  getNextSibling
+}) {
+  function insert(parent, accessor, marker, initial) {
+    if (marker !== undefined && !initial) initial = [];
+    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+    createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
+  }
+  function insertExpression(parent, value, current, marker, unwrapArray) {
+    while (typeof current === "function") current = current();
+    if (value === current) return current;
+    const t = typeof value,
+      multi = marker !== undefined;
+    if (t === "string" || t === "number") {
+      if (t === "number") value = value.toString();
+      if (multi) {
+        let node = current[0];
+        if (node && isTextNode(node)) {
+          replaceText(node, value);
+        } else node = createTextNode(value);
+        current = cleanChildren(parent, current, marker, node);
+      } else {
+        if (current !== "" && typeof current === "string") {
+          replaceText(getFirstChild(parent), current = value);
+        } else {
+          cleanChildren(parent, current, marker, createTextNode(value));
+          current = value;
+        }
+      }
+    } else if (value == null || t === "boolean") {
+      current = cleanChildren(parent, current, marker);
+    } else if (t === "function") {
+      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 = [];
+      if (normalizeIncomingArray(array, value, unwrapArray)) {
+        createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+        return () => current;
+      }
+      if (array.length === 0) {
+        const replacement = cleanChildren(parent, current, marker);
+        if (multi) return current = replacement;
+      } else {
+        if (Array.isArray(current)) {
+          if (current.length === 0) {
+            appendNodes(parent, array, marker);
+          } else reconcileArrays(parent, current, array);
+        } else if (current == null || current === "") {
+          appendNodes(parent, array);
+        } else {
+          reconcileArrays(parent, multi && current || [getFirstChild(parent)], array);
+        }
+      }
+      current = array;
+    } else {
+      if (Array.isArray(current)) {
+        if (multi) return current = cleanChildren(parent, current, marker, value);
+        cleanChildren(parent, current, null, value);
+      } else if (current == null || current === "" || !getFirstChild(parent)) {
+        insertNode(parent, value);
+      } else replaceNode(parent, value, getFirstChild(parent));
+      current = value;
+    }
+    return current;
+  }
+  function normalizeIncomingArray(normalized, array, unwrap) {
+    let dynamic = false;
+    for (let i = 0, len = array.length; i < len; i++) {
+      let item = array[i],
+        t;
+      if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
+        dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+      } else if ((t = typeof item) === "string" || t === "number") {
+        normalized.push(createTextNode(item));
+      } else if (t === "function") {
+        if (unwrap) {
+          while (typeof item === "function") item = item();
+          dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
+        } else {
+          normalized.push(item);
+          dynamic = true;
+        }
+      } else normalized.push(item);
+    }
+    return dynamic;
+  }
+  function reconcileArrays(parentNode, a, b) {
+    let bLength = b.length,
+      aEnd = a.length,
+      bEnd = bLength,
+      aStart = 0,
+      bStart = 0,
+      after = getNextSibling(a[aEnd - 1]),
+      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 ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
+        while (bStart < bEnd) insertNode(parentNode, b[bStart++], node);
+      } else if (bEnd === bStart) {
+        while (aStart < aEnd) {
+          if (!map || !map.has(a[aStart])) removeNode(parentNode, a[aStart]);
+          aStart++;
+        }
+      } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+        const node = getNextSibling(a[--aEnd]);
+        insertNode(parentNode, b[bStart++], getNextSibling(a[aStart++]));
+        insertNode(parentNode, 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) insertNode(parentNode, b[bStart++], node);
+            } else replaceNode(parentNode, b[bStart++], a[aStart++]);
+          } else aStart++;
+        } else removeNode(parentNode, a[aStart++]);
+      }
+    }
+  }
+  function cleanChildren(parent, current, marker, replacement) {
+    if (marker === undefined) {
+      let removed;
+      while (removed = getFirstChild(parent)) removeNode(parent, removed);
+      replacement && insertNode(parent, replacement);
+      return "";
+    }
+    const node = replacement || 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 = getParentNode(el) === parent;
+          if (!inserted && !i) isParent ? replaceNode(parent, node, el) : insertNode(parent, node, marker);else isParent && removeNode(parent, el);
+        } else inserted = true;
+      }
+    } else insertNode(parent, node, marker);
+    return [node];
+  }
+  function appendNodes(parent, array, marker) {
+    for (let i = 0, len = array.length; i < len; i++) insertNode(parent, array[i], marker);
+  }
+  function replaceNode(parent, newNode, oldNode) {
+    insertNode(parent, newNode, oldNode);
+    removeNode(parent, oldNode);
+  }
+  function spreadExpression(node, props, prevProps = {}, skipChildren) {
+    props || (props = {});
+    if (!skipChildren) {
+      createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+    }
+    createRenderEffect(() => props.ref && props.ref(node));
+    createRenderEffect(() => {
+      for (const prop in props) {
+        if (prop === "children" || prop === "ref") continue;
+        const value = props[prop];
+        if (value === prevProps[prop]) continue;
+        setProperty(node, prop, value, prevProps[prop]);
+        prevProps[prop] = value;
+      }
+    });
+    return prevProps;
+  }
+  return {
+    render(code, element) {
+      let disposer;
+      createRoot(dispose => {
+        disposer = dispose;
+        insert(element, code());
+      });
+      return disposer;
+    },
+    insert,
+    spread(node, accessor, skipChildren) {
+      if (typeof accessor === "function") {
+        createRenderEffect(current => spreadExpression(node, accessor(), current, skipChildren));
+      } else spreadExpression(node, accessor, undefined, skipChildren);
+    },
+    createElement,
+    createTextNode,
+    insertNode,
+    setProp(node, name, value, prev) {
+      setProperty(node, name, value, prev);
+      return value;
+    },
+    mergeProps,
+    effect: createRenderEffect,
+    memo,
+    createComponent,
+    use(fn, element, arg) {
+      return untrack(() => fn(element, arg));
+    }
+  };
+}
+
+function createRenderer(options) {
+  const renderer = createRenderer$1(options);
+  renderer.mergeProps = mergeProps;
+  return renderer;
+}
+
+export { createRenderer };

web/node_modules/solid-js/universal/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "solid-js/universal",
+  "main": "./dist/universal.cjs",
+  "module": "./dist/universal.js",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "development": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/dev.js",
+        "require": "./dist/dev.cjs"
+      },
+      "types": "./types/index.d.ts",
+      "import": "./dist/universal.js",
+      "require": "./dist/universal.cjs"
+    }
+  }
+}

web/node_modules/solid-js/universal/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { RendererOptions, Renderer } from "./universal.js";
+export type { RendererOptions, Renderer } from "./universal.js";
+export declare function createRenderer<NodeType>(options: RendererOptions<NodeType>): Renderer<NodeType>;

web/node_modules/solid-js/universal/types/universal.d.ts

@@ -0,0 +1,30 @@
+export interface RendererOptions<NodeType> {
+  createElement(tag: string): NodeType;
+  createTextNode(value: string): NodeType;
+  replaceText(textNode: NodeType, value: string): void;
+  isTextNode(node: NodeType): boolean;
+  setProperty<T>(node: NodeType, name: string, value: T, prev?: T): void;
+  insertNode(parent: NodeType, node: NodeType, anchor?: NodeType): void;
+  removeNode(parent: NodeType, node: NodeType): void;
+  getParentNode(node: NodeType): NodeType | undefined;
+  getFirstChild(node: NodeType): NodeType | undefined;
+  getNextSibling(node: NodeType): NodeType | undefined;
+}
+
+export interface Renderer<NodeType> {
+  render(code: () => NodeType, node: NodeType): () => void;
+  effect<T>(fn: (prev?: T) => T, init?: T): void;
+  memo<T>(fn: () => T, equal: boolean): () => T;
+  createComponent<T>(Comp: (props: T) => NodeType, props: T): NodeType;
+  createElement(tag: string): NodeType;
+  createTextNode(value: string): NodeType;
+  insertNode(parent: NodeType, node: NodeType, anchor?: NodeType): void;
+  insert<T>(parent: any, accessor: (() => T) | T, marker?: any | null, initial?: any): NodeType;
+  spread<T>(node: any, accessor: (() => T) | T, skipChildren?: boolean): void;
+  setProp<T>(node: NodeType, name: string, value: T, prev?: T): T;
+  mergeProps(...sources: unknown[]): unknown;
+  use<A, T>(fn: (element: NodeType, arg: A) => T, element: NodeType, arg: A): T;
+}
+
+export function createRenderer<NodeType>(options: RendererOptions<NodeType>): Renderer<NodeType>;
+

web/node_modules/solid-js/web/dist/dev.cjs

@@ -0,0 +1,894 @@
+'use strict';
+
+var solidJs = require('solid-js');
+
+const booleans = ["allowfullscreen", "async", "alpha",
+"autofocus",
+"autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden",
+"indeterminate", "inert",
+"ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless",
+"selected", "adauctionheaders",
+"browsingtopics",
+"credentialless",
+"defaultchecked", "defaultmuted", "defaultselected", "defer", "disablepictureinpicture", "disableremoteplayback", "preservespitch",
+"shadowrootclonable", "shadowrootcustomelementregistry",
+"shadowrootdelegatesfocus", "shadowrootserializable",
+"sharedstoragewritable"
+];
+const Properties = /*#__PURE__*/new Set([
+"className", "value",
+"readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", "adAuctionHeaders",
+"allowFullscreen", "browsingTopics",
+"defaultChecked", "defaultMuted", "defaultSelected", "disablePictureInPicture", "disableRemotePlayback", "preservesPitch", "shadowRootClonable", "shadowRootCustomElementRegistry",
+"shadowRootDelegatesFocus", "shadowRootSerializable",
+"sharedStorageWritable",
+...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
+  },
+  adauctionheaders: {
+    $: "adAuctionHeaders",
+    IFRAME: 1
+  },
+  allowfullscreen: {
+    $: "allowFullscreen",
+    IFRAME: 1
+  },
+  browsingtopics: {
+    $: "browsingTopics",
+    IMG: 1
+  },
+  defaultchecked: {
+    $: "defaultChecked",
+    INPUT: 1
+  },
+  defaultmuted: {
+    $: "defaultMuted",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  defaultselected: {
+    $: "defaultSelected",
+    OPTION: 1
+  },
+  disablepictureinpicture: {
+    $: "disablePictureInPicture",
+    VIDEO: 1
+  },
+  disableremoteplayback: {
+    $: "disableRemotePlayback",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  preservespitch: {
+    $: "preservesPitch",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  shadowrootclonable: {
+    $: "shadowRootClonable",
+    TEMPLATE: 1
+  },
+  shadowrootdelegatesfocus: {
+    $: "shadowRootDelegatesFocus",
+    TEMPLATE: 1
+  },
+  shadowrootserializable: {
+    $: "shadowRootSerializable",
+    TEMPLATE: 1
+  },
+  sharedstoragewritable: {
+    $: "sharedStorageWritable",
+    IFRAME: 1,
+    IMG: 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",
+"webview",
+"isindex", "listing", "multicol", "nextid", "noindex", "search"]);
+
+const memo = fn => solidJs.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 = {}) {
+  if (!element) {
+    throw new Error("The `element` passed to `render(..., element)` doesn't exist. Make sure `element` exists in the document.");
+  }
+  let disposer;
+  solidJs.createRoot(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 = () => {
+    if (isHydrating()) throw new Error("Failed attempt to create new DOM elements during hydration. Check that the libraries you are using support hydration.");
+    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 ? () => solidJs.untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+  fn.cloneNode = fn;
+  return fn;
+}
+function delegateEvents(eventNames, document = window.document) {
+  const e = document[$$EVENTS] || (document[$$EVENTS] = new Set());
+  for (let i = 0, l = eventNames.length; i < l; i++) {
+    const name = eventNames[i];
+    if (!e.has(name)) {
+      e.add(name);
+      document.addEventListener(name, eventHandler);
+    }
+  }
+}
+function clearDelegatedEvents(document = window.document) {
+  if (document[$$EVENTS]) {
+    for (let name of document[$$EVENTS].keys()) document.removeEventListener(name, eventHandler);
+    delete document[$$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 setStyleProperty(node, name, value) {
+  value != null ? node.style.setProperty(name, value) : node.style.removeProperty(name);
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+  const prevProps = {};
+  if (!skipChildren) {
+    solidJs.createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+  }
+  solidJs.createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node));
+  solidJs.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 solidJs.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);
+  solidJs.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);
+  solidJs.sharedConfig.completed = globalThis._$HY.completed;
+  solidJs.sharedConfig.events = globalThis._$HY.events;
+  solidJs.sharedConfig.load = id => globalThis._$HY.r[id];
+  solidJs.sharedConfig.has = id => id in globalThis._$HY.r;
+  solidJs.sharedConfig.gather = root => gatherHydratable(element, root);
+  solidJs.sharedConfig.registry = new Map();
+  solidJs.sharedConfig.context = {
+    id: options.renderId || "",
+    count: 0
+  };
+  try {
+    gatherHydratable(element, options.renderId);
+    return render(code, element, [...element.childNodes], options);
+  } finally {
+    solidJs.sharedConfig.context = null;
+  }
+}
+function getNextElement(template) {
+  let node,
+    key,
+    hydrating = isHydrating();
+  if (!hydrating || !(node = solidJs.sharedConfig.registry.get(key = getHydrationKey()))) {
+    if (hydrating) {
+      solidJs.sharedConfig.done = true;
+      throw new Error(`Hydration Mismatch. Unable to find DOM nodes for hydration key: ${key}\n${template ? template().outerHTML : ""}`);
+    }
+    return template();
+  }
+  if (solidJs.sharedConfig.completed) solidJs.sharedConfig.completed.add(node);
+  solidJs.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 (solidJs.sharedConfig.events && !solidJs.sharedConfig.events.queued) {
+    queueMicrotask(() => {
+      const {
+        completed,
+        events
+      } = solidJs.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 (solidJs.sharedConfig.done) {
+        solidJs.sharedConfig.events = _$HY.events = null;
+        solidJs.sharedConfig.completed = _$HY.completed = null;
+      }
+    });
+    solidJs.sharedConfig.events.queued = true;
+  }
+}
+function isHydrating(node) {
+  return !!solidJs.sharedConfig.context && !solidJs.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 (solidJs.sharedConfig.registry && solidJs.sharedConfig.events) {
+    if (solidJs.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 (solidJs.sharedConfig.registry && !solidJs.sharedConfig.done) solidJs.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") {
+    solidJs.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)) {
+      solidJs.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;
+  } else console.warn(`Unrecognized value. Skipped inserting`, 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)) && !solidJs.sharedConfig.registry.has(key)) solidJs.sharedConfig.registry.set(key, node);
+  }
+}
+function getHydrationKey() {
+  return solidJs.sharedConfig.getNextContextId();
+}
+function NoHydration(props) {
+  return solidJs.sharedConfig.context ? undefined : props.children;
+}
+function Hydration(props) {
+  return props.children;
+}
+const voidFn = () => undefined;
+const RequestContext = Symbol();
+function innerHTML(parent, content) {
+  !solidJs.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 = true;
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function createElement(tagName, isSVG = false, is = undefined) {
+  return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName, {
+    is
+  });
+}
+const hydrate = (...args) => {
+  solidJs.enableHydration();
+  return hydrate$1(...args);
+};
+function Portal(props) {
+  const {
+      useShadow
+    } = props,
+    marker = document.createTextNode(""),
+    mount = () => props.mount || document.body,
+    owner = solidJs.getOwner();
+  let content;
+  let hydrating = !!solidJs.sharedConfig.context;
+  solidJs.createEffect(() => {
+    if (hydrating) solidJs.getOwner().user = hydrating = false;
+    content || (content = solidJs.runWithOwner(owner, () => solidJs.createMemo(() => props.children)));
+    const el = mount();
+    if (el instanceof HTMLHeadElement) {
+      const [clean, setClean] = solidJs.createSignal(false);
+      const cleanup = () => setClean(true);
+      solidJs.createRoot(dispose => insert(el, () => !clean() ? content() : dispose(), null));
+      solidJs.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);
+      solidJs.onCleanup(() => el.removeChild(container));
+    }
+  }, undefined, {
+    render: !hydrating
+  });
+  return marker;
+}
+function createDynamic(component, props) {
+  const cached = solidJs.createMemo(component);
+  return solidJs.createMemo(() => {
+    const component = cached();
+    switch (typeof component) {
+      case "function":
+        Object.assign(component, {
+          [solidJs.$DEVCOMP]: true
+        });
+        return solidJs.untrack(() => component(props));
+      case "string":
+        const isSvg = SVGElements.has(component);
+        const el = solidJs.sharedConfig.context ? getNextElement() : createElement(component, isSvg, solidJs.untrack(() => props.is));
+        spread(el, props, isSvg);
+        return el;
+    }
+  });
+}
+function Dynamic(props) {
+  const [, others] = solidJs.splitProps(props, ["component"]);
+  return createDynamic(() => props.component, others);
+}
+
+Object.defineProperty(exports, "ErrorBoundary", {
+  enumerable: true,
+  get: function () { return solidJs.ErrorBoundary; }
+});
+Object.defineProperty(exports, "For", {
+  enumerable: true,
+  get: function () { return solidJs.For; }
+});
+Object.defineProperty(exports, "Index", {
+  enumerable: true,
+  get: function () { return solidJs.Index; }
+});
+Object.defineProperty(exports, "Match", {
+  enumerable: true,
+  get: function () { return solidJs.Match; }
+});
+Object.defineProperty(exports, "Show", {
+  enumerable: true,
+  get: function () { return solidJs.Show; }
+});
+Object.defineProperty(exports, "Suspense", {
+  enumerable: true,
+  get: function () { return solidJs.Suspense; }
+});
+Object.defineProperty(exports, "SuspenseList", {
+  enumerable: true,
+  get: function () { return solidJs.SuspenseList; }
+});
+Object.defineProperty(exports, "Switch", {
+  enumerable: true,
+  get: function () { return solidJs.Switch; }
+});
+Object.defineProperty(exports, "createComponent", {
+  enumerable: true,
+  get: function () { return solidJs.createComponent; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return solidJs.createRenderEffect; }
+});
+Object.defineProperty(exports, "getOwner", {
+  enumerable: true,
+  get: function () { return solidJs.getOwner; }
+});
+Object.defineProperty(exports, "mergeProps", {
+  enumerable: true,
+  get: function () { return solidJs.mergeProps; }
+});
+Object.defineProperty(exports, "untrack", {
+  enumerable: true,
+  get: function () { return solidJs.untrack; }
+});
+exports.Aliases = Aliases;
+exports.Assets = voidFn;
+exports.ChildProperties = ChildProperties;
+exports.DOMElements = DOMElements;
+exports.DelegatedEvents = DelegatedEvents;
+exports.Dynamic = Dynamic;
+exports.Hydration = Hydration;
+exports.HydrationScript = voidFn;
+exports.NoHydration = NoHydration;
+exports.Portal = Portal;
+exports.Properties = Properties;
+exports.RequestContext = RequestContext;
+exports.SVGElements = SVGElements;
+exports.SVGNamespace = SVGNamespace;
+exports.addEventListener = addEventListener;
+exports.assign = assign;
+exports.classList = classList;
+exports.className = className;
+exports.clearDelegatedEvents = clearDelegatedEvents;
+exports.createDynamic = createDynamic;
+exports.delegateEvents = delegateEvents;
+exports.dynamicProperty = dynamicProperty;
+exports.escape = escape;
+exports.generateHydrationScript = voidFn;
+exports.getAssets = voidFn;
+exports.getHydrationKey = getHydrationKey;
+exports.getNextElement = getNextElement;
+exports.getNextMarker = getNextMarker;
+exports.getNextMatch = getNextMatch;
+exports.getPropAlias = getPropAlias;
+exports.getRequestEvent = voidFn;
+exports.hydrate = hydrate;
+exports.innerHTML = innerHTML;
+exports.insert = insert;
+exports.isDev = isDev;
+exports.isServer = isServer;
+exports.memo = memo;
+exports.render = render;
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+exports.renderToStringAsync = renderToStringAsync;
+exports.resolveSSRNode = resolveSSRNode;
+exports.runHydrationEvents = runHydrationEvents;
+exports.setAttribute = setAttribute;
+exports.setAttributeNS = setAttributeNS;
+exports.setBoolAttribute = setBoolAttribute;
+exports.setProperty = setProperty;
+exports.setStyleProperty = setStyleProperty;
+exports.spread = spread;
+exports.ssr = ssr;
+exports.ssrAttribute = ssrAttribute;
+exports.ssrClassList = ssrClassList;
+exports.ssrElement = ssrElement;
+exports.ssrHydrationKey = ssrHydrationKey;
+exports.ssrSpread = ssrSpread;
+exports.ssrStyle = ssrStyle;
+exports.style = style;
+exports.template = template;
+exports.use = use;
+exports.useAssets = voidFn;

web/node_modules/solid-js/web/dist/dev.js

@@ -0,0 +1,782 @@
+import { createMemo, sharedConfig, createRenderEffect, createRoot, untrack, splitProps, getOwner, createEffect, runWithOwner, createSignal, onCleanup, $DEVCOMP, enableHydration } from 'solid-js';
+export { ErrorBoundary, For, Index, Match, Show, Suspense, SuspenseList, Switch, createComponent, createRenderEffect as effect, getOwner, mergeProps, untrack } from 'solid-js';
+
+const booleans = ["allowfullscreen", "async", "alpha",
+"autofocus",
+"autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden",
+"indeterminate", "inert",
+"ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless",
+"selected", "adauctionheaders",
+"browsingtopics",
+"credentialless",
+"defaultchecked", "defaultmuted", "defaultselected", "defer", "disablepictureinpicture", "disableremoteplayback", "preservespitch",
+"shadowrootclonable", "shadowrootcustomelementregistry",
+"shadowrootdelegatesfocus", "shadowrootserializable",
+"sharedstoragewritable"
+];
+const Properties = /*#__PURE__*/new Set([
+"className", "value",
+"readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", "adAuctionHeaders",
+"allowFullscreen", "browsingTopics",
+"defaultChecked", "defaultMuted", "defaultSelected", "disablePictureInPicture", "disableRemotePlayback", "preservesPitch", "shadowRootClonable", "shadowRootCustomElementRegistry",
+"shadowRootDelegatesFocus", "shadowRootSerializable",
+"sharedStorageWritable",
+...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
+  },
+  adauctionheaders: {
+    $: "adAuctionHeaders",
+    IFRAME: 1
+  },
+  allowfullscreen: {
+    $: "allowFullscreen",
+    IFRAME: 1
+  },
+  browsingtopics: {
+    $: "browsingTopics",
+    IMG: 1
+  },
+  defaultchecked: {
+    $: "defaultChecked",
+    INPUT: 1
+  },
+  defaultmuted: {
+    $: "defaultMuted",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  defaultselected: {
+    $: "defaultSelected",
+    OPTION: 1
+  },
+  disablepictureinpicture: {
+    $: "disablePictureInPicture",
+    VIDEO: 1
+  },
+  disableremoteplayback: {
+    $: "disableRemotePlayback",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  preservespitch: {
+    $: "preservesPitch",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  shadowrootclonable: {
+    $: "shadowRootClonable",
+    TEMPLATE: 1
+  },
+  shadowrootdelegatesfocus: {
+    $: "shadowRootDelegatesFocus",
+    TEMPLATE: 1
+  },
+  shadowrootserializable: {
+    $: "shadowRootSerializable",
+    TEMPLATE: 1
+  },
+  sharedstoragewritable: {
+    $: "sharedStorageWritable",
+    IFRAME: 1,
+    IMG: 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",
+"webview",
+"isindex", "listing", "multicol", "nextid", "noindex", "search"]);
+
+const memo = fn => 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 = {}) {
+  if (!element) {
+    throw new Error("The `element` passed to `render(..., element)` doesn't exist. Make sure `element` exists in the document.");
+  }
+  let disposer;
+  createRoot(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 = () => {
+    if (isHydrating()) throw new Error("Failed attempt to create new DOM elements during hydration. Check that the libraries you are using support hydration.");
+    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 ? () => untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+  fn.cloneNode = fn;
+  return fn;
+}
+function delegateEvents(eventNames, document = window.document) {
+  const e = document[$$EVENTS] || (document[$$EVENTS] = new Set());
+  for (let i = 0, l = eventNames.length; i < l; i++) {
+    const name = eventNames[i];
+    if (!e.has(name)) {
+      e.add(name);
+      document.addEventListener(name, eventHandler);
+    }
+  }
+}
+function clearDelegatedEvents(document = window.document) {
+  if (document[$$EVENTS]) {
+    for (let name of document[$$EVENTS].keys()) document.removeEventListener(name, eventHandler);
+    delete document[$$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 setStyleProperty(node, name, value) {
+  value != null ? node.style.setProperty(name, value) : node.style.removeProperty(name);
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+  const prevProps = {};
+  if (!skipChildren) {
+    createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+  }
+  createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node));
+  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 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);
+  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);
+  sharedConfig.completed = globalThis._$HY.completed;
+  sharedConfig.events = globalThis._$HY.events;
+  sharedConfig.load = id => globalThis._$HY.r[id];
+  sharedConfig.has = id => id in globalThis._$HY.r;
+  sharedConfig.gather = root => gatherHydratable(element, root);
+  sharedConfig.registry = new Map();
+  sharedConfig.context = {
+    id: options.renderId || "",
+    count: 0
+  };
+  try {
+    gatherHydratable(element, options.renderId);
+    return render(code, element, [...element.childNodes], options);
+  } finally {
+    sharedConfig.context = null;
+  }
+}
+function getNextElement(template) {
+  let node,
+    key,
+    hydrating = isHydrating();
+  if (!hydrating || !(node = sharedConfig.registry.get(key = getHydrationKey()))) {
+    if (hydrating) {
+      sharedConfig.done = true;
+      throw new Error(`Hydration Mismatch. Unable to find DOM nodes for hydration key: ${key}\n${template ? template().outerHTML : ""}`);
+    }
+    return template();
+  }
+  if (sharedConfig.completed) sharedConfig.completed.add(node);
+  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 (sharedConfig.events && !sharedConfig.events.queued) {
+    queueMicrotask(() => {
+      const {
+        completed,
+        events
+      } = 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 (sharedConfig.done) {
+        sharedConfig.events = _$HY.events = null;
+        sharedConfig.completed = _$HY.completed = null;
+      }
+    });
+    sharedConfig.events.queued = true;
+  }
+}
+function isHydrating(node) {
+  return !!sharedConfig.context && !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 (sharedConfig.registry && sharedConfig.events) {
+    if (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 (sharedConfig.registry && !sharedConfig.done) 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") {
+    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)) {
+      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;
+  } else console.warn(`Unrecognized value. Skipped inserting`, 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)) && !sharedConfig.registry.has(key)) sharedConfig.registry.set(key, node);
+  }
+}
+function getHydrationKey() {
+  return sharedConfig.getNextContextId();
+}
+function NoHydration(props) {
+  return sharedConfig.context ? undefined : props.children;
+}
+function Hydration(props) {
+  return props.children;
+}
+const voidFn = () => undefined;
+const RequestContext = Symbol();
+function innerHTML(parent, content) {
+  !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 = true;
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function createElement(tagName, isSVG = false, is = undefined) {
+  return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName, {
+    is
+  });
+}
+const hydrate = (...args) => {
+  enableHydration();
+  return hydrate$1(...args);
+};
+function Portal(props) {
+  const {
+      useShadow
+    } = props,
+    marker = document.createTextNode(""),
+    mount = () => props.mount || document.body,
+    owner = getOwner();
+  let content;
+  let hydrating = !!sharedConfig.context;
+  createEffect(() => {
+    if (hydrating) getOwner().user = hydrating = false;
+    content || (content = runWithOwner(owner, () => createMemo(() => props.children)));
+    const el = mount();
+    if (el instanceof HTMLHeadElement) {
+      const [clean, setClean] = createSignal(false);
+      const cleanup = () => setClean(true);
+      createRoot(dispose => insert(el, () => !clean() ? content() : dispose(), null));
+      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);
+      onCleanup(() => el.removeChild(container));
+    }
+  }, undefined, {
+    render: !hydrating
+  });
+  return marker;
+}
+function createDynamic(component, props) {
+  const cached = createMemo(component);
+  return createMemo(() => {
+    const component = cached();
+    switch (typeof component) {
+      case "function":
+        Object.assign(component, {
+          [$DEVCOMP]: true
+        });
+        return untrack(() => component(props));
+      case "string":
+        const isSvg = SVGElements.has(component);
+        const el = sharedConfig.context ? getNextElement() : createElement(component, isSvg, untrack(() => props.is));
+        spread(el, props, isSvg);
+        return el;
+    }
+  });
+}
+function Dynamic(props) {
+  const [, others] = splitProps(props, ["component"]);
+  return createDynamic(() => props.component, others);
+}
+
+export { Aliases, voidFn as Assets, ChildProperties, DOMElements, DelegatedEvents, Dynamic, Hydration, voidFn as HydrationScript, NoHydration, Portal, Properties, RequestContext, SVGElements, SVGNamespace, addEventListener, assign, classList, className, clearDelegatedEvents, createDynamic, delegateEvents, dynamicProperty, escape, voidFn as generateHydrationScript, voidFn as getAssets, getHydrationKey, getNextElement, getNextMarker, getNextMatch, getPropAlias, voidFn as getRequestEvent, hydrate, innerHTML, insert, isDev, isServer, memo, render, renderToStream, renderToString, renderToStringAsync, resolveSSRNode, runHydrationEvents, setAttribute, setAttributeNS, setBoolAttribute, setProperty, setStyleProperty, spread, ssr, ssrAttribute, ssrClassList, ssrElement, ssrHydrationKey, ssrSpread, ssrStyle, style, template, use, voidFn as useAssets };

web/node_modules/solid-js/web/dist/server.cjs

@@ -0,0 +1,892 @@
+'use strict';
+
+var solidJs = require('solid-js');
+var seroval = require('seroval');
+var web = require('seroval-plugins/web');
+
+const booleans = ["allowfullscreen", "async", "alpha",
+"autofocus",
+"autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden",
+"indeterminate", "inert",
+"ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless",
+"selected", "adauctionheaders",
+"browsingtopics",
+"credentialless",
+"defaultchecked", "defaultmuted", "defaultselected", "defer", "disablepictureinpicture", "disableremoteplayback", "preservespitch",
+"shadowrootclonable", "shadowrootcustomelementregistry",
+"shadowrootdelegatesfocus", "shadowrootserializable",
+"sharedstoragewritable"
+];
+const BooleanAttributes = /*#__PURE__*/new Set(booleans);
+const Properties = /*#__PURE__*/new Set([
+"className", "value",
+"readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", "adAuctionHeaders",
+"allowFullscreen", "browsingTopics",
+"defaultChecked", "defaultMuted", "defaultSelected", "disablePictureInPicture", "disableRemotePlayback", "preservesPitch", "shadowRootClonable", "shadowRootCustomElementRegistry",
+"shadowRootDelegatesFocus", "shadowRootSerializable",
+"sharedStorageWritable",
+...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
+  },
+  adauctionheaders: {
+    $: "adAuctionHeaders",
+    IFRAME: 1
+  },
+  allowfullscreen: {
+    $: "allowFullscreen",
+    IFRAME: 1
+  },
+  browsingtopics: {
+    $: "browsingTopics",
+    IMG: 1
+  },
+  defaultchecked: {
+    $: "defaultChecked",
+    INPUT: 1
+  },
+  defaultmuted: {
+    $: "defaultMuted",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  defaultselected: {
+    $: "defaultSelected",
+    OPTION: 1
+  },
+  disablepictureinpicture: {
+    $: "disablePictureInPicture",
+    VIDEO: 1
+  },
+  disableremoteplayback: {
+    $: "disableRemotePlayback",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  preservespitch: {
+    $: "preservesPitch",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  shadowrootclonable: {
+    $: "shadowRootClonable",
+    TEMPLATE: 1
+  },
+  shadowrootdelegatesfocus: {
+    $: "shadowRootDelegatesFocus",
+    TEMPLATE: 1
+  },
+  shadowrootserializable: {
+    $: "shadowRootSerializable",
+    TEMPLATE: 1
+  },
+  sharedstoragewritable: {
+    $: "sharedStorageWritable",
+    IFRAME: 1,
+    IMG: 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",
+"webview",
+"isindex", "listing", "multicol", "nextid", "noindex", "search"]);
+
+const memo = fn => solidJs.createMemo(() => fn());
+
+const ES2017FLAG = seroval.Feature.AggregateError
+| seroval.Feature.BigIntTypedArray;
+const GLOBAL_IDENTIFIER = '_$HY.r';
+function createSerializer({
+  onData,
+  onDone,
+  scopeId,
+  onError,
+  plugins: customPlugins
+}) {
+  const defaultPlugins = [web.AbortSignalPlugin,
+  web.CustomEventPlugin, web.DOMExceptionPlugin, web.EventPlugin,
+  web.FormDataPlugin, web.HeadersPlugin, web.ReadableStreamPlugin, web.RequestPlugin, web.ResponsePlugin, web.URLSearchParamsPlugin, web.URLPlugin];
+  const allPlugins = customPlugins ? [...customPlugins, ...defaultPlugins] : defaultPlugins;
+  return new seroval.Serializer({
+    scopeId,
+    plugins: allPlugins,
+    globalIdentifier: GLOBAL_IDENTIFIER,
+    disabledFeatures: ES2017FLAG,
+    onData,
+    onDone,
+    onError
+  });
+}
+function getLocalHeaderScript(id) {
+  return seroval.getCrossReferenceHeader(id) + ';';
+}
+
+const VOID_ELEMENTS = /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i;
+const REPLACE_SCRIPT = `function $df(e,n,o,t){if(n=document.getElementById(e),o=document.getElementById("pl-"+e)){for(;o&&8!==o.nodeType&&o.nodeValue!=="pl-"+e;)t=o.nextSibling,o.remove(),o=t;_$HY.done?o.remove():o.replaceWith(n.content)}n.remove(),_$HY.fe(e)}`;
+function renderToString(code, options = {}) {
+  const {
+    renderId
+  } = options;
+  let scripts = "";
+  const serializer = createSerializer({
+    scopeId: renderId,
+    plugins: options.plugins,
+    onData(script) {
+      if (!scripts) {
+        scripts = getLocalHeaderScript(renderId);
+      }
+      scripts += script + ";";
+    },
+    onError: options.onError
+  });
+  solidJs.sharedConfig.context = {
+    id: renderId || "",
+    count: 0,
+    suspense: {},
+    lazy: {},
+    assets: [],
+    nonce: options.nonce,
+    serialize(id, p) {
+      !solidJs.sharedConfig.context.noHydrate && serializer.write(id, p);
+    },
+    roots: 0,
+    nextRoot() {
+      return this.renderId + "i-" + this.roots++;
+    }
+  };
+  let html = solidJs.createRoot(d => {
+    setTimeout(d);
+    return resolveSSRNode(escape(code()));
+  });
+  solidJs.sharedConfig.context.noHydrate = true;
+  serializer.close();
+  html = injectAssets(solidJs.sharedConfig.context.assets, html);
+  if (scripts.length) html = injectScripts(html, scripts, options.nonce);
+  return html;
+}
+function renderToStringAsync(code, options = {}) {
+  const {
+    timeoutMs = 30000
+  } = options;
+  let timeoutHandle;
+  const timeout = new Promise((_, reject) => {
+    timeoutHandle = setTimeout(() => reject("renderToString timed out"), timeoutMs);
+  });
+  return Promise.race([renderToStream(code, options), timeout]).then(html => {
+    clearTimeout(timeoutHandle);
+    return html;
+  });
+}
+function renderToStream(code, options = {}) {
+  let {
+    nonce,
+    onCompleteShell,
+    onCompleteAll,
+    renderId,
+    noScripts
+  } = options;
+  let dispose;
+  const blockingPromises = [];
+  const pushTask = task => {
+    if (noScripts) return;
+    if (!tasks && !firstFlushed) {
+      tasks = getLocalHeaderScript(renderId);
+    }
+    tasks += task + ";";
+    if (!timer && firstFlushed) {
+      timer = setTimeout(writeTasks);
+    }
+  };
+  const onDone = () => {
+    writeTasks();
+    doShell();
+    onCompleteAll && onCompleteAll({
+      write(v) {
+        !completed && buffer.write(v);
+      }
+    });
+    writable && writable.end();
+    completed = true;
+    if (firstFlushed) dispose();
+  };
+  const serializer = createSerializer({
+    scopeId: options.renderId,
+    plugins: options.plugins,
+    onData: pushTask,
+    onDone,
+    onError: options.onError
+  });
+  const flushEnd = () => {
+    if (!registry.size) {
+      queue(() => queue(() => serializer.flush()));
+    }
+  };
+  const registry = new Map();
+  const writeTasks = () => {
+    if (tasks.length && !completed && firstFlushed) {
+      buffer.write(`<script${nonce ? ` nonce="${nonce}"` : ""}>${tasks}</script>`);
+      tasks = "";
+    }
+    timer && clearTimeout(timer);
+    timer = null;
+  };
+  let context;
+  let writable;
+  let tmp = "";
+  let tasks = "";
+  let firstFlushed = false;
+  let completed = false;
+  let shellCompleted = false;
+  let scriptFlushed = false;
+  let timer = null;
+  let buffer = {
+    write(payload) {
+      tmp += payload;
+    }
+  };
+  solidJs.sharedConfig.context = context = {
+    id: renderId || "",
+    count: 0,
+    async: true,
+    resources: {},
+    lazy: {},
+    suspense: {},
+    assets: [],
+    nonce,
+    block(p) {
+      if (!firstFlushed) blockingPromises.push(p);
+    },
+    replace(id, payloadFn) {
+      if (firstFlushed) return;
+      const placeholder = `<!--!$${id}-->`;
+      const first = html.indexOf(placeholder);
+      if (first === -1) return;
+      const last = html.indexOf(`<!--!$/${id}-->`, first + placeholder.length);
+      html = html.slice(0, first) + resolveSSRNode(escape(payloadFn())) + html.slice(last + placeholder.length + 1);
+    },
+    serialize(id, p, wait) {
+      const serverOnly = solidJs.sharedConfig.context.noHydrate;
+      if (!firstFlushed && wait && typeof p === "object" && "then" in p) {
+        blockingPromises.push(p);
+        !serverOnly && p.then(d => {
+          serializer.write(id, d);
+        }).catch(e => {
+          serializer.write(id, e);
+        });
+      } else if (!serverOnly) serializer.write(id, p);
+    },
+    roots: 0,
+    nextRoot() {
+      return this.renderId + "i-" + this.roots++;
+    },
+    registerFragment(key) {
+      if (!registry.has(key)) {
+        let resolve, reject;
+        const p = new Promise((r, rej) => (resolve = r, reject = rej));
+        registry.set(key, err => queue(() => queue(() => {
+          err ? reject(err) : resolve(true);
+          queue(flushEnd);
+        })));
+        serializer.write(key, p);
+      }
+      return (value, error) => {
+        if (registry.has(key)) {
+          const resolve = registry.get(key);
+          registry.delete(key);
+          if (waitForFragments(registry, key)) {
+            resolve();
+            return;
+          }
+          if (!completed) {
+            if (!firstFlushed) {
+              queue(() => html = replacePlaceholder(html, key, value !== undefined ? value : ""));
+              resolve(error);
+            } else {
+              buffer.write(`<template id="${key}">${value !== undefined ? value : " "}</template>`);
+              pushTask(`$df("${key}")${!scriptFlushed ? ";" + REPLACE_SCRIPT : ""}`);
+              resolve(error);
+              scriptFlushed = true;
+            }
+          }
+        }
+        return firstFlushed;
+      };
+    }
+  };
+  let html = solidJs.createRoot(d => {
+    dispose = d;
+    return resolveSSRNode(escape(code()));
+  });
+  function doShell() {
+    if (shellCompleted) return;
+    solidJs.sharedConfig.context = context;
+    context.noHydrate = true;
+    html = injectAssets(context.assets, html);
+    if (tasks.length) html = injectScripts(html, tasks, nonce);
+    buffer.write(html);
+    tasks = "";
+    onCompleteShell && onCompleteShell({
+      write(v) {
+        !completed && buffer.write(v);
+      }
+    });
+    shellCompleted = true;
+  }
+  return {
+    then(fn) {
+      function complete() {
+        dispose();
+        fn(tmp);
+      }
+      if (onCompleteAll) {
+        let ogComplete = onCompleteAll;
+        onCompleteAll = options => {
+          ogComplete(options);
+          complete();
+        };
+      } else onCompleteAll = complete;
+      queue(flushEnd);
+    },
+    pipe(w) {
+      allSettled(blockingPromises).then(() => {
+        setTimeout(() => {
+          doShell();
+          buffer = writable = w;
+          buffer.write(tmp);
+          firstFlushed = true;
+          if (completed) {
+            dispose();
+            writable.end();
+          } else flushEnd();
+        });
+      });
+    },
+    pipeTo(w) {
+      return allSettled(blockingPromises).then(() => {
+        let resolve;
+        const p = new Promise(r => resolve = r);
+        setTimeout(() => {
+          doShell();
+          const encoder = new TextEncoder();
+          const writer = w.getWriter();
+          writable = {
+            end() {
+              writer.releaseLock();
+              w.close().catch(() => {});
+              resolve();
+            }
+          };
+          buffer = {
+            write(payload) {
+              writer.write(encoder.encode(payload)).catch(() => {});
+            }
+          };
+          buffer.write(tmp);
+          firstFlushed = true;
+          if (completed) {
+            dispose();
+            writable.end();
+          } else flushEnd();
+        });
+        return p;
+      });
+    }
+  };
+}
+function HydrationScript(props) {
+  const {
+    nonce
+  } = solidJs.sharedConfig.context;
+  return ssr(generateHydrationScript({
+    nonce,
+    ...props
+  }));
+}
+function ssr(t, ...nodes) {
+  if (nodes.length) {
+    let result = "";
+    for (let i = 0; i < nodes.length; i++) {
+      result += t[i];
+      const node = nodes[i];
+      if (node !== undefined) result += resolveSSRNode(node);
+    }
+    t = result + t[nodes.length];
+  }
+  return {
+    t
+  };
+}
+function ssrClassList(value) {
+  if (!value) return "";
+  let classKeys = Object.keys(value),
+    result = "";
+  for (let i = 0, len = classKeys.length; i < len; i++) {
+    const key = classKeys[i],
+      classValue = !!value[key];
+    if (!key || key === "undefined" || !classValue) continue;
+    i && (result += " ");
+    result += escape(key);
+  }
+  return result;
+}
+function ssrStyle(value) {
+  if (!value) return "";
+  if (typeof value === "string") return escape(value, true);
+  let result = "";
+  const k = Object.keys(value);
+  for (let i = 0; i < k.length; i++) {
+    const s = k[i];
+    const v = value[s];
+    if (v != undefined) {
+      if (i) result += ";";
+      const r = escape(v, true);
+      if (r != undefined && r !== "undefined") {
+        result += `${s}:${r}`;
+      }
+    }
+  }
+  return result;
+}
+function ssrStyleProperty(name, value) {
+  return value != null ? name + value : "";
+}
+function ssrElement(tag, props, children, needsId) {
+  if (props == null) props = {};else if (typeof props === "function") props = props();
+  const skipChildren = VOID_ELEMENTS.test(tag);
+  const keys = Object.keys(props);
+  let result = `<${tag}${needsId ? ssrHydrationKey() : ""} `;
+  let classResolved;
+  for (let i = 0; i < keys.length; i++) {
+    const prop = keys[i];
+    if (ChildProperties.has(prop)) {
+      if (children === undefined && !skipChildren) children = tag === "script" || tag === "style" || prop === "innerHTML" ? props[prop] : escape(props[prop]);
+      continue;
+    }
+    const value = props[prop];
+    if (prop === "style") {
+      result += `style="${ssrStyle(value)}"`;
+    } else if (prop === "class" || prop === "className" || prop === "classList") {
+      if (classResolved) continue;
+      let n;
+      result += `class="${escape(((n = props.class) ? n + " " : "") + ((n = props.className) ? n + " " : ""), true) + ssrClassList(props.classList)}"`;
+      classResolved = true;
+    } else if (BooleanAttributes.has(prop)) {
+      if (value) result += prop;else continue;
+    } else if (value == undefined || prop === "ref" || prop.slice(0, 2) === "on" || prop.slice(0, 5) === "prop:") {
+      continue;
+    } else if (prop.slice(0, 5) === "bool:") {
+      if (!value) continue;
+      result += escape(prop.slice(5));
+    } else if (prop.slice(0, 5) === "attr:") {
+      result += `${escape(prop.slice(5))}="${escape(value, true)}"`;
+    } else {
+      result += `${Aliases[prop] || escape(prop)}="${escape(value, true)}"`;
+    }
+    if (i !== keys.length - 1) result += " ";
+  }
+  if (skipChildren) return {
+    t: result + "/>"
+  };
+  if (typeof children === "function") children = children();
+  return {
+    t: result + `>${resolveSSRNode(children, true)}</${tag}>`
+  };
+}
+function ssrAttribute(key, value, isBoolean) {
+  return isBoolean ? value ? " " + key : "" : value != null ? ` ${key}="${value}"` : "";
+}
+function ssrHydrationKey() {
+  const hk = getHydrationKey();
+  return hk ? ` data-hk="${hk}"` : "";
+}
+function escape(s, attr) {
+  const t = typeof s;
+  if (t !== "string") {
+    if (!attr && t === "function") return escape(s());
+    if (!attr && Array.isArray(s)) {
+      s = s.slice();
+      for (let i = 0; i < s.length; i++) s[i] = escape(s[i]);
+      return s;
+    }
+    if (attr && t === "boolean") return String(s);
+    return s;
+  }
+  const delim = attr ? '"' : "<";
+  const escDelim = attr ? "&quot;" : "&lt;";
+  let iDelim = s.indexOf(delim);
+  let iAmp = s.indexOf("&");
+  if (iDelim < 0 && iAmp < 0) return s;
+  let left = 0,
+    out = "";
+  while (iDelim >= 0 && iAmp >= 0) {
+    if (iDelim < iAmp) {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } else {
+      if (left < iAmp) out += s.substring(left, iAmp);
+      out += "&amp;";
+      left = iAmp + 1;
+      iAmp = s.indexOf("&", left);
+    }
+  }
+  if (iDelim >= 0) {
+    do {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } while (iDelim >= 0);
+  } else while (iAmp >= 0) {
+    if (left < iAmp) out += s.substring(left, iAmp);
+    out += "&amp;";
+    left = iAmp + 1;
+    iAmp = s.indexOf("&", left);
+  }
+  return left < s.length ? out + s.substring(left) : out;
+}
+function resolveSSRNode(node, top) {
+  const t = typeof node;
+  if (t === "string") return node;
+  if (node == null || t === "boolean") return "";
+  if (Array.isArray(node)) {
+    let prev = {};
+    let mapped = "";
+    for (let i = 0, len = node.length; i < len; i++) {
+      if (!top && typeof prev !== "object" && typeof node[i] !== "object") mapped += `<!--!$-->`;
+      mapped += resolveSSRNode(prev = node[i]);
+    }
+    return mapped;
+  }
+  if (t === "object") return node.t;
+  if (t === "function") return resolveSSRNode(node());
+  return String(node);
+}
+function getHydrationKey() {
+  const hydrate = solidJs.sharedConfig.context;
+  return hydrate && !hydrate.noHydrate && solidJs.sharedConfig.getNextContextId();
+}
+function useAssets(fn) {
+  solidJs.sharedConfig.context.assets.push(() => resolveSSRNode(escape(fn())));
+}
+function getAssets() {
+  const assets = solidJs.sharedConfig.context.assets;
+  let out = "";
+  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
+  return out;
+}
+function generateHydrationScript({
+  eventNames = ["click", "input"],
+  nonce
+} = {}) {
+  return `<script${nonce ? ` nonce="${nonce}"` : ""}>window._$HY||(e=>{let t=e=>e&&e.hasAttribute&&(e.hasAttribute("data-hk")?e:t(e.host&&e.host.nodeType?e.host:e.parentNode));["${eventNames.join('", "')}"].forEach((o=>document.addEventListener(o,(o=>{if(!e.events)return;let s=t(o.composedPath&&o.composedPath()[0]||o.target);s&&!e.completed.has(s)&&e.events.push([s,o])}))))})(_$HY={events:[],completed:new WeakSet,r:{},fe(){}});</script><!--xs-->`;
+}
+function Hydration(props) {
+  if (!solidJs.sharedConfig.context.noHydrate) return props.children;
+  const context = solidJs.sharedConfig.context;
+  solidJs.sharedConfig.context = {
+    ...context,
+    count: 0,
+    id: solidJs.sharedConfig.getNextContextId(),
+    noHydrate: false
+  };
+  const res = props.children;
+  solidJs.sharedConfig.context = context;
+  return res;
+}
+function NoHydration(props) {
+  if (solidJs.sharedConfig.context) solidJs.sharedConfig.context.noHydrate = true;
+  return props.children;
+}
+function queue(fn) {
+  return Promise.resolve().then(fn);
+}
+function allSettled(promises) {
+  let length = promises.length;
+  return Promise.allSettled(promises).then(() => {
+    if (promises.length !== length) return allSettled(promises);
+    return;
+  });
+}
+function injectAssets(assets, html) {
+  if (!assets || !assets.length) return html;
+  let out = "";
+  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
+  const index = html.indexOf("</head>");
+  if (index === -1) return html;
+  return html.slice(0, index) + out + html.slice(index);
+}
+function injectScripts(html, scripts, nonce) {
+  const tag = `<script${nonce ? ` nonce="${nonce}"` : ""}>${scripts}</script>`;
+  const index = html.indexOf("<!--xs-->");
+  if (index > -1) {
+    return html.slice(0, index) + tag + html.slice(index);
+  }
+  return html + tag;
+}
+function waitForFragments(registry, key) {
+  for (const k of [...registry.keys()].reverse()) {
+    if (key.startsWith(k)) return true;
+  }
+  return false;
+}
+function replacePlaceholder(html, key, value) {
+  const marker = `<template id="pl-${key}">`;
+  const close = `<!--pl-${key}-->`;
+  const first = html.indexOf(marker);
+  if (first === -1) return html;
+  const last = html.indexOf(close, first + marker.length);
+  return html.slice(0, first) + value + html.slice(last + close.length);
+}
+const RequestContext = Symbol();
+function getRequestEvent() {
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || solidJs.sharedConfig.context && solidJs.sharedConfig.context.event || console.log("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+}
+function Assets(props) {
+  useAssets(() => props.children);
+}
+function pipeToNodeWritable(code, writable, options = {}) {
+  if (options.onReady) {
+    options.onCompleteShell = ({
+      write
+    }) => {
+      options.onReady({
+        write,
+        startWriting() {
+          stream.pipe(writable);
+        }
+      });
+    };
+  }
+  const stream = renderToStream(code, options);
+  if (!options.onReady) stream.pipe(writable);
+}
+function pipeToWritable(code, writable, options = {}) {
+  if (options.onReady) {
+    options.onCompleteShell = ({
+      write
+    }) => {
+      options.onReady({
+        write,
+        startWriting() {
+          stream.pipeTo(writable);
+        }
+      });
+    };
+  }
+  const stream = renderToStream(code, options);
+  if (!options.onReady) stream.pipeTo(writable);
+}
+function ssrSpread(props, isSVG, skipChildren) {
+  let result = "";
+  if (props == null) return result;
+  if (typeof props === "function") props = props();
+  const keys = Object.keys(props);
+  let classResolved;
+  for (let i = 0; i < keys.length; i++) {
+    let prop = keys[i];
+    if (prop === "children") {
+      !skipChildren && console.warn(`SSR currently does not support spread children.`);
+      continue;
+    }
+    const value = props[prop];
+    if (prop === "style") {
+      result += `style="${ssrStyle(value)}"`;
+    } else if (prop === "class" || prop === "className" || prop === "classList") {
+      if (classResolved) continue;
+      let n;
+      result += `class="${(n = props.class) ? n + " " : ""}${(n = props.className) ? n + " " : ""}${ssrClassList(props.classList)}"`;
+      classResolved = true;
+    } else if (prop !== "value" && Properties.has(prop)) {
+      if (value) result += prop;else continue;
+    } else if (value == undefined || prop === "ref" || prop.slice(0, 2) === "on" || prop.slice(0, 5) === "prop:") {
+      continue;
+    } else if (prop.slice(0, 5) === "bool:") {
+      if (!value) continue;
+      result += escape(prop.slice(5));
+    } else if (prop.slice(0, 5) === "attr:") {
+      result += `${escape(prop.slice(5))}="${escape(value, true)}"`;
+    } else {
+      result += `${Aliases[prop] || escape(prop)}="${escape(value, true)}"`;
+    }
+    if (i !== keys.length - 1) result += " ";
+  }
+  return result;
+}
+function notSup() {
+  throw new Error("Client-only API called on the server side. Run client-only code in onMount, or conditionally run client-only component with <Show>.");
+}
+
+const isServer = true;
+const isDev = false;
+function createDynamic(component, props) {
+  const comp = component(),
+    t = typeof comp;
+  if (comp) {
+    if (t === "function") return comp(props);else if (t === "string") {
+      return ssrElement(comp, props, undefined, true);
+    }
+  }
+}
+function Dynamic(props) {
+  const [, others] = solidJs.splitProps(props, ["component"]);
+  return createDynamic(() => props.component, others);
+}
+function Portal(props) {
+  return "";
+}
+
+Object.defineProperty(exports, "ErrorBoundary", {
+  enumerable: true,
+  get: function () { return solidJs.ErrorBoundary; }
+});
+Object.defineProperty(exports, "For", {
+  enumerable: true,
+  get: function () { return solidJs.For; }
+});
+Object.defineProperty(exports, "Index", {
+  enumerable: true,
+  get: function () { return solidJs.Index; }
+});
+Object.defineProperty(exports, "Match", {
+  enumerable: true,
+  get: function () { return solidJs.Match; }
+});
+Object.defineProperty(exports, "Show", {
+  enumerable: true,
+  get: function () { return solidJs.Show; }
+});
+Object.defineProperty(exports, "Suspense", {
+  enumerable: true,
+  get: function () { return solidJs.Suspense; }
+});
+Object.defineProperty(exports, "SuspenseList", {
+  enumerable: true,
+  get: function () { return solidJs.SuspenseList; }
+});
+Object.defineProperty(exports, "Switch", {
+  enumerable: true,
+  get: function () { return solidJs.Switch; }
+});
+Object.defineProperty(exports, "createComponent", {
+  enumerable: true,
+  get: function () { return solidJs.createComponent; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return solidJs.createRenderEffect; }
+});
+Object.defineProperty(exports, "getOwner", {
+  enumerable: true,
+  get: function () { return solidJs.getOwner; }
+});
+Object.defineProperty(exports, "mergeProps", {
+  enumerable: true,
+  get: function () { return solidJs.mergeProps; }
+});
+Object.defineProperty(exports, "untrack", {
+  enumerable: true,
+  get: function () { return solidJs.untrack; }
+});
+exports.Aliases = Aliases;
+exports.Assets = Assets;
+exports.ChildProperties = ChildProperties;
+exports.DOMElements = DOMElements;
+exports.DelegatedEvents = DelegatedEvents;
+exports.Dynamic = Dynamic;
+exports.Hydration = Hydration;
+exports.HydrationScript = HydrationScript;
+exports.NoHydration = NoHydration;
+exports.Portal = Portal;
+exports.Properties = Properties;
+exports.RequestContext = RequestContext;
+exports.SVGElements = SVGElements;
+exports.SVGNamespace = SVGNamespace;
+exports.addEventListener = notSup;
+exports.assign = notSup;
+exports.classList = notSup;
+exports.className = notSup;
+exports.createDynamic = createDynamic;
+exports.delegateEvents = notSup;
+exports.dynamicProperty = notSup;
+exports.escape = escape;
+exports.generateHydrationScript = generateHydrationScript;
+exports.getAssets = getAssets;
+exports.getHydrationKey = getHydrationKey;
+exports.getNextElement = notSup;
+exports.getNextMarker = notSup;
+exports.getNextMatch = notSup;
+exports.getPropAlias = getPropAlias;
+exports.getRequestEvent = getRequestEvent;
+exports.hydrate = notSup;
+exports.insert = notSup;
+exports.isDev = isDev;
+exports.isServer = isServer;
+exports.memo = memo;
+exports.pipeToNodeWritable = pipeToNodeWritable;
+exports.pipeToWritable = pipeToWritable;
+exports.render = notSup;
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+exports.renderToStringAsync = renderToStringAsync;
+exports.resolveSSRNode = resolveSSRNode;
+exports.runHydrationEvents = notSup;
+exports.setAttribute = notSup;
+exports.setAttributeNS = notSup;
+exports.setProperty = notSup;
+exports.spread = notSup;
+exports.ssr = ssr;
+exports.ssrAttribute = ssrAttribute;
+exports.ssrClassList = ssrClassList;
+exports.ssrElement = ssrElement;
+exports.ssrHydrationKey = ssrHydrationKey;
+exports.ssrSpread = ssrSpread;
+exports.ssrStyle = ssrStyle;
+exports.ssrStyleProperty = ssrStyleProperty;
+exports.style = notSup;
+exports.template = notSup;
+exports.useAssets = useAssets;

web/node_modules/solid-js/web/dist/server.js

@@ -0,0 +1,782 @@
+import { createMemo, sharedConfig, createRoot, splitProps } from 'solid-js';
+export { ErrorBoundary, For, Index, Match, Show, Suspense, SuspenseList, Switch, createComponent, createRenderEffect as effect, getOwner, mergeProps, untrack } from 'solid-js';
+import { Serializer, Feature, getCrossReferenceHeader } from 'seroval';
+import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
+
+const booleans = ["allowfullscreen", "async", "alpha",
+"autofocus",
+"autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden",
+"indeterminate", "inert",
+"ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless",
+"selected", "adauctionheaders",
+"browsingtopics",
+"credentialless",
+"defaultchecked", "defaultmuted", "defaultselected", "defer", "disablepictureinpicture", "disableremoteplayback", "preservespitch",
+"shadowrootclonable", "shadowrootcustomelementregistry",
+"shadowrootdelegatesfocus", "shadowrootserializable",
+"sharedstoragewritable"
+];
+const BooleanAttributes = /*#__PURE__*/new Set(booleans);
+const Properties = /*#__PURE__*/new Set([
+"className", "value",
+"readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", "adAuctionHeaders",
+"allowFullscreen", "browsingTopics",
+"defaultChecked", "defaultMuted", "defaultSelected", "disablePictureInPicture", "disableRemotePlayback", "preservesPitch", "shadowRootClonable", "shadowRootCustomElementRegistry",
+"shadowRootDelegatesFocus", "shadowRootSerializable",
+"sharedStorageWritable",
+...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
+  },
+  adauctionheaders: {
+    $: "adAuctionHeaders",
+    IFRAME: 1
+  },
+  allowfullscreen: {
+    $: "allowFullscreen",
+    IFRAME: 1
+  },
+  browsingtopics: {
+    $: "browsingTopics",
+    IMG: 1
+  },
+  defaultchecked: {
+    $: "defaultChecked",
+    INPUT: 1
+  },
+  defaultmuted: {
+    $: "defaultMuted",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  defaultselected: {
+    $: "defaultSelected",
+    OPTION: 1
+  },
+  disablepictureinpicture: {
+    $: "disablePictureInPicture",
+    VIDEO: 1
+  },
+  disableremoteplayback: {
+    $: "disableRemotePlayback",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  preservespitch: {
+    $: "preservesPitch",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  shadowrootclonable: {
+    $: "shadowRootClonable",
+    TEMPLATE: 1
+  },
+  shadowrootdelegatesfocus: {
+    $: "shadowRootDelegatesFocus",
+    TEMPLATE: 1
+  },
+  shadowrootserializable: {
+    $: "shadowRootSerializable",
+    TEMPLATE: 1
+  },
+  sharedstoragewritable: {
+    $: "sharedStorageWritable",
+    IFRAME: 1,
+    IMG: 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",
+"webview",
+"isindex", "listing", "multicol", "nextid", "noindex", "search"]);
+
+const memo = fn => createMemo(() => fn());
+
+const ES2017FLAG = Feature.AggregateError
+| Feature.BigIntTypedArray;
+const GLOBAL_IDENTIFIER = '_$HY.r';
+function createSerializer({
+  onData,
+  onDone,
+  scopeId,
+  onError,
+  plugins: customPlugins
+}) {
+  const defaultPlugins = [AbortSignalPlugin,
+  CustomEventPlugin, DOMExceptionPlugin, EventPlugin,
+  FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin];
+  const allPlugins = customPlugins ? [...customPlugins, ...defaultPlugins] : defaultPlugins;
+  return new Serializer({
+    scopeId,
+    plugins: allPlugins,
+    globalIdentifier: GLOBAL_IDENTIFIER,
+    disabledFeatures: ES2017FLAG,
+    onData,
+    onDone,
+    onError
+  });
+}
+function getLocalHeaderScript(id) {
+  return getCrossReferenceHeader(id) + ';';
+}
+
+const VOID_ELEMENTS = /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i;
+const REPLACE_SCRIPT = `function $df(e,n,o,t){if(n=document.getElementById(e),o=document.getElementById("pl-"+e)){for(;o&&8!==o.nodeType&&o.nodeValue!=="pl-"+e;)t=o.nextSibling,o.remove(),o=t;_$HY.done?o.remove():o.replaceWith(n.content)}n.remove(),_$HY.fe(e)}`;
+function renderToString(code, options = {}) {
+  const {
+    renderId
+  } = options;
+  let scripts = "";
+  const serializer = createSerializer({
+    scopeId: renderId,
+    plugins: options.plugins,
+    onData(script) {
+      if (!scripts) {
+        scripts = getLocalHeaderScript(renderId);
+      }
+      scripts += script + ";";
+    },
+    onError: options.onError
+  });
+  sharedConfig.context = {
+    id: renderId || "",
+    count: 0,
+    suspense: {},
+    lazy: {},
+    assets: [],
+    nonce: options.nonce,
+    serialize(id, p) {
+      !sharedConfig.context.noHydrate && serializer.write(id, p);
+    },
+    roots: 0,
+    nextRoot() {
+      return this.renderId + "i-" + this.roots++;
+    }
+  };
+  let html = createRoot(d => {
+    setTimeout(d);
+    return resolveSSRNode(escape(code()));
+  });
+  sharedConfig.context.noHydrate = true;
+  serializer.close();
+  html = injectAssets(sharedConfig.context.assets, html);
+  if (scripts.length) html = injectScripts(html, scripts, options.nonce);
+  return html;
+}
+function renderToStringAsync(code, options = {}) {
+  const {
+    timeoutMs = 30000
+  } = options;
+  let timeoutHandle;
+  const timeout = new Promise((_, reject) => {
+    timeoutHandle = setTimeout(() => reject("renderToString timed out"), timeoutMs);
+  });
+  return Promise.race([renderToStream(code, options), timeout]).then(html => {
+    clearTimeout(timeoutHandle);
+    return html;
+  });
+}
+function renderToStream(code, options = {}) {
+  let {
+    nonce,
+    onCompleteShell,
+    onCompleteAll,
+    renderId,
+    noScripts
+  } = options;
+  let dispose;
+  const blockingPromises = [];
+  const pushTask = task => {
+    if (noScripts) return;
+    if (!tasks && !firstFlushed) {
+      tasks = getLocalHeaderScript(renderId);
+    }
+    tasks += task + ";";
+    if (!timer && firstFlushed) {
+      timer = setTimeout(writeTasks);
+    }
+  };
+  const onDone = () => {
+    writeTasks();
+    doShell();
+    onCompleteAll && onCompleteAll({
+      write(v) {
+        !completed && buffer.write(v);
+      }
+    });
+    writable && writable.end();
+    completed = true;
+    if (firstFlushed) dispose();
+  };
+  const serializer = createSerializer({
+    scopeId: options.renderId,
+    plugins: options.plugins,
+    onData: pushTask,
+    onDone,
+    onError: options.onError
+  });
+  const flushEnd = () => {
+    if (!registry.size) {
+      queue(() => queue(() => serializer.flush()));
+    }
+  };
+  const registry = new Map();
+  const writeTasks = () => {
+    if (tasks.length && !completed && firstFlushed) {
+      buffer.write(`<script${nonce ? ` nonce="${nonce}"` : ""}>${tasks}</script>`);
+      tasks = "";
+    }
+    timer && clearTimeout(timer);
+    timer = null;
+  };
+  let context;
+  let writable;
+  let tmp = "";
+  let tasks = "";
+  let firstFlushed = false;
+  let completed = false;
+  let shellCompleted = false;
+  let scriptFlushed = false;
+  let timer = null;
+  let buffer = {
+    write(payload) {
+      tmp += payload;
+    }
+  };
+  sharedConfig.context = context = {
+    id: renderId || "",
+    count: 0,
+    async: true,
+    resources: {},
+    lazy: {},
+    suspense: {},
+    assets: [],
+    nonce,
+    block(p) {
+      if (!firstFlushed) blockingPromises.push(p);
+    },
+    replace(id, payloadFn) {
+      if (firstFlushed) return;
+      const placeholder = `<!--!$${id}-->`;
+      const first = html.indexOf(placeholder);
+      if (first === -1) return;
+      const last = html.indexOf(`<!--!$/${id}-->`, first + placeholder.length);
+      html = html.slice(0, first) + resolveSSRNode(escape(payloadFn())) + html.slice(last + placeholder.length + 1);
+    },
+    serialize(id, p, wait) {
+      const serverOnly = sharedConfig.context.noHydrate;
+      if (!firstFlushed && wait && typeof p === "object" && "then" in p) {
+        blockingPromises.push(p);
+        !serverOnly && p.then(d => {
+          serializer.write(id, d);
+        }).catch(e => {
+          serializer.write(id, e);
+        });
+      } else if (!serverOnly) serializer.write(id, p);
+    },
+    roots: 0,
+    nextRoot() {
+      return this.renderId + "i-" + this.roots++;
+    },
+    registerFragment(key) {
+      if (!registry.has(key)) {
+        let resolve, reject;
+        const p = new Promise((r, rej) => (resolve = r, reject = rej));
+        registry.set(key, err => queue(() => queue(() => {
+          err ? reject(err) : resolve(true);
+          queue(flushEnd);
+        })));
+        serializer.write(key, p);
+      }
+      return (value, error) => {
+        if (registry.has(key)) {
+          const resolve = registry.get(key);
+          registry.delete(key);
+          if (waitForFragments(registry, key)) {
+            resolve();
+            return;
+          }
+          if (!completed) {
+            if (!firstFlushed) {
+              queue(() => html = replacePlaceholder(html, key, value !== undefined ? value : ""));
+              resolve(error);
+            } else {
+              buffer.write(`<template id="${key}">${value !== undefined ? value : " "}</template>`);
+              pushTask(`$df("${key}")${!scriptFlushed ? ";" + REPLACE_SCRIPT : ""}`);
+              resolve(error);
+              scriptFlushed = true;
+            }
+          }
+        }
+        return firstFlushed;
+      };
+    }
+  };
+  let html = createRoot(d => {
+    dispose = d;
+    return resolveSSRNode(escape(code()));
+  });
+  function doShell() {
+    if (shellCompleted) return;
+    sharedConfig.context = context;
+    context.noHydrate = true;
+    html = injectAssets(context.assets, html);
+    if (tasks.length) html = injectScripts(html, tasks, nonce);
+    buffer.write(html);
+    tasks = "";
+    onCompleteShell && onCompleteShell({
+      write(v) {
+        !completed && buffer.write(v);
+      }
+    });
+    shellCompleted = true;
+  }
+  return {
+    then(fn) {
+      function complete() {
+        dispose();
+        fn(tmp);
+      }
+      if (onCompleteAll) {
+        let ogComplete = onCompleteAll;
+        onCompleteAll = options => {
+          ogComplete(options);
+          complete();
+        };
+      } else onCompleteAll = complete;
+      queue(flushEnd);
+    },
+    pipe(w) {
+      allSettled(blockingPromises).then(() => {
+        setTimeout(() => {
+          doShell();
+          buffer = writable = w;
+          buffer.write(tmp);
+          firstFlushed = true;
+          if (completed) {
+            dispose();
+            writable.end();
+          } else flushEnd();
+        });
+      });
+    },
+    pipeTo(w) {
+      return allSettled(blockingPromises).then(() => {
+        let resolve;
+        const p = new Promise(r => resolve = r);
+        setTimeout(() => {
+          doShell();
+          const encoder = new TextEncoder();
+          const writer = w.getWriter();
+          writable = {
+            end() {
+              writer.releaseLock();
+              w.close().catch(() => {});
+              resolve();
+            }
+          };
+          buffer = {
+            write(payload) {
+              writer.write(encoder.encode(payload)).catch(() => {});
+            }
+          };
+          buffer.write(tmp);
+          firstFlushed = true;
+          if (completed) {
+            dispose();
+            writable.end();
+          } else flushEnd();
+        });
+        return p;
+      });
+    }
+  };
+}
+function HydrationScript(props) {
+  const {
+    nonce
+  } = sharedConfig.context;
+  return ssr(generateHydrationScript({
+    nonce,
+    ...props
+  }));
+}
+function ssr(t, ...nodes) {
+  if (nodes.length) {
+    let result = "";
+    for (let i = 0; i < nodes.length; i++) {
+      result += t[i];
+      const node = nodes[i];
+      if (node !== undefined) result += resolveSSRNode(node);
+    }
+    t = result + t[nodes.length];
+  }
+  return {
+    t
+  };
+}
+function ssrClassList(value) {
+  if (!value) return "";
+  let classKeys = Object.keys(value),
+    result = "";
+  for (let i = 0, len = classKeys.length; i < len; i++) {
+    const key = classKeys[i],
+      classValue = !!value[key];
+    if (!key || key === "undefined" || !classValue) continue;
+    i && (result += " ");
+    result += escape(key);
+  }
+  return result;
+}
+function ssrStyle(value) {
+  if (!value) return "";
+  if (typeof value === "string") return escape(value, true);
+  let result = "";
+  const k = Object.keys(value);
+  for (let i = 0; i < k.length; i++) {
+    const s = k[i];
+    const v = value[s];
+    if (v != undefined) {
+      if (i) result += ";";
+      const r = escape(v, true);
+      if (r != undefined && r !== "undefined") {
+        result += `${s}:${r}`;
+      }
+    }
+  }
+  return result;
+}
+function ssrStyleProperty(name, value) {
+  return value != null ? name + value : "";
+}
+function ssrElement(tag, props, children, needsId) {
+  if (props == null) props = {};else if (typeof props === "function") props = props();
+  const skipChildren = VOID_ELEMENTS.test(tag);
+  const keys = Object.keys(props);
+  let result = `<${tag}${needsId ? ssrHydrationKey() : ""} `;
+  let classResolved;
+  for (let i = 0; i < keys.length; i++) {
+    const prop = keys[i];
+    if (ChildProperties.has(prop)) {
+      if (children === undefined && !skipChildren) children = tag === "script" || tag === "style" || prop === "innerHTML" ? props[prop] : escape(props[prop]);
+      continue;
+    }
+    const value = props[prop];
+    if (prop === "style") {
+      result += `style="${ssrStyle(value)}"`;
+    } else if (prop === "class" || prop === "className" || prop === "classList") {
+      if (classResolved) continue;
+      let n;
+      result += `class="${escape(((n = props.class) ? n + " " : "") + ((n = props.className) ? n + " " : ""), true) + ssrClassList(props.classList)}"`;
+      classResolved = true;
+    } else if (BooleanAttributes.has(prop)) {
+      if (value) result += prop;else continue;
+    } else if (value == undefined || prop === "ref" || prop.slice(0, 2) === "on" || prop.slice(0, 5) === "prop:") {
+      continue;
+    } else if (prop.slice(0, 5) === "bool:") {
+      if (!value) continue;
+      result += escape(prop.slice(5));
+    } else if (prop.slice(0, 5) === "attr:") {
+      result += `${escape(prop.slice(5))}="${escape(value, true)}"`;
+    } else {
+      result += `${Aliases[prop] || escape(prop)}="${escape(value, true)}"`;
+    }
+    if (i !== keys.length - 1) result += " ";
+  }
+  if (skipChildren) return {
+    t: result + "/>"
+  };
+  if (typeof children === "function") children = children();
+  return {
+    t: result + `>${resolveSSRNode(children, true)}</${tag}>`
+  };
+}
+function ssrAttribute(key, value, isBoolean) {
+  return isBoolean ? value ? " " + key : "" : value != null ? ` ${key}="${value}"` : "";
+}
+function ssrHydrationKey() {
+  const hk = getHydrationKey();
+  return hk ? ` data-hk="${hk}"` : "";
+}
+function escape(s, attr) {
+  const t = typeof s;
+  if (t !== "string") {
+    if (!attr && t === "function") return escape(s());
+    if (!attr && Array.isArray(s)) {
+      s = s.slice();
+      for (let i = 0; i < s.length; i++) s[i] = escape(s[i]);
+      return s;
+    }
+    if (attr && t === "boolean") return String(s);
+    return s;
+  }
+  const delim = attr ? '"' : "<";
+  const escDelim = attr ? "&quot;" : "&lt;";
+  let iDelim = s.indexOf(delim);
+  let iAmp = s.indexOf("&");
+  if (iDelim < 0 && iAmp < 0) return s;
+  let left = 0,
+    out = "";
+  while (iDelim >= 0 && iAmp >= 0) {
+    if (iDelim < iAmp) {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } else {
+      if (left < iAmp) out += s.substring(left, iAmp);
+      out += "&amp;";
+      left = iAmp + 1;
+      iAmp = s.indexOf("&", left);
+    }
+  }
+  if (iDelim >= 0) {
+    do {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } while (iDelim >= 0);
+  } else while (iAmp >= 0) {
+    if (left < iAmp) out += s.substring(left, iAmp);
+    out += "&amp;";
+    left = iAmp + 1;
+    iAmp = s.indexOf("&", left);
+  }
+  return left < s.length ? out + s.substring(left) : out;
+}
+function resolveSSRNode(node, top) {
+  const t = typeof node;
+  if (t === "string") return node;
+  if (node == null || t === "boolean") return "";
+  if (Array.isArray(node)) {
+    let prev = {};
+    let mapped = "";
+    for (let i = 0, len = node.length; i < len; i++) {
+      if (!top && typeof prev !== "object" && typeof node[i] !== "object") mapped += `<!--!$-->`;
+      mapped += resolveSSRNode(prev = node[i]);
+    }
+    return mapped;
+  }
+  if (t === "object") return node.t;
+  if (t === "function") return resolveSSRNode(node());
+  return String(node);
+}
+function getHydrationKey() {
+  const hydrate = sharedConfig.context;
+  return hydrate && !hydrate.noHydrate && sharedConfig.getNextContextId();
+}
+function useAssets(fn) {
+  sharedConfig.context.assets.push(() => resolveSSRNode(escape(fn())));
+}
+function getAssets() {
+  const assets = sharedConfig.context.assets;
+  let out = "";
+  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
+  return out;
+}
+function generateHydrationScript({
+  eventNames = ["click", "input"],
+  nonce
+} = {}) {
+  return `<script${nonce ? ` nonce="${nonce}"` : ""}>window._$HY||(e=>{let t=e=>e&&e.hasAttribute&&(e.hasAttribute("data-hk")?e:t(e.host&&e.host.nodeType?e.host:e.parentNode));["${eventNames.join('", "')}"].forEach((o=>document.addEventListener(o,(o=>{if(!e.events)return;let s=t(o.composedPath&&o.composedPath()[0]||o.target);s&&!e.completed.has(s)&&e.events.push([s,o])}))))})(_$HY={events:[],completed:new WeakSet,r:{},fe(){}});</script><!--xs-->`;
+}
+function Hydration(props) {
+  if (!sharedConfig.context.noHydrate) return props.children;
+  const context = sharedConfig.context;
+  sharedConfig.context = {
+    ...context,
+    count: 0,
+    id: sharedConfig.getNextContextId(),
+    noHydrate: false
+  };
+  const res = props.children;
+  sharedConfig.context = context;
+  return res;
+}
+function NoHydration(props) {
+  if (sharedConfig.context) sharedConfig.context.noHydrate = true;
+  return props.children;
+}
+function queue(fn) {
+  return Promise.resolve().then(fn);
+}
+function allSettled(promises) {
+  let length = promises.length;
+  return Promise.allSettled(promises).then(() => {
+    if (promises.length !== length) return allSettled(promises);
+    return;
+  });
+}
+function injectAssets(assets, html) {
+  if (!assets || !assets.length) return html;
+  let out = "";
+  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
+  const index = html.indexOf("</head>");
+  if (index === -1) return html;
+  return html.slice(0, index) + out + html.slice(index);
+}
+function injectScripts(html, scripts, nonce) {
+  const tag = `<script${nonce ? ` nonce="${nonce}"` : ""}>${scripts}</script>`;
+  const index = html.indexOf("<!--xs-->");
+  if (index > -1) {
+    return html.slice(0, index) + tag + html.slice(index);
+  }
+  return html + tag;
+}
+function waitForFragments(registry, key) {
+  for (const k of [...registry.keys()].reverse()) {
+    if (key.startsWith(k)) return true;
+  }
+  return false;
+}
+function replacePlaceholder(html, key, value) {
+  const marker = `<template id="pl-${key}">`;
+  const close = `<!--pl-${key}-->`;
+  const first = html.indexOf(marker);
+  if (first === -1) return html;
+  const last = html.indexOf(close, first + marker.length);
+  return html.slice(0, first) + value + html.slice(last + close.length);
+}
+const RequestContext = Symbol();
+function getRequestEvent() {
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || sharedConfig.context && sharedConfig.context.event || console.log("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+}
+function Assets(props) {
+  useAssets(() => props.children);
+}
+function pipeToNodeWritable(code, writable, options = {}) {
+  if (options.onReady) {
+    options.onCompleteShell = ({
+      write
+    }) => {
+      options.onReady({
+        write,
+        startWriting() {
+          stream.pipe(writable);
+        }
+      });
+    };
+  }
+  const stream = renderToStream(code, options);
+  if (!options.onReady) stream.pipe(writable);
+}
+function pipeToWritable(code, writable, options = {}) {
+  if (options.onReady) {
+    options.onCompleteShell = ({
+      write
+    }) => {
+      options.onReady({
+        write,
+        startWriting() {
+          stream.pipeTo(writable);
+        }
+      });
+    };
+  }
+  const stream = renderToStream(code, options);
+  if (!options.onReady) stream.pipeTo(writable);
+}
+function ssrSpread(props, isSVG, skipChildren) {
+  let result = "";
+  if (props == null) return result;
+  if (typeof props === "function") props = props();
+  const keys = Object.keys(props);
+  let classResolved;
+  for (let i = 0; i < keys.length; i++) {
+    let prop = keys[i];
+    if (prop === "children") {
+      !skipChildren && console.warn(`SSR currently does not support spread children.`);
+      continue;
+    }
+    const value = props[prop];
+    if (prop === "style") {
+      result += `style="${ssrStyle(value)}"`;
+    } else if (prop === "class" || prop === "className" || prop === "classList") {
+      if (classResolved) continue;
+      let n;
+      result += `class="${(n = props.class) ? n + " " : ""}${(n = props.className) ? n + " " : ""}${ssrClassList(props.classList)}"`;
+      classResolved = true;
+    } else if (prop !== "value" && Properties.has(prop)) {
+      if (value) result += prop;else continue;
+    } else if (value == undefined || prop === "ref" || prop.slice(0, 2) === "on" || prop.slice(0, 5) === "prop:") {
+      continue;
+    } else if (prop.slice(0, 5) === "bool:") {
+      if (!value) continue;
+      result += escape(prop.slice(5));
+    } else if (prop.slice(0, 5) === "attr:") {
+      result += `${escape(prop.slice(5))}="${escape(value, true)}"`;
+    } else {
+      result += `${Aliases[prop] || escape(prop)}="${escape(value, true)}"`;
+    }
+    if (i !== keys.length - 1) result += " ";
+  }
+  return result;
+}
+function notSup() {
+  throw new Error("Client-only API called on the server side. Run client-only code in onMount, or conditionally run client-only component with <Show>.");
+}
+
+const isServer = true;
+const isDev = false;
+function createDynamic(component, props) {
+  const comp = component(),
+    t = typeof comp;
+  if (comp) {
+    if (t === "function") return comp(props);else if (t === "string") {
+      return ssrElement(comp, props, undefined, true);
+    }
+  }
+}
+function Dynamic(props) {
+  const [, others] = splitProps(props, ["component"]);
+  return createDynamic(() => props.component, others);
+}
+function Portal(props) {
+  return "";
+}
+
+export { Aliases, Assets, ChildProperties, DOMElements, DelegatedEvents, Dynamic, Hydration, HydrationScript, NoHydration, Portal, Properties, RequestContext, SVGElements, SVGNamespace, notSup as addEventListener, notSup as assign, notSup as classList, notSup as className, createDynamic, notSup as delegateEvents, notSup as dynamicProperty, escape, generateHydrationScript, getAssets, getHydrationKey, notSup as getNextElement, notSup as getNextMarker, notSup as getNextMatch, getPropAlias, getRequestEvent, notSup as hydrate, notSup as insert, isDev, isServer, memo, pipeToNodeWritable, pipeToWritable, notSup as render, renderToStream, renderToString, renderToStringAsync, resolveSSRNode, notSup as runHydrationEvents, notSup as setAttribute, notSup as setAttributeNS, notSup as setProperty, notSup as spread, ssr, ssrAttribute, ssrClassList, ssrElement, ssrHydrationKey, ssrSpread, ssrStyle, ssrStyleProperty, notSup as style, notSup as template, useAssets };

web/node_modules/solid-js/web/dist/web.cjs

@@ -0,0 +1,883 @@
+'use strict';
+
+var solidJs = require('solid-js');
+
+const booleans = ["allowfullscreen", "async", "alpha",
+"autofocus",
+"autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden",
+"indeterminate", "inert",
+"ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless",
+"selected", "adauctionheaders",
+"browsingtopics",
+"credentialless",
+"defaultchecked", "defaultmuted", "defaultselected", "defer", "disablepictureinpicture", "disableremoteplayback", "preservespitch",
+"shadowrootclonable", "shadowrootcustomelementregistry",
+"shadowrootdelegatesfocus", "shadowrootserializable",
+"sharedstoragewritable"
+];
+const Properties = /*#__PURE__*/new Set([
+"className", "value",
+"readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", "adAuctionHeaders",
+"allowFullscreen", "browsingTopics",
+"defaultChecked", "defaultMuted", "defaultSelected", "disablePictureInPicture", "disableRemotePlayback", "preservesPitch", "shadowRootClonable", "shadowRootCustomElementRegistry",
+"shadowRootDelegatesFocus", "shadowRootSerializable",
+"sharedStorageWritable",
+...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
+  },
+  adauctionheaders: {
+    $: "adAuctionHeaders",
+    IFRAME: 1
+  },
+  allowfullscreen: {
+    $: "allowFullscreen",
+    IFRAME: 1
+  },
+  browsingtopics: {
+    $: "browsingTopics",
+    IMG: 1
+  },
+  defaultchecked: {
+    $: "defaultChecked",
+    INPUT: 1
+  },
+  defaultmuted: {
+    $: "defaultMuted",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  defaultselected: {
+    $: "defaultSelected",
+    OPTION: 1
+  },
+  disablepictureinpicture: {
+    $: "disablePictureInPicture",
+    VIDEO: 1
+  },
+  disableremoteplayback: {
+    $: "disableRemotePlayback",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  preservespitch: {
+    $: "preservesPitch",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  shadowrootclonable: {
+    $: "shadowRootClonable",
+    TEMPLATE: 1
+  },
+  shadowrootdelegatesfocus: {
+    $: "shadowRootDelegatesFocus",
+    TEMPLATE: 1
+  },
+  shadowrootserializable: {
+    $: "shadowRootSerializable",
+    TEMPLATE: 1
+  },
+  sharedstoragewritable: {
+    $: "sharedStorageWritable",
+    IFRAME: 1,
+    IMG: 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",
+"webview",
+"isindex", "listing", "multicol", "nextid", "noindex", "search"]);
+
+const memo = fn => solidJs.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;
+  solidJs.createRoot(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 ? () => solidJs.untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+  fn.cloneNode = fn;
+  return fn;
+}
+function delegateEvents(eventNames, document = window.document) {
+  const e = document[$$EVENTS] || (document[$$EVENTS] = new Set());
+  for (let i = 0, l = eventNames.length; i < l; i++) {
+    const name = eventNames[i];
+    if (!e.has(name)) {
+      e.add(name);
+      document.addEventListener(name, eventHandler);
+    }
+  }
+}
+function clearDelegatedEvents(document = window.document) {
+  if (document[$$EVENTS]) {
+    for (let name of document[$$EVENTS].keys()) document.removeEventListener(name, eventHandler);
+    delete document[$$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 setStyleProperty(node, name, value) {
+  value != null ? node.style.setProperty(name, value) : node.style.removeProperty(name);
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+  const prevProps = {};
+  if (!skipChildren) {
+    solidJs.createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+  }
+  solidJs.createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node));
+  solidJs.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 solidJs.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);
+  solidJs.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);
+  solidJs.sharedConfig.completed = globalThis._$HY.completed;
+  solidJs.sharedConfig.events = globalThis._$HY.events;
+  solidJs.sharedConfig.load = id => globalThis._$HY.r[id];
+  solidJs.sharedConfig.has = id => id in globalThis._$HY.r;
+  solidJs.sharedConfig.gather = root => gatherHydratable(element, root);
+  solidJs.sharedConfig.registry = new Map();
+  solidJs.sharedConfig.context = {
+    id: options.renderId || "",
+    count: 0
+  };
+  try {
+    gatherHydratable(element, options.renderId);
+    return render(code, element, [...element.childNodes], options);
+  } finally {
+    solidJs.sharedConfig.context = null;
+  }
+}
+function getNextElement(template) {
+  let node,
+    key,
+    hydrating = isHydrating();
+  if (!hydrating || !(node = solidJs.sharedConfig.registry.get(key = getHydrationKey()))) {
+    return template();
+  }
+  if (solidJs.sharedConfig.completed) solidJs.sharedConfig.completed.add(node);
+  solidJs.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 (solidJs.sharedConfig.events && !solidJs.sharedConfig.events.queued) {
+    queueMicrotask(() => {
+      const {
+        completed,
+        events
+      } = solidJs.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 (solidJs.sharedConfig.done) {
+        solidJs.sharedConfig.events = _$HY.events = null;
+        solidJs.sharedConfig.completed = _$HY.completed = null;
+      }
+    });
+    solidJs.sharedConfig.events.queued = true;
+  }
+}
+function isHydrating(node) {
+  return !!solidJs.sharedConfig.context && !solidJs.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 (solidJs.sharedConfig.registry && solidJs.sharedConfig.events) {
+    if (solidJs.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 (solidJs.sharedConfig.registry && !solidJs.sharedConfig.done) solidJs.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") {
+    solidJs.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)) {
+      solidJs.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;
+  } else ;
+  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)) && !solidJs.sharedConfig.registry.has(key)) solidJs.sharedConfig.registry.set(key, node);
+  }
+}
+function getHydrationKey() {
+  return solidJs.sharedConfig.getNextContextId();
+}
+function NoHydration(props) {
+  return solidJs.sharedConfig.context ? undefined : props.children;
+}
+function Hydration(props) {
+  return props.children;
+}
+const voidFn = () => undefined;
+const RequestContext = Symbol();
+function innerHTML(parent, content) {
+  !solidJs.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, is = undefined) {
+  return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName, {
+    is
+  });
+}
+const hydrate = (...args) => {
+  solidJs.enableHydration();
+  return hydrate$1(...args);
+};
+function Portal(props) {
+  const {
+      useShadow
+    } = props,
+    marker = document.createTextNode(""),
+    mount = () => props.mount || document.body,
+    owner = solidJs.getOwner();
+  let content;
+  let hydrating = !!solidJs.sharedConfig.context;
+  solidJs.createEffect(() => {
+    if (hydrating) solidJs.getOwner().user = hydrating = false;
+    content || (content = solidJs.runWithOwner(owner, () => solidJs.createMemo(() => props.children)));
+    const el = mount();
+    if (el instanceof HTMLHeadElement) {
+      const [clean, setClean] = solidJs.createSignal(false);
+      const cleanup = () => setClean(true);
+      solidJs.createRoot(dispose => insert(el, () => !clean() ? content() : dispose(), null));
+      solidJs.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);
+      solidJs.onCleanup(() => el.removeChild(container));
+    }
+  }, undefined, {
+    render: !hydrating
+  });
+  return marker;
+}
+function createDynamic(component, props) {
+  const cached = solidJs.createMemo(component);
+  return solidJs.createMemo(() => {
+    const component = cached();
+    switch (typeof component) {
+      case "function":
+        return solidJs.untrack(() => component(props));
+      case "string":
+        const isSvg = SVGElements.has(component);
+        const el = solidJs.sharedConfig.context ? getNextElement() : createElement(component, isSvg, solidJs.untrack(() => props.is));
+        spread(el, props, isSvg);
+        return el;
+    }
+  });
+}
+function Dynamic(props) {
+  const [, others] = solidJs.splitProps(props, ["component"]);
+  return createDynamic(() => props.component, others);
+}
+
+Object.defineProperty(exports, "ErrorBoundary", {
+  enumerable: true,
+  get: function () { return solidJs.ErrorBoundary; }
+});
+Object.defineProperty(exports, "For", {
+  enumerable: true,
+  get: function () { return solidJs.For; }
+});
+Object.defineProperty(exports, "Index", {
+  enumerable: true,
+  get: function () { return solidJs.Index; }
+});
+Object.defineProperty(exports, "Match", {
+  enumerable: true,
+  get: function () { return solidJs.Match; }
+});
+Object.defineProperty(exports, "Show", {
+  enumerable: true,
+  get: function () { return solidJs.Show; }
+});
+Object.defineProperty(exports, "Suspense", {
+  enumerable: true,
+  get: function () { return solidJs.Suspense; }
+});
+Object.defineProperty(exports, "SuspenseList", {
+  enumerable: true,
+  get: function () { return solidJs.SuspenseList; }
+});
+Object.defineProperty(exports, "Switch", {
+  enumerable: true,
+  get: function () { return solidJs.Switch; }
+});
+Object.defineProperty(exports, "createComponent", {
+  enumerable: true,
+  get: function () { return solidJs.createComponent; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return solidJs.createRenderEffect; }
+});
+Object.defineProperty(exports, "getOwner", {
+  enumerable: true,
+  get: function () { return solidJs.getOwner; }
+});
+Object.defineProperty(exports, "mergeProps", {
+  enumerable: true,
+  get: function () { return solidJs.mergeProps; }
+});
+Object.defineProperty(exports, "untrack", {
+  enumerable: true,
+  get: function () { return solidJs.untrack; }
+});
+exports.Aliases = Aliases;
+exports.Assets = voidFn;
+exports.ChildProperties = ChildProperties;
+exports.DOMElements = DOMElements;
+exports.DelegatedEvents = DelegatedEvents;
+exports.Dynamic = Dynamic;
+exports.Hydration = Hydration;
+exports.HydrationScript = voidFn;
+exports.NoHydration = NoHydration;
+exports.Portal = Portal;
+exports.Properties = Properties;
+exports.RequestContext = RequestContext;
+exports.SVGElements = SVGElements;
+exports.SVGNamespace = SVGNamespace;
+exports.addEventListener = addEventListener;
+exports.assign = assign;
+exports.classList = classList;
+exports.className = className;
+exports.clearDelegatedEvents = clearDelegatedEvents;
+exports.createDynamic = createDynamic;
+exports.delegateEvents = delegateEvents;
+exports.dynamicProperty = dynamicProperty;
+exports.escape = escape;
+exports.generateHydrationScript = voidFn;
+exports.getAssets = voidFn;
+exports.getHydrationKey = getHydrationKey;
+exports.getNextElement = getNextElement;
+exports.getNextMarker = getNextMarker;
+exports.getNextMatch = getNextMatch;
+exports.getPropAlias = getPropAlias;
+exports.getRequestEvent = voidFn;
+exports.hydrate = hydrate;
+exports.innerHTML = innerHTML;
+exports.insert = insert;
+exports.isDev = isDev;
+exports.isServer = isServer;
+exports.memo = memo;
+exports.render = render;
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+exports.renderToStringAsync = renderToStringAsync;
+exports.resolveSSRNode = resolveSSRNode;
+exports.runHydrationEvents = runHydrationEvents;
+exports.setAttribute = setAttribute;
+exports.setAttributeNS = setAttributeNS;
+exports.setBoolAttribute = setBoolAttribute;
+exports.setProperty = setProperty;
+exports.setStyleProperty = setStyleProperty;
+exports.spread = spread;
+exports.ssr = ssr;
+exports.ssrAttribute = ssrAttribute;
+exports.ssrClassList = ssrClassList;
+exports.ssrElement = ssrElement;
+exports.ssrHydrationKey = ssrHydrationKey;
+exports.ssrSpread = ssrSpread;
+exports.ssrStyle = ssrStyle;
+exports.style = style;
+exports.template = template;
+exports.use = use;
+exports.useAssets = voidFn;

web/node_modules/solid-js/web/dist/web.js

@@ -0,0 +1,771 @@
+import { createMemo, sharedConfig, createRenderEffect, createRoot, untrack, splitProps, getOwner, createEffect, runWithOwner, createSignal, onCleanup, enableHydration } from 'solid-js';
+export { ErrorBoundary, For, Index, Match, Show, Suspense, SuspenseList, Switch, createComponent, createRenderEffect as effect, getOwner, mergeProps, untrack } from 'solid-js';
+
+const booleans = ["allowfullscreen", "async", "alpha",
+"autofocus",
+"autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden",
+"indeterminate", "inert",
+"ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless",
+"selected", "adauctionheaders",
+"browsingtopics",
+"credentialless",
+"defaultchecked", "defaultmuted", "defaultselected", "defer", "disablepictureinpicture", "disableremoteplayback", "preservespitch",
+"shadowrootclonable", "shadowrootcustomelementregistry",
+"shadowrootdelegatesfocus", "shadowrootserializable",
+"sharedstoragewritable"
+];
+const Properties = /*#__PURE__*/new Set([
+"className", "value",
+"readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", "adAuctionHeaders",
+"allowFullscreen", "browsingTopics",
+"defaultChecked", "defaultMuted", "defaultSelected", "disablePictureInPicture", "disableRemotePlayback", "preservesPitch", "shadowRootClonable", "shadowRootCustomElementRegistry",
+"shadowRootDelegatesFocus", "shadowRootSerializable",
+"sharedStorageWritable",
+...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
+  },
+  adauctionheaders: {
+    $: "adAuctionHeaders",
+    IFRAME: 1
+  },
+  allowfullscreen: {
+    $: "allowFullscreen",
+    IFRAME: 1
+  },
+  browsingtopics: {
+    $: "browsingTopics",
+    IMG: 1
+  },
+  defaultchecked: {
+    $: "defaultChecked",
+    INPUT: 1
+  },
+  defaultmuted: {
+    $: "defaultMuted",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  defaultselected: {
+    $: "defaultSelected",
+    OPTION: 1
+  },
+  disablepictureinpicture: {
+    $: "disablePictureInPicture",
+    VIDEO: 1
+  },
+  disableremoteplayback: {
+    $: "disableRemotePlayback",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  preservespitch: {
+    $: "preservesPitch",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  shadowrootclonable: {
+    $: "shadowRootClonable",
+    TEMPLATE: 1
+  },
+  shadowrootdelegatesfocus: {
+    $: "shadowRootDelegatesFocus",
+    TEMPLATE: 1
+  },
+  shadowrootserializable: {
+    $: "shadowRootSerializable",
+    TEMPLATE: 1
+  },
+  sharedstoragewritable: {
+    $: "sharedStorageWritable",
+    IFRAME: 1,
+    IMG: 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",
+"webview",
+"isindex", "listing", "multicol", "nextid", "noindex", "search"]);
+
+const memo = fn => 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;
+  createRoot(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 ? () => untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+  fn.cloneNode = fn;
+  return fn;
+}
+function delegateEvents(eventNames, document = window.document) {
+  const e = document[$$EVENTS] || (document[$$EVENTS] = new Set());
+  for (let i = 0, l = eventNames.length; i < l; i++) {
+    const name = eventNames[i];
+    if (!e.has(name)) {
+      e.add(name);
+      document.addEventListener(name, eventHandler);
+    }
+  }
+}
+function clearDelegatedEvents(document = window.document) {
+  if (document[$$EVENTS]) {
+    for (let name of document[$$EVENTS].keys()) document.removeEventListener(name, eventHandler);
+    delete document[$$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 setStyleProperty(node, name, value) {
+  value != null ? node.style.setProperty(name, value) : node.style.removeProperty(name);
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+  const prevProps = {};
+  if (!skipChildren) {
+    createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+  }
+  createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node));
+  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 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);
+  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);
+  sharedConfig.completed = globalThis._$HY.completed;
+  sharedConfig.events = globalThis._$HY.events;
+  sharedConfig.load = id => globalThis._$HY.r[id];
+  sharedConfig.has = id => id in globalThis._$HY.r;
+  sharedConfig.gather = root => gatherHydratable(element, root);
+  sharedConfig.registry = new Map();
+  sharedConfig.context = {
+    id: options.renderId || "",
+    count: 0
+  };
+  try {
+    gatherHydratable(element, options.renderId);
+    return render(code, element, [...element.childNodes], options);
+  } finally {
+    sharedConfig.context = null;
+  }
+}
+function getNextElement(template) {
+  let node,
+    key,
+    hydrating = isHydrating();
+  if (!hydrating || !(node = sharedConfig.registry.get(key = getHydrationKey()))) {
+    return template();
+  }
+  if (sharedConfig.completed) sharedConfig.completed.add(node);
+  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 (sharedConfig.events && !sharedConfig.events.queued) {
+    queueMicrotask(() => {
+      const {
+        completed,
+        events
+      } = 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 (sharedConfig.done) {
+        sharedConfig.events = _$HY.events = null;
+        sharedConfig.completed = _$HY.completed = null;
+      }
+    });
+    sharedConfig.events.queued = true;
+  }
+}
+function isHydrating(node) {
+  return !!sharedConfig.context && !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 (sharedConfig.registry && sharedConfig.events) {
+    if (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 (sharedConfig.registry && !sharedConfig.done) 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") {
+    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)) {
+      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;
+  } else ;
+  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)) && !sharedConfig.registry.has(key)) sharedConfig.registry.set(key, node);
+  }
+}
+function getHydrationKey() {
+  return sharedConfig.getNextContextId();
+}
+function NoHydration(props) {
+  return sharedConfig.context ? undefined : props.children;
+}
+function Hydration(props) {
+  return props.children;
+}
+const voidFn = () => undefined;
+const RequestContext = Symbol();
+function innerHTML(parent, content) {
+  !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, is = undefined) {
+  return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName, {
+    is
+  });
+}
+const hydrate = (...args) => {
+  enableHydration();
+  return hydrate$1(...args);
+};
+function Portal(props) {
+  const {
+      useShadow
+    } = props,
+    marker = document.createTextNode(""),
+    mount = () => props.mount || document.body,
+    owner = getOwner();
+  let content;
+  let hydrating = !!sharedConfig.context;
+  createEffect(() => {
+    if (hydrating) getOwner().user = hydrating = false;
+    content || (content = runWithOwner(owner, () => createMemo(() => props.children)));
+    const el = mount();
+    if (el instanceof HTMLHeadElement) {
+      const [clean, setClean] = createSignal(false);
+      const cleanup = () => setClean(true);
+      createRoot(dispose => insert(el, () => !clean() ? content() : dispose(), null));
+      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);
+      onCleanup(() => el.removeChild(container));
+    }
+  }, undefined, {
+    render: !hydrating
+  });
+  return marker;
+}
+function createDynamic(component, props) {
+  const cached = createMemo(component);
+  return createMemo(() => {
+    const component = cached();
+    switch (typeof component) {
+      case "function":
+        return untrack(() => component(props));
+      case "string":
+        const isSvg = SVGElements.has(component);
+        const el = sharedConfig.context ? getNextElement() : createElement(component, isSvg, untrack(() => props.is));
+        spread(el, props, isSvg);
+        return el;
+    }
+  });
+}
+function Dynamic(props) {
+  const [, others] = splitProps(props, ["component"]);
+  return createDynamic(() => props.component, others);
+}
+
+export { Aliases, voidFn as Assets, ChildProperties, DOMElements, DelegatedEvents, Dynamic, Hydration, voidFn as HydrationScript, NoHydration, Portal, Properties, RequestContext, SVGElements, SVGNamespace, addEventListener, assign, classList, className, clearDelegatedEvents, createDynamic, delegateEvents, dynamicProperty, escape, voidFn as generateHydrationScript, voidFn as getAssets, getHydrationKey, getNextElement, getNextMarker, getNextMatch, getPropAlias, voidFn as getRequestEvent, hydrate, innerHTML, insert, isDev, isServer, memo, render, renderToStream, renderToString, renderToStringAsync, resolveSSRNode, runHydrationEvents, setAttribute, setAttributeNS, setBoolAttribute, setProperty, setStyleProperty, spread, ssr, ssrAttribute, ssrClassList, ssrElement, ssrHydrationKey, ssrSpread, ssrStyle, style, template, use, voidFn as useAssets };

web/node_modules/solid-js/web/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "solid-js/web",
+  "main": "./dist/server.cjs",
+  "module": "./dist/server.js",
+  "unpkg": "./dist/web.cjs",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "worker": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "browser": {
+        "development": {
+          "types": "./types/index.d.ts",
+          "import": "./dist/dev.js",
+          "require": "./dist/dev.cjs"
+        },
+        "types": "./types/index.d.ts",
+        "import": "./dist/web.js",
+        "require": "./dist/web.cjs"
+      },
+      "deno": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "node": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/server.js",
+        "require": "./dist/server.cjs"
+      },
+      "development": {
+        "types": "./types/index.d.ts",
+        "import": "./dist/dev.js",
+        "require": "./dist/dev.cjs"
+      },
+      "types": "./types/index.d.ts",
+      "import": "./dist/web.js",
+      "require": "./dist/web.cjs"
+    }
+  }
+}

web/node_modules/solid-js/web/storage/dist/storage.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var node_async_hooks = require('node:async_hooks');
+var web = require('solid-js/web');
+
+function provideRequestEvent(init, cb) {
+  if (!web.isServer) throw new Error("Attempting to use server context in non-server build");
+  const ctx = globalThis[web.RequestContext] = globalThis[web.RequestContext] || new node_async_hooks.AsyncLocalStorage();
+  return ctx.run(init, cb);
+}
+
+exports.provideRequestEvent = provideRequestEvent;

web/node_modules/solid-js/web/storage/dist/storage.js

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { isServer, RequestContext } from 'solid-js/web';
+
+function provideRequestEvent(init, cb) {
+  if (!isServer) throw new Error("Attempting to use server context in non-server build");
+  const ctx = globalThis[RequestContext] = globalThis[RequestContext] || new AsyncLocalStorage();
+  return ctx.run(init, cb);
+}
+
+export { provideRequestEvent };

web/node_modules/solid-js/web/storage/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "solid-js/web/storage",
+  "main": "./dist/storage.cjs",
+  "module": "./dist/storage.js",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/storage.js",
+      "require": "./dist/storage.cjs"
+    }
+  }
+}

web/node_modules/solid-js/web/storage/types/index.d.ts

@@ -0,0 +1,2 @@
+import type { RequestEvent } from "solid-js/web";
+export declare function provideRequestEvent<T extends RequestEvent, U>(init: T, cb: () => U): U;

web/node_modules/solid-js/web/types/client.d.ts

@@ -0,0 +1,93 @@
+import { JSX } from "./jsx.js";
+export const Aliases: Record<string, string>;
+export const Properties: Set<string>;
+export const ChildProperties: Set<string>;
+export const DelegatedEvents: Set<string>;
+export const DOMElements: Set<string>;
+export const SVGElements: Set<string>;
+export const SVGNamespace: Record<string, string>;
+export function getPropAlias(prop: string, tagName: string): string | undefined;
+
+type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+export function render(
+  code: () => JSX.Element,
+  element: MountableElement,
+  init?: JSX.Element,
+  options?: { owner?: unknown }
+): () => void;
+export function template(html: string, isCE?: boolean, isSVG?: boolean): () => Element;
+export function effect<T>(fn: (prev?: T) => T, init?: T): void;
+export function memo<T>(fn: () => T, equal: boolean): () => T;
+export function untrack<T>(fn: () => T): T;
+export function insert<T>(
+  parent: MountableElement,
+  accessor: (() => T) | T,
+  marker?: Node | null,
+  init?: JSX.Element
+): JSX.Element;
+export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+export function delegateEvents(eventNames: string[], d?: Document): void;
+export function clearDelegatedEvents(d?: Document): void;
+export function spread<T>(
+  node: Element,
+  accessor: T,
+  isSVG?: Boolean,
+  skipChildren?: Boolean
+): void;
+export function assign(
+  node: Element,
+  props: any,
+  isSVG?: Boolean,
+  skipChildren?: Boolean,
+  prevProps?: any,
+  skipRef?: Boolean
+): void;
+export function setAttribute(node: Element, name: string, value: string): void;
+export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+export function setBoolAttribute(node: Element, name: string, value: any): void;
+export function className(node: Element, value: string): void;
+export function setProperty(node: Element, name: string, value: any): void;
+export function setStyleProperty(node: Element, name: string, value: any): void;
+export function addEventListener(
+  node: Element,
+  name: string,
+  handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions),
+  delegate: boolean
+): void;
+export function classList(
+  node: Element,
+  value: { [k: string]: boolean },
+  prev?: { [k: string]: boolean }
+): { [k: string]: boolean };
+export function style(
+  node: Element,
+  value: { [k: string]: string },
+  prev?: { [k: string]: string }
+): void;
+export function getOwner(): unknown;
+export function mergeProps(...sources: unknown[]): unknown;
+export function dynamicProperty(props: unknown, key: string): unknown;
+export function use<Arg, Ret>(fn: (node: Element, arg: Arg) => Ret, node: Element, arg?: Arg): Ret
+
+export function hydrate(
+  fn: () => JSX.Element,
+  node: MountableElement,
+  options?: { renderId?: string; owner?: unknown }
+): () => void;
+export function getHydrationKey(): string;
+export function getNextElement(template?: () => Element): Element;
+export function getNextMatch(start: Node, elementName: string): Element;
+export function getNextMarker(start: Node): [Node, Array<Node>];
+export function useAssets(fn: () => JSX.Element): void;
+export function getAssets(): string;
+export function HydrationScript(): JSX.Element;
+export function generateHydrationScript(): string;
+export function Assets(props: { children?: JSX.Element }): JSX.Element;
+export function Hydration(props: { children?: JSX.Element }): JSX.Element;
+export function NoHydration(props: { children?: JSX.Element }): JSX.Element;
+export interface RequestEvent {
+  request: Request;
+}
+export declare const RequestContext: unique symbol;
+export function getRequestEvent(): RequestEvent | undefined;
+export function runHydrationEvents(): void;

web/node_modules/solid-js/web/types/core.d.ts

@@ -0,0 +1,2 @@
+export { getOwner, createComponent, createRoot as root, createRenderEffect as effect, sharedConfig, untrack, mergeProps } from "solid-js";
+export declare const memo: (fn: any) => import("solid-js").Accessor<any>;

web/node_modules/solid-js/web/types/index.d.ts

@@ -0,0 +1,50 @@
+import { hydrate as hydrateCore } from "./client.js";
+import { JSX, ComponentProps, ValidComponent } from "solid-js";
+export * from "./client.js";
+export { For, Show, Suspense, SuspenseList, Switch, Match, Index, ErrorBoundary, mergeProps } from "solid-js";
+export * from "./server-mock.js";
+export declare const isServer: boolean;
+export declare const isDev: boolean;
+export declare const hydrate: typeof hydrateCore;
+/**
+ * Renders components somewhere else in the DOM
+ *
+ * Useful for inserting modals and tooltips outside of an cropping layout. If no mount point is given, the portal is inserted in document.body; it is wrapped in a `<div>` unless the target is document.head or `isSVG` is true. setting `useShadow` to true places the element in a shadow root to isolate styles.
+ *
+ * @description https://docs.solidjs.com/reference/components/portal
+ */
+export declare function Portal<T extends boolean = false, S extends boolean = false>(props: {
+    mount?: Node;
+    useShadow?: T;
+    isSVG?: S;
+    ref?: (S extends true ? SVGGElement : HTMLDivElement) | ((el: (T extends true ? {
+        readonly shadowRoot: ShadowRoot;
+    } : {}) & (S extends true ? SVGGElement : HTMLDivElement)) => void);
+    children: JSX.Element;
+}): Text;
+export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
+    [K in keyof P]: P[K];
+} & {
+    component: T | undefined;
+};
+/**
+ * Renders an arbitrary component or element with the given props
+ *
+ * This is a lower level version of the `Dynamic` component, useful for
+ * performance optimizations in libraries. Do not use this unless you know
+ * what you are doing.
+ * ```typescript
+ * const element = () => multiline() ? 'textarea' : 'input';
+ * createDynamic(element, { value: value() });
+ * ```
+ * @description https://docs.solidjs.com/reference/components/dynamic
+ */
+export declare function createDynamic<T extends ValidComponent>(component: () => T | undefined, props: ComponentProps<T>): JSX.Element;
+/**
+ * Renders an arbitrary custom or native component and passes the other props
+ * ```typescript
+ * <Dynamic component={multiline() ? 'textarea' : 'input'} value={value()} />
+ * ```
+ * @description https://docs.solidjs.com/reference/components/dynamic
+ */
+export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX.Element;

web/node_modules/solid-js/web/types/jsx.d.ts

@@ -0,0 +1 @@
+export type { JSX } from "../../types/jsx.js";

web/node_modules/solid-js/web/types/server-mock.d.ts

@@ -0,0 +1,65 @@
+export declare function renderToString<T>(fn: () => T, options?: {
+    nonce?: string;
+    renderId?: string;
+}): string;
+export declare function renderToStringAsync<T>(fn: () => T, options?: {
+    timeoutMs?: number;
+    nonce?: string;
+    renderId?: string;
+}): Promise<string>;
+export declare function renderToStream<T>(fn: () => T, options?: {
+    nonce?: string;
+    renderId?: string;
+    onCompleteShell?: (info: {
+        write: (v: string) => void;
+    }) => void;
+    onCompleteAll?: (info: {
+        write: (v: string) => void;
+    }) => void;
+}): {
+    pipe: (writable: {
+        write: (v: string) => void;
+    }) => void;
+    pipeTo: (writable: WritableStream) => void;
+};
+export declare function ssr(template: string[] | string, ...nodes: any[]): {
+    t: string;
+};
+export declare function ssrElement(name: string, props: any, children: any, needsId: boolean): {
+    t: string;
+};
+export declare function ssrClassList(value: {
+    [k: string]: boolean;
+}): string;
+export declare function ssrStyle(value: {
+    [k: string]: string;
+}): string;
+export declare function ssrAttribute(key: string, value: boolean): string;
+export declare function ssrHydrationKey(): string;
+export declare function resolveSSRNode(node: any): string;
+export declare function escape(html: string): string;
+/**
+ * @deprecated Replaced by ssrElement
+ */
+export declare function ssrSpread(props: any, isSVG: boolean, skipChildren: boolean): void;
+export type LegacyResults = {
+    startWriting: () => void;
+};
+/**
+ * @deprecated Replaced by renderToStream
+ */
+export declare function pipeToWritable<T>(fn: () => T, writable: WritableStream, options?: {
+    nonce?: string;
+    onReady?: (res: LegacyResults) => void;
+    onCompleteAll?: () => void;
+}): void;
+/**
+ * @deprecated Replaced by renderToStream
+ */
+export declare function pipeToNodeWritable<T>(fn: () => T, writable: {
+    write: (v: string) => void;
+}, options?: {
+    nonce?: string;
+    onReady?: (res: LegacyResults) => void;
+    onCompleteAll?: () => void;
+}): void;

web/node_modules/solid-js/web/types/server.d.ts

@@ -0,0 +1,177 @@
+import { JSX } from "./jsx.js";
+export const Aliases: Record<string, string>;
+export const Properties: Set<string>;
+export const ChildProperties: Set<string>;
+export const DelegatedEvents: Set<string>;
+export const DOMElements: Set<string>;
+export const SVGElements: Set<string>;
+export const SVGNamespace: Record<string, string>;
+export function getPropAlias(prop: string, tagName: string): string | undefined;
+
+type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+
+export function renderToString<T>(
+  fn: () => T,
+  options?: {
+    nonce?: string;
+    renderId?: string;
+    onError?: (err: any) => void;
+  }
+): string;
+export function renderToStringAsync<T>(
+  fn: () => T,
+  options?: {
+    timeoutMs?: number;
+    nonce?: string;
+    renderId?: string;
+    noScripts?: boolean;
+    onError?: (err: any) => void;
+  }
+): Promise<string>;
+export function renderToStream<T>(
+  fn: () => T,
+  options?: {
+    nonce?: string;
+    renderId?: string;
+    onCompleteShell?: (info: { write: (v: string) => void }) => void;
+    onCompleteAll?: (info: { write: (v: string) => void }) => void;
+    onError?: (err: any) => void;
+  }
+): {
+  pipe: (writable: { write: (v: string) => void }) => void;
+  pipeTo: (writable: WritableStream) => Promise<void>;
+};
+
+export function HydrationScript(props: { nonce?: string; eventNames?: string[] }): JSX.Element;
+export function ssr(template: string[] | string, ...nodes: any[]): { t: string };
+export function ssrElement(
+  name: string,
+  props: any,
+  children: any,
+  needsId: boolean
+): { t: string };
+export function ssrClassList(value: { [k: string]: boolean }): string;
+export function ssrStyle(value: { [k: string]: string }): string;
+export function ssrAttribute(key: string, value: any, isBoolean: boolean): string;
+export function ssrHydrationKey(): string;
+export function resolveSSRNode(node: any): string;
+export function escape(html: string): string;
+export function useAssets(fn: () => JSX.Element): void;
+export function getAssets(): string;
+export function getHydrationKey(): string;
+export function effect<T>(fn: (prev?: T) => T, init?: T): void;
+export function memo<T>(fn: () => T, equal: boolean): () => T;
+export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+export function mergeProps(...sources: unknown[]): unknown;
+export function getOwner(): unknown;
+export function generateHydrationScript(options: { nonce?: string; eventNames?: string[] }): string;
+export declare const RequestContext: unique symbol;
+export interface RequestEvent {
+  request: Request;
+  locals: Record<string | number | symbol, any>;
+}
+export function getRequestEvent(): RequestEvent | undefined;
+
+export function Hydration(props: { children?: JSX.Element }): JSX.Element;
+export function NoHydration(props: { children?: JSX.Element }): JSX.Element;
+export function Assets(props: { children?: JSX.Element }): JSX.Element;
+
+// deprecated
+export type LegacyResults = {
+  write: (text: string) => void;
+  startWriting: () => void;
+};
+export function pipeToWritable<T>(
+  fn: () => T,
+  writable: WritableStream,
+  options?: {
+    nonce?: string;
+    onReady?: (res: LegacyResults) => void;
+    onCompleteAll?: () => void;
+  }
+): void;
+export function pipeToNodeWritable<T>(
+  fn: () => T,
+  writable: { write: (v: string) => void },
+  options?: {
+    nonce?: string;
+    onReady?: (res: LegacyResults) => void;
+    onCompleteAll?: () => void;
+  }
+): void;
+
+export function untrack<T>(fn: () => T): T;
+
+// client-only APIs
+
+/** @deprecated not supported on the server side */
+export function classList(
+  node: Element,
+  value: { [k: string]: boolean },
+  prev?: { [k: string]: boolean }
+): { [k: string]: boolean };
+
+/** @deprecated not supported on the server side */
+export function style(
+  node: Element,
+  value: { [k: string]: string },
+  prev?: { [k: string]: string }
+): void;
+
+/** @deprecated not supported on the server side */
+export function insert<T>(
+  parent: MountableElement,
+  accessor: (() => T) | T,
+  marker?: Node | null,
+  init?: JSX.Element
+): JSX.Element;
+
+/** @deprecated not supported on the server side */
+export function spread<T>(
+  node: Element,
+  accessor: T,
+  isSVG?: Boolean,
+  skipChildren?: Boolean
+): void;
+
+/** @deprecated not supported on the server side */
+export function delegateEvents(eventNames: string[], d?: Document): void;
+/** @deprecated not supported on the server side */
+export function dynamicProperty(props: unknown, key: string): unknown;
+/** @deprecated not supported on the server side */
+export function setAttribute(node: Element, name: string, value: string): void;
+/** @deprecated not supported on the server side */
+export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+
+/** @deprecated not supported on the server side */
+export function addEventListener(
+  node: Element,
+  name: string,
+  handler: () => void,
+  delegate: boolean
+): void;
+
+/** @deprecated not supported on the server side */
+export function render(code: () => JSX.Element, element: MountableElement): () => void;
+/** @deprecated not supported on the server side */
+export function template(html: string, isCE?: boolean, isSVG?: boolean): () => Element;
+/** @deprecated not supported on the server side */
+export function setProperty(node: Element, name: string, value: any): void;
+/** @deprecated not supported on the server side */
+export function className(node: Element, value: string): void;
+/** @deprecated not supported on the server side */
+export function assign(node: Element, props: any, isSVG?: Boolean, skipChildren?: Boolean): void;
+
+/** @deprecated not supported on the server side */
+export function hydrate(
+  fn: () => JSX.Element,
+  node: MountableElement,
+  options?: { renderId?: string; owner?: unknown }
+): () => void;
+
+/** @deprecated not supported on the server side */
+export function getNextElement(template?: HTMLTemplateElement): Element;
+/** @deprecated not supported on the server side */
+export function getNextMatch(start: Node, elementName: string): Element;
+/** @deprecated not supported on the server side */
+export function getNextMarker(start: Node): [Node, Array<Node>];