JCEEE
750 lines
25 KiB
JavaScript
750 lines
25 KiB
JavaScript
import "./internal2.js";
|
|
import { t as uneval } from "./uneval.js";
|
|
import { $ as define_property, A as get_next_sibling, B as hydrate_node, C as get, D as clear_text_content, E as component_root, F as boundary, H as set_hydrate_node, I as component_context, J as hydration_failed, L as pop, M as mutable_source, N as set, O as create_text, P as flushSync, Q as array_from, R as push, S as active_reaction, T as set_active_reaction, U as set_hydrating, V as hydrating, W as hydration_mismatch, X as LEGACY_PROPS, Y as experimental_async_required, a as get_render_context, c as getContext, d as ssr_context, et as noop, h as getAbortSignal, j as init_operations, k as get_first_child, l as hasContext, m as lifecycle_function_unavailable, o as createContext, p as hydratable_serialization_failed, q as HYDRATION_ERROR, r as render, s as getAllContexts, t as derived, tt as run, u as setContext, v as is_passive_event, w as set_active_effect, x as active_effect, z as async_mode_flag } from "./async.js";
|
|
//#region \0rolldown/runtime.js
|
|
var __defProp = Object.defineProperty;
|
|
var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
|
|
var __exportAll = (all, no_symbols) => {
|
|
let target = {};
|
|
for (var name in all) __defProp(target, name, {
|
|
get: all[name],
|
|
enumerable: true
|
|
});
|
|
if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
|
|
return target;
|
|
};
|
|
//#endregion
|
|
//#region \0virtual:__sveltekit/env
|
|
var explicit_public_env = {};
|
|
var rendered_env = {};
|
|
function set_env(env) {}
|
|
//#endregion
|
|
//#region \0virtual:__sveltekit/server
|
|
var read_implementation = null;
|
|
function set_read_implementation(fn) {
|
|
read_implementation = fn;
|
|
}
|
|
function set_manifest(_) {}
|
|
//#endregion
|
|
//#region ../node_modules/.pnpm/svelte@5.56.3/node_modules/svelte/src/internal/client/dom/elements/events.js
|
|
/**
|
|
* Used on elements, as a map of event type -> event handler,
|
|
* and on events themselves to track which element handled an event
|
|
*/
|
|
var event_symbol = Symbol("events");
|
|
/** @type {Set<string>} */
|
|
var all_registered_events = /* @__PURE__ */ new Set();
|
|
/** @type {Set<(events: Array<string>) => void>} */
|
|
var root_event_handles = /* @__PURE__ */ new Set();
|
|
var last_propagated_event = null;
|
|
/**
|
|
* @this {EventTarget}
|
|
* @param {Event} event
|
|
* @returns {void}
|
|
*/
|
|
function handle_event_propagation(event) {
|
|
var handler_element = this;
|
|
var owner_document = handler_element.ownerDocument;
|
|
var event_name = event.type;
|
|
var path = event.composedPath?.() || [];
|
|
var current_target = path[0] || event.target;
|
|
last_propagated_event = event;
|
|
var path_idx = 0;
|
|
var handled_at = last_propagated_event === event && event[event_symbol];
|
|
if (handled_at) {
|
|
var at_idx = path.indexOf(handled_at);
|
|
if (at_idx !== -1 && (handler_element === document || handler_element === window)) {
|
|
event[event_symbol] = handler_element;
|
|
return;
|
|
}
|
|
var handler_idx = path.indexOf(handler_element);
|
|
if (handler_idx === -1) return;
|
|
if (at_idx <= handler_idx) path_idx = at_idx;
|
|
}
|
|
current_target = path[path_idx] || event.target;
|
|
if (current_target === handler_element) return;
|
|
define_property(event, "currentTarget", {
|
|
configurable: true,
|
|
get() {
|
|
return current_target || owner_document;
|
|
}
|
|
});
|
|
var previous_reaction = active_reaction;
|
|
var previous_effect = active_effect;
|
|
set_active_reaction(null);
|
|
set_active_effect(null);
|
|
try {
|
|
/**
|
|
* @type {unknown}
|
|
*/
|
|
var throw_error;
|
|
/**
|
|
* @type {unknown[]}
|
|
*/
|
|
var other_errors = [];
|
|
while (current_target !== null) {
|
|
if (current_target === handler_element) break;
|
|
try {
|
|
var delegated = current_target[event_symbol]?.[event_name];
|
|
if (delegated != null && (!current_target.disabled || event.target === current_target)) delegated.call(current_target, event);
|
|
} catch (error) {
|
|
if (throw_error) other_errors.push(error);
|
|
else throw_error = error;
|
|
}
|
|
if (event.cancelBubble) break;
|
|
path_idx++;
|
|
current_target = path_idx < path.length ? path[path_idx] : null;
|
|
}
|
|
if (throw_error) {
|
|
for (let error of other_errors) queueMicrotask(() => {
|
|
throw error;
|
|
});
|
|
throw throw_error;
|
|
}
|
|
} finally {
|
|
event[event_symbol] = handler_element;
|
|
delete event.currentTarget;
|
|
set_active_reaction(previous_reaction);
|
|
set_active_effect(previous_effect);
|
|
}
|
|
}
|
|
globalThis?.window?.trustedTypes;
|
|
//#endregion
|
|
//#region ../node_modules/.pnpm/svelte@5.56.3/node_modules/svelte/src/internal/client/dom/template.js
|
|
/**
|
|
* @param {TemplateNode} start
|
|
* @param {TemplateNode | null} end
|
|
*/
|
|
function assign_nodes(start, end) {
|
|
var effect = active_effect;
|
|
if (effect.nodes === null) effect.nodes = {
|
|
start,
|
|
end,
|
|
a: null,
|
|
t: null
|
|
};
|
|
}
|
|
/**
|
|
* Mounts a component to the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component.
|
|
* Transitions will play during the initial render unless the `intro` option is set to `false`.
|
|
*
|
|
* @template {Record<string, any>} Props
|
|
* @template {Record<string, any>} Exports
|
|
* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
|
|
* @param {MountOptions<Props>} options
|
|
* @returns {Exports}
|
|
*/
|
|
function mount$1(component, options) {
|
|
return _mount(component, options);
|
|
}
|
|
/**
|
|
* Hydrates a component on the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component
|
|
*
|
|
* @template {Record<string, any>} Props
|
|
* @template {Record<string, any>} Exports
|
|
* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
|
|
* @param {{} extends Props ? {
|
|
* target: Document | Element | ShadowRoot;
|
|
* props?: Props;
|
|
* events?: Record<string, (e: any) => any>;
|
|
* context?: Map<any, any>;
|
|
* intro?: boolean;
|
|
* recover?: boolean;
|
|
* transformError?: (error: unknown) => unknown;
|
|
* } : {
|
|
* target: Document | Element | ShadowRoot;
|
|
* props: Props;
|
|
* events?: Record<string, (e: any) => any>;
|
|
* context?: Map<any, any>;
|
|
* intro?: boolean;
|
|
* recover?: boolean;
|
|
* transformError?: (error: unknown) => unknown;
|
|
* }} options
|
|
* @returns {Exports}
|
|
*/
|
|
function hydrate$1(component, options) {
|
|
init_operations();
|
|
options.intro = options.intro ?? false;
|
|
const target = options.target;
|
|
const was_hydrating = hydrating;
|
|
const previous_hydrate_node = hydrate_node;
|
|
try {
|
|
var anchor = /* @__PURE__ */ get_first_child(target);
|
|
while (anchor && (anchor.nodeType !== 8 || anchor.data !== "[")) anchor = /* @__PURE__ */ get_next_sibling(anchor);
|
|
if (!anchor) throw HYDRATION_ERROR;
|
|
set_hydrating(true);
|
|
set_hydrate_node(anchor);
|
|
const instance = _mount(component, {
|
|
...options,
|
|
anchor
|
|
});
|
|
set_hydrating(false);
|
|
return instance;
|
|
} catch (error) {
|
|
if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) throw error;
|
|
if (error !== HYDRATION_ERROR) console.warn("Failed to hydrate: ", error);
|
|
if (options.recover === false) hydration_failed();
|
|
init_operations();
|
|
clear_text_content(target);
|
|
set_hydrating(false);
|
|
return mount$1(component, options);
|
|
} finally {
|
|
set_hydrating(was_hydrating);
|
|
set_hydrate_node(previous_hydrate_node);
|
|
}
|
|
}
|
|
/** @type {Map<EventTarget, Map<string, number>>} */
|
|
var listeners = /* @__PURE__ */ new Map();
|
|
/**
|
|
* @template {Record<string, any>} Exports
|
|
* @param {ComponentType<SvelteComponent<any>> | Component<any>} Component
|
|
* @param {MountOptions} options
|
|
* @returns {Exports}
|
|
*/
|
|
function _mount(Component, { target, anchor, props = {}, events, context, intro = true, transformError }) {
|
|
init_operations();
|
|
/** @type {Exports} */
|
|
var component = void 0;
|
|
var unmount = component_root(() => {
|
|
var anchor_node = anchor ?? target.appendChild(create_text());
|
|
boundary(anchor_node, { pending: () => {} }, (anchor_node) => {
|
|
push({});
|
|
var ctx = component_context;
|
|
if (context) ctx.c = context;
|
|
if (events)
|
|
/** @type {any} */ props.$$events = events;
|
|
if (hydrating) assign_nodes(anchor_node, null);
|
|
component = Component(anchor_node, props) || {};
|
|
if (hydrating) {
|
|
/** @type {Effect & { nodes: EffectNodes }} */ active_effect.nodes.end = hydrate_node;
|
|
if (hydrate_node === null || hydrate_node.nodeType !== 8 || hydrate_node.data !== "]") {
|
|
hydration_mismatch();
|
|
throw HYDRATION_ERROR;
|
|
}
|
|
}
|
|
pop();
|
|
}, transformError);
|
|
/** @type {Set<string>} */
|
|
var registered_events = /* @__PURE__ */ new Set();
|
|
/** @param {Array<string>} events */
|
|
var event_handle = (events) => {
|
|
for (var i = 0; i < events.length; i++) {
|
|
var event_name = events[i];
|
|
if (registered_events.has(event_name)) continue;
|
|
registered_events.add(event_name);
|
|
var passive = is_passive_event(event_name);
|
|
for (const node of [target, document]) {
|
|
var counts = listeners.get(node);
|
|
if (counts === void 0) {
|
|
counts = /* @__PURE__ */ new Map();
|
|
listeners.set(node, counts);
|
|
}
|
|
var count = counts.get(event_name);
|
|
if (count === void 0) {
|
|
node.addEventListener(event_name, handle_event_propagation, { passive });
|
|
counts.set(event_name, 1);
|
|
} else counts.set(event_name, count + 1);
|
|
}
|
|
}
|
|
};
|
|
event_handle(array_from(all_registered_events));
|
|
root_event_handles.add(event_handle);
|
|
return () => {
|
|
for (var event_name of registered_events) for (const node of [target, document]) {
|
|
var counts = listeners.get(node);
|
|
var count = counts.get(event_name);
|
|
if (--count == 0) {
|
|
node.removeEventListener(event_name, handle_event_propagation);
|
|
counts.delete(event_name);
|
|
if (counts.size === 0) listeners.delete(node);
|
|
} else counts.set(event_name, count);
|
|
}
|
|
root_event_handles.delete(event_handle);
|
|
if (anchor_node !== anchor) anchor_node.parentNode?.removeChild(anchor_node);
|
|
};
|
|
});
|
|
mounted_components.set(component, unmount);
|
|
return component;
|
|
}
|
|
/**
|
|
* References of the components that were mounted or hydrated.
|
|
* Uses a `WeakMap` to avoid memory leaks.
|
|
*/
|
|
var mounted_components = /* @__PURE__ */ new WeakMap();
|
|
/**
|
|
* Unmounts a component that was previously mounted using `mount` or `hydrate`.
|
|
*
|
|
* Since 5.13.0, if `options.outro` is `true`, [transitions](https://svelte.dev/docs/svelte/transition) will play before the component is removed from the DOM.
|
|
*
|
|
* Returns a `Promise` that resolves after transitions have completed if `options.outro` is true, or immediately otherwise (prior to 5.13.0, returns `void`).
|
|
*
|
|
* ```js
|
|
* import { mount, unmount } from 'svelte';
|
|
* import App from './App.svelte';
|
|
*
|
|
* const app = mount(App, { target: document.body });
|
|
*
|
|
* // later...
|
|
* unmount(app, { outro: true });
|
|
* ```
|
|
* @param {Record<string, any>} component
|
|
* @param {{ outro?: boolean }} [options]
|
|
* @returns {Promise<void>}
|
|
*/
|
|
function unmount$1(component, options) {
|
|
const fn = mounted_components.get(component);
|
|
if (fn) {
|
|
mounted_components.delete(component);
|
|
return fn(options);
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
//#endregion
|
|
//#region ../node_modules/.pnpm/svelte@5.56.3/node_modules/svelte/src/legacy/legacy-client.js
|
|
/** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
|
|
/**
|
|
* Takes the component function and returns a Svelte 4 compatible component constructor.
|
|
*
|
|
* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
|
|
*
|
|
* @template {Record<string, any>} Props
|
|
* @template {Record<string, any>} Exports
|
|
* @template {Record<string, any>} Events
|
|
* @template {Record<string, any>} Slots
|
|
*
|
|
* @param {SvelteComponent<Props, Events, Slots> | Component<Props>} component
|
|
* @returns {ComponentType<SvelteComponent<Props, Events, Slots> & Exports>}
|
|
*/
|
|
function asClassComponent$1(component) {
|
|
return class extends Svelte4Component {
|
|
/** @param {any} options */
|
|
constructor(options) {
|
|
super({
|
|
component,
|
|
...options
|
|
});
|
|
}
|
|
};
|
|
}
|
|
/**
|
|
* Support using the component as both a class and function during the transition period
|
|
* @typedef {{new (o: ComponentConstructorOptions): SvelteComponent;(...args: Parameters<Component<Record<string, any>>>): ReturnType<Component<Record<string, any>, Record<string, any>>>;}} LegacyComponentType
|
|
*/
|
|
var Svelte4Component = class {
|
|
/** @type {any} */
|
|
#events;
|
|
/** @type {Record<string, any>} */
|
|
#instance;
|
|
/**
|
|
* @param {ComponentConstructorOptions & {
|
|
* component: any;
|
|
* }} options
|
|
*/
|
|
constructor(options) {
|
|
var sources = /* @__PURE__ */ new Map();
|
|
/**
|
|
* @param {string | symbol} key
|
|
* @param {unknown} value
|
|
*/
|
|
var add_source = (key, value) => {
|
|
var s = /* @__PURE__ */ mutable_source(value, false, false);
|
|
sources.set(key, s);
|
|
return s;
|
|
};
|
|
const props = new Proxy({
|
|
...options.props || {},
|
|
$$events: {}
|
|
}, {
|
|
get(target, prop) {
|
|
return get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
|
|
},
|
|
has(target, prop) {
|
|
if (prop === LEGACY_PROPS) return true;
|
|
get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
|
|
return Reflect.has(target, prop);
|
|
},
|
|
set(target, prop, value) {
|
|
set(sources.get(prop) ?? add_source(prop, value), value);
|
|
return Reflect.set(target, prop, value);
|
|
}
|
|
});
|
|
this.#instance = (options.hydrate ? hydrate$1 : mount$1)(options.component, {
|
|
target: options.target,
|
|
anchor: options.anchor,
|
|
props,
|
|
context: options.context,
|
|
intro: options.intro ?? false,
|
|
recover: options.recover,
|
|
transformError: options.transformError
|
|
});
|
|
if (!async_mode_flag && (!options?.props?.$$host || options.sync === false)) flushSync();
|
|
this.#events = props.$$events;
|
|
for (const key of Object.keys(this.#instance)) {
|
|
if (key === "$set" || key === "$destroy" || key === "$on") continue;
|
|
define_property(this, key, {
|
|
get() {
|
|
return this.#instance[key];
|
|
},
|
|
/** @param {any} value */
|
|
set(value) {
|
|
this.#instance[key] = value;
|
|
},
|
|
enumerable: true
|
|
});
|
|
}
|
|
this.#instance.$set = (next) => {
|
|
Object.assign(props, next);
|
|
};
|
|
this.#instance.$destroy = () => {
|
|
unmount$1(this.#instance);
|
|
};
|
|
}
|
|
/** @param {Record<string, any>} props */
|
|
$set(props) {
|
|
this.#instance.$set(props);
|
|
}
|
|
/**
|
|
* @param {string} event
|
|
* @param {(...args: any[]) => any} callback
|
|
* @returns {any}
|
|
*/
|
|
$on(event, callback) {
|
|
this.#events[event] = this.#events[event] || [];
|
|
/** @param {any[]} args */
|
|
const cb = (...args) => callback.call(this, ...args);
|
|
this.#events[event].push(cb);
|
|
return () => {
|
|
this.#events[event] = this.#events[event].filter(
|
|
/** @param {any} fn */
|
|
(fn) => fn !== cb
|
|
);
|
|
};
|
|
}
|
|
$destroy() {
|
|
this.#instance.$destroy();
|
|
}
|
|
};
|
|
//#endregion
|
|
//#region ../node_modules/.pnpm/svelte@5.56.3/node_modules/svelte/src/legacy/legacy-server.js
|
|
/** @import { SvelteComponent } from '../index.js' */
|
|
/** @import { Csp } from '#server' */
|
|
/** @typedef {{ head: string, html: string, css: { code: string, map: null }; hashes?: { script: `sha256-${string}`[] } }} LegacyRenderResult */
|
|
/**
|
|
* Takes a Svelte 5 component and returns a Svelte 4 compatible component constructor.
|
|
*
|
|
* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
|
|
*
|
|
* @template {Record<string, any>} Props
|
|
* @template {Record<string, any>} Exports
|
|
* @template {Record<string, any>} Events
|
|
* @template {Record<string, any>} Slots
|
|
*
|
|
* @param {SvelteComponent<Props, Events, Slots>} component
|
|
* @returns {typeof SvelteComponent<Props, Events, Slots> & Exports}
|
|
*/
|
|
function asClassComponent(component) {
|
|
const component_constructor = asClassComponent$1(component);
|
|
/** @type {(props?: {}, opts?: { $$slots?: {}; context?: Map<any, any>; csp?: Csp; transformError?: (error: unknown) => unknown }) => LegacyRenderResult & PromiseLike<LegacyRenderResult> } */
|
|
const _render = (props, { context, csp, transformError } = {}) => {
|
|
const result = render(component, {
|
|
props,
|
|
context,
|
|
csp,
|
|
transformError
|
|
});
|
|
const munged = Object.defineProperties({}, {
|
|
css: { value: {
|
|
code: "",
|
|
map: null
|
|
} },
|
|
head: { get: () => result.head },
|
|
html: { get: () => result.body },
|
|
then: {
|
|
/**
|
|
* this is not type-safe, but honestly it's the best I can do right now, and it's a straightforward function.
|
|
*
|
|
* @template TResult1
|
|
* @template [TResult2=never]
|
|
* @param { (value: LegacyRenderResult) => TResult1 } onfulfilled
|
|
* @param { (reason: unknown) => TResult2 } onrejected
|
|
*/
|
|
value: (onfulfilled, onrejected) => {
|
|
if (!async_mode_flag) {
|
|
const user_result = onfulfilled({
|
|
css: munged.css,
|
|
head: munged.head,
|
|
html: munged.html
|
|
});
|
|
return Promise.resolve(user_result);
|
|
}
|
|
return result.then((result) => {
|
|
return onfulfilled({
|
|
css: munged.css,
|
|
head: result.head,
|
|
html: result.body,
|
|
hashes: result.hashes
|
|
});
|
|
}, onrejected);
|
|
} }
|
|
});
|
|
return munged;
|
|
};
|
|
component_constructor.render = _render;
|
|
return component_constructor;
|
|
}
|
|
//#endregion
|
|
//#region ../node_modules/.pnpm/svelte@5.56.3/node_modules/svelte/src/internal/server/hydratable.js
|
|
/** @import { HydratableLookupEntry } from '#server' */
|
|
/**
|
|
* @template T
|
|
* @param {string} key
|
|
* @param {() => T} fn
|
|
* @returns {T}
|
|
*/
|
|
function hydratable(key, fn) {
|
|
if (!async_mode_flag) experimental_async_required("hydratable");
|
|
const { hydratable } = get_render_context();
|
|
let entry = hydratable.lookup.get(key);
|
|
if (entry !== void 0) return entry.value;
|
|
const value = fn();
|
|
entry = encode(key, value, hydratable.unresolved_promises);
|
|
hydratable.lookup.set(key, entry);
|
|
return value;
|
|
}
|
|
/**
|
|
* @param {string} key
|
|
* @param {any} value
|
|
* @param {Map<Promise<any>, string>} [unresolved]
|
|
*/
|
|
function encode(key, value, unresolved) {
|
|
/** @type {HydratableLookupEntry} */
|
|
const entry = {
|
|
value,
|
|
serialized: ""
|
|
};
|
|
let uid = 1;
|
|
entry.serialized = uneval(entry.value, (value, uneval) => {
|
|
if (is_promise(value)) {
|
|
const placeholder = `"${uid++}"`;
|
|
const p = value.then((v) => {
|
|
entry.serialized = entry.serialized.replace(placeholder, () => `r(${uneval(v)})`);
|
|
}).catch((devalue_error) => hydratable_serialization_failed(key, serialization_stack(entry.stack, devalue_error?.stack)));
|
|
unresolved?.set(p, key);
|
|
p.catch(() => {}).finally(() => unresolved?.delete(p));
|
|
(entry.promises ??= []).push(p);
|
|
return placeholder;
|
|
}
|
|
});
|
|
return entry;
|
|
}
|
|
/**
|
|
* @param {any} value
|
|
* @returns {value is Promise<any>}
|
|
*/
|
|
function is_promise(value) {
|
|
return Object.prototype.toString.call(value) === "[object Promise]";
|
|
}
|
|
/**
|
|
* @param {string | undefined} root_stack
|
|
* @param {string | undefined} uneval_stack
|
|
*/
|
|
function serialization_stack(root_stack, uneval_stack) {
|
|
let out = "";
|
|
if (root_stack) out += root_stack + "\n";
|
|
if (uneval_stack) out += "Caused by:\n" + uneval_stack + "\n";
|
|
return out || "<missing stack trace>";
|
|
}
|
|
//#endregion
|
|
//#region ../node_modules/.pnpm/svelte@5.56.3/node_modules/svelte/src/internal/server/blocks/snippet.js
|
|
/** @import { Snippet } from 'svelte' */
|
|
/** @import { Renderer } from '../renderer' */
|
|
/** @import { Getters } from '#shared' */
|
|
/**
|
|
* Create a snippet programmatically
|
|
* @template {unknown[]} Params
|
|
* @param {(...params: Getters<Params>) => {
|
|
* render: () => string
|
|
* setup?: (element: Element) => void | (() => void)
|
|
* }} fn
|
|
* @returns {Snippet<Params>}
|
|
*/
|
|
function createRawSnippet(fn) {
|
|
return (renderer, ...args) => {
|
|
var getters = args.map((value) => () => value);
|
|
renderer.push(fn(...getters).render().trim());
|
|
};
|
|
}
|
|
//#endregion
|
|
//#region ../node_modules/.pnpm/svelte@5.56.3/node_modules/svelte/src/index-server.js
|
|
/** @import { SSRContext } from '#server' */
|
|
/** @import { Renderer } from './internal/server/renderer.js' */
|
|
var index_server_exports = /* @__PURE__ */ __exportAll({
|
|
afterUpdate: () => noop,
|
|
beforeUpdate: () => noop,
|
|
createContext: () => createContext,
|
|
createEventDispatcher: () => createEventDispatcher,
|
|
createRawSnippet: () => createRawSnippet,
|
|
flushSync: () => noop,
|
|
fork: () => fork,
|
|
getAbortSignal: () => getAbortSignal,
|
|
getAllContexts: () => getAllContexts,
|
|
getContext: () => getContext,
|
|
hasContext: () => hasContext,
|
|
hydratable: () => hydratable,
|
|
hydrate: () => hydrate,
|
|
mount: () => mount,
|
|
onDestroy: () => onDestroy,
|
|
onMount: () => noop,
|
|
setContext: () => setContext,
|
|
settled: () => settled,
|
|
tick: () => tick,
|
|
unmount: () => unmount,
|
|
untrack: () => run
|
|
});
|
|
/** @param {() => void} fn */
|
|
function onDestroy(fn) {
|
|
/** @type {Renderer} */ ssr_context.r.on_destroy(fn);
|
|
}
|
|
function createEventDispatcher() {
|
|
return noop;
|
|
}
|
|
function mount() {
|
|
lifecycle_function_unavailable("mount");
|
|
}
|
|
function hydrate() {
|
|
lifecycle_function_unavailable("hydrate");
|
|
}
|
|
function unmount() {
|
|
lifecycle_function_unavailable("unmount");
|
|
}
|
|
function fork() {
|
|
lifecycle_function_unavailable("fork");
|
|
}
|
|
async function tick() {}
|
|
async function settled() {}
|
|
//#endregion
|
|
//#region .svelte-kit/generated/root.svelte
|
|
function Root($$renderer, $$props) {
|
|
$$renderer.component(($$renderer) => {
|
|
let { stores, page, constructors, components = [], form, errors = [], error, data_0 = null, data_1 = null } = $$props;
|
|
let data = derived(() => ({
|
|
"0": data_0,
|
|
"1": data_1
|
|
}));
|
|
setContext("__svelte__", stores);
|
|
stores.page.set(page);
|
|
derived(() => constructors[1]);
|
|
function pyramid($$renderer, depth) {
|
|
const Pyramid = constructors[depth];
|
|
function failed($$renderer, error) {
|
|
const ErrorPage = errors[depth];
|
|
if (ErrorPage) {
|
|
$$renderer.push("<!--[-->");
|
|
ErrorPage($$renderer, { error });
|
|
$$renderer.push("<!--]-->");
|
|
} else {
|
|
$$renderer.push("<!--[!-->");
|
|
$$renderer.push("<!--]-->");
|
|
}
|
|
}
|
|
$$renderer.boundary({ failed: errors[depth] ? failed : void 0 }, ($$renderer) => {
|
|
$$renderer.push(`<!--[-->`);
|
|
if (constructors[depth + 1]) {
|
|
$$renderer.push("<!--[0-->");
|
|
const d = data()[depth];
|
|
if (Pyramid) {
|
|
$$renderer.push("<!--[-->");
|
|
Pyramid($$renderer, {
|
|
data: d,
|
|
form,
|
|
params: page.params,
|
|
children: ($$renderer) => {
|
|
pyramid($$renderer, depth + 1);
|
|
},
|
|
$$slots: { default: true }
|
|
});
|
|
$$renderer.push("<!--]-->");
|
|
} else {
|
|
$$renderer.push("<!--[!-->");
|
|
$$renderer.push("<!--]-->");
|
|
}
|
|
} else {
|
|
$$renderer.push("<!--[-1-->");
|
|
const d = data()[depth];
|
|
if (Pyramid) {
|
|
$$renderer.push("<!--[-->");
|
|
Pyramid($$renderer, {
|
|
data: d,
|
|
form,
|
|
params: page.params,
|
|
error
|
|
});
|
|
$$renderer.push("<!--]-->");
|
|
} else {
|
|
$$renderer.push("<!--[!-->");
|
|
$$renderer.push("<!--]-->");
|
|
}
|
|
}
|
|
$$renderer.push(`<!--]-->`);
|
|
$$renderer.push(`<!--]-->`);
|
|
});
|
|
}
|
|
pyramid($$renderer, 0);
|
|
$$renderer.push(`<!----> `);
|
|
$$renderer.push("<!--[-1-->");
|
|
$$renderer.push(`<!--]-->`);
|
|
});
|
|
}
|
|
//#endregion
|
|
//#region .svelte-kit/generated/server/internal.js
|
|
var options = {
|
|
app_template_contains_nonce: false,
|
|
async: true,
|
|
csp: {
|
|
"mode": "auto",
|
|
"directives": {
|
|
"upgrade-insecure-requests": false,
|
|
"block-all-mixed-content": false
|
|
},
|
|
"reportOnly": {
|
|
"upgrade-insecure-requests": false,
|
|
"block-all-mixed-content": false
|
|
}
|
|
},
|
|
csrf_check_origin: true,
|
|
csrf_trusted_origins: [],
|
|
embedded: false,
|
|
hash_routing: false,
|
|
hooks: null,
|
|
link_header_preload: false,
|
|
root: asClassComponent(Root),
|
|
service_worker: false,
|
|
service_worker_options: void 0,
|
|
server_error_boundaries: true,
|
|
templates: {
|
|
app: ({ head, body, assets, nonce, env }) => "<!doctype html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\" />\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n <meta name=\"text-scale\" content=\"scale\" />\n " + head + "\n </head>\n <body data-sveltekit-preload-data=\"hover\">\n <div style=\"display: contents\">" + body + "</div>\n </body>\n</html>\n",
|
|
error: ({ status, message }) => "<!doctype html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\" />\n <title>" + message + "</title>\n\n <style>\n body {\n --bg: white;\n --fg: #222;\n --divider: #ccc;\n background: var(--bg);\n color: var(--fg);\n font-family:\n system-ui,\n -apple-system,\n BlinkMacSystemFont,\n 'Segoe UI',\n Roboto,\n Oxygen,\n Ubuntu,\n Cantarell,\n 'Open Sans',\n 'Helvetica Neue',\n sans-serif;\n display: flex;\n align-items: center;\n justify-content: center;\n height: 100vh;\n margin: 0;\n }\n\n .error {\n display: flex;\n align-items: center;\n max-width: 32rem;\n margin: 0 1rem;\n }\n\n .status {\n font-weight: 200;\n font-size: 3rem;\n line-height: 1;\n position: relative;\n top: -0.05rem;\n }\n\n .message {\n border-left: 1px solid var(--divider);\n padding: 0 0 0 1rem;\n margin: 0 0 0 1rem;\n min-height: 2.5rem;\n display: flex;\n align-items: center;\n }\n\n .message h1 {\n font-weight: 400;\n font-size: 1em;\n margin: 0;\n }\n\n @media (prefers-color-scheme: dark) {\n body {\n --bg: #222;\n --fg: #ddd;\n --divider: #666;\n }\n }\n </style>\n </head>\n <body>\n <div class=\"error\">\n <span class=\"status\">" + status + "</span>\n <div class=\"message\">\n <h1>" + message + "</h1>\n </div>\n </div>\n </body>\n</html>\n"
|
|
},
|
|
version_hash: "1d1q9qt"
|
|
};
|
|
async function get_hooks() {
|
|
let handle;
|
|
let handleFetch;
|
|
let handleError;
|
|
let handleValidationError;
|
|
let init;
|
|
let reroute;
|
|
let transport;
|
|
return {
|
|
handle,
|
|
handleFetch,
|
|
handleError,
|
|
handleValidationError,
|
|
init,
|
|
reroute,
|
|
transport
|
|
};
|
|
}
|
|
//#endregion
|
|
export { set_manifest as a, rendered_env as c, read_implementation as i, set_env as l, options as n, set_read_implementation as o, index_server_exports as r, explicit_public_env as s, get_hooks as t, __commonJSMin as u };
|