FRE-651: CEO coordination notes for founder bio/headshot assets

node_modules/.vite/deps/_metadata.json

@@ -0,0 +1,61 @@
+{
+  "hash": "6f3e0877",
+  "configHash": "197762a3",
+  "lockfileHash": "c625b10d",
+  "browserHash": "d0c1873a",
+  "optimized": {
+    "solid-js": {
+      "src": "../../solid-js/dist/dev.js",
+      "file": "solid-js.js",
+      "fileHash": "3164fc80",
+      "needsInterop": false
+    },
+    "solid-js/web": {
+      "src": "../../solid-js/web/dist/dev.js",
+      "file": "solid-js_web.js",
+      "fileHash": "201f5c79",
+      "needsInterop": false
+    },
+    "solid-js/store": {
+      "src": "../../solid-js/store/dist/dev.js",
+      "file": "solid-js_store.js",
+      "fileHash": "667f0457",
+      "needsInterop": false
+    },
+    "solid-js/html": {
+      "src": "../../solid-js/html/dist/html.js",
+      "file": "solid-js_html.js",
+      "fileHash": "03866eae",
+      "needsInterop": false
+    },
+    "solid-js/h": {
+      "src": "../../solid-js/h/dist/h.js",
+      "file": "solid-js_h.js",
+      "fileHash": "e3a86101",
+      "needsInterop": false
+    },
+    "@clerk/clerk-js": {
+      "src": "../../@clerk/clerk-js/dist/clerk.mjs",
+      "file": "@clerk_clerk-js.js",
+      "fileHash": "4646143d",
+      "needsInterop": false
+    },
+    "@trpc/client": {
+      "src": "../../@trpc/client/dist/index.mjs",
+      "file": "@trpc_client.js",
+      "fileHash": "aef77499",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-C3OSZ7ZC": {
+      "file": "chunk-C3OSZ7ZC.js"
+    },
+    "chunk-P5AEBATJ": {
+      "file": "chunk-P5AEBATJ.js"
+    },
+    "chunk-5Z66FT5C": {
+      "file": "chunk-5Z66FT5C.js"
+    }
+  }
+}

node_modules/.vite/deps/chunk-5Z66FT5C.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+export {
+  __publicField,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __privateWrapper
+};
+//# sourceMappingURL=chunk-5Z66FT5C.js.map

node_modules/.vite/deps/chunk-5Z66FT5C.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

node_modules/.vite/deps/solid-js.js

@@ -0,0 +1,114 @@
+import {
+  $DEVCOMP,
+  $PROXY,
+  $TRACK,
+  DEV,
+  ErrorBoundary,
+  For,
+  Index,
+  Match,
+  Show,
+  Suspense,
+  SuspenseList,
+  Switch,
+  batch,
+  cancelCallback,
+  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
+} from "./chunk-P5AEBATJ.js";
+import "./chunk-5Z66FT5C.js";
+export {
+  $DEVCOMP,
+  $PROXY,
+  $TRACK,
+  DEV,
+  ErrorBoundary,
+  For,
+  Index,
+  Match,
+  Show,
+  Suspense,
+  SuspenseList,
+  Switch,
+  batch,
+  cancelCallback,
+  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
+};
+//# sourceMappingURL=solid-js.js.map

node_modules/.vite/deps/solid-js.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/deps/solid-js_h.js

@@ -0,0 +1,123 @@
+import {
+  SVGElements,
+  assign,
+  dynamicProperty,
+  insert,
+  spread
+} from "./chunk-C3OSZ7ZC.js";
+import {
+  createComponent
+} from "./chunk-P5AEBATJ.js";
+import "./chunk-5Z66FT5C.js";
+
+// node_modules/solid-js/h/dist/h.js
+var $ELEMENT = Symbol("hyper-element");
+function createHyperScript(r) {
+  function h2() {
+    let args = [].slice.call(arguments), e, classes = [], multiExpression = false;
+    while (Array.isArray(args[0])) args = args[0];
+    if (args[0][$ELEMENT]) args.unshift(h2.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 : void 0);
+      } 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 : void 0);
+        }
+      }
+    }
+    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]);
+        }
+      }
+    }
+  }
+  h2.Fragment = (props) => props.children;
+  return h2;
+}
+var h = createHyperScript({
+  spread,
+  assign,
+  insert,
+  createComponent,
+  dynamicProperty,
+  SVGElements
+});
+export {
+  h as default
+};
+//# sourceMappingURL=solid-js_h.js.map

