commit 7508ff67dd20c07d748c4e4c121f15b20f646663 Author: burningtree Date: Sat Feb 11 20:55:49 2023 +0000 deploy: e46f22b7e4a3d4dcde0244d23b8a2a97657cd92b diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000..e69de29 diff --git a/CNAME b/CNAME new file mode 100644 index 0000000..89fd356 --- /dev/null +++ b/CNAME @@ -0,0 +1 @@ +prague.web3privacy.info diff --git a/__data.json b/__data.json new file mode 100644 index 0000000..b29102c --- /dev/null +++ b/__data.json @@ -0,0 +1 @@ +{"type":"data","nodes":[{"type":"data","data":[null],"uses":{}},null]} \ No newline at end of file diff --git a/_app/immutable/assets/_layout-ea040a37.css b/_app/immutable/assets/_layout-ea040a37.css new file mode 100644 index 0000000..ad9027e --- /dev/null +++ b/_app/immutable/assets/_layout-ea040a37.css @@ -0,0 +1,763 @@ +@import url('https://fonts.googleapis.com/css2?family=Ubuntu+Mono&display=swap'); + + +/* +! tailwindcss v3.2.6 | MIT License | https://tailwindcss.com +*/ + +/* +1. Prevent padding and border from affecting element width. (https://github.com/mozdevs/cssremedy/issues/4) +2. Allow adding a border to an element by just adding a border-width. (https://github.com/tailwindcss/tailwindcss/pull/116) +*/ + +*, +::before, +::after { + box-sizing: border-box; /* 1 */ + border-width: 0; /* 2 */ + border-style: solid; /* 2 */ + border-color: #e5e7eb; /* 2 */ +} + +::before, +::after { + --tw-content: ''; +} + +/* +1. Use a consistent sensible line-height in all browsers. +2. Prevent adjustments of font size after orientation changes in iOS. +3. Use a more readable tab size. +4. Use the user's configured `sans` font-family by default. +5. Use the user's configured `sans` font-feature-settings by default. +*/ + +html { + line-height: 1.5; /* 1 */ + -webkit-text-size-adjust: 100%; /* 2 */ + -moz-tab-size: 4; /* 3 */ + -o-tab-size: 4; + tab-size: 4; /* 3 */ + font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; /* 4 */ + font-feature-settings: normal; /* 5 */ +} + +/* +1. Remove the margin in all browsers. +2. Inherit line-height from `html` so users can set them as a class directly on the `html` element. +*/ + +body { + margin: 0; /* 1 */ + line-height: inherit; /* 2 */ +} + +/* +1. Add the correct height in Firefox. +2. Correct the inheritance of border color in Firefox. (https://bugzilla.mozilla.org/show_bug.cgi?id=190655) +3. Ensure horizontal rules are visible by default. +*/ + +hr { + height: 0; /* 1 */ + color: inherit; /* 2 */ + border-top-width: 1px; /* 3 */ +} + +/* +Add the correct text decoration in Chrome, Edge, and Safari. +*/ + +abbr:where([title]) { + -webkit-text-decoration: underline dotted; + text-decoration: underline dotted; +} + +/* +Remove the default font size and weight for headings. +*/ + +h1, +h2, +h3, +h4, +h5, +h6 { + font-size: inherit; + font-weight: inherit; +} + +/* +Reset links to optimize for opt-in styling instead of opt-out. +*/ + +a { + color: inherit; + text-decoration: inherit; +} + +/* +Add the correct font weight in Edge and Safari. +*/ + +b, +strong { + font-weight: bolder; +} + +/* +1. Use the user's configured `mono` font family by default. +2. Correct the odd `em` font sizing in all browsers. +*/ + +code, +kbd, +samp, +pre { + font-family: Ubuntu Mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; /* 1 */ + font-size: 1em; /* 2 */ +} + +/* +Add the correct font size in all browsers. +*/ + +small { + font-size: 80%; +} + +/* +Prevent `sub` and `sup` elements from affecting the line height in all browsers. +*/ + +sub, +sup { + font-size: 75%; + line-height: 0; + position: relative; + vertical-align: baseline; +} + +sub { + bottom: -0.25em; +} + +sup { + top: -0.5em; +} + +/* +1. Remove text indentation from table contents in Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=999088, https://bugs.webkit.org/show_bug.cgi?id=201297) +2. Correct table border color inheritance in all Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=935729, https://bugs.webkit.org/show_bug.cgi?id=195016) +3. Remove gaps between table borders by default. +*/ + +table { + text-indent: 0; /* 1 */ + border-color: inherit; /* 2 */ + border-collapse: collapse; /* 3 */ +} + +/* +1. Change the font styles in all browsers. +2. Remove the margin in Firefox and Safari. +3. Remove default padding in all browsers. +*/ + +button, +input, +optgroup, +select, +textarea { + font-family: inherit; /* 1 */ + font-size: 100%; /* 1 */ + font-weight: inherit; /* 1 */ + line-height: inherit; /* 1 */ + color: inherit; /* 1 */ + margin: 0; /* 2 */ + padding: 0; /* 3 */ +} + +/* +Remove the inheritance of text transform in Edge and Firefox. +*/ + +button, +select { + text-transform: none; +} + +/* +1. Correct the inability to style clickable types in iOS and Safari. +2. Remove default button styles. +*/ + +button, +[type='button'], +[type='reset'], +[type='submit'] { + -webkit-appearance: button; /* 1 */ + background-color: transparent; /* 2 */ + background-image: none; /* 2 */ +} + +/* +Use the modern Firefox focus style for all focusable elements. +*/ + +:-moz-focusring { + outline: auto; +} + +/* +Remove the additional `:invalid` styles in Firefox. (https://github.com/mozilla/gecko-dev/blob/2f9eacd9d3d995c937b4251a5557d95d494c9be1/layout/style/res/forms.css#L728-L737) +*/ + +:-moz-ui-invalid { + box-shadow: none; +} + +/* +Add the correct vertical alignment in Chrome and Firefox. +*/ + +progress { + vertical-align: baseline; +} + +/* +Correct the cursor style of increment and decrement buttons in Safari. +*/ + +::-webkit-inner-spin-button, +::-webkit-outer-spin-button { + height: auto; +} + +/* +1. Correct the odd appearance in Chrome and Safari. +2. Correct the outline style in Safari. +*/ + +[type='search'] { + -webkit-appearance: textfield; /* 1 */ + outline-offset: -2px; /* 2 */ +} + +/* +Remove the inner padding in Chrome and Safari on macOS. +*/ + +::-webkit-search-decoration { + -webkit-appearance: none; +} + +/* +1. Correct the inability to style clickable types in iOS and Safari. +2. Change font properties to `inherit` in Safari. +*/ + +::-webkit-file-upload-button { + -webkit-appearance: button; /* 1 */ + font: inherit; /* 2 */ +} + +/* +Add the correct display in Chrome and Safari. +*/ + +summary { + display: list-item; +} + +/* +Removes the default spacing and border for appropriate elements. +*/ + +blockquote, +dl, +dd, +h1, +h2, +h3, +h4, +h5, +h6, +hr, +figure, +p, +pre { + margin: 0; +} + +fieldset { + margin: 0; + padding: 0; +} + +legend { + padding: 0; +} + +ol, +ul, +menu { + list-style: none; + margin: 0; + padding: 0; +} + +/* +Prevent resizing textareas horizontally by default. +*/ + +textarea { + resize: vertical; +} + +/* +1. Reset the default placeholder opacity in Firefox. (https://github.com/tailwindlabs/tailwindcss/issues/3300) +2. Set the default placeholder color to the user's configured gray 400 color. +*/ + +input::-moz-placeholder, textarea::-moz-placeholder { + opacity: 1; /* 1 */ + color: #9ca3af; /* 2 */ +} + +input::placeholder, +textarea::placeholder { + opacity: 1; /* 1 */ + color: #9ca3af; /* 2 */ +} + +/* +Set the default cursor for buttons. +*/ + +button, +[role="button"] { + cursor: pointer; +} + +/* +Make sure disabled buttons don't get the pointer cursor. +*/ + +:disabled { + cursor: default; +} + +/* +1. Make replaced elements `display: block` by default. (https://github.com/mozdevs/cssremedy/issues/14) +2. Add `vertical-align: middle` to align replaced elements more sensibly by default. (https://github.com/jensimmons/cssremedy/issues/14#issuecomment-634934210) + This can trigger a poorly considered lint error in some tools but is included by design. +*/ + +img, +svg, +video, +canvas, +audio, +iframe, +embed, +object { + display: block; /* 1 */ + vertical-align: middle; /* 2 */ +} + +/* +Constrain images and videos to the parent width and preserve their intrinsic aspect ratio. (https://github.com/mozdevs/cssremedy/issues/14) +*/ + +img, +video { + max-width: 100%; + height: auto; +} + +/* Make elements with the HTML hidden attribute stay hidden by default */ + +[hidden] { + display: none; +} + +*, ::before, ::after{ + --tw-border-spacing-x: 0; + --tw-border-spacing-y: 0; + --tw-translate-x: 0; + --tw-translate-y: 0; + --tw-rotate: 0; + --tw-skew-x: 0; + --tw-skew-y: 0; + --tw-scale-x: 1; + --tw-scale-y: 1; + --tw-pan-x: ; + --tw-pan-y: ; + --tw-pinch-zoom: ; + --tw-scroll-snap-strictness: proximity; + --tw-ordinal: ; + --tw-slashed-zero: ; + --tw-numeric-figure: ; + --tw-numeric-spacing: ; + --tw-numeric-fraction: ; + --tw-ring-inset: ; + --tw-ring-offset-width: 0px; + --tw-ring-offset-color: #fff; + --tw-ring-color: rgb(59 130 246 / 0.5); + --tw-ring-offset-shadow: 0 0 #0000; + --tw-ring-shadow: 0 0 #0000; + --tw-shadow: 0 0 #0000; + --tw-shadow-colored: 0 0 #0000; + --tw-blur: ; + --tw-brightness: ; + --tw-contrast: ; + --tw-grayscale: ; + --tw-hue-rotate: ; + --tw-invert: ; + --tw-saturate: ; + --tw-sepia: ; + --tw-drop-shadow: ; + --tw-backdrop-blur: ; + --tw-backdrop-brightness: ; + --tw-backdrop-contrast: ; + --tw-backdrop-grayscale: ; + --tw-backdrop-hue-rotate: ; + --tw-backdrop-invert: ; + --tw-backdrop-opacity: ; + --tw-backdrop-saturate: ; + --tw-backdrop-sepia: ; +} + +::backdrop{ + --tw-border-spacing-x: 0; + --tw-border-spacing-y: 0; + --tw-translate-x: 0; + --tw-translate-y: 0; + --tw-rotate: 0; + --tw-skew-x: 0; + --tw-skew-y: 0; + --tw-scale-x: 1; + --tw-scale-y: 1; + --tw-pan-x: ; + --tw-pan-y: ; + --tw-pinch-zoom: ; + --tw-scroll-snap-strictness: proximity; + --tw-ordinal: ; + --tw-slashed-zero: ; + --tw-numeric-figure: ; + --tw-numeric-spacing: ; + --tw-numeric-fraction: ; + --tw-ring-inset: ; + --tw-ring-offset-width: 0px; + --tw-ring-offset-color: #fff; + --tw-ring-color: rgb(59 130 246 / 0.5); + --tw-ring-offset-shadow: 0 0 #0000; + --tw-ring-shadow: 0 0 #0000; + --tw-shadow: 0 0 #0000; + --tw-shadow-colored: 0 0 #0000; + --tw-blur: ; + --tw-brightness: ; + --tw-contrast: ; + --tw-grayscale: ; + --tw-hue-rotate: ; + --tw-invert: ; + --tw-saturate: ; + --tw-sepia: ; + --tw-drop-shadow: ; + --tw-backdrop-blur: ; + --tw-backdrop-brightness: ; + --tw-backdrop-contrast: ; + --tw-backdrop-grayscale: ; + --tw-backdrop-hue-rotate: ; + --tw-backdrop-invert: ; + --tw-backdrop-opacity: ; + --tw-backdrop-saturate: ; + --tw-backdrop-sepia: ; +} + +body{ + --tw-bg-opacity: 1; + background-color: rgb(13 17 23 / var(--tw-bg-opacity)); +} + +*{ + font-family: Ubuntu Mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; + --tw-text-opacity: 1; + color: rgb(255 255 255 / var(--tw-text-opacity)); +} + +.middle-pane-medium{ + margin-left: auto; + margin-right: auto; + max-width: 80rem; + padding-left: 1rem; + padding-right: 1rem; +} + +@media (min-width: 1280px){ + + .middle-pane-medium{ + padding-left: 0px; + padding-right: 0px; + } +} + +.middle-pane-big{ + margin-left: auto; + margin-right: auto; + max-width: 1536px; + padding-left: 1rem; + padding-right: 1rem; +} + +@media (min-width: 1536px){ + + .middle-pane-big{ + padding-left: 0px; + padding-right: 0px; + } +} + +.button{ + --tw-bg-opacity: 1; + background-color: rgb(255 255 255 / var(--tw-bg-opacity)); + padding-left: 0.75rem; + padding-right: 0.75rem; + padding-top: 0.375rem; + padding-bottom: 0.375rem; + --tw-text-opacity: 1; + color: rgb(0 0 0 / var(--tw-text-opacity)); +} + +.section-header{ + margin-bottom: 4rem; + font-size: 3rem; + line-height: 1; + font-weight: 700; +} + +.fixed{ + position: fixed; +} + +.relative{ + position: relative; +} + +.mx-auto{ + margin-left: auto; + margin-right: auto; +} + +.mb-4{ + margin-bottom: 1rem; +} + +.mb-48{ + margin-bottom: 12rem; +} + +.mb-8{ + margin-bottom: 2rem; +} + +.mt-4{ + margin-top: 1rem; +} + +.inline-block{ + display: inline-block; +} + +.flex{ + display: flex; +} + +.grid{ + display: grid; +} + +.contents{ + display: contents; +} + +.h-full{ + height: 100%; +} + +.h-screen{ + height: 100vh; +} + +.min-h-screen{ + min-height: 100vh; +} + +.w-1\/2{ + width: 50%; +} + +.w-2\/3{ + width: 66.666667%; +} + +.w-20{ + width: 5rem; +} + +.w-48{ + width: 12rem; +} + +.w-full{ + width: 100%; +} + +.grow{ + flex-grow: 1; +} + +.grid-cols-2{ + grid-template-columns: repeat(2, minmax(0, 1fr)); +} + +.grid-cols-3{ + grid-template-columns: repeat(3, minmax(0, 1fr)); +} + +.items-center{ + align-items: center; +} + +.gap-10{ + gap: 2.5rem; +} + +.gap-4{ + gap: 1rem; +} + +.gap-6{ + gap: 1.5rem; +} + +.border{ + border-width: 1px; +} + +.bg-black{ + --tw-bg-opacity: 1; + background-color: rgb(0 0 0 / var(--tw-bg-opacity)); +} + +.bg-white{ + --tw-bg-opacity: 1; + background-color: rgb(255 255 255 / var(--tw-bg-opacity)); +} + +.px-3{ + padding-left: 0.75rem; + padding-right: 0.75rem; +} + +.px-4{ + padding-left: 1rem; + padding-right: 1rem; +} + +.py-10{ + padding-top: 2.5rem; + padding-bottom: 2.5rem; +} + +.py-32{ + padding-top: 8rem; + padding-bottom: 8rem; +} + +.py-6{ + padding-top: 1.5rem; + padding-bottom: 1.5rem; +} + +.pb-16{ + padding-bottom: 4rem; +} + +.pb-2{ + padding-bottom: 0.5rem; +} + +.pb-20{ + padding-bottom: 5rem; +} + +.pt-20{ + padding-top: 5rem; +} + +.pt-6{ + padding-top: 1.5rem; +} + +.text-center{ + text-align: center; +} + +.text-right{ + text-align: right; +} + +.text-2xl{ + font-size: 1.5rem; + line-height: 2rem; +} + +.text-5xl{ + font-size: 3rem; + line-height: 1; +} + +.text-7xl{ + font-size: 4.5rem; + line-height: 1; +} + +.text-lg{ + font-size: 1.125rem; + line-height: 1.75rem; +} + +.text-xl{ + font-size: 1.25rem; + line-height: 1.75rem; +} + +.font-bold{ + font-weight: 700; +} + +.uppercase{ + text-transform: uppercase; +} + +.text-black{ + --tw-text-opacity: 1; + color: rgb(0 0 0 / var(--tw-text-opacity)); +} + +.underline{ + text-decoration-line: underline; +} + +.hover\:no-underline:hover{ + text-decoration-line: none; +} + +@media (min-width: 768px){ + + .md\:pt-2{ + padding-top: 0.5rem; + } +} \ No newline at end of file diff --git a/_app/immutable/chunks/0-96e52675.js b/_app/immutable/chunks/0-96e52675.js new file mode 100644 index 0000000..0f8e13a --- /dev/null +++ b/_app/immutable/chunks/0-96e52675.js @@ -0,0 +1,6 @@ +import { _ } from "./_layout-505b36c8.js"; +import { default as default2 } from "../components/pages/_layout.svelte-5af7c4a4.js"; +export { + default2 as component, + _ as universal +}; diff --git a/_app/immutable/chunks/1-1cedc3a7.js b/_app/immutable/chunks/1-1cedc3a7.js new file mode 100644 index 0000000..4abb42d --- /dev/null +++ b/_app/immutable/chunks/1-1cedc3a7.js @@ -0,0 +1,4 @@ +import { default as default2 } from "../components/error.svelte-63d63419.js"; +export { + default2 as component +}; diff --git a/_app/immutable/chunks/2-14d5175e.js b/_app/immutable/chunks/2-14d5175e.js new file mode 100644 index 0000000..3b7c075 --- /dev/null +++ b/_app/immutable/chunks/2-14d5175e.js @@ -0,0 +1,4 @@ +import { default as default2 } from "../components/pages/_page.svelte-e1dabd3b.js"; +export { + default2 as component +}; diff --git a/_app/immutable/chunks/_layout-505b36c8.js b/_app/immutable/chunks/_layout-505b36c8.js new file mode 100644 index 0000000..7f5fdd2 --- /dev/null +++ b/_app/immutable/chunks/_layout-505b36c8.js @@ -0,0 +1,38 @@ +const config = { + title: "Web3Privacy Prague 2023", + shortname: "Web3Privacy Prague", + date: "Monday, 5. June 2023", + venue: "X10, Prague", + themes: [ + { title: "Human rights DAOs (pro-privacy)" }, + { title: "Identity (ID)" }, + { title: "Mixnets โ†’ Full-Stack Privacy" }, + { title: "Cryptography" }, + { title: "Tech journalists" }, + { title: "Asian community" }, + { title: "Privacy wars" }, + { title: "Privacy workforce" }, + { title: "Privacy activist's" }, + { title: "R&D (ZK, MPC)" }, + { title: "Network states (with a privacy focus)" }, + { title: "Solarpunk vs Lunarpunk" }, + { title: "Veksl" } + ], + tickets: [ + { title: "Conference ticket" }, + { title: "Party ticket" } + ] +}; +async function load({ params, url, fetch }) { + return { + config + }; +} +const _layout = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + load +}, Symbol.toStringTag, { value: "Module" })); +export { + _layout as _, + load as l +}; diff --git a/_app/immutable/chunks/index-dc145a1c.js b/_app/immutable/chunks/index-dc145a1c.js new file mode 100644 index 0000000..81deadb --- /dev/null +++ b/_app/immutable/chunks/index-dc145a1c.js @@ -0,0 +1,627 @@ +function noop() { +} +function assign(tar, src) { + for (const k in src) + tar[k] = src[k]; + return tar; +} +function run(fn) { + return fn(); +} +function blank_object() { + return /* @__PURE__ */ Object.create(null); +} +function run_all(fns) { + fns.forEach(run); +} +function is_function(thing) { + return typeof thing === "function"; +} +function safe_not_equal(a, b) { + return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function"); +} +let src_url_equal_anchor; +function src_url_equal(element_src, url) { + if (!src_url_equal_anchor) { + src_url_equal_anchor = document.createElement("a"); + } + src_url_equal_anchor.href = url; + return element_src === src_url_equal_anchor.href; +} +function is_empty(obj) { + return Object.keys(obj).length === 0; +} +function subscribe(store, ...callbacks) { + if (store == null) { + return noop; + } + const unsub = store.subscribe(...callbacks); + return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub; +} +function component_subscribe(component, store, callback) { + component.$$.on_destroy.push(subscribe(store, callback)); +} +function create_slot(definition, ctx, $$scope, fn) { + if (definition) { + const slot_ctx = get_slot_context(definition, ctx, $$scope, fn); + return definition[0](slot_ctx); + } +} +function get_slot_context(definition, ctx, $$scope, fn) { + return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx; +} +function get_slot_changes(definition, $$scope, dirty, fn) { + if (definition[2] && fn) { + const lets = definition[2](fn(dirty)); + if ($$scope.dirty === void 0) { + return lets; + } + if (typeof lets === "object") { + const merged = []; + const len = Math.max($$scope.dirty.length, lets.length); + for (let i = 0; i < len; i += 1) { + merged[i] = $$scope.dirty[i] | lets[i]; + } + return merged; + } + return $$scope.dirty | lets; + } + return $$scope.dirty; +} +function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) { + if (slot_changes) { + const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn); + slot.p(slot_context, slot_changes); + } +} +function get_all_dirty_from_scope($$scope) { + if ($$scope.ctx.length > 32) { + const dirty = []; + const length = $$scope.ctx.length / 32; + for (let i = 0; i < length; i++) { + dirty[i] = -1; + } + return dirty; + } + return -1; +} +let is_hydrating = false; +function start_hydrating() { + is_hydrating = true; +} +function end_hydrating() { + is_hydrating = false; +} +function upper_bound(low, high, key, value) { + while (low < high) { + const mid = low + (high - low >> 1); + if (key(mid) <= value) { + low = mid + 1; + } else { + high = mid; + } + } + return low; +} +function init_hydrate(target) { + if (target.hydrate_init) + return; + target.hydrate_init = true; + let children2 = target.childNodes; + if (target.nodeName === "HEAD") { + const myChildren = []; + for (let i = 0; i < children2.length; i++) { + const node = children2[i]; + if (node.claim_order !== void 0) { + myChildren.push(node); + } + } + children2 = myChildren; + } + const m = new Int32Array(children2.length + 1); + const p = new Int32Array(children2.length); + m[0] = -1; + let longest = 0; + for (let i = 0; i < children2.length; i++) { + const current = children2[i].claim_order; + const seqLen = (longest > 0 && children2[m[longest]].claim_order <= current ? longest + 1 : upper_bound(1, longest, (idx) => children2[m[idx]].claim_order, current)) - 1; + p[i] = m[seqLen] + 1; + const newLen = seqLen + 1; + m[newLen] = i; + longest = Math.max(newLen, longest); + } + const lis = []; + const toMove = []; + let last = children2.length - 1; + for (let cur = m[longest] + 1; cur != 0; cur = p[cur - 1]) { + lis.push(children2[cur - 1]); + for (; last >= cur; last--) { + toMove.push(children2[last]); + } + last--; + } + for (; last >= 0; last--) { + toMove.push(children2[last]); + } + lis.reverse(); + toMove.sort((a, b) => a.claim_order - b.claim_order); + for (let i = 0, j = 0; i < toMove.length; i++) { + while (j < lis.length && toMove[i].claim_order >= lis[j].claim_order) { + j++; + } + const anchor = j < lis.length ? lis[j] : null; + target.insertBefore(toMove[i], anchor); + } +} +function append_hydration(target, node) { + if (is_hydrating) { + init_hydrate(target); + if (target.actual_end_child === void 0 || target.actual_end_child !== null && target.actual_end_child.parentNode !== target) { + target.actual_end_child = target.firstChild; + } + while (target.actual_end_child !== null && target.actual_end_child.claim_order === void 0) { + target.actual_end_child = target.actual_end_child.nextSibling; + } + if (node !== target.actual_end_child) { + if (node.claim_order !== void 0 || node.parentNode !== target) { + target.insertBefore(node, target.actual_end_child); + } + } else { + target.actual_end_child = node.nextSibling; + } + } else if (node.parentNode !== target || node.nextSibling !== null) { + target.appendChild(node); + } +} +function insert_hydration(target, node, anchor) { + if (is_hydrating && !anchor) { + append_hydration(target, node); + } else if (node.parentNode !== target || node.nextSibling != anchor) { + target.insertBefore(node, anchor || null); + } +} +function detach(node) { + if (node.parentNode) { + node.parentNode.removeChild(node); + } +} +function destroy_each(iterations, detaching) { + for (let i = 0; i < iterations.length; i += 1) { + if (iterations[i]) + iterations[i].d(detaching); + } +} +function element(name) { + return document.createElement(name); +} +function svg_element(name) { + return document.createElementNS("http://www.w3.org/2000/svg", name); +} +function text(data) { + return document.createTextNode(data); +} +function space() { + return text(" "); +} +function empty() { + return text(""); +} +function attr(node, attribute, value) { + if (value == null) + node.removeAttribute(attribute); + else if (node.getAttribute(attribute) !== value) + node.setAttribute(attribute, value); +} +function children(element2) { + return Array.from(element2.childNodes); +} +function init_claim_info(nodes) { + if (nodes.claim_info === void 0) { + nodes.claim_info = { last_index: 0, total_claimed: 0 }; + } +} +function claim_node(nodes, predicate, processNode, createNode, dontUpdateLastIndex = false) { + init_claim_info(nodes); + const resultNode = (() => { + for (let i = nodes.claim_info.last_index; i < nodes.length; i++) { + const node = nodes[i]; + if (predicate(node)) { + const replacement = processNode(node); + if (replacement === void 0) { + nodes.splice(i, 1); + } else { + nodes[i] = replacement; + } + if (!dontUpdateLastIndex) { + nodes.claim_info.last_index = i; + } + return node; + } + } + for (let i = nodes.claim_info.last_index - 1; i >= 0; i--) { + const node = nodes[i]; + if (predicate(node)) { + const replacement = processNode(node); + if (replacement === void 0) { + nodes.splice(i, 1); + } else { + nodes[i] = replacement; + } + if (!dontUpdateLastIndex) { + nodes.claim_info.last_index = i; + } else if (replacement === void 0) { + nodes.claim_info.last_index--; + } + return node; + } + } + return createNode(); + })(); + resultNode.claim_order = nodes.claim_info.total_claimed; + nodes.claim_info.total_claimed += 1; + return resultNode; +} +function claim_element_base(nodes, name, attributes, create_element) { + return claim_node(nodes, (node) => node.nodeName === name, (node) => { + const remove = []; + for (let j = 0; j < node.attributes.length; j++) { + const attribute = node.attributes[j]; + if (!attributes[attribute.name]) { + remove.push(attribute.name); + } + } + remove.forEach((v) => node.removeAttribute(v)); + return void 0; + }, () => create_element(name)); +} +function claim_element(nodes, name, attributes) { + return claim_element_base(nodes, name, attributes, element); +} +function claim_svg_element(nodes, name, attributes) { + return claim_element_base(nodes, name, attributes, svg_element); +} +function claim_text(nodes, data) { + return claim_node( + nodes, + (node) => node.nodeType === 3, + (node) => { + const dataStr = "" + data; + if (node.data.startsWith(dataStr)) { + if (node.data.length !== dataStr.length) { + return node.splitText(dataStr.length); + } + } else { + node.data = dataStr; + } + }, + () => text(data), + true + // Text nodes should not update last index since it is likely not worth it to eliminate an increasing subsequence of actual elements + ); +} +function claim_space(nodes) { + return claim_text(nodes, " "); +} +function set_data(text2, data) { + data = "" + data; + if (text2.wholeText !== data) + text2.data = data; +} +function set_style(node, key, value, important) { + if (value === null) { + node.style.removeProperty(key); + } else { + node.style.setProperty(key, value, important ? "important" : ""); + } +} +function head_selector(nodeId, head) { + const result = []; + let started = 0; + for (const node of head.childNodes) { + if (node.nodeType === 8) { + const comment = node.textContent.trim(); + if (comment === `HEAD_${nodeId}_END`) { + started -= 1; + result.push(node); + } else if (comment === `HEAD_${nodeId}_START`) { + started += 1; + result.push(node); + } + } else if (started > 0) { + result.push(node); + } + } + return result; +} +function construct_svelte_component(component, props) { + return new component(props); +} +let current_component; +function set_current_component(component) { + current_component = component; +} +function get_current_component() { + if (!current_component) + throw new Error("Function called outside component initialization"); + return current_component; +} +function onMount(fn) { + get_current_component().$$.on_mount.push(fn); +} +function afterUpdate(fn) { + get_current_component().$$.after_update.push(fn); +} +const dirty_components = []; +const binding_callbacks = []; +const render_callbacks = []; +const flush_callbacks = []; +const resolved_promise = Promise.resolve(); +let update_scheduled = false; +function schedule_update() { + if (!update_scheduled) { + update_scheduled = true; + resolved_promise.then(flush); + } +} +function tick() { + schedule_update(); + return resolved_promise; +} +function add_render_callback(fn) { + render_callbacks.push(fn); +} +const seen_callbacks = /* @__PURE__ */ new Set(); +let flushidx = 0; +function flush() { + if (flushidx !== 0) { + return; + } + const saved_component = current_component; + do { + try { + while (flushidx < dirty_components.length) { + const component = dirty_components[flushidx]; + flushidx++; + set_current_component(component); + update(component.$$); + } + } catch (e) { + dirty_components.length = 0; + flushidx = 0; + throw e; + } + set_current_component(null); + dirty_components.length = 0; + flushidx = 0; + while (binding_callbacks.length) + binding_callbacks.pop()(); + for (let i = 0; i < render_callbacks.length; i += 1) { + const callback = render_callbacks[i]; + if (!seen_callbacks.has(callback)) { + seen_callbacks.add(callback); + callback(); + } + } + render_callbacks.length = 0; + } while (dirty_components.length); + while (flush_callbacks.length) { + flush_callbacks.pop()(); + } + update_scheduled = false; + seen_callbacks.clear(); + set_current_component(saved_component); +} +function update($$) { + if ($$.fragment !== null) { + $$.update(); + run_all($$.before_update); + const dirty = $$.dirty; + $$.dirty = [-1]; + $$.fragment && $$.fragment.p($$.ctx, dirty); + $$.after_update.forEach(add_render_callback); + } +} +const outroing = /* @__PURE__ */ new Set(); +let outros; +function group_outros() { + outros = { + r: 0, + c: [], + p: outros + // parent group + }; +} +function check_outros() { + if (!outros.r) { + run_all(outros.c); + } + outros = outros.p; +} +function transition_in(block, local) { + if (block && block.i) { + outroing.delete(block); + block.i(local); + } +} +function transition_out(block, local, detach2, callback) { + if (block && block.o) { + if (outroing.has(block)) + return; + outroing.add(block); + outros.c.push(() => { + outroing.delete(block); + if (callback) { + if (detach2) + block.d(1); + callback(); + } + }); + block.o(local); + } else if (callback) { + callback(); + } +} +function create_component(block) { + block && block.c(); +} +function claim_component(block, parent_nodes) { + block && block.l(parent_nodes); +} +function mount_component(component, target, anchor, customElement) { + const { fragment, after_update } = component.$$; + fragment && fragment.m(target, anchor); + if (!customElement) { + add_render_callback(() => { + const new_on_destroy = component.$$.on_mount.map(run).filter(is_function); + if (component.$$.on_destroy) { + component.$$.on_destroy.push(...new_on_destroy); + } else { + run_all(new_on_destroy); + } + component.$$.on_mount = []; + }); + } + after_update.forEach(add_render_callback); +} +function destroy_component(component, detaching) { + const $$ = component.$$; + if ($$.fragment !== null) { + run_all($$.on_destroy); + $$.fragment && $$.fragment.d(detaching); + $$.on_destroy = $$.fragment = null; + $$.ctx = []; + } +} +function make_dirty(component, i) { + if (component.$$.dirty[0] === -1) { + dirty_components.push(component); + schedule_update(); + component.$$.dirty.fill(0); + } + component.$$.dirty[i / 31 | 0] |= 1 << i % 31; +} +function init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) { + const parent_component = current_component; + set_current_component(component); + const $$ = component.$$ = { + fragment: null, + ctx: [], + // state + props, + update: noop, + not_equal, + bound: blank_object(), + // lifecycle + on_mount: [], + on_destroy: [], + on_disconnect: [], + before_update: [], + after_update: [], + context: new Map(options.context || (parent_component ? parent_component.$$.context : [])), + // everything else + callbacks: blank_object(), + dirty, + skip_bound: false, + root: options.target || parent_component.$$.root + }; + append_styles && append_styles($$.root); + let ready = false; + $$.ctx = instance ? instance(component, options.props || {}, (i, ret, ...rest) => { + const value = rest.length ? rest[0] : ret; + if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) { + if (!$$.skip_bound && $$.bound[i]) + $$.bound[i](value); + if (ready) + make_dirty(component, i); + } + return ret; + }) : []; + $$.update(); + ready = true; + run_all($$.before_update); + $$.fragment = create_fragment ? create_fragment($$.ctx) : false; + if (options.target) { + if (options.hydrate) { + start_hydrating(); + const nodes = children(options.target); + $$.fragment && $$.fragment.l(nodes); + nodes.forEach(detach); + } else { + $$.fragment && $$.fragment.c(); + } + if (options.intro) + transition_in(component.$$.fragment); + mount_component(component, options.target, options.anchor, options.customElement); + end_hydrating(); + flush(); + } + set_current_component(parent_component); +} +class SvelteComponent { + $destroy() { + destroy_component(this, 1); + this.$destroy = noop; + } + $on(type, callback) { + if (!is_function(callback)) { + return noop; + } + const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []); + callbacks.push(callback); + return () => { + const index = callbacks.indexOf(callback); + if (index !== -1) + callbacks.splice(index, 1); + }; + } + $set($$props) { + if (this.$$set && !is_empty($$props)) { + this.$$.skip_bound = true; + this.$$set($$props); + this.$$.skip_bound = false; + } + } +} +export { + destroy_component as A, + tick as B, + noop as C, + create_slot as D, + svg_element as E, + claim_svg_element as F, + src_url_equal as G, + append_hydration as H, + update_slot_base as I, + get_all_dirty_from_scope as J, + get_slot_changes as K, + destroy_each as L, + component_subscribe as M, + head_selector as N, + SvelteComponent as S, + space as a, + insert_hydration as b, + claim_space as c, + check_outros as d, + empty as e, + transition_in as f, + group_outros as g, + detach as h, + init as i, + afterUpdate as j, + element as k, + claim_element as l, + children as m, + attr as n, + onMount as o, + set_style as p, + text as q, + claim_text as r, + safe_not_equal as s, + transition_out as t, + set_data as u, + binding_callbacks as v, + construct_svelte_component as w, + create_component as x, + claim_component as y, + mount_component as z +}; diff --git a/_app/immutable/chunks/singletons-57b7ce3e.js b/_app/immutable/chunks/singletons-57b7ce3e.js new file mode 100644 index 0000000..b11dd5c --- /dev/null +++ b/_app/immutable/chunks/singletons-57b7ce3e.js @@ -0,0 +1,227 @@ +import { C as noop, s as safe_not_equal } from "./index-dc145a1c.js"; +const subscriber_queue = []; +function writable(value, start = noop) { + let stop; + const subscribers = /* @__PURE__ */ new Set(); + function set(new_value) { + if (safe_not_equal(value, new_value)) { + value = new_value; + if (stop) { + const run_queue = !subscriber_queue.length; + for (const subscriber of subscribers) { + subscriber[1](); + subscriber_queue.push(subscriber, value); + } + if (run_queue) { + for (let i = 0; i < subscriber_queue.length; i += 2) { + subscriber_queue[i][0](subscriber_queue[i + 1]); + } + subscriber_queue.length = 0; + } + } + } + } + function update(fn) { + set(fn(value)); + } + function subscribe(run, invalidate = noop) { + const subscriber = [run, invalidate]; + subscribers.add(subscriber); + if (subscribers.size === 1) { + stop = start(set) || noop; + } + run(value); + return () => { + subscribers.delete(subscriber); + if (subscribers.size === 0) { + stop(); + stop = null; + } + }; + } + return { set, update, subscribe }; +} +const base = ""; +let assets = base; +function set_assets(path) { + assets = path; +} +let version = ""; +function set_version(value) { + version = value; +} +const SNAPSHOT_KEY = "sveltekit:snapshot"; +const SCROLL_KEY = "sveltekit:scroll"; +const INDEX_KEY = "sveltekit:index"; +const PRELOAD_PRIORITIES = ( + /** @type {const} */ + { + tap: 1, + hover: 2, + viewport: 3, + eager: 4, + off: -1 + } +); +function get_base_uri(doc) { + let baseURI = doc.baseURI; + if (!baseURI) { + const baseTags = doc.getElementsByTagName("base"); + baseURI = baseTags.length ? baseTags[0].href : doc.URL; + } + return baseURI; +} +function scroll_state() { + return { + x: pageXOffset, + y: pageYOffset + }; +} +function link_option(element, name) { + const value = ( + /** @type {ValidLinkOptions | null} */ + element.getAttribute(`data-sveltekit-${name}`) + ); + return value; +} +const levels = { + ...PRELOAD_PRIORITIES, + "": PRELOAD_PRIORITIES.hover +}; +function parent_element(element) { + let parent = element.assignedSlot ?? element.parentNode; + if ((parent == null ? void 0 : parent.nodeType) === 11) + parent = parent.host; + return ( + /** @type {Element} */ + parent + ); +} +function find_anchor(element, target) { + while (element && element !== target) { + if (element.nodeName.toUpperCase() === "A" && element.hasAttribute("href")) { + return ( + /** @type {HTMLAnchorElement | SVGAElement} */ + element + ); + } + element = /** @type {Element} */ + parent_element(element); + } +} +function get_link_info(a, base2) { + let url; + try { + url = new URL(a instanceof SVGAElement ? a.href.baseVal : a.href, document.baseURI); + } catch { + } + const target = a instanceof SVGAElement ? a.target.baseVal : a.target; + const external = !url || !!target || is_external_url(url, base2) || (a.getAttribute("rel") || "").split(/\s+/).includes("external") || a.hasAttribute("download"); + return { url, external, target }; +} +function get_router_options(element) { + let noscroll = null; + let preload_code = null; + let preload_data = null; + let reload = null; + let el = element; + while (el && el !== document.documentElement) { + if (preload_code === null) + preload_code = link_option(el, "preload-code"); + if (preload_data === null) + preload_data = link_option(el, "preload-data"); + if (noscroll === null) + noscroll = link_option(el, "noscroll"); + if (reload === null) + reload = link_option(el, "reload"); + el = /** @type {Element} */ + parent_element(el); + } + return { + preload_code: levels[preload_code ?? "off"], + preload_data: levels[preload_data ?? "off"], + noscroll: noscroll === "off" ? false : noscroll === "" ? true : null, + reload: reload === "off" ? false : reload === "" ? true : null + }; +} +function notifiable_store(value) { + const store = writable(value); + let ready = true; + function notify() { + ready = true; + store.update((val) => val); + } + function set(new_value) { + ready = false; + store.set(new_value); + } + function subscribe(run) { + let old_value; + return store.subscribe((new_value) => { + if (old_value === void 0 || ready && new_value !== old_value) { + run(old_value = new_value); + } + }); + } + return { notify, set, subscribe }; +} +function create_updated_store() { + const { set, subscribe } = writable(false); + let timeout; + async function check() { + clearTimeout(timeout); + const res = await fetch(`${assets}/${"_app/version.json"}`, { + headers: { + pragma: "no-cache", + "cache-control": "no-cache" + } + }); + if (res.ok) { + const data = await res.json(); + const updated = data.version !== version; + if (updated) { + set(true); + clearTimeout(timeout); + } + return updated; + } else { + throw new Error(`Version check failed: ${res.status}`); + } + } + return { + subscribe, + check + }; +} +function is_external_url(url, base2) { + return url.origin !== location.origin || !url.pathname.startsWith(base2); +} +function init(opts) { + opts.client; +} +const stores = { + url: notifiable_store({}), + page: notifiable_store({}), + navigating: writable( + /** @type {import('types').Navigation | null} */ + null + ), + updated: create_updated_store() +}; +export { + INDEX_KEY as I, + PRELOAD_PRIORITIES as P, + SCROLL_KEY as S, + SNAPSHOT_KEY as a, + get_link_info as b, + get_router_options as c, + scroll_state as d, + base as e, + find_anchor as f, + get_base_uri as g, + init as h, + is_external_url as i, + set_assets as j, + set_version as k, + stores as s +}; diff --git a/_app/immutable/components/error.svelte-63d63419.js b/_app/immutable/components/error.svelte-63d63419.js new file mode 100644 index 0000000..a69ce8a --- /dev/null +++ b/_app/immutable/components/error.svelte-63d63419.js @@ -0,0 +1,99 @@ +import { S as SvelteComponent, i as init, s as safe_not_equal, k as element, q as text, a as space, l as claim_element, m as children, r as claim_text, h as detach, c as claim_space, b as insert_hydration, H as append_hydration, u as set_data, C as noop, M as component_subscribe } from "../chunks/index-dc145a1c.js"; +import { s as stores } from "../chunks/singletons-57b7ce3e.js"; +const getStores = () => { + const stores$1 = stores; + return { + page: { + subscribe: stores$1.page.subscribe + }, + navigating: { + subscribe: stores$1.navigating.subscribe + }, + updated: stores$1.updated + }; +}; +const page = { + /** @param {(value: any) => void} fn */ + subscribe(fn) { + const store = getStores().page; + return store.subscribe(fn); + } +}; +function create_fragment(ctx) { + var _a; + let h1; + let t0_value = ( + /*$page*/ + ctx[0].status + "" + ); + let t0; + let t1; + let p; + let t2_value = ( + /*$page*/ + ((_a = ctx[0].error) == null ? void 0 : _a.message) + "" + ); + let t2; + return { + c() { + h1 = element("h1"); + t0 = text(t0_value); + t1 = space(); + p = element("p"); + t2 = text(t2_value); + }, + l(nodes) { + h1 = claim_element(nodes, "H1", {}); + var h1_nodes = children(h1); + t0 = claim_text(h1_nodes, t0_value); + h1_nodes.forEach(detach); + t1 = claim_space(nodes); + p = claim_element(nodes, "P", {}); + var p_nodes = children(p); + t2 = claim_text(p_nodes, t2_value); + p_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, h1, anchor); + append_hydration(h1, t0); + insert_hydration(target, t1, anchor); + insert_hydration(target, p, anchor); + append_hydration(p, t2); + }, + p(ctx2, [dirty]) { + var _a2; + if (dirty & /*$page*/ + 1 && t0_value !== (t0_value = /*$page*/ + ctx2[0].status + "")) + set_data(t0, t0_value); + if (dirty & /*$page*/ + 1 && t2_value !== (t2_value = /*$page*/ + ((_a2 = ctx2[0].error) == null ? void 0 : _a2.message) + "")) + set_data(t2, t2_value); + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(h1); + if (detaching) + detach(t1); + if (detaching) + detach(p); + } + }; +} +function instance($$self, $$props, $$invalidate) { + let $page; + component_subscribe($$self, page, ($$value) => $$invalidate(0, $page = $$value)); + return [$page]; +} +let Error$1 = class Error extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance, create_fragment, safe_not_equal, {}); + } +}; +export { + Error$1 as default +}; diff --git a/_app/immutable/components/pages/_layout.svelte-5af7c4a4.js b/_app/immutable/components/pages/_layout.svelte-5af7c4a4.js new file mode 100644 index 0000000..3840b8f --- /dev/null +++ b/_app/immutable/components/pages/_layout.svelte-5af7c4a4.js @@ -0,0 +1,503 @@ +import { S as SvelteComponent, i as init, s as safe_not_equal, D as create_slot, k as element, a as space, q as text, E as svg_element, l as claim_element, m as children, h as detach, c as claim_space, r as claim_text, F as claim_svg_element, G as src_url_equal, n as attr, b as insert_hydration, H as append_hydration, u as set_data, I as update_slot_base, J as get_all_dirty_from_scope, K as get_slot_changes, f as transition_in, t as transition_out, L as destroy_each, C as noop } from "../../chunks/index-dc145a1c.js"; +const app = ""; +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[4] = list[i]; + return child_ctx; +} +function create_each_block(ctx) { + let div; + let a; + let t_value = ( + /*mi*/ + ctx[4].title + "" + ); + let t; + return { + c() { + div = element("div"); + a = element("a"); + t = text(t_value); + this.h(); + }, + l(nodes) { + div = claim_element(nodes, "DIV", { class: true }); + var div_nodes = children(div); + a = claim_element(div_nodes, "A", { href: true }); + var a_nodes = children(a); + t = claim_text(a_nodes, t_value); + a_nodes.forEach(detach); + div_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + a, + "href", + /*mi*/ + ctx[4].url + ); + attr( + div, + "class", + /*mi*/ + ctx[4].class + ); + }, + m(target, anchor) { + insert_hydration(target, div, anchor); + append_hydration(div, a); + append_hydration(a, t); + }, + p: noop, + d(detaching) { + if (detaching) + detach(div); + } + }; +} +function create_fragment(ctx) { + let div21; + let div12; + let div5; + let div4; + let div3; + let div1; + let div0; + let a0; + let img0; + let img0_src_value; + let t0; + let div2; + let t1; + let div11; + let div10; + let div9; + let div6; + let t2_value = ( + /*data*/ + ctx[0].config.shortname + "" + ); + let t2; + let t3; + let div7; + let t4_value = ( + /*data*/ + ctx[0].config.date + "" + ); + let t4; + let t5; + let div8; + let t6_value = ( + /*data*/ + ctx[0].config.venue + "" + ); + let t6; + let t7; + let t8; + let div20; + let div19; + let div18; + let div14; + let div13; + let a1; + let img1; + let img1_src_value; + let t9; + let div17; + let div15; + let a2; + let svg; + let path; + let t10; + let div16; + let t11; + let a3; + let t12; + let t13; + let current; + let each_value = ( + /*menu*/ + ctx[1] + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); + } + const default_slot_template = ( + /*#slots*/ + ctx[3].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ); + return { + c() { + div21 = element("div"); + div12 = element("div"); + div5 = element("div"); + div4 = element("div"); + div3 = element("div"); + div1 = element("div"); + div0 = element("div"); + a0 = element("a"); + img0 = element("img"); + t0 = space(); + div2 = element("div"); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + t1 = space(); + div11 = element("div"); + div10 = element("div"); + div9 = element("div"); + div6 = element("div"); + t2 = text(t2_value); + t3 = space(); + div7 = element("div"); + t4 = text(t4_value); + t5 = space(); + div8 = element("div"); + t6 = text(t6_value); + t7 = space(); + if (default_slot) + default_slot.c(); + t8 = space(); + div20 = element("div"); + div19 = element("div"); + div18 = element("div"); + div14 = element("div"); + div13 = element("div"); + a1 = element("a"); + img1 = element("img"); + t9 = space(); + div17 = element("div"); + div15 = element("div"); + a2 = element("a"); + svg = svg_element("svg"); + path = svg_element("path"); + t10 = space(); + div16 = element("div"); + t11 = text("๐Ÿ’› Organized by "); + a3 = element("a"); + t12 = text("ETHBrno"); + t13 = text(" team"); + this.h(); + }, + l(nodes) { + div21 = claim_element(nodes, "DIV", { class: true }); + var div21_nodes = children(div21); + div12 = claim_element(div21_nodes, "DIV", { class: true }); + var div12_nodes = children(div12); + div5 = claim_element(div12_nodes, "DIV", { class: true }); + var div5_nodes = children(div5); + div4 = claim_element(div5_nodes, "DIV", { class: true }); + var div4_nodes = children(div4); + div3 = claim_element(div4_nodes, "DIV", { class: true }); + var div3_nodes = children(div3); + div1 = claim_element(div3_nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + div0 = claim_element(div1_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + a0 = claim_element(div0_nodes, "A", { href: true }); + var a0_nodes = children(a0); + img0 = claim_element(a0_nodes, "IMG", { src: true }); + a0_nodes.forEach(detach); + div0_nodes.forEach(detach); + div1_nodes.forEach(detach); + t0 = claim_space(div3_nodes); + div2 = claim_element(div3_nodes, "DIV", { class: true }); + var div2_nodes = children(div2); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(div2_nodes); + } + div2_nodes.forEach(detach); + div3_nodes.forEach(detach); + div4_nodes.forEach(detach); + div5_nodes.forEach(detach); + t1 = claim_space(div12_nodes); + div11 = claim_element(div12_nodes, "DIV", { class: true }); + var div11_nodes = children(div11); + div10 = claim_element(div11_nodes, "DIV", { class: true }); + var div10_nodes = children(div10); + div9 = claim_element(div10_nodes, "DIV", { class: true }); + var div9_nodes = children(div9); + div6 = claim_element(div9_nodes, "DIV", { class: true }); + var div6_nodes = children(div6); + t2 = claim_text(div6_nodes, t2_value); + div6_nodes.forEach(detach); + t3 = claim_space(div9_nodes); + div7 = claim_element(div9_nodes, "DIV", { class: true }); + var div7_nodes = children(div7); + t4 = claim_text(div7_nodes, t4_value); + div7_nodes.forEach(detach); + t5 = claim_space(div9_nodes); + div8 = claim_element(div9_nodes, "DIV", { class: true }); + var div8_nodes = children(div8); + t6 = claim_text(div8_nodes, t6_value); + div8_nodes.forEach(detach); + div9_nodes.forEach(detach); + div10_nodes.forEach(detach); + div11_nodes.forEach(detach); + div12_nodes.forEach(detach); + t7 = claim_space(div21_nodes); + if (default_slot) + default_slot.l(div21_nodes); + t8 = claim_space(div21_nodes); + div20 = claim_element(div21_nodes, "DIV", { class: true }); + var div20_nodes = children(div20); + div19 = claim_element(div20_nodes, "DIV", { class: true }); + var div19_nodes = children(div19); + div18 = claim_element(div19_nodes, "DIV", { class: true }); + var div18_nodes = children(div18); + div14 = claim_element(div18_nodes, "DIV", { class: true }); + var div14_nodes = children(div14); + div13 = claim_element(div14_nodes, "DIV", { class: true }); + var div13_nodes = children(div13); + a1 = claim_element(div13_nodes, "A", { href: true }); + var a1_nodes = children(a1); + img1 = claim_element(a1_nodes, "IMG", { src: true }); + a1_nodes.forEach(detach); + div13_nodes.forEach(detach); + div14_nodes.forEach(detach); + t9 = claim_space(div18_nodes); + div17 = claim_element(div18_nodes, "DIV", { class: true }); + var div17_nodes = children(div17); + div15 = claim_element(div17_nodes, "DIV", { class: true }); + var div15_nodes = children(div15); + a2 = claim_element(div15_nodes, "A", { href: true }); + var a2_nodes = children(a2); + svg = claim_svg_element(a2_nodes, "svg", { + width: true, + height: true, + viewBox: true, + fill: true, + xmlns: true + }); + var svg_nodes = children(svg); + path = claim_svg_element(svg_nodes, "path", { d: true, fill: true }); + children(path).forEach(detach); + svg_nodes.forEach(detach); + a2_nodes.forEach(detach); + div15_nodes.forEach(detach); + t10 = claim_space(div17_nodes); + div16 = claim_element(div17_nodes, "DIV", { class: true }); + var div16_nodes = children(div16); + t11 = claim_text(div16_nodes, "๐Ÿ’› Organized by "); + a3 = claim_element(div16_nodes, "A", { href: true, class: true }); + var a3_nodes = children(a3); + t12 = claim_text(a3_nodes, "ETHBrno"); + a3_nodes.forEach(detach); + t13 = claim_text(div16_nodes, " team"); + div16_nodes.forEach(detach); + div17_nodes.forEach(detach); + div18_nodes.forEach(detach); + div19_nodes.forEach(detach); + div20_nodes.forEach(detach); + div21_nodes.forEach(detach); + this.h(); + }, + h() { + if (!src_url_equal(img0.src, img0_src_value = "/web3privacy.png")) + attr(img0, "src", img0_src_value); + attr(a0, "href", "https://web3privacy.info"); + attr(div0, "class", "w-20"); + attr(div1, "class", "flex items-center gap-4 grow"); + attr(div2, "class", "flex items-center gap-6 uppercase text-xl"); + attr(div3, "class", "flex"); + attr(div4, "class", "middle-pane-big bg-black"); + attr(div5, "class", "fixed w-full h-18 bg-black pt-6 md:pt-2 pb-2"); + attr(div6, "class", "text-7xl font-bold uppercase mb-8"); + attr(div7, "class", "text-5xl mb-4"); + attr(div8, "class", "text-5xl"); + attr(div9, "class", "mx-auto"); + attr(div10, "class", "w-full h-full flex items-center text-center"); + attr(div11, "class", "w-full h-full"); + attr(div12, "class", "w-full h-screen"); + if (!src_url_equal(img1.src, img1_src_value = "/web3privacy.png")) + attr(img1, "src", img1_src_value); + attr(a1, "href", "https://web3privacy.info"); + attr(div13, "class", "w-48"); + attr(div14, "class", "grow"); + attr(path, "d", "M28.0266 3.12733C26.9955 3.62938 25.8872 3.96853 24.7242 4.12112C25.9113 3.34005 26.8231 2.10325 27.2524 0.629411C26.1413 1.35279 24.9107 1.87791 23.6009 2.16092C22.5522 0.934264 21.0578 0.167969 19.4039 0.167969C16.2285 0.167969 13.6538 2.99367 13.6538 6.47907C13.6538 6.97373 13.7047 7.45548 13.8028 7.91738C9.02398 7.6542 4.78719 5.14151 1.95117 1.3231C1.45622 2.25521 1.17259 3.33929 1.17259 4.49596C1.17259 6.68564 2.18771 8.61738 3.73058 9.74913C2.78804 9.71637 1.90142 9.43244 1.1262 8.95977C1.12555 8.98607 1.12555 9.01252 1.12555 9.03913C1.12555 12.0969 3.1076 14.6476 5.73804 15.2278C5.25556 15.3721 4.74758 15.4491 4.2232 15.4491C3.85268 15.4491 3.49255 15.4095 3.14137 15.3359C3.87315 17.8432 5.99658 19.6679 8.51282 19.7187C6.54493 21.4115 4.06569 22.4206 1.37163 22.4206C0.907503 22.4206 0.449828 22.3906 0 22.3323C2.54468 24.1231 5.56708 25.168 8.81424 25.168C19.3905 25.168 25.1742 15.5511 25.1742 7.21076C25.1742 6.93712 25.1686 6.66503 25.1576 6.39416C26.2809 5.50451 27.2556 4.39306 28.0265 3.12733H28.0266Z"); + attr(path, "fill", "white"); + attr(svg, "width", "29"); + attr(svg, "height", "26"); + attr(svg, "viewBox", "0 0 29 26"); + attr(svg, "fill", "none"); + attr(svg, "xmlns", "http://www.w3.org/2000/svg"); + attr(a2, "href", "https://twitter.com/web3privacy"); + attr(div15, "class", "inline-block"); + attr(a3, "href", "https://ethbrno.cz"); + attr(a3, "class", "underline hover:no-underline"); + attr(div16, "class", "mt-4"); + attr(div17, "class", "text-right"); + attr(div18, "class", "flex items-center"); + attr(div19, "class", "middle-pane-medium pt-6 mx-auto"); + attr(div20, "class", "pb-16 bg-black"); + attr(div21, "class", "relative w-full min-h-screen"); + }, + m(target, anchor) { + insert_hydration(target, div21, anchor); + append_hydration(div21, div12); + append_hydration(div12, div5); + append_hydration(div5, div4); + append_hydration(div4, div3); + append_hydration(div3, div1); + append_hydration(div1, div0); + append_hydration(div0, a0); + append_hydration(a0, img0); + append_hydration(div3, t0); + append_hydration(div3, div2); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(div2, null); + } + append_hydration(div12, t1); + append_hydration(div12, div11); + append_hydration(div11, div10); + append_hydration(div10, div9); + append_hydration(div9, div6); + append_hydration(div6, t2); + append_hydration(div9, t3); + append_hydration(div9, div7); + append_hydration(div7, t4); + append_hydration(div9, t5); + append_hydration(div9, div8); + append_hydration(div8, t6); + append_hydration(div21, t7); + if (default_slot) { + default_slot.m(div21, null); + } + append_hydration(div21, t8); + append_hydration(div21, div20); + append_hydration(div20, div19); + append_hydration(div19, div18); + append_hydration(div18, div14); + append_hydration(div14, div13); + append_hydration(div13, a1); + append_hydration(a1, img1); + append_hydration(div18, t9); + append_hydration(div18, div17); + append_hydration(div17, div15); + append_hydration(div15, a2); + append_hydration(a2, svg); + append_hydration(svg, path); + append_hydration(div17, t10); + append_hydration(div17, div16); + append_hydration(div16, t11); + append_hydration(div16, a3); + append_hydration(a3, t12); + append_hydration(div16, t13); + current = true; + }, + p(ctx2, [dirty]) { + if (dirty & /*menu*/ + 2) { + each_value = /*menu*/ + ctx2[1]; + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + } else { + each_blocks[i] = create_each_block(child_ctx); + each_blocks[i].c(); + each_blocks[i].m(div2, null); + } + } + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1); + } + each_blocks.length = each_value.length; + } + if ((!current || dirty & /*data*/ + 1) && t2_value !== (t2_value = /*data*/ + ctx2[0].config.shortname + "")) + set_data(t2, t2_value); + if ((!current || dirty & /*data*/ + 1) && t4_value !== (t4_value = /*data*/ + ctx2[0].config.date + "")) + set_data(t4, t4_value); + if ((!current || dirty & /*data*/ + 1) && t6_value !== (t6_value = /*data*/ + ctx2[0].config.venue + "")) + set_data(t6, t6_value); + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[2], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[2] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[2], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(div21); + destroy_each(each_blocks, detaching); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + let { data } = $$props; + const menu = [ + { title: "About", url: "#about" }, + { title: "Speakers", url: "#speakers" }, + { title: "Program", url: "#program" }, + { title: "Sponsors", url: "#sponsors" }, + { + title: "Ticket", + url: "#ticket", + class: "button" + } + ]; + $$self.$$set = ($$props2) => { + if ("data" in $$props2) + $$invalidate(0, data = $$props2.data); + if ("$$scope" in $$props2) + $$invalidate(2, $$scope = $$props2.$$scope); + }; + return [data, menu, $$scope, slots]; +} +class Layout extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance, create_fragment, safe_not_equal, { data: 0 }); + } +} +export { + Layout as default +}; diff --git a/_app/immutable/components/pages/_page.svelte-e1dabd3b.js b/_app/immutable/components/pages/_page.svelte-e1dabd3b.js new file mode 100644 index 0000000..755324c --- /dev/null +++ b/_app/immutable/components/pages/_page.svelte-e1dabd3b.js @@ -0,0 +1,466 @@ +import { S as SvelteComponent, i as init, s as safe_not_equal, a as space, k as element, q as text, N as head_selector, h as detach, c as claim_space, l as claim_element, m as children, r as claim_text, n as attr, b as insert_hydration, H as append_hydration, C as noop, L as destroy_each, u as set_data } from "../../chunks/index-dc145a1c.js"; +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[1] = list[i]; + return child_ctx; +} +function get_each_context_1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[4] = list[i]; + return child_ctx; +} +function create_each_block_1(ctx) { + let div2; + let div0; + let t0_value = ( + /*ti*/ + ctx[4].title + "" + ); + let t0; + let t1; + let div1; + let t2; + let t3; + return { + c() { + div2 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div1 = element("div"); + t2 = text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat."); + t3 = space(); + this.h(); + }, + l(nodes) { + div2 = claim_element(nodes, "DIV", { class: true }); + var div2_nodes = children(div2); + div0 = claim_element(div2_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + t0 = claim_text(div0_nodes, t0_value); + div0_nodes.forEach(detach); + t1 = claim_space(div2_nodes); + div1 = claim_element(div2_nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + t2 = claim_text(div1_nodes, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat."); + div1_nodes.forEach(detach); + t3 = claim_space(div2_nodes); + div2_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div0, "class", "text-black text-2xl uppercase"); + attr(div1, "class", "text-black mt-4 text-lg"); + attr(div2, "class", "bg-white px-4 py-6"); + }, + m(target, anchor) { + insert_hydration(target, div2, anchor); + append_hydration(div2, div0); + append_hydration(div0, t0); + append_hydration(div2, t1); + append_hydration(div2, div1); + append_hydration(div1, t2); + append_hydration(div2, t3); + }, + p(ctx2, dirty) { + if (dirty & /*data*/ + 1 && t0_value !== (t0_value = /*ti*/ + ctx2[4].title + "")) + set_data(t0, t0_value); + }, + d(detaching) { + if (detaching) + detach(div2); + } + }; +} +function create_each_block(ctx) { + let div1; + let div0; + let t0_value = ( + /*tt*/ + ctx[1].title + "" + ); + let t0; + let t1; + return { + c() { + div1 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + this.h(); + }, + l(nodes) { + div1 = claim_element(nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + div0 = claim_element(div1_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + t0 = claim_text(div0_nodes, t0_value); + div0_nodes.forEach(detach); + t1 = claim_space(div1_nodes); + div1_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div0, "class", "text-2xl"); + attr(div1, "class", "border px-3 py-10"); + }, + m(target, anchor) { + insert_hydration(target, div1, anchor); + append_hydration(div1, div0); + append_hydration(div0, t0); + append_hydration(div1, t1); + }, + p(ctx2, dirty) { + if (dirty & /*data*/ + 1 && t0_value !== (t0_value = /*tt*/ + ctx2[1].title + "")) + set_data(t0, t0_value); + }, + d(detaching) { + if (detaching) + detach(div1); + } + }; +} +function create_fragment(ctx) { + let title_value; + let t0; + let div4; + let div3; + let div0; + let t1; + let t2; + let div1; + let t3; + let t4; + let div2; + let t5; + let div8; + let div7; + let div5; + let t6; + let t7; + let div6; + let t8; + let div11; + let div10; + let div9; + let t9; + let t10; + let div14; + let div13; + let div12; + let t11; + let t12; + let div18; + let div17; + let div15; + let t13; + let t14; + let div16; + document.title = title_value = /*data*/ + ctx[0].config.title; + let each_value_1 = ( + /*data*/ + ctx[0].config.themes + ); + let each_blocks_1 = []; + for (let i = 0; i < each_value_1.length; i += 1) { + each_blocks_1[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i)); + } + let each_value = ( + /*data*/ + ctx[0].config.tickets + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); + } + return { + c() { + t0 = space(); + div4 = element("div"); + div3 = element("div"); + div0 = element("div"); + t1 = text("For the first time in the internetโ€™s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy."); + t2 = space(); + div1 = element("div"); + t3 = text("Key themes"); + t4 = space(); + div2 = element("div"); + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].c(); + } + t5 = space(); + div8 = element("div"); + div7 = element("div"); + div5 = element("div"); + t6 = text("Speakers"); + t7 = space(); + div6 = element("div"); + t8 = space(); + div11 = element("div"); + div10 = element("div"); + div9 = element("div"); + t9 = text("Program"); + t10 = space(); + div14 = element("div"); + div13 = element("div"); + div12 = element("div"); + t11 = text("Sponsors"); + t12 = space(); + div18 = element("div"); + div17 = element("div"); + div15 = element("div"); + t13 = text("Ticket"); + t14 = space(); + div16 = element("div"); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + this.h(); + }, + l(nodes) { + const head_nodes = head_selector("svelte-smlx4f", document.head); + head_nodes.forEach(detach); + t0 = claim_space(nodes); + div4 = claim_element(nodes, "DIV", { class: true, id: true }); + var div4_nodes = children(div4); + div3 = claim_element(div4_nodes, "DIV", { class: true }); + var div3_nodes = children(div3); + div0 = claim_element(div3_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + t1 = claim_text(div0_nodes, "For the first time in the internetโ€™s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy."); + div0_nodes.forEach(detach); + t2 = claim_space(div3_nodes); + div1 = claim_element(div3_nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + t3 = claim_text(div1_nodes, "Key themes"); + div1_nodes.forEach(detach); + t4 = claim_space(div3_nodes); + div2 = claim_element(div3_nodes, "DIV", { class: true }); + var div2_nodes = children(div2); + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].l(div2_nodes); + } + div2_nodes.forEach(detach); + div3_nodes.forEach(detach); + div4_nodes.forEach(detach); + t5 = claim_space(nodes); + div8 = claim_element(nodes, "DIV", { class: true, id: true }); + var div8_nodes = children(div8); + div7 = claim_element(div8_nodes, "DIV", { class: true }); + var div7_nodes = children(div7); + div5 = claim_element(div7_nodes, "DIV", { class: true }); + var div5_nodes = children(div5); + t6 = claim_text(div5_nodes, "Speakers"); + div5_nodes.forEach(detach); + t7 = claim_space(div7_nodes); + div6 = claim_element(div7_nodes, "DIV", { class: true }); + children(div6).forEach(detach); + div7_nodes.forEach(detach); + div8_nodes.forEach(detach); + t8 = claim_space(nodes); + div11 = claim_element(nodes, "DIV", { class: true, id: true }); + var div11_nodes = children(div11); + div10 = claim_element(div11_nodes, "DIV", { class: true }); + var div10_nodes = children(div10); + div9 = claim_element(div10_nodes, "DIV", { class: true }); + var div9_nodes = children(div9); + t9 = claim_text(div9_nodes, "Program"); + div9_nodes.forEach(detach); + div10_nodes.forEach(detach); + div11_nodes.forEach(detach); + t10 = claim_space(nodes); + div14 = claim_element(nodes, "DIV", { class: true, id: true }); + var div14_nodes = children(div14); + div13 = claim_element(div14_nodes, "DIV", { class: true }); + var div13_nodes = children(div13); + div12 = claim_element(div13_nodes, "DIV", { class: true }); + var div12_nodes = children(div12); + t11 = claim_text(div12_nodes, "Sponsors"); + div12_nodes.forEach(detach); + div13_nodes.forEach(detach); + div14_nodes.forEach(detach); + t12 = claim_space(nodes); + div18 = claim_element(nodes, "DIV", { class: true, id: true }); + var div18_nodes = children(div18); + div17 = claim_element(div18_nodes, "DIV", { class: true }); + var div17_nodes = children(div17); + div15 = claim_element(div17_nodes, "DIV", { class: true }); + var div15_nodes = children(div15); + t13 = claim_text(div15_nodes, "Ticket"); + div15_nodes.forEach(detach); + t14 = claim_space(div17_nodes); + div16 = claim_element(div17_nodes, "DIV", { class: true }); + var div16_nodes = children(div16); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(div16_nodes); + } + div16_nodes.forEach(detach); + div17_nodes.forEach(detach); + div18_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div0, "class", "py-32 w-1/2 mx-auto"); + attr(div1, "class", "section-header"); + attr(div2, "class", "grid grid-cols-3 gap-10"); + attr(div3, "class", "middle-pane-medium pb-20 text-xl text-center mx-auto"); + attr(div4, "class", "bg-black"); + attr(div4, "id", "about"); + attr(div5, "class", "section-header"); + attr(div6, "class", "h-screen"); + attr(div7, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); + attr(div8, "class", ""); + attr(div8, "id", "speakers"); + attr(div9, "class", "section-header"); + attr(div10, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); + attr(div11, "class", ""); + attr(div11, "id", "program"); + attr(div12, "class", "section-header"); + attr(div13, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); + attr(div14, "class", ""); + attr(div14, "id", "sponsors"); + attr(div15, "class", "section-header"); + attr(div16, "class", "grid grid-cols-2 mb-48 gap-10 w-2/3 mx-auto"); + attr(div17, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); + attr(div18, "class", ""); + attr(div18, "id", "ticket"); + }, + m(target, anchor) { + insert_hydration(target, t0, anchor); + insert_hydration(target, div4, anchor); + append_hydration(div4, div3); + append_hydration(div3, div0); + append_hydration(div0, t1); + append_hydration(div3, t2); + append_hydration(div3, div1); + append_hydration(div1, t3); + append_hydration(div3, t4); + append_hydration(div3, div2); + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].m(div2, null); + } + insert_hydration(target, t5, anchor); + insert_hydration(target, div8, anchor); + append_hydration(div8, div7); + append_hydration(div7, div5); + append_hydration(div5, t6); + append_hydration(div7, t7); + append_hydration(div7, div6); + insert_hydration(target, t8, anchor); + insert_hydration(target, div11, anchor); + append_hydration(div11, div10); + append_hydration(div10, div9); + append_hydration(div9, t9); + insert_hydration(target, t10, anchor); + insert_hydration(target, div14, anchor); + append_hydration(div14, div13); + append_hydration(div13, div12); + append_hydration(div12, t11); + insert_hydration(target, t12, anchor); + insert_hydration(target, div18, anchor); + append_hydration(div18, div17); + append_hydration(div17, div15); + append_hydration(div15, t13); + append_hydration(div17, t14); + append_hydration(div17, div16); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(div16, null); + } + }, + p(ctx2, [dirty]) { + if (dirty & /*data*/ + 1 && title_value !== (title_value = /*data*/ + ctx2[0].config.title)) { + document.title = title_value; + } + if (dirty & /*data*/ + 1) { + each_value_1 = /*data*/ + ctx2[0].config.themes; + let i; + for (i = 0; i < each_value_1.length; i += 1) { + const child_ctx = get_each_context_1(ctx2, each_value_1, i); + if (each_blocks_1[i]) { + each_blocks_1[i].p(child_ctx, dirty); + } else { + each_blocks_1[i] = create_each_block_1(child_ctx); + each_blocks_1[i].c(); + each_blocks_1[i].m(div2, null); + } + } + for (; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].d(1); + } + each_blocks_1.length = each_value_1.length; + } + if (dirty & /*data*/ + 1) { + each_value = /*data*/ + ctx2[0].config.tickets; + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + } else { + each_blocks[i] = create_each_block(child_ctx); + each_blocks[i].c(); + each_blocks[i].m(div16, null); + } + } + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1); + } + each_blocks.length = each_value.length; + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(t0); + if (detaching) + detach(div4); + destroy_each(each_blocks_1, detaching); + if (detaching) + detach(t5); + if (detaching) + detach(div8); + if (detaching) + detach(t8); + if (detaching) + detach(div11); + if (detaching) + detach(t10); + if (detaching) + detach(div14); + if (detaching) + detach(t12); + if (detaching) + detach(div18); + destroy_each(each_blocks, detaching); + } + }; +} +function instance($$self, $$props, $$invalidate) { + let { data } = $$props; + $$self.$$set = ($$props2) => { + if ("data" in $$props2) + $$invalidate(0, data = $$props2.data); + }; + return [data]; +} +class Page extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance, create_fragment, safe_not_equal, { data: 0 }); + } +} +export { + Page as default +}; diff --git a/_app/immutable/modules/pages/_layout.js-7751b67e.js b/_app/immutable/modules/pages/_layout.js-7751b67e.js new file mode 100644 index 0000000..8869b50 --- /dev/null +++ b/_app/immutable/modules/pages/_layout.js-7751b67e.js @@ -0,0 +1,4 @@ +import { l } from "../../chunks/_layout-505b36c8.js"; +export { + l as load +}; diff --git a/_app/immutable/start-d1b6dada.js b/_app/immutable/start-d1b6dada.js new file mode 100644 index 0000000..f6085d3 --- /dev/null +++ b/_app/immutable/start-d1b6dada.js @@ -0,0 +1,2354 @@ +import { S as SvelteComponent, i as init, s as safe_not_equal, a as space, e as empty, c as claim_space, b as insert_hydration, g as group_outros, t as transition_out, d as check_outros, f as transition_in, h as detach, j as afterUpdate, o as onMount, k as element, l as claim_element, m as children, n as attr, p as set_style, q as text, r as claim_text, u as set_data, v as binding_callbacks, w as construct_svelte_component, x as create_component, y as claim_component, z as mount_component, A as destroy_component, B as tick } from "./chunks/index-dc145a1c.js"; +import { S as SCROLL_KEY, a as SNAPSHOT_KEY, I as INDEX_KEY, g as get_base_uri, f as find_anchor, b as get_link_info, c as get_router_options, s as stores, i as is_external_url, d as scroll_state, e as base, P as PRELOAD_PRIORITIES, h as init$1, j as set_assets, k as set_version } from "./chunks/singletons-57b7ce3e.js"; +function normalize_path(path, trailing_slash) { + if (path === "/" || trailing_slash === "ignore") + return path; + if (trailing_slash === "never") { + return path.endsWith("/") ? path.slice(0, -1) : path; + } else if (trailing_slash === "always" && !path.endsWith("/")) { + return path + "/"; + } + return path; +} +function decode_pathname(pathname) { + return pathname.split("%25").map(decodeURI).join("%25"); +} +function decode_params(params) { + for (const key in params) { + params[key] = decodeURIComponent(params[key]); + } + return params; +} +const tracked_url_properties = ["href", "pathname", "search", "searchParams", "toString", "toJSON"]; +function make_trackable(url, callback) { + const tracked = new URL(url); + for (const property of tracked_url_properties) { + let value = tracked[property]; + Object.defineProperty(tracked, property, { + get() { + callback(); + return value; + }, + enumerable: true, + configurable: true + }); + } + disable_hash(tracked); + return tracked; +} +function disable_hash(url) { + Object.defineProperty(url, "hash", { + get() { + throw new Error( + "Cannot access event.url.hash. Consider using `$page.url.hash` inside a component instead" + ); + } + }); +} +const DATA_SUFFIX = "/__data.json"; +function add_data_suffix(pathname) { + return pathname.replace(/\/$/, "") + DATA_SUFFIX; +} +function get(key) { + try { + return JSON.parse(sessionStorage[key]); + } catch { + } +} +function set(key, value) { + const json = JSON.stringify(value); + try { + sessionStorage[key] = json; + } catch { + } +} +function hash(...values) { + let hash2 = 5381; + for (const value of values) { + if (typeof value === "string") { + let i = value.length; + while (i) + hash2 = hash2 * 33 ^ value.charCodeAt(--i); + } else if (ArrayBuffer.isView(value)) { + const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength); + let i = buffer.length; + while (i) + hash2 = hash2 * 33 ^ buffer[--i]; + } else { + throw new TypeError("value must be a string or TypedArray"); + } + } + return (hash2 >>> 0).toString(36); +} +const native_fetch = window.fetch; +{ + window.fetch = (input, init2) => { + const method = input instanceof Request ? input.method : (init2 == null ? void 0 : init2.method) || "GET"; + if (method !== "GET") { + cache.delete(build_selector(input)); + } + return native_fetch(input, init2); + }; +} +const cache = /* @__PURE__ */ new Map(); +function initial_fetch(resource, opts) { + const selector = build_selector(resource, opts); + const script = document.querySelector(selector); + if (script == null ? void 0 : script.textContent) { + const { body, ...init2 } = JSON.parse(script.textContent); + const ttl = script.getAttribute("data-ttl"); + if (ttl) + cache.set(selector, { body, init: init2, ttl: 1e3 * Number(ttl) }); + return Promise.resolve(new Response(body, init2)); + } + return native_fetch(resource, opts); +} +function subsequent_fetch(resource, resolved, opts) { + if (cache.size > 0) { + const selector = build_selector(resource, opts); + const cached = cache.get(selector); + if (cached) { + if (performance.now() < cached.ttl && ["default", "force-cache", "only-if-cached", void 0].includes(opts == null ? void 0 : opts.cache)) { + return new Response(cached.body, cached.init); + } + cache.delete(selector); + } + } + return native_fetch(resolved, opts); +} +function build_selector(resource, opts) { + const url = JSON.stringify(resource instanceof Request ? resource.url : resource); + let selector = `script[data-sveltekit-fetched][data-url=${url}]`; + if ((opts == null ? void 0 : opts.headers) || (opts == null ? void 0 : opts.body)) { + const values = []; + if (opts.headers) { + values.push([...new Headers(opts.headers)].join(",")); + } + if (opts.body && (typeof opts.body === "string" || ArrayBuffer.isView(opts.body))) { + values.push(opts.body); + } + selector += `[data-hash="${hash(...values)}"]`; + } + return selector; +} +const param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/; +function parse_route_id(id) { + const params = []; + const pattern = id === "/" ? /^\/$/ : new RegExp( + `^${get_route_segments(id).map((segment) => { + const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment); + if (rest_match) { + params.push({ + name: rest_match[1], + matcher: rest_match[2], + optional: false, + rest: true, + chained: true + }); + return "(?:/(.*))?"; + } + const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment); + if (optional_match) { + params.push({ + name: optional_match[1], + matcher: optional_match[2], + optional: true, + rest: false, + chained: true + }); + return "(?:/([^/]+))?"; + } + if (!segment) { + return; + } + const parts = segment.split(/\[(.+?)\](?!\])/); + const result = parts.map((content, i) => { + if (i % 2) { + if (content.startsWith("x+")) { + return escape(String.fromCharCode(parseInt(content.slice(2), 16))); + } + if (content.startsWith("u+")) { + return escape( + String.fromCharCode( + ...content.slice(2).split("-").map((code) => parseInt(code, 16)) + ) + ); + } + const match = param_pattern.exec(content); + if (!match) { + throw new Error( + `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.` + ); + } + const [, is_optional, is_rest, name, matcher] = match; + params.push({ + name, + matcher, + optional: !!is_optional, + rest: !!is_rest, + chained: is_rest ? i === 1 && parts[0] === "" : false + }); + return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)"; + } + return escape(content); + }).join(""); + return "/" + result; + }).join("")}/?$` + ); + return { pattern, params }; +} +function affects_path(segment) { + return !/^\([^)]+\)$/.test(segment); +} +function get_route_segments(route) { + return route.slice(1).split("/").filter(affects_path); +} +function exec(match, params, matchers2) { + const result = {}; + const values = match.slice(1); + let buffered = 0; + for (let i = 0; i < params.length; i += 1) { + const param = params[i]; + const value = values[i - buffered]; + if (param.chained && param.rest && buffered) { + result[param.name] = values.slice(i - buffered, i + 1).filter((s) => s).join("/"); + buffered = 0; + continue; + } + if (value === void 0) { + if (param.rest) + result[param.name] = ""; + continue; + } + if (!param.matcher || matchers2[param.matcher](value)) { + result[param.name] = value; + continue; + } + if (param.optional && param.chained) { + buffered++; + continue; + } + return; + } + if (buffered) + return; + return result; +} +function escape(str) { + return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&"); +} +function parse(nodes2, server_loads2, dictionary2, matchers2) { + const layouts_with_server_load = new Set(server_loads2); + return Object.entries(dictionary2).map(([id, [leaf, layouts, errors]]) => { + const { pattern, params } = parse_route_id(id); + const route = { + id, + /** @param {string} path */ + exec: (path) => { + const match = pattern.exec(path); + if (match) + return exec(match, params, matchers2); + }, + errors: [1, ...errors || []].map((n) => nodes2[n]), + layouts: [0, ...layouts || []].map(create_layout_loader), + leaf: create_leaf_loader(leaf) + }; + route.errors.length = route.layouts.length = Math.max( + route.errors.length, + route.layouts.length + ); + return route; + }); + function create_leaf_loader(id) { + const uses_server_data = id < 0; + if (uses_server_data) + id = ~id; + return [uses_server_data, nodes2[id]]; + } + function create_layout_loader(id) { + return id === void 0 ? id : [layouts_with_server_load.has(id), nodes2[id]]; + } +} +function create_else_block(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*constructors*/ + ctx[1][0] + ); + function switch_props(ctx2) { + let switch_instance_props = { + data: ( + /*data_0*/ + ctx2[3] + ), + form: ( + /*form*/ + ctx2[2] + ) + }; + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + ctx[12](switch_instance); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes2) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes2); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*data_0*/ + 8) + switch_instance_changes.data = /*data_0*/ + ctx2[3]; + if (dirty & /*form*/ + 4) + switch_instance_changes.form = /*form*/ + ctx2[2]; + if (switch_value !== (switch_value = /*constructors*/ + ctx2[1][0])) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + ctx2[12](switch_instance); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + ctx[12](null); + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_if_block_2(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*constructors*/ + ctx[1][0] + ); + function switch_props(ctx2) { + let switch_instance_props = { + data: ( + /*data_0*/ + ctx2[3] + ), + $$slots: { default: [create_default_slot] }, + $$scope: { ctx: ctx2 } + }; + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + ctx[11](switch_instance); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes2) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes2); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*data_0*/ + 8) + switch_instance_changes.data = /*data_0*/ + ctx2[3]; + if (dirty & /*$$scope, constructors, data_1, form, components*/ + 8215) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*constructors*/ + ctx2[1][0])) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + ctx2[11](switch_instance); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + ctx[11](null); + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*constructors*/ + ctx[1][1] + ); + function switch_props(ctx2) { + let switch_instance_props = { + data: ( + /*data_1*/ + ctx2[4] + ), + form: ( + /*form*/ + ctx2[2] + ) + }; + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + ctx[10](switch_instance); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes2) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes2); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*data_1*/ + 16) + switch_instance_changes.data = /*data_1*/ + ctx2[4]; + if (dirty & /*form*/ + 4) + switch_instance_changes.form = /*form*/ + ctx2[2]; + if (switch_value !== (switch_value = /*constructors*/ + ctx2[1][1])) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + ctx2[10](switch_instance); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + ctx[10](null); + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_if_block(ctx) { + let div; + let if_block = ( + /*navigated*/ + ctx[6] && create_if_block_1(ctx) + ); + return { + c() { + div = element("div"); + if (if_block) + if_block.c(); + this.h(); + }, + l(nodes2) { + div = claim_element(nodes2, "DIV", { + id: true, + "aria-live": true, + "aria-atomic": true, + style: true + }); + var div_nodes = children(div); + if (if_block) + if_block.l(div_nodes); + div_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div, "id", "svelte-announcer"); + attr(div, "aria-live", "assertive"); + attr(div, "aria-atomic", "true"); + set_style(div, "position", "absolute"); + set_style(div, "left", "0"); + set_style(div, "top", "0"); + set_style(div, "clip", "rect(0 0 0 0)"); + set_style(div, "clip-path", "inset(50%)"); + set_style(div, "overflow", "hidden"); + set_style(div, "white-space", "nowrap"); + set_style(div, "width", "1px"); + set_style(div, "height", "1px"); + }, + m(target, anchor) { + insert_hydration(target, div, anchor); + if (if_block) + if_block.m(div, null); + }, + p(ctx2, dirty) { + if ( + /*navigated*/ + ctx2[6] + ) { + if (if_block) { + if_block.p(ctx2, dirty); + } else { + if_block = create_if_block_1(ctx2); + if_block.c(); + if_block.m(div, null); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + }, + d(detaching) { + if (detaching) + detach(div); + if (if_block) + if_block.d(); + } + }; +} +function create_if_block_1(ctx) { + let t; + return { + c() { + t = text( + /*title*/ + ctx[7] + ); + }, + l(nodes2) { + t = claim_text( + nodes2, + /*title*/ + ctx[7] + ); + }, + m(target, anchor) { + insert_hydration(target, t, anchor); + }, + p(ctx2, dirty) { + if (dirty & /*title*/ + 128) + set_data( + t, + /*title*/ + ctx2[7] + ); + }, + d(detaching) { + if (detaching) + detach(t); + } + }; +} +function create_fragment(ctx) { + let current_block_type_index; + let if_block0; + let t; + let if_block1_anchor; + let current; + const if_block_creators = [create_if_block_2, create_else_block]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*constructors*/ + ctx2[1][1] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type(ctx); + if_block0 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + let if_block1 = ( + /*mounted*/ + ctx[5] && create_if_block(ctx) + ); + return { + c() { + if_block0.c(); + t = space(); + if (if_block1) + if_block1.c(); + if_block1_anchor = empty(); + }, + l(nodes2) { + if_block0.l(nodes2); + t = claim_space(nodes2); + if (if_block1) + if_block1.l(nodes2); + if_block1_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert_hydration(target, t, anchor); + if (if_block1) + if_block1.m(target, anchor); + insert_hydration(target, if_block1_anchor, anchor); + current = true; + }, + p(ctx2, [dirty]) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block0 = if_blocks[current_block_type_index]; + if (!if_block0) { + if_block0 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block0.c(); + } else { + if_block0.p(ctx2, dirty); + } + transition_in(if_block0, 1); + if_block0.m(t.parentNode, t); + } + if ( + /*mounted*/ + ctx2[5] + ) { + if (if_block1) { + if_block1.p(ctx2, dirty); + } else { + if_block1 = create_if_block(ctx2); + if_block1.c(); + if_block1.m(if_block1_anchor.parentNode, if_block1_anchor); + } + } else if (if_block1) { + if_block1.d(1); + if_block1 = null; + } + }, + i(local) { + if (current) + return; + transition_in(if_block0); + current = true; + }, + o(local) { + transition_out(if_block0); + current = false; + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching); + if (detaching) + detach(t); + if (if_block1) + if_block1.d(detaching); + if (detaching) + detach(if_block1_anchor); + } + }; +} +function instance($$self, $$props, $$invalidate) { + let { stores: stores2 } = $$props; + let { page } = $$props; + let { constructors } = $$props; + let { components = [] } = $$props; + let { form } = $$props; + let { data_0 = null } = $$props; + let { data_1 = null } = $$props; + afterUpdate(stores2.page.notify); + let mounted = false; + let navigated = false; + let title = null; + onMount(() => { + const unsubscribe = stores2.page.subscribe(() => { + if (mounted) { + $$invalidate(6, navigated = true); + $$invalidate(7, title = document.title || "untitled page"); + } + }); + $$invalidate(5, mounted = true); + return unsubscribe; + }); + function switch_instance_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + components[1] = $$value; + $$invalidate(0, components); + }); + } + function switch_instance_binding_1($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + components[0] = $$value; + $$invalidate(0, components); + }); + } + function switch_instance_binding_2($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + components[0] = $$value; + $$invalidate(0, components); + }); + } + $$self.$$set = ($$props2) => { + if ("stores" in $$props2) + $$invalidate(8, stores2 = $$props2.stores); + if ("page" in $$props2) + $$invalidate(9, page = $$props2.page); + if ("constructors" in $$props2) + $$invalidate(1, constructors = $$props2.constructors); + if ("components" in $$props2) + $$invalidate(0, components = $$props2.components); + if ("form" in $$props2) + $$invalidate(2, form = $$props2.form); + if ("data_0" in $$props2) + $$invalidate(3, data_0 = $$props2.data_0); + if ("data_1" in $$props2) + $$invalidate(4, data_1 = $$props2.data_1); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*stores, page*/ + 768) { + stores2.page.set(page); + } + }; + return [ + components, + constructors, + form, + data_0, + data_1, + mounted, + navigated, + title, + stores2, + page, + switch_instance_binding, + switch_instance_binding_1, + switch_instance_binding_2 + ]; +} +class Root extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance, create_fragment, safe_not_equal, { + stores: 8, + page: 9, + constructors: 1, + components: 0, + form: 2, + data_0: 3, + data_1: 4 + }); + } +} +const scriptRel = "modulepreload"; +const assetsURL = function(dep, importerUrl) { + return new URL(dep, importerUrl).href; +}; +const seen = {}; +const __vitePreload = function preload(baseModule, deps, importerUrl) { + if (!deps || deps.length === 0) { + return baseModule(); + } + const links = document.getElementsByTagName("link"); + return Promise.all(deps.map((dep) => { + dep = assetsURL(dep, importerUrl); + if (dep in seen) + return; + seen[dep] = true; + const isCss = dep.endsWith(".css"); + const cssSelector = isCss ? '[rel="stylesheet"]' : ""; + const isBaseRelative = !!importerUrl; + if (isBaseRelative) { + for (let i = links.length - 1; i >= 0; i--) { + const link2 = links[i]; + if (link2.href === dep && (!isCss || link2.rel === "stylesheet")) { + return; + } + } + } else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) { + return; + } + const link = document.createElement("link"); + link.rel = isCss ? "stylesheet" : scriptRel; + if (!isCss) { + link.as = "script"; + link.crossOrigin = ""; + } + link.href = dep; + document.head.appendChild(link); + if (isCss) { + return new Promise((res, rej) => { + link.addEventListener("load", res); + link.addEventListener("error", () => rej(new Error(`Unable to preload CSS for ${dep}`))); + }); + } + })).then(() => baseModule()); +}; +const matchers = {}; +const nodes = [ + () => __vitePreload(() => import("./chunks/0-96e52675.js"), true ? ["./chunks/0-96e52675.js","./chunks/_layout-505b36c8.js","./components/pages/_layout.svelte-5af7c4a4.js","./chunks/index-dc145a1c.js","./assets/_layout-ea040a37.css"] : void 0, import.meta.url), + () => __vitePreload(() => import("./chunks/1-1cedc3a7.js"), true ? ["./chunks/1-1cedc3a7.js","./components/error.svelte-63d63419.js","./chunks/index-dc145a1c.js","./chunks/singletons-57b7ce3e.js"] : void 0, import.meta.url), + () => __vitePreload(() => import("./chunks/2-14d5175e.js"), true ? ["./chunks/2-14d5175e.js","./components/pages/_page.svelte-e1dabd3b.js","./chunks/index-dc145a1c.js"] : void 0, import.meta.url) +]; +const server_loads = []; +const dictionary = { + "/": [2] +}; +const hooks = { + handleError: ({ error }) => { + console.error(error); + } +}; +let HttpError = class HttpError2 { + /** + * @param {number} status + * @param {{message: string} extends App.Error ? (App.Error | string | undefined) : App.Error} body + */ + constructor(status, body) { + this.status = status; + if (typeof body === "string") { + this.body = { message: body }; + } else if (body) { + this.body = body; + } else { + this.body = { message: `Error: ${status}` }; + } + } + toString() { + return JSON.stringify(this.body); + } +}; +let Redirect = class Redirect2 { + /** + * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status + * @param {string} location + */ + constructor(status, location2) { + this.status = status; + this.location = location2; + } +}; +async function unwrap_promises(object) { + var _a; + for (const key in object) { + if (typeof ((_a = object[key]) == null ? void 0 : _a.then) === "function") { + return Object.fromEntries( + await Promise.all(Object.entries(object).map(async ([key2, value]) => [key2, await value])) + ); + } + } + return object; +} +Object.getOwnPropertyNames(Object.prototype).sort().join("\0"); +const UNDEFINED = -1; +const HOLE = -2; +const NAN = -3; +const POSITIVE_INFINITY = -4; +const NEGATIVE_INFINITY = -5; +const NEGATIVE_ZERO = -6; +function unflatten(parsed, revivers) { + if (typeof parsed === "number") + return hydrate(parsed, true); + if (!Array.isArray(parsed) || parsed.length === 0) { + throw new Error("Invalid input"); + } + const values = ( + /** @type {any[]} */ + parsed + ); + const hydrated = Array(values.length); + function hydrate(index, standalone = false) { + if (index === UNDEFINED) + return void 0; + if (index === NAN) + return NaN; + if (index === POSITIVE_INFINITY) + return Infinity; + if (index === NEGATIVE_INFINITY) + return -Infinity; + if (index === NEGATIVE_ZERO) + return -0; + if (standalone) + throw new Error(`Invalid input`); + if (index in hydrated) + return hydrated[index]; + const value = values[index]; + if (!value || typeof value !== "object") { + hydrated[index] = value; + } else if (Array.isArray(value)) { + if (typeof value[0] === "string") { + const type = value[0]; + const reviver = revivers == null ? void 0 : revivers[type]; + if (reviver) { + return hydrated[index] = reviver(hydrate(value[1])); + } + switch (type) { + case "Date": + hydrated[index] = new Date(value[1]); + break; + case "Set": + const set2 = /* @__PURE__ */ new Set(); + hydrated[index] = set2; + for (let i = 1; i < value.length; i += 1) { + set2.add(hydrate(value[i])); + } + break; + case "Map": + const map = /* @__PURE__ */ new Map(); + hydrated[index] = map; + for (let i = 1; i < value.length; i += 2) { + map.set(hydrate(value[i]), hydrate(value[i + 1])); + } + break; + case "RegExp": + hydrated[index] = new RegExp(value[1], value[2]); + break; + case "Object": + hydrated[index] = Object(value[1]); + break; + case "BigInt": + hydrated[index] = BigInt(value[1]); + break; + case "null": + const obj = /* @__PURE__ */ Object.create(null); + hydrated[index] = obj; + for (let i = 1; i < value.length; i += 2) { + obj[value[i]] = hydrate(value[i + 1]); + } + break; + default: + throw new Error(`Unknown type ${type}`); + } + } else { + const array = new Array(value.length); + hydrated[index] = array; + for (let i = 0; i < value.length; i += 1) { + const n = value[i]; + if (n === HOLE) + continue; + array[i] = hydrate(n); + } + } + } else { + const object = {}; + hydrated[index] = object; + for (const key in value) { + const n = value[key]; + object[key] = hydrate(n); + } + } + return hydrated[index]; + } + return hydrate(0); +} +function compact(arr) { + return arr.filter( + /** @returns {val is NonNullable} */ + (val) => val != null + ); +} +const routes = parse(nodes, server_loads, dictionary, matchers); +const default_layout_loader = nodes[0]; +const default_error_loader = nodes[1]; +default_layout_loader(); +default_error_loader(); +const scroll_positions = get(SCROLL_KEY) ?? {}; +const snapshots = get(SNAPSHOT_KEY) ?? {}; +function update_scroll_positions(index) { + scroll_positions[index] = scroll_state(); +} +function create_client({ target }) { + var _a; + const container = document.documentElement; + const invalidated = []; + const components = []; + let load_cache = null; + const callbacks = { + /** @type {Array<(navigation: import('types').BeforeNavigate) => void>} */ + before_navigate: [], + /** @type {Array<(navigation: import('types').AfterNavigate) => void>} */ + after_navigate: [] + }; + let current = { + branch: [], + error: null, + // @ts-ignore - we need the initial value to be null + url: null + }; + let hydrated = false; + let started = false; + let autoscroll = true; + let updating = false; + let navigating = false; + let hash_navigating = false; + let force_invalidation = false; + let root; + let current_history_index = (_a = history.state) == null ? void 0 : _a[INDEX_KEY]; + if (!current_history_index) { + current_history_index = Date.now(); + history.replaceState( + { ...history.state, [INDEX_KEY]: current_history_index }, + "", + location.href + ); + } + const scroll = scroll_positions[current_history_index]; + if (scroll) { + history.scrollRestoration = "manual"; + scrollTo(scroll.x, scroll.y); + } + let page; + let token; + let pending_invalidate; + async function invalidate() { + pending_invalidate = pending_invalidate || Promise.resolve(); + await pending_invalidate; + pending_invalidate = null; + const url = new URL(location.href); + const intent = get_navigation_intent(url, true); + load_cache = null; + await update(intent, url, []); + } + function capture_snapshot(index) { + if (components.some((c) => c == null ? void 0 : c.snapshot)) { + snapshots[index] = components.map((c) => { + var _a2; + return (_a2 = c == null ? void 0 : c.snapshot) == null ? void 0 : _a2.capture(); + }); + } + } + function restore_snapshot(index) { + var _a2; + (_a2 = snapshots[index]) == null ? void 0 : _a2.forEach((value, i) => { + var _a3, _b; + (_b = (_a3 = components[i]) == null ? void 0 : _a3.snapshot) == null ? void 0 : _b.restore(value); + }); + } + async function goto(url, { + noScroll = false, + replaceState = false, + keepFocus = false, + state = {}, + invalidateAll = false + }, redirect_chain, nav_token) { + if (typeof url === "string") { + url = new URL(url, get_base_uri(document)); + } + return navigate({ + url, + scroll: noScroll ? scroll_state() : null, + keepfocus: keepFocus, + redirect_chain, + details: { + state, + replaceState + }, + nav_token, + accepted: () => { + if (invalidateAll) { + force_invalidation = true; + } + }, + blocked: () => { + }, + type: "goto" + }); + } + async function preload_data(intent) { + load_cache = { + id: intent.id, + promise: load_route(intent).then((result) => { + if (result.type === "loaded" && result.state.error) { + load_cache = null; + } + return result; + }) + }; + return load_cache.promise; + } + async function preload_code(...pathnames) { + const matching = routes.filter((route) => pathnames.some((pathname) => route.exec(pathname))); + const promises = matching.map((r) => { + return Promise.all([...r.layouts, r.leaf].map((load) => load == null ? void 0 : load[1]())); + }); + await Promise.all(promises); + } + async function update(intent, url, redirect_chain, previous_history_index, opts, nav_token = {}, callback) { + var _a2, _b; + token = nav_token; + let navigation_result = intent && await load_route(intent); + if (!navigation_result) { + navigation_result = await server_fallback( + url, + { id: null }, + await handle_error(new Error(`Not found: ${url.pathname}`), { + url, + params: {}, + route: { id: null } + }), + 404 + ); + } + url = (intent == null ? void 0 : intent.url) || url; + if (token !== nav_token) + return false; + if (navigation_result.type === "redirect") { + if (redirect_chain.length > 10 || redirect_chain.includes(url.pathname)) { + navigation_result = await load_root_error_page({ + status: 500, + error: await handle_error(new Error("Redirect loop"), { + url, + params: {}, + route: { id: null } + }), + url, + route: { id: null } + }); + } else { + goto( + new URL(navigation_result.location, url).href, + {}, + [...redirect_chain, url.pathname], + nav_token + ); + return false; + } + } else if ( + /** @type {number} */ + ((_b = (_a2 = navigation_result.props) == null ? void 0 : _a2.page) == null ? void 0 : _b.status) >= 400 + ) { + const updated = await stores.updated.check(); + if (updated) { + await native_navigation(url); + } + } + invalidated.length = 0; + force_invalidation = false; + updating = true; + if (previous_history_index) { + update_scroll_positions(previous_history_index); + capture_snapshot(previous_history_index); + } + if (opts && opts.details) { + const { details } = opts; + const change = details.replaceState ? 0 : 1; + details.state[INDEX_KEY] = current_history_index += change; + history[details.replaceState ? "replaceState" : "pushState"](details.state, "", url); + if (!details.replaceState) { + let i = current_history_index + 1; + while (snapshots[i] || scroll_positions[i]) { + delete snapshots[i]; + delete scroll_positions[i]; + i += 1; + } + } + } + load_cache = null; + if (started) { + current = navigation_result.state; + if (navigation_result.props.page) { + navigation_result.props.page.url = url; + } + root.$set(navigation_result.props); + } else { + initialize(navigation_result); + } + if (opts) { + const { scroll: scroll2, keepfocus } = opts; + const { activeElement } = document; + await tick(); + const changed_focus = ( + // reset focus only if any manual focus management didn't override it + document.activeElement !== activeElement && // also refocus when activeElement is body already because the + // focus event might not have been fired on it yet + document.activeElement !== document.body + ); + if (!keepfocus && !changed_focus) { + await reset_focus(); + } + if (autoscroll) { + const deep_linked = url.hash && document.getElementById(decodeURIComponent(url.hash.slice(1))); + if (scroll2) { + scrollTo(scroll2.x, scroll2.y); + } else if (deep_linked) { + deep_linked.scrollIntoView(); + } else { + scrollTo(0, 0); + } + } + } else { + await tick(); + } + autoscroll = true; + if (navigation_result.props.page) { + page = navigation_result.props.page; + } + if (callback) + callback(); + updating = false; + } + function initialize(result) { + var _a2; + current = result.state; + const style = document.querySelector("style[data-sveltekit]"); + if (style) + style.remove(); + page = /** @type {import('types').Page} */ + result.props.page; + root = new Root({ + target, + props: { ...result.props, stores, components }, + hydrate: true + }); + restore_snapshot(current_history_index); + const navigation = { + from: null, + to: { + params: current.params, + route: { id: ((_a2 = current.route) == null ? void 0 : _a2.id) ?? null }, + url: new URL(location.href) + }, + willUnload: false, + type: "enter" + }; + callbacks.after_navigate.forEach((fn) => fn(navigation)); + started = true; + } + async function get_navigation_result_from_branch({ + url, + params, + branch, + status, + error, + route, + form + }) { + let slash = "never"; + for (const node of branch) { + if ((node == null ? void 0 : node.slash) !== void 0) + slash = node.slash; + } + url.pathname = normalize_path(url.pathname, slash); + url.search = url.search; + const result = { + type: "loaded", + state: { + url, + params, + branch, + error, + route + }, + props: { + // @ts-ignore Somehow it's getting SvelteComponent and SvelteComponentDev mixed up + constructors: compact(branch).map((branch_node) => branch_node.node.component) + } + }; + if (form !== void 0) { + result.props.form = form; + } + let data = {}; + let data_changed = !page; + let p = 0; + for (let i = 0; i < Math.max(branch.length, current.branch.length); i += 1) { + const node = branch[i]; + const prev = current.branch[i]; + if ((node == null ? void 0 : node.data) !== (prev == null ? void 0 : prev.data)) + data_changed = true; + if (!node) + continue; + data = { ...data, ...node.data }; + if (data_changed) { + result.props[`data_${p}`] = data; + } + p += 1; + } + const page_changed = !current.url || url.href !== current.url.href || current.error !== error || form !== void 0 && form !== page.form || data_changed; + if (page_changed) { + result.props.page = { + error, + params, + route: { + id: (route == null ? void 0 : route.id) ?? null + }, + status, + url: new URL(url), + form: form ?? null, + // The whole page store is updated, but this way the object reference stays the same + data: data_changed ? data : page.data + }; + } + return result; + } + async function load_node({ loader, parent, url, params, route, server_data_node }) { + var _a2, _b, _c; + let data = null; + const uses = { + dependencies: /* @__PURE__ */ new Set(), + params: /* @__PURE__ */ new Set(), + parent: false, + route: false, + url: false + }; + const node = await loader(); + if ((_a2 = node.universal) == null ? void 0 : _a2.load) { + let depends = function(...deps) { + for (const dep of deps) { + const { href } = new URL(dep, url); + uses.dependencies.add(href); + } + }; + const load_input = { + route: { + get id() { + uses.route = true; + return route.id; + } + }, + params: new Proxy(params, { + get: (target2, key) => { + uses.params.add( + /** @type {string} */ + key + ); + return target2[ + /** @type {string} */ + key + ]; + } + }), + data: (server_data_node == null ? void 0 : server_data_node.data) ?? null, + url: make_trackable(url, () => { + uses.url = true; + }), + async fetch(resource, init2) { + let requested; + if (resource instanceof Request) { + requested = resource.url; + init2 = { + // the request body must be consumed in memory until browsers + // implement streaming request bodies and/or the body getter + body: resource.method === "GET" || resource.method === "HEAD" ? void 0 : await resource.blob(), + cache: resource.cache, + credentials: resource.credentials, + headers: resource.headers, + integrity: resource.integrity, + keepalive: resource.keepalive, + method: resource.method, + mode: resource.mode, + redirect: resource.redirect, + referrer: resource.referrer, + referrerPolicy: resource.referrerPolicy, + signal: resource.signal, + ...init2 + }; + } else { + requested = resource; + } + const resolved = new URL(requested, url); + depends(resolved.href); + if (resolved.origin === url.origin) { + requested = resolved.href.slice(url.origin.length); + } + return started ? subsequent_fetch(requested, resolved.href, init2) : initial_fetch(requested, init2); + }, + setHeaders: () => { + }, + // noop + depends, + parent() { + uses.parent = true; + return parent(); + } + }; + { + data = await node.universal.load.call(null, load_input) ?? null; + } + data = data ? await unwrap_promises(data) : null; + } + return { + node, + loader, + server: server_data_node, + universal: ((_b = node.universal) == null ? void 0 : _b.load) ? { type: "data", data, uses } : null, + data: data ?? (server_data_node == null ? void 0 : server_data_node.data) ?? null, + slash: ((_c = node.universal) == null ? void 0 : _c.trailingSlash) ?? (server_data_node == null ? void 0 : server_data_node.slash) + }; + } + function has_changed(parent_changed, route_changed, url_changed, uses, params) { + if (force_invalidation) + return true; + if (!uses) + return false; + if (uses.parent && parent_changed) + return true; + if (uses.route && route_changed) + return true; + if (uses.url && url_changed) + return true; + for (const param of uses.params) { + if (params[param] !== current.params[param]) + return true; + } + for (const href of uses.dependencies) { + if (invalidated.some((fn) => fn(new URL(href)))) + return true; + } + return false; + } + function create_data_node(node, previous) { + if ((node == null ? void 0 : node.type) === "data") { + return { + type: "data", + data: node.data, + uses: { + dependencies: new Set(node.uses.dependencies ?? []), + params: new Set(node.uses.params ?? []), + parent: !!node.uses.parent, + route: !!node.uses.route, + url: !!node.uses.url + }, + slash: node.slash + }; + } else if ((node == null ? void 0 : node.type) === "skip") { + return previous ?? null; + } + return null; + } + async function load_route({ id, invalidating, url, params, route }) { + if ((load_cache == null ? void 0 : load_cache.id) === id) { + return load_cache.promise; + } + const { errors, layouts, leaf } = route; + const loaders = [...layouts, leaf]; + errors.forEach((loader) => loader == null ? void 0 : loader().catch(() => { + })); + loaders.forEach((loader) => loader == null ? void 0 : loader[1]().catch(() => { + })); + let server_data = null; + const url_changed = current.url ? id !== current.url.pathname + current.url.search : false; + const route_changed = current.route ? route.id !== current.route.id : false; + let parent_invalid = false; + const invalid_server_nodes = loaders.map((loader, i) => { + var _a2; + const previous = current.branch[i]; + const invalid = !!(loader == null ? void 0 : loader[0]) && ((previous == null ? void 0 : previous.loader) !== loader[1] || has_changed(parent_invalid, route_changed, url_changed, (_a2 = previous.server) == null ? void 0 : _a2.uses, params)); + if (invalid) { + parent_invalid = true; + } + return invalid; + }); + if (invalid_server_nodes.some(Boolean)) { + try { + server_data = await load_data(url, invalid_server_nodes); + } catch (error) { + return load_root_error_page({ + status: error instanceof HttpError ? error.status : 500, + error: await handle_error(error, { url, params, route: { id: route.id } }), + url, + route + }); + } + if (server_data.type === "redirect") { + return server_data; + } + } + const server_data_nodes = server_data == null ? void 0 : server_data.nodes; + let parent_changed = false; + const branch_promises = loaders.map(async (loader, i) => { + var _a2; + if (!loader) + return; + const previous = current.branch[i]; + const server_data_node = server_data_nodes == null ? void 0 : server_data_nodes[i]; + const valid = (!server_data_node || server_data_node.type === "skip") && loader[1] === (previous == null ? void 0 : previous.loader) && !has_changed(parent_changed, route_changed, url_changed, (_a2 = previous.universal) == null ? void 0 : _a2.uses, params); + if (valid) + return previous; + parent_changed = true; + if ((server_data_node == null ? void 0 : server_data_node.type) === "error") { + throw server_data_node; + } + return load_node({ + loader: loader[1], + url, + params, + route, + parent: async () => { + var _a3; + const data = {}; + for (let j = 0; j < i; j += 1) { + Object.assign(data, (_a3 = await branch_promises[j]) == null ? void 0 : _a3.data); + } + return data; + }, + server_data_node: create_data_node( + // server_data_node is undefined if it wasn't reloaded from the server; + // and if current loader uses server data, we want to reuse previous data. + server_data_node === void 0 && loader[0] ? { type: "skip" } : server_data_node ?? null, + loader[0] ? previous == null ? void 0 : previous.server : void 0 + ) + }); + }); + for (const p of branch_promises) + p.catch(() => { + }); + const branch = []; + for (let i = 0; i < loaders.length; i += 1) { + if (loaders[i]) { + try { + branch.push(await branch_promises[i]); + } catch (err) { + if (err instanceof Redirect) { + return { + type: "redirect", + location: err.location + }; + } + let status = 500; + let error; + if (server_data_nodes == null ? void 0 : server_data_nodes.includes( + /** @type {import('types').ServerErrorNode} */ + err + )) { + status = /** @type {import('types').ServerErrorNode} */ + err.status ?? status; + error = /** @type {import('types').ServerErrorNode} */ + err.error; + } else if (err instanceof HttpError) { + status = err.status; + error = err.body; + } else { + const updated = await stores.updated.check(); + if (updated) { + return await native_navigation(url); + } + error = await handle_error(err, { params, url, route: { id: route.id } }); + } + const error_load = await load_nearest_error_page(i, branch, errors); + if (error_load) { + return await get_navigation_result_from_branch({ + url, + params, + branch: branch.slice(0, error_load.idx).concat(error_load.node), + status, + error, + route + }); + } else { + return await server_fallback(url, { id: route.id }, error, status); + } + } + } else { + branch.push(void 0); + } + } + return await get_navigation_result_from_branch({ + url, + params, + branch, + status: 200, + error: null, + route, + // Reset `form` on navigation, but not invalidation + form: invalidating ? void 0 : null + }); + } + async function load_nearest_error_page(i, branch, errors) { + while (i--) { + if (errors[i]) { + let j = i; + while (!branch[j]) + j -= 1; + try { + return { + idx: j + 1, + node: { + node: await /** @type {import('types').CSRPageNodeLoader } */ + errors[i](), + loader: ( + /** @type {import('types').CSRPageNodeLoader } */ + errors[i] + ), + data: {}, + server: null, + universal: null + } + }; + } catch (e) { + continue; + } + } + } + } + async function load_root_error_page({ status, error, url, route }) { + const params = {}; + let server_data_node = null; + const default_layout_has_server_load = server_loads[0] === 0; + if (default_layout_has_server_load) { + try { + const server_data = await load_data(url, [true]); + if (server_data.type !== "data" || server_data.nodes[0] && server_data.nodes[0].type !== "data") { + throw 0; + } + server_data_node = server_data.nodes[0] ?? null; + } catch { + if (url.origin !== location.origin || url.pathname !== location.pathname || hydrated) { + await native_navigation(url); + } + } + } + const root_layout = await load_node({ + loader: default_layout_loader, + url, + params, + route, + parent: () => Promise.resolve({}), + server_data_node: create_data_node(server_data_node) + }); + const root_error = { + node: await default_error_loader(), + loader: default_error_loader, + universal: null, + server: null, + data: null + }; + return await get_navigation_result_from_branch({ + url, + params, + branch: [root_layout, root_error], + status, + error, + route: null + }); + } + function get_navigation_intent(url, invalidating) { + if (is_external_url(url, base)) + return; + const path = get_url_path(url); + for (const route of routes) { + const params = route.exec(path); + if (params) { + const id = url.pathname + url.search; + const intent = { id, invalidating, route, params: decode_params(params), url }; + return intent; + } + } + } + function get_url_path(url) { + return decode_pathname(url.pathname.slice(base.length) || "/"); + } + function before_navigate({ url, type, intent, delta }) { + var _a2, _b; + let should_block = false; + const navigation = { + from: { + params: current.params, + route: { id: ((_a2 = current.route) == null ? void 0 : _a2.id) ?? null }, + url: current.url + }, + to: { + params: (intent == null ? void 0 : intent.params) ?? null, + route: { id: ((_b = intent == null ? void 0 : intent.route) == null ? void 0 : _b.id) ?? null }, + url + }, + willUnload: !intent, + type + }; + if (delta !== void 0) { + navigation.delta = delta; + } + const cancellable = { + ...navigation, + cancel: () => { + should_block = true; + } + }; + if (!navigating) { + callbacks.before_navigate.forEach((fn) => fn(cancellable)); + } + return should_block ? null : navigation; + } + async function navigate({ + url, + scroll: scroll2, + keepfocus, + redirect_chain, + details, + type, + delta, + nav_token, + accepted, + blocked + }) { + const intent = get_navigation_intent(url, false); + const navigation = before_navigate({ url, type, delta, intent }); + if (!navigation) { + blocked(); + return; + } + const previous_history_index = current_history_index; + accepted(); + navigating = true; + if (started) { + stores.navigating.set(navigation); + } + await update( + intent, + url, + redirect_chain, + previous_history_index, + { + scroll: scroll2, + keepfocus, + details + }, + nav_token, + () => { + navigating = false; + callbacks.after_navigate.forEach( + (fn) => fn( + /** @type {import('types').AfterNavigate} */ + navigation + ) + ); + stores.navigating.set(null); + } + ); + } + async function server_fallback(url, route, error, status) { + if (url.origin === location.origin && url.pathname === location.pathname && !hydrated) { + return await load_root_error_page({ + status, + error, + url, + route + }); + } + return await native_navigation(url); + } + function native_navigation(url) { + location.href = url.href; + return new Promise(() => { + }); + } + function setup_preload() { + let mousemove_timeout; + container.addEventListener("mousemove", (event) => { + const target2 = ( + /** @type {Element} */ + event.target + ); + clearTimeout(mousemove_timeout); + mousemove_timeout = setTimeout(() => { + preload2(target2, 2); + }, 20); + }); + function tap(event) { + preload2( + /** @type {Element} */ + event.composedPath()[0], + 1 + ); + } + container.addEventListener("mousedown", tap); + container.addEventListener("touchstart", tap, { passive: true }); + const observer = new IntersectionObserver( + (entries) => { + for (const entry of entries) { + if (entry.isIntersecting) { + preload_code( + get_url_path(new URL( + /** @type {HTMLAnchorElement} */ + entry.target.href + )) + ); + observer.unobserve(entry.target); + } + } + }, + { threshold: 0 } + ); + function preload2(element2, priority) { + const a = find_anchor(element2, container); + if (!a) + return; + const { url, external } = get_link_info(a, base); + if (external) + return; + const options = get_router_options(a); + if (!options.reload) { + if (priority <= options.preload_data) { + const intent = get_navigation_intent( + /** @type {URL} */ + url, + false + ); + if (intent) { + { + preload_data(intent); + } + } + } else if (priority <= options.preload_code) { + preload_code(get_url_path( + /** @type {URL} */ + url + )); + } + } + } + function after_navigate() { + observer.disconnect(); + for (const a of container.querySelectorAll("a")) { + const { url, external } = get_link_info(a, base); + if (external) + continue; + const options = get_router_options(a); + if (options.reload) + continue; + if (options.preload_code === PRELOAD_PRIORITIES.viewport) { + observer.observe(a); + } + if (options.preload_code === PRELOAD_PRIORITIES.eager) { + preload_code(get_url_path( + /** @type {URL} */ + url + )); + } + } + } + callbacks.after_navigate.push(after_navigate); + after_navigate(); + } + return { + after_navigate: (fn) => { + onMount(() => { + callbacks.after_navigate.push(fn); + return () => { + const i = callbacks.after_navigate.indexOf(fn); + callbacks.after_navigate.splice(i, 1); + }; + }); + }, + before_navigate: (fn) => { + onMount(() => { + callbacks.before_navigate.push(fn); + return () => { + const i = callbacks.before_navigate.indexOf(fn); + callbacks.before_navigate.splice(i, 1); + }; + }); + }, + disable_scroll_handling: () => { + if (updating || !started) { + autoscroll = false; + } + }, + goto: (href, opts = {}) => { + return goto(href, opts, []); + }, + invalidate: (resource) => { + if (typeof resource === "function") { + invalidated.push(resource); + } else { + const { href } = new URL(resource, location.href); + invalidated.push((url) => url.href === href); + } + return invalidate(); + }, + invalidateAll: () => { + force_invalidation = true; + return invalidate(); + }, + preload_data: async (href) => { + const url = new URL(href, get_base_uri(document)); + const intent = get_navigation_intent(url, false); + if (!intent) { + throw new Error(`Attempted to preload a URL that does not belong to this app: ${url}`); + } + await preload_data(intent); + }, + preload_code, + apply_action: async (result) => { + if (result.type === "error") { + const url = new URL(location.href); + const { branch, route } = current; + if (!route) + return; + const error_load = await load_nearest_error_page( + current.branch.length, + branch, + route.errors + ); + if (error_load) { + const navigation_result = await get_navigation_result_from_branch({ + url, + params: current.params, + branch: branch.slice(0, error_load.idx).concat(error_load.node), + status: result.status ?? 500, + error: result.error, + route + }); + current = navigation_result.state; + root.$set(navigation_result.props); + tick().then(reset_focus); + } + } else if (result.type === "redirect") { + goto(result.location, { invalidateAll: true }, []); + } else { + const props = { + form: result.data, + page: { ...page, form: result.data, status: result.status } + }; + root.$set(props); + if (result.type === "success") { + tick().then(reset_focus); + } + } + }, + _start_router: () => { + var _a2; + history.scrollRestoration = "manual"; + addEventListener("beforeunload", (e) => { + var _a3; + let should_block = false; + if (!navigating) { + const navigation = { + from: { + params: current.params, + route: { id: ((_a3 = current.route) == null ? void 0 : _a3.id) ?? null }, + url: current.url + }, + to: null, + willUnload: true, + type: "leave", + cancel: () => should_block = true + }; + callbacks.before_navigate.forEach((fn) => fn(navigation)); + } + if (should_block) { + e.preventDefault(); + e.returnValue = ""; + } else { + history.scrollRestoration = "auto"; + } + }); + addEventListener("visibilitychange", () => { + if (document.visibilityState === "hidden") { + update_scroll_positions(current_history_index); + set(SCROLL_KEY, scroll_positions); + capture_snapshot(current_history_index); + set(SNAPSHOT_KEY, snapshots); + } + }); + if (!((_a2 = navigator.connection) == null ? void 0 : _a2.saveData)) { + setup_preload(); + } + container.addEventListener("click", (event) => { + if (event.button || event.which !== 1) + return; + if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) + return; + if (event.defaultPrevented) + return; + const a = find_anchor( + /** @type {Element} */ + event.composedPath()[0], + container + ); + if (!a) + return; + const { url, external, target: target2 } = get_link_info(a, base); + if (!url) + return; + if (target2 === "_parent" || target2 === "_top") { + if (window.parent !== window) + return; + } else if (target2 && target2 !== "_self") { + return; + } + const options = get_router_options(a); + const is_svg_a_element = a instanceof SVGAElement; + if (!is_svg_a_element && url.protocol !== location.protocol && !(url.protocol === "https:" || url.protocol === "http:")) + return; + if (external || options.reload) { + const navigation = before_navigate({ url, type: "link" }); + if (!navigation) { + event.preventDefault(); + } + navigating = true; + return; + } + const [nonhash, hash2] = url.href.split("#"); + if (hash2 !== void 0 && nonhash === location.href.split("#")[0]) { + hash_navigating = true; + update_scroll_positions(current_history_index); + current.url = url; + stores.page.set({ ...page, url }); + stores.page.notify(); + return; + } + navigate({ + url, + scroll: options.noscroll ? scroll_state() : null, + keepfocus: false, + redirect_chain: [], + details: { + state: {}, + replaceState: url.href === location.href + }, + accepted: () => event.preventDefault(), + blocked: () => event.preventDefault(), + type: "link" + }); + }); + container.addEventListener("submit", (event) => { + if (event.defaultPrevented) + return; + const form = ( + /** @type {HTMLFormElement} */ + HTMLFormElement.prototype.cloneNode.call(event.target) + ); + const submitter = ( + /** @type {HTMLButtonElement | HTMLInputElement | null} */ + event.submitter + ); + const method = (submitter == null ? void 0 : submitter.formMethod) || form.method; + if (method !== "get") + return; + const url = new URL( + (submitter == null ? void 0 : submitter.hasAttribute("formaction")) && (submitter == null ? void 0 : submitter.formAction) || form.action + ); + if (is_external_url(url, base)) + return; + const event_form = ( + /** @type {HTMLFormElement} */ + event.target + ); + const { noscroll, reload } = get_router_options(event_form); + if (reload) + return; + event.preventDefault(); + event.stopPropagation(); + const data = new FormData(event_form); + const submitter_name = submitter == null ? void 0 : submitter.getAttribute("name"); + if (submitter_name) { + data.append(submitter_name, (submitter == null ? void 0 : submitter.getAttribute("value")) ?? ""); + } + url.search = new URLSearchParams(data).toString(); + navigate({ + url, + scroll: noscroll ? scroll_state() : null, + keepfocus: false, + redirect_chain: [], + details: { + state: {}, + replaceState: false + }, + nav_token: {}, + accepted: () => { + }, + blocked: () => { + }, + type: "form" + }); + }); + addEventListener("popstate", async (event) => { + var _a3; + if ((_a3 = event.state) == null ? void 0 : _a3[INDEX_KEY]) { + if (event.state[INDEX_KEY] === current_history_index) + return; + const scroll2 = scroll_positions[event.state[INDEX_KEY]]; + if (current.url.href.split("#")[0] === location.href.split("#")[0]) { + scroll_positions[current_history_index] = scroll_state(); + current_history_index = event.state[INDEX_KEY]; + scrollTo(scroll2.x, scroll2.y); + return; + } + const delta = event.state[INDEX_KEY] - current_history_index; + let blocked = false; + await navigate({ + url: new URL(location.href), + scroll: scroll2, + keepfocus: false, + redirect_chain: [], + details: null, + accepted: () => { + current_history_index = event.state[INDEX_KEY]; + }, + blocked: () => { + history.go(-delta); + blocked = true; + }, + type: "popstate", + delta + }); + if (!blocked) { + restore_snapshot(current_history_index); + } + } + }); + addEventListener("hashchange", () => { + if (hash_navigating) { + hash_navigating = false; + history.replaceState( + { ...history.state, [INDEX_KEY]: ++current_history_index }, + "", + location.href + ); + } + }); + for (const link of document.querySelectorAll("link")) { + if (link.rel === "icon") + link.href = link.href; + } + addEventListener("pageshow", (event) => { + if (event.persisted) { + stores.navigating.set(null); + } + }); + }, + _hydrate: async ({ + status = 200, + error, + node_ids, + params, + route, + data: server_data_nodes, + form + }) => { + hydrated = true; + const url = new URL(location.href); + { + ({ params = {}, route = { id: null } } = get_navigation_intent(url, false) || {}); + } + let result; + try { + const branch_promises = node_ids.map(async (n, i) => { + const server_data_node = server_data_nodes[i]; + return load_node({ + loader: nodes[n], + url, + params, + route, + parent: async () => { + const data = {}; + for (let j = 0; j < i; j += 1) { + Object.assign(data, (await branch_promises[j]).data); + } + return data; + }, + server_data_node: create_data_node(server_data_node) + }); + }); + result = await get_navigation_result_from_branch({ + url, + params, + branch: await Promise.all(branch_promises), + status, + error, + form, + route: routes.find(({ id }) => id === route.id) ?? null + }); + } catch (error2) { + if (error2 instanceof Redirect) { + await native_navigation(new URL(error2.location, location.href)); + return; + } + result = await load_root_error_page({ + status: error2 instanceof HttpError ? error2.status : 500, + error: await handle_error(error2, { url, params, route }), + url, + route + }); + } + initialize(result); + } + }; +} +async function load_data(url, invalid) { + var _a; + const data_url = new URL(url); + data_url.pathname = add_data_suffix(url.pathname); + data_url.searchParams.append( + "x-sveltekit-invalidated", + invalid.map((x) => x ? "1" : "").join("_") + ); + const res = await native_fetch(data_url.href); + const data = await res.json(); + if (!res.ok) { + throw new HttpError(res.status, data); + } + (_a = data.nodes) == null ? void 0 : _a.forEach((node) => { + if ((node == null ? void 0 : node.type) === "data") { + node.data = unflatten(node.data); + node.uses = { + dependencies: new Set(node.uses.dependencies ?? []), + params: new Set(node.uses.params ?? []), + parent: !!node.uses.parent, + route: !!node.uses.route, + url: !!node.uses.url + }; + } + }); + return data; +} +function handle_error(error, event) { + if (error instanceof HttpError) { + return error.body; + } + return hooks.handleError({ error, event }) ?? /** @type {any} */ + { message: event.route.id != null ? "Internal Error" : "Not Found" }; +} +function reset_focus() { + const autofocus = document.querySelector("[autofocus]"); + if (autofocus) { + autofocus.focus(); + } else { + const root = document.body; + const tabindex = root.getAttribute("tabindex"); + root.tabIndex = -1; + root.focus({ preventScroll: true }); + if (tabindex !== null) { + root.setAttribute("tabindex", tabindex); + } else { + root.removeAttribute("tabindex"); + } + return new Promise((resolve) => { + setTimeout(() => { + var _a; + resolve((_a = getSelection()) == null ? void 0 : _a.removeAllRanges()); + }); + }); + } +} +async function start({ assets, env, hydrate, target, version }) { + set_assets(assets); + set_version(version); + const client = create_client({ + target + }); + init$1({ client }); + if (hydrate) { + await client._hydrate(hydrate); + } else { + client.goto(location.href, { replaceState: true }); + } + client._start_router(); +} +export { + start +}; diff --git a/_app/version.json b/_app/version.json new file mode 100644 index 0000000..2c21e5b --- /dev/null +++ b/_app/version.json @@ -0,0 +1 @@ +{"version":"1676148945818"} \ No newline at end of file diff --git a/favicon.png b/favicon.png new file mode 100644 index 0000000..17fc761 Binary files /dev/null and b/favicon.png differ diff --git a/index.html b/index.html new file mode 100644 index 0000000..a6c4c5b --- /dev/null +++ b/index.html @@ -0,0 +1,97 @@ + + + + + + + + + + + + + + + Web3Privacy Prague 2023 + + +
+ + +
+
+
Ticket
+
Web3Privacy Prague
+
Monday, 5. June 2023
+
X10, Prague
+ + + +
For the first time in the internetโ€™s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy. +
+
Key themes
+
Human rights DAOs (pro-privacy)
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Identity (ID)
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Mixnets โ†’ Full-Stack Privacy
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Cryptography
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Tech journalists
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Asian community
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Privacy wars
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Privacy workforce
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Privacy activist's
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
R&D (ZK, MPC)
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Network states (with a privacy focus)
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Solarpunk vs Lunarpunk
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
Veksl
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
+
+ +
Speakers
+
+ +
Program
+ +
Sponsors
+ +
Ticket
+
Conference ticket
+
Party ticket
+
+ + +
+
+
๐Ÿ’› Organized by ETHBrno team
+ + + +
+ + diff --git a/web3privacy.png b/web3privacy.png new file mode 100644 index 0000000..378c11f Binary files /dev/null and b/web3privacy.png differ