node_modules/.vite/deps/solid-js_h.js.map

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

node_modules/.vite/deps/solid-js_html.js

@@ -0,0 +1,608 @@
+import {
+  Aliases,
+  ChildProperties,
+  DelegatedEvents,
+  Properties,
+  SVGElements,
+  SVGNamespace,
+  addEventListener,
+  classList,
+  delegateEvents,
+  dynamicProperty,
+  getPropAlias,
+  insert,
+  setAttribute,
+  setAttributeNS,
+  spread,
+  style
+} from "./chunk-C3OSZ7ZC.js";
+import {
+  createComponent,
+  createRenderEffect,
+  mergeProps,
+  untrack
+} from "./chunk-P5AEBATJ.js";
+import "./chunk-5Z66FT5C.js";
+
+// node_modules/solid-js/html/dist/html.js
+var tagRE = /(?:<!--[\S\s]*?-->|<(?:"[^"]*"['"]*|'[^']*'['"]*|[^'">])+>)/g;
+var attrRE = /(?:\s(?<boolean>[^/\s><=]+?)(?=[\s/>]))|(?:(?<name>\S+?)(?:\s*=\s*(?:(['"])(?<quotedValue>[\s\S]*?)\3|(?<unquotedValue>[^\s>]+))))/g;
+var 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, html2, start) {
+  const end = html2.indexOf("<", start);
+  const content = html2.slice(start, end === -1 ? void 0 : end);
+  if (!/^\s*$/.test(content)) {
+    list.push({
+      type: "text",
+      content
+    });
+  }
+}
+function pushCommentNode(list, tag) {
+  const content = tag.replace("<!--", "").replace("-->", "");
+  if (!/^\s*$/.test(content)) {
+    list.push({
+      type: "comment",
+      content
+    });
+  }
+}
+function parse(html2) {
+  const result = [];
+  let current = void 0;
+  let level = -1;
+  const arr = [];
+  const byTag = {};
+  html2.replace(tagRE, (tag, index) => {
+    const isOpen = tag.charAt(1) !== "/";
+    const isComment = tag.slice(0, 4) === "<!--";
+    const start = index + tag.length;
+    const nextChar = html2.charAt(start);
+    let parent = void 0;
+    if (isOpen && !isComment) {
+      level++;
+      current = parseTag(tag);
+      if (!current.voidElement && nextChar && nextChar !== "<") {
+        pushTextNode(current.children, html2, 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, html2, 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);
+  }, "");
+}
+var cache = /* @__PURE__ */ new Map();
+var VOID_ELEMENTS = /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i;
+var spaces = " \\f\\n\\r\\t";
+var almostEverything = "[^" + spaces + `\\/>"'=]+`;
+var attrName = "[ " + spaces + "]+(?:use:<!--#-->|" + almostEverything + ")";
+var tagName = "<([A-Za-z$#]+[A-Za-z0-9:_-]*)((?:";
+var attrPartials = `(?:\\s*=\\s*(?:'[^']*?'|"[^"]*?"|\\([^)]*?\\)|<[^>]*?>|` + almostEverything + "))?)";
+var attrSeeker = new RegExp(tagName + attrName + attrPartials + "+)([ " + spaces + "]*/?>)", "g");
+var findAttributes = new RegExp("(" + attrName + `\\s*=\\s*)(<!--#-->|['"(]([\\w\\s]*<!--#-->[\\w\\s]*)*['")])`, "gi");
+var selfClosing = new RegExp(tagName + attrName + attrPartials + "*)([ " + spaces + "]*/>)", "g");
+var marker = "<!--#-->";
+var reservedNameSpaces = /* @__PURE__ */ 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: delegateEvents2 = 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) {
+    var _a;
+    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 [html3, code] = parseTemplate(pars, opt.funcBuilder), templates = [];
+    for (let i2 = 0; i2 < html3.length; i2++) {
+      templates.push(document.createElement("template"));
+      templates[i2].innerHTML = html3[i2];
+      const nomarkers = templates[i2].content.querySelectorAll("script,style");
+      for (let j = 0; j < nomarkers.length; j++) {
+        const d = ((_a = nomarkers[j].firstChild) == null ? void 0 : _a.data) || "";
+        if (d.indexOf(marker) > -1) {
+          const parts = d.split(marker).reduce((memo, p, i3) => {
+            i3 && memo.push("");
+            memo.push(p);
+            return memo;
+          }, []);
+          nomarkers[i2].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 = delegateEvents2 && 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" : ""}) => {
+${childOptions.exprs.join(";\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 i2 = 0; i2 < node.children.length; i2++) {
+        const child = node.children[i2];
+        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 tag2 = `_$el${uuid++}`;
+        const topDecl = !options.decl.length;
+        options.decl.push(topDecl ? "" : `${tag2} = ${options.path}.${options.first ? "firstChild" : "nextSibling"}`);
+        parseDirective(name, value, tag2, 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 childOptions2 = Object.assign({}, options, {
+              first: true,
+              fragment: true,
+              decl: [],
+              exprs: []
+            });
+            processComponent(child, childOptions2);
+            parts.push(childOptions2.exprs[0]);
+            options.counter = childOptions2.counter;
+            options.templateId = childOptions2.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") + `;
+return _$el${id};
+`}}()`);
+          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: /* @__PURE__ */ 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 ? "" : `;
+return _$el${id};
+`))];
+  }
+  function html2(statics, ...args) {
+    const templates = cache.get(statics) || createTemplate(statics, {
+      funcBuilder: functionBuilder
+    });
+    return templates[0].create(templates, args, r);
+  }
+  return html2;
+}
+var html = createHTML({
+  effect: createRenderEffect,
+  style,
+  insert,
+  untrack,
+  spread,
+  createComponent,
+  delegateEvents,
+  classList,
+  mergeProps,
+  dynamicProperty,
+  setAttribute,
+  setAttributeNS,
+  addEventListener,
+  Aliases,
+  getPropAlias,
+  Properties,
+  ChildProperties,
+  DelegatedEvents,
+  SVGElements,
+  SVGNamespace
+});
+export {
+  html as default
+};
+//# sourceMappingURL=solid-js_html.js.map

node_modules/.vite/deps/solid-js_store.js

@@ -0,0 +1,456 @@
+import {
+  $PROXY,
+  $TRACK,
+  DEV,
+  batch,
+  createSignal,
+  getListener
+} from "./chunk-P5AEBATJ.js";
+import "./chunk-5Z66FT5C.js";
+
+// node_modules/solid-js/store/dist/dev.js
+var $RAW = Symbol("store-raw");
+var $NODE = Symbol("store-node");
+var $HAS = Symbol("store-has");
+var $SELF = Symbol("store-self");
+var 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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);
+}
+var 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,
+  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 === void 0) {
+    delete state[property];
+    if (state[$HAS] && state[$HAS][property] && prev !== void 0) state[$HAS][property].$();
+  } else {
+    state[property] = value;
+    if (state[$HAS] && state[$HAS][property] && prev === void 0) 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 === void 0 && value == void 0) return;
+  value = unwrap(value);
+  if (part === void 0 || 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.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;
+}
+var 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, void 0, true));
+    return true;
+  },
+  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.registerGraph({
+    value: unwrappedStore,
+    name: options && options.name
+  });
+  return wrappedStore;
+}
+function modifyMutable(state, modifier) {
+  batch(() => modifier(unwrap(state)));
+}
+var $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 = /* @__PURE__ */ 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 === void 0 ? -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 !== void 0 && 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]] === void 0) setProperty(previous, previousKeys[i], void 0);
+  }
+}
+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 === void 0 ? state : res;
+  };
+}
+var producers = /* @__PURE__ */ new WeakMap();
+var 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, void 0, 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;
+  };
+}
+var DEV2 = {
+  $NODE,
+  isWrappable,
+  hooks: DevHooks
+};
+export {
+  $RAW,
+  DEV2 as DEV,
+  createMutable,
+  createStore,
+  modifyMutable,
+  produce,
+  reconcile,
+  unwrap
+};
+//# sourceMappingURL=solid-js_store.js.map

node_modules/.vite/deps/solid-js_web.js

@@ -0,0 +1,149 @@
+import {
+  Aliases,
+  ChildProperties,
+  DOMElements,
+  DelegatedEvents,
+  Dynamic,
+  Hydration,
+  NoHydration,
+  Portal,
+  Properties,
+  RequestContext,
+  SVGElements,
+  SVGNamespace,
+  addEventListener,
+  assign,
+  classList,
+  className,
+  clearDelegatedEvents,
+  createDynamic,
+  delegateEvents,
+  dynamicProperty,
+  escape,
+  getHydrationKey,
+  getNextElement,
+  getNextMarker,
+  getNextMatch,
+  getPropAlias,
+  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
+} from "./chunk-C3OSZ7ZC.js";
+import {
+  ErrorBoundary,
+  For,
+  Index,
+  Match,
+  Show,
+  Suspense,
+  SuspenseList,
+  Switch,
+  createComponent,
+  createRenderEffect,
+  getOwner,
+  mergeProps,
+  untrack
+} from "./chunk-P5AEBATJ.js";
+import "./chunk-5Z66FT5C.js";
+export {
+  Aliases,
+  voidFn as Assets,
+  ChildProperties,
+  DOMElements,
+  DelegatedEvents,
+  Dynamic,
+  ErrorBoundary,
+  For,
+  Hydration,
+  voidFn as HydrationScript,
+  Index,
+  Match,
+  NoHydration,
+  Portal,
+  Properties,
+  RequestContext,
+  SVGElements,
+  SVGNamespace,
+  Show,
+  Suspense,
+  SuspenseList,
+  Switch,
+  addEventListener,
+  assign,
+  classList,
+  className,
+  clearDelegatedEvents,
+  createComponent,
+  createDynamic,
+  delegateEvents,
+  dynamicProperty,
+  createRenderEffect as effect,
+  escape,
+  voidFn as generateHydrationScript,
+  voidFn as getAssets,
+  getHydrationKey,
+  getNextElement,
+  getNextMarker,
+  getNextMatch,
+  getOwner,
+  getPropAlias,
+  voidFn as getRequestEvent,
+  hydrate,
+  innerHTML,
+  insert,
+  isDev,
+  isServer,
+  memo,
+  mergeProps,
+  render,
+  renderToStream,
+  renderToString,
+  renderToStringAsync,
+  resolveSSRNode,
+  runHydrationEvents,
+  setAttribute,
+  setAttributeNS,
+  setBoolAttribute,
+  setProperty,
+  setStyleProperty,
+  spread,
+  ssr,
+  ssrAttribute,
+  ssrClassList,
+  ssrElement,
+  ssrHydrationKey,
+  ssrSpread,
+  ssrStyle,
+  style,
+  template,
+  untrack,
+  use,
+  voidFn as useAssets
+};
+//# sourceMappingURL=solid-js_web.js.map

node_modules/.vite/deps/solid-js_web.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/vitest/results.json

@@ -1 +1 @@
-{"version":"1.6.1","results":[[":src/lib/collaboration/presence.test.ts",{"duration":17,"failed":true}]]}
+{"version":"1.6.1","results":[[":server/trpc/project-router.test.ts",{"duration":36,"failed":true}],[":server/trpc/character-router.test.ts",{"duration":27,"failed":true}],[":server/trpc/revisions-router.test.ts",{"duration":55,"failed":true}]]}