4056 lines
123 KiB
JavaScript
4056 lines
123 KiB
JavaScript
import * as devalue from "devalue";
|
||
import { clsx } from "clsx";
|
||
//#region node_modules/svelte/src/internal/shared/errors.js
|
||
/**
|
||
* Cannot use `%name%(...)` unless the `experimental.async` compiler option is `true`
|
||
* @param {string} name
|
||
* @returns {never}
|
||
*/
|
||
function experimental_async_required(name) {
|
||
throw new Error(`https://svelte.dev/e/experimental_async_required`);
|
||
}
|
||
/**
|
||
* `%name%(...)` can only be used during component initialisation
|
||
* @param {string} name
|
||
* @returns {never}
|
||
*/
|
||
function lifecycle_outside_component(name) {
|
||
throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
|
||
}
|
||
/**
|
||
* Context was not set in a parent component
|
||
* @returns {never}
|
||
*/
|
||
function missing_context() {
|
||
throw new Error(`https://svelte.dev/e/missing_context`);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/errors.js
|
||
/**
|
||
* The node API `AsyncLocalStorage` is not available, but is required to use async server rendering.
|
||
* @returns {never}
|
||
*/
|
||
function async_local_storage_unavailable() {
|
||
const error = /* @__PURE__ */ new Error(`async_local_storage_unavailable\nThe node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.\nhttps://svelte.dev/e/async_local_storage_unavailable`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* Encountered asynchronous work while rendering synchronously.
|
||
* @returns {never}
|
||
*/
|
||
function await_invalid() {
|
||
const error = /* @__PURE__ */ new Error(`await_invalid\nEncountered asynchronous work while rendering synchronously.\nhttps://svelte.dev/e/await_invalid`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* The `html` property of server render results has been deprecated. Use `body` instead.
|
||
* @returns {never}
|
||
*/
|
||
function html_deprecated() {
|
||
const error = /* @__PURE__ */ new Error(`html_deprecated\nThe \`html\` property of server render results has been deprecated. Use \`body\` instead.\nhttps://svelte.dev/e/html_deprecated`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* Attempted to set `hydratable` with key `%key%` twice with different values.
|
||
*
|
||
* %stack%
|
||
* @param {string} key
|
||
* @param {string} stack
|
||
* @returns {never}
|
||
*/
|
||
function hydratable_clobbering(key, stack) {
|
||
const error = /* @__PURE__ */ new Error(`hydratable_clobbering\nAttempted to set \`hydratable\` with key \`${key}\` twice with different values.
|
||
|
||
${stack}\nhttps://svelte.dev/e/hydratable_clobbering`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* Failed to serialize `hydratable` data for key `%key%`.
|
||
*
|
||
* `hydratable` can serialize anything [`uneval` from `devalue`](https://npmjs.com/package/uneval) can, plus Promises.
|
||
*
|
||
* Cause:
|
||
* %stack%
|
||
* @param {string} key
|
||
* @param {string} stack
|
||
* @returns {never}
|
||
*/
|
||
function hydratable_serialization_failed(key, stack) {
|
||
const error = /* @__PURE__ */ new Error(`hydratable_serialization_failed\nFailed to serialize \`hydratable\` data for key \`${key}\`.
|
||
|
||
\`hydratable\` can serialize anything [\`uneval\` from \`devalue\`](https://npmjs.com/package/uneval) can, plus Promises.
|
||
|
||
Cause:
|
||
${stack}\nhttps://svelte.dev/e/hydratable_serialization_failed`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* `csp.nonce` was set while `csp.hash` was `true`. These options cannot be used simultaneously.
|
||
* @returns {never}
|
||
*/
|
||
function invalid_csp() {
|
||
const error = /* @__PURE__ */ new Error(`invalid_csp\n\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.\nhttps://svelte.dev/e/invalid_csp`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* The `idPrefix` option cannot include `--`.
|
||
* @returns {never}
|
||
*/
|
||
function invalid_id_prefix() {
|
||
const error = /* @__PURE__ */ new Error(`invalid_id_prefix\nThe \`idPrefix\` option cannot include \`--\`.\nhttps://svelte.dev/e/invalid_id_prefix`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* `%name%(...)` is not available on the server
|
||
* @param {string} name
|
||
* @returns {never}
|
||
*/
|
||
function lifecycle_function_unavailable(name) {
|
||
const error = /* @__PURE__ */ new Error(`lifecycle_function_unavailable\n\`${name}(...)\` is not available on the server\nhttps://svelte.dev/e/lifecycle_function_unavailable`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
/**
|
||
* Could not resolve `render` context.
|
||
* @returns {never}
|
||
*/
|
||
function server_context_required() {
|
||
const error = /* @__PURE__ */ new Error(`server_context_required\nCould not resolve \`render\` context.\nhttps://svelte.dev/e/server_context_required`);
|
||
error.name = "Svelte error";
|
||
throw error;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/context.js
|
||
/** @import { SSRContext } from '#server' */
|
||
/** @type {SSRContext | null} */
|
||
var ssr_context = null;
|
||
/** @param {SSRContext | null} v */
|
||
function set_ssr_context(v) {
|
||
ssr_context = v;
|
||
}
|
||
/**
|
||
* @template T
|
||
* @returns {[() => T, (context: T) => T]}
|
||
* @since 5.40.0
|
||
*/
|
||
function createContext() {
|
||
const key = {};
|
||
return [() => {
|
||
if (!hasContext(key)) missing_context();
|
||
return getContext(key);
|
||
}, (context) => setContext(key, context)];
|
||
}
|
||
/**
|
||
* @template T
|
||
* @param {any} key
|
||
* @returns {T}
|
||
*/
|
||
function getContext(key) {
|
||
return get_or_init_context_map("getContext").get(key);
|
||
}
|
||
/**
|
||
* @template T
|
||
* @param {any} key
|
||
* @param {T} context
|
||
* @returns {T}
|
||
*/
|
||
function setContext(key, context) {
|
||
get_or_init_context_map("setContext").set(key, context);
|
||
return context;
|
||
}
|
||
/**
|
||
* @param {any} key
|
||
* @returns {boolean}
|
||
*/
|
||
function hasContext(key) {
|
||
return get_or_init_context_map("hasContext").has(key);
|
||
}
|
||
/** @returns {Map<any, any>} */
|
||
function getAllContexts() {
|
||
return get_or_init_context_map("getAllContexts");
|
||
}
|
||
/**
|
||
* @param {string} name
|
||
* @returns {Map<unknown, unknown>}
|
||
*/
|
||
function get_or_init_context_map(name) {
|
||
if (ssr_context === null) lifecycle_outside_component(name);
|
||
return ssr_context.c ??= new Map(get_parent_context(ssr_context) || void 0);
|
||
}
|
||
/**
|
||
* @param {Function} [fn]
|
||
*/
|
||
function push$1(fn) {
|
||
ssr_context = {
|
||
p: ssr_context,
|
||
c: null,
|
||
r: null
|
||
};
|
||
}
|
||
function pop$1() {
|
||
ssr_context = ssr_context.p;
|
||
}
|
||
/**
|
||
* @param {SSRContext} ssr_context
|
||
* @returns {Map<unknown, unknown> | null}
|
||
*/
|
||
function get_parent_context(ssr_context) {
|
||
let parent = ssr_context.p;
|
||
while (parent !== null) {
|
||
const context_map = parent.c;
|
||
if (context_map !== null) return context_map;
|
||
parent = parent.p;
|
||
}
|
||
return null;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/shared/utils.js
|
||
var is_array = Array.isArray;
|
||
var index_of = Array.prototype.indexOf;
|
||
var includes = Array.prototype.includes;
|
||
var array_from = Array.from;
|
||
var define_property = Object.defineProperty;
|
||
var get_descriptor = Object.getOwnPropertyDescriptor;
|
||
var object_prototype = Object.prototype;
|
||
var array_prototype = Array.prototype;
|
||
var get_prototype_of = Object.getPrototypeOf;
|
||
var is_extensible = Object.isExtensible;
|
||
var has_own_property = Object.prototype.hasOwnProperty;
|
||
var noop = () => {};
|
||
/** @param {Function} fn */
|
||
function run(fn) {
|
||
return fn();
|
||
}
|
||
/** @param {Array<() => void>} arr */
|
||
function run_all(arr) {
|
||
for (var i = 0; i < arr.length; i++) arr[i]();
|
||
}
|
||
/**
|
||
* TODO replace with Promise.withResolvers once supported widely enough
|
||
* @template [T=void]
|
||
*/
|
||
function deferred() {
|
||
/** @type {(value: T) => void} */
|
||
var resolve;
|
||
/** @type {(reason: any) => void} */
|
||
var reject;
|
||
return {
|
||
promise: new Promise((res, rej) => {
|
||
resolve = res;
|
||
reject = rej;
|
||
}),
|
||
resolve,
|
||
reject
|
||
};
|
||
}
|
||
var CLEAN = 1024;
|
||
var DIRTY = 2048;
|
||
var MAYBE_DIRTY = 4096;
|
||
var INERT = 8192;
|
||
var DESTROYED = 16384;
|
||
/** Set once a reaction has run for the first time */
|
||
var REACTION_RAN = 32768;
|
||
/** Effect is in the process of getting destroyed. Can be observed in child teardown functions */
|
||
var DESTROYING = 1 << 25;
|
||
/**
|
||
* 'Transparent' effects do not create a transition boundary.
|
||
* This is on a block effect 99% of the time but may also be on a branch effect if its parent block effect was pruned
|
||
*/
|
||
var EFFECT_TRANSPARENT = 65536;
|
||
var EFFECT_PRESERVED = 1 << 19;
|
||
var USER_EFFECT = 1 << 20;
|
||
/**
|
||
* Tells that we marked this derived and its reactions as visited during the "mark as (maybe) dirty"-phase.
|
||
* Will be lifted during execution of the derived and during checking its dirty state (both are necessary
|
||
* because a derived might be checked but not executed). This is a pure performance optimization flag and
|
||
* should not be used for any other purpose!
|
||
*/
|
||
var WAS_MARKED = 65536;
|
||
var REACTION_IS_UPDATING = 1 << 21;
|
||
var ERROR_VALUE = 1 << 23;
|
||
var STATE_SYMBOL = Symbol("$state");
|
||
var LEGACY_PROPS = Symbol("legacy props");
|
||
/** allow users to ignore aborted signal errors if `reason.name === 'StaleReactionError` */
|
||
var STALE_REACTION = new class StaleReactionError extends Error {
|
||
name = "StaleReactionError";
|
||
message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
|
||
}();
|
||
globalThis.document?.contentType;
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/abort-signal.js
|
||
/** @type {AbortController | null} */
|
||
var controller = null;
|
||
function abort() {
|
||
controller?.abort(STALE_REACTION);
|
||
controller = null;
|
||
}
|
||
function getAbortSignal() {
|
||
return (controller ??= new AbortController()).signal;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/flags/index.js
|
||
/** True if experimental.async=true */
|
||
var async_mode_flag = false;
|
||
/** True if we're not certain that we only have Svelte 5 code in the compilation */
|
||
var legacy_mode_flag = false;
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/render-context.js
|
||
/** @import { AsyncLocalStorage } from 'node:async_hooks' */
|
||
/** @import { RenderContext } from '#server' */
|
||
/** @type {Promise<void> | null} */
|
||
var current_render = null;
|
||
/** @type {RenderContext | null} */
|
||
var context = null;
|
||
/** @returns {RenderContext} */
|
||
function get_render_context() {
|
||
const store = context ?? als?.getStore();
|
||
if (!store) server_context_required();
|
||
return store;
|
||
}
|
||
/**
|
||
* @template T
|
||
* @param {() => Promise<T>} fn
|
||
* @returns {Promise<T>}
|
||
*/
|
||
async function with_render_context(fn) {
|
||
context = { hydratable: {
|
||
lookup: /* @__PURE__ */ new Map(),
|
||
comparisons: [],
|
||
unresolved_promises: /* @__PURE__ */ new Map()
|
||
} };
|
||
if (in_webcontainer()) {
|
||
const { promise, resolve } = deferred();
|
||
const previous_render = current_render;
|
||
current_render = promise;
|
||
await previous_render;
|
||
return fn().finally(resolve);
|
||
}
|
||
try {
|
||
if (als === null) async_local_storage_unavailable();
|
||
return als.run(context, fn);
|
||
} finally {
|
||
context = null;
|
||
}
|
||
}
|
||
/** @type {AsyncLocalStorage<RenderContext | null> | null} */
|
||
var als = null;
|
||
/** @type {Promise<void> | null} */
|
||
var als_import = null;
|
||
/**
|
||
*
|
||
* @returns {Promise<void>}
|
||
*/
|
||
function init_render_context() {
|
||
als_import ??= import("node:async_hooks").then((hooks) => {
|
||
als = new hooks.AsyncLocalStorage();
|
||
}).then(noop, noop);
|
||
return als_import;
|
||
}
|
||
function in_webcontainer() {
|
||
return !!globalThis.process?.versions?.webcontainer;
|
||
}
|
||
/**
|
||
* @returns {string[]}
|
||
*/
|
||
function get_stack() {
|
||
const limit = Error.stackTraceLimit;
|
||
Error.stackTraceLimit = Infinity;
|
||
const stack = (/* @__PURE__ */ new Error()).stack;
|
||
Error.stackTraceLimit = limit;
|
||
if (!stack) return [];
|
||
const lines = stack.split("\n");
|
||
const new_lines = [];
|
||
for (let i = 0; i < lines.length; i++) {
|
||
const line = lines[i];
|
||
const posixified = line.replaceAll("\\", "/");
|
||
if (line.trim() === "Error") continue;
|
||
if (line.includes("validate_each_keys")) return [];
|
||
if (posixified.includes("svelte/src/internal") || posixified.includes("node_modules/.vite")) continue;
|
||
new_lines.push(line);
|
||
}
|
||
return new_lines;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/constants.js
|
||
var HYDRATION_ERROR = {};
|
||
var UNINITIALIZED = Symbol();
|
||
/**
|
||
* A `hydratable` value with key `%key%` was created, but at least part of it was not used during the render.
|
||
*
|
||
* The `hydratable` was initialized in:
|
||
* %stack%
|
||
* @param {string} key
|
||
* @param {string} stack
|
||
*/
|
||
function unresolved_hydratable(key, stack) {
|
||
console.warn(`https://svelte.dev/e/unresolved_hydratable`);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/hydration.js
|
||
var BLOCK_OPEN = `<!--[-->`;
|
||
var BLOCK_CLOSE = `<!--]-->`;
|
||
//#endregion
|
||
//#region node_modules/svelte/src/escaping.js
|
||
var ATTR_REGEX = /[&"<]/g;
|
||
var CONTENT_REGEX = /[&<]/g;
|
||
/**
|
||
* @template V
|
||
* @param {V} value
|
||
* @param {boolean} [is_attr]
|
||
*/
|
||
function escape_html(value, is_attr) {
|
||
const str = String(value ?? "");
|
||
const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;
|
||
pattern.lastIndex = 0;
|
||
let escaped = "";
|
||
let last = 0;
|
||
while (pattern.test(str)) {
|
||
const i = pattern.lastIndex - 1;
|
||
const ch = str[i];
|
||
escaped += str.substring(last, i) + (ch === "&" ? "&" : ch === "\"" ? """ : "<");
|
||
last = i + 1;
|
||
}
|
||
return escaped + str.substring(last);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/shared/attributes.js
|
||
/**
|
||
* `<div translate={false}>` should be rendered as `<div translate="no">` and _not_
|
||
* `<div translate="false">`, which is equivalent to `<div translate="yes">`. There
|
||
* may be other odd cases that need to be added to this list in future
|
||
* @type {Record<string, Map<any, string>>}
|
||
*/
|
||
var replacements = { translate: new Map([[true, "yes"], [false, "no"]]) };
|
||
/**
|
||
* @template V
|
||
* @param {string} name
|
||
* @param {V} value
|
||
* @param {boolean} [is_boolean]
|
||
* @returns {string}
|
||
*/
|
||
function attr(name, value, is_boolean = false) {
|
||
if (name === "hidden" && value !== "until-found") is_boolean = true;
|
||
if (value == null || !value && is_boolean) return "";
|
||
const normalized = has_own_property.call(replacements, name) && replacements[name].get(value) || value;
|
||
return ` ${name}${is_boolean ? `=""` : `="${escape_html(normalized, true)}"`}`;
|
||
}
|
||
/**
|
||
* Small wrapper around clsx to preserve Svelte's (weird) handling of falsy values.
|
||
* TODO Svelte 6 revisit this, and likely turn all falsy values into the empty string (what clsx also does)
|
||
* @param {any} value
|
||
*/
|
||
function clsx$1(value) {
|
||
if (typeof value === "object") return clsx(value);
|
||
else return value ?? "";
|
||
}
|
||
var whitespace = [..." \n\r\f\xA0\v"];
|
||
/**
|
||
* @param {any} value
|
||
* @param {string | null} [hash]
|
||
* @param {Record<string, boolean>} [directives]
|
||
* @returns {string | null}
|
||
*/
|
||
function to_class(value, hash, directives) {
|
||
var classname = value == null ? "" : "" + value;
|
||
if (hash) classname = classname ? classname + " " + hash : hash;
|
||
if (directives) {
|
||
for (var key of Object.keys(directives)) if (directives[key]) classname = classname ? classname + " " + key : key;
|
||
else if (classname.length) {
|
||
var len = key.length;
|
||
var a = 0;
|
||
while ((a = classname.indexOf(key, a)) >= 0) {
|
||
var b = a + len;
|
||
if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
|
||
else a = b;
|
||
}
|
||
}
|
||
}
|
||
return classname === "" ? null : classname;
|
||
}
|
||
/**
|
||
*
|
||
* @param {Record<string,any>} styles
|
||
* @param {boolean} important
|
||
*/
|
||
function append_styles(styles, important = false) {
|
||
var separator = important ? " !important;" : ";";
|
||
var css = "";
|
||
for (var key of Object.keys(styles)) {
|
||
var value = styles[key];
|
||
if (value != null && value !== "") css += " " + key + ": " + value + separator;
|
||
}
|
||
return css;
|
||
}
|
||
/**
|
||
* @param {string} name
|
||
* @returns {string}
|
||
*/
|
||
function to_css_name(name) {
|
||
if (name[0] !== "-" || name[1] !== "-") return name.toLowerCase();
|
||
return name;
|
||
}
|
||
/**
|
||
* @param {any} value
|
||
* @param {Record<string, any> | [Record<string, any>, Record<string, any>]} [styles]
|
||
* @returns {string | null}
|
||
*/
|
||
function to_style(value, styles) {
|
||
if (styles) {
|
||
var new_style = "";
|
||
/** @type {Record<string,any> | undefined} */
|
||
var normal_styles;
|
||
/** @type {Record<string,any> | undefined} */
|
||
var important_styles;
|
||
if (Array.isArray(styles)) {
|
||
normal_styles = styles[0];
|
||
important_styles = styles[1];
|
||
} else normal_styles = styles;
|
||
if (value) {
|
||
value = String(value).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
|
||
/** @type {boolean | '"' | "'"} */
|
||
var in_str = false;
|
||
var in_apo = 0;
|
||
var in_comment = false;
|
||
var reserved_names = [];
|
||
if (normal_styles) reserved_names.push(...Object.keys(normal_styles).map(to_css_name));
|
||
if (important_styles) reserved_names.push(...Object.keys(important_styles).map(to_css_name));
|
||
var start_index = 0;
|
||
var name_index = -1;
|
||
const len = value.length;
|
||
for (var i = 0; i < len; i++) {
|
||
var c = value[i];
|
||
if (in_comment) {
|
||
if (c === "/" && value[i - 1] === "*") in_comment = false;
|
||
} else if (in_str) {
|
||
if (in_str === c) in_str = false;
|
||
} else if (c === "/" && value[i + 1] === "*") in_comment = true;
|
||
else if (c === "\"" || c === "'") in_str = c;
|
||
else if (c === "(") in_apo++;
|
||
else if (c === ")") in_apo--;
|
||
if (!in_comment && in_str === false && in_apo === 0) {
|
||
if (c === ":" && name_index === -1) name_index = i;
|
||
else if (c === ";" || i === len - 1) {
|
||
if (name_index !== -1) {
|
||
var name = to_css_name(value.substring(start_index, name_index).trim());
|
||
if (!reserved_names.includes(name)) {
|
||
if (c !== ";") i++;
|
||
var property = value.substring(start_index, i).trim();
|
||
new_style += " " + property + ";";
|
||
}
|
||
}
|
||
start_index = i + 1;
|
||
name_index = -1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (normal_styles) new_style += append_styles(normal_styles);
|
||
if (important_styles) new_style += append_styles(important_styles, true);
|
||
new_style = new_style.trim();
|
||
return new_style === "" ? null : new_style;
|
||
}
|
||
return value == null ? null : String(value);
|
||
}
|
||
/**
|
||
* Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state
|
||
* @returns {never}
|
||
*/
|
||
function effect_update_depth_exceeded() {
|
||
throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
|
||
}
|
||
/**
|
||
* Failed to hydrate the application
|
||
* @returns {never}
|
||
*/
|
||
function hydration_failed() {
|
||
throw new Error(`https://svelte.dev/e/hydration_failed`);
|
||
}
|
||
/**
|
||
* Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`.
|
||
* @returns {never}
|
||
*/
|
||
function state_descriptors_fixed() {
|
||
throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
|
||
}
|
||
/**
|
||
* Cannot set prototype of `$state` object
|
||
* @returns {never}
|
||
*/
|
||
function state_prototype_fixed() {
|
||
throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
|
||
}
|
||
/**
|
||
* Updating state inside `$derived(...)`, `$inspect(...)` or a template expression is forbidden. If the value should not be reactive, declare it without `$state`
|
||
* @returns {never}
|
||
*/
|
||
function state_unsafe_mutation() {
|
||
throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
|
||
}
|
||
/**
|
||
* A `<svelte:boundary>` `reset` function cannot be called while an error is still being handled
|
||
* @returns {never}
|
||
*/
|
||
function svelte_boundary_reset_onerror() {
|
||
throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
|
||
}
|
||
/**
|
||
* Reading a derived belonging to a now-destroyed effect may result in stale values
|
||
*/
|
||
function derived_inert() {
|
||
console.warn(`https://svelte.dev/e/derived_inert`);
|
||
}
|
||
/**
|
||
* Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near %location%
|
||
* @param {string | undefined | null} [location]
|
||
*/
|
||
function hydration_mismatch(location) {
|
||
console.warn(`https://svelte.dev/e/hydration_mismatch`);
|
||
}
|
||
/**
|
||
* Tried to unmount a component that was not mounted
|
||
*/
|
||
function lifecycle_double_unmount() {
|
||
console.warn(`https://svelte.dev/e/lifecycle_double_unmount`);
|
||
}
|
||
/**
|
||
* Tried to unmount a state proxy, rather than a component
|
||
*/
|
||
function state_proxy_unmount() {
|
||
console.warn(`https://svelte.dev/e/state_proxy_unmount`);
|
||
}
|
||
/**
|
||
* A `<svelte:boundary>` `reset` function only resets the boundary the first time it is called
|
||
*/
|
||
function svelte_boundary_reset_noop() {
|
||
console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/dom/hydration.js
|
||
/** @import { TemplateNode } from '#client' */
|
||
/**
|
||
* Use this variable to guard everything related to hydration code so it can be treeshaken out
|
||
* if the user doesn't use the `hydrate` method and these code paths are therefore not needed.
|
||
*/
|
||
var hydrating = false;
|
||
/** @param {boolean} value */
|
||
function set_hydrating(value) {
|
||
hydrating = value;
|
||
}
|
||
/**
|
||
* The node that is currently being hydrated. This starts out as the first node inside the opening
|
||
* <!--[--> comment, and updates each time a component calls `$.child(...)` or `$.sibling(...)`.
|
||
* When entering a block (e.g. `{#if ...}`), `hydrate_node` is the block opening comment; by the
|
||
* time we leave the block it is the closing comment, which serves as the block's anchor.
|
||
* @type {TemplateNode}
|
||
*/
|
||
var hydrate_node;
|
||
/** @param {TemplateNode | null} node */
|
||
function set_hydrate_node(node) {
|
||
if (node === null) {
|
||
hydration_mismatch();
|
||
throw HYDRATION_ERROR;
|
||
}
|
||
return hydrate_node = node;
|
||
}
|
||
function hydrate_next() {
|
||
return set_hydrate_node(/* @__PURE__ */ get_next_sibling(hydrate_node));
|
||
}
|
||
function next(count = 1) {
|
||
if (hydrating) {
|
||
var i = count;
|
||
var node = hydrate_node;
|
||
while (i--) node = /* @__PURE__ */ get_next_sibling(node);
|
||
hydrate_node = node;
|
||
}
|
||
}
|
||
/**
|
||
* Skips or removes (depending on {@link remove}) all nodes starting at `hydrate_node` up until the next hydration end comment
|
||
* @param {boolean} remove
|
||
*/
|
||
function skip_nodes(remove = true) {
|
||
var depth = 0;
|
||
var node = hydrate_node;
|
||
while (true) {
|
||
if (node.nodeType === 8) {
|
||
var data = node.data;
|
||
if (data === "]") {
|
||
if (depth === 0) return node;
|
||
depth -= 1;
|
||
} else if (data === "[" || data === "[!" || data[0] === "[" && !isNaN(Number(data.slice(1)))) depth += 1;
|
||
}
|
||
var next = /* @__PURE__ */ get_next_sibling(node);
|
||
if (remove) node.remove();
|
||
node = next;
|
||
}
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/reactivity/equality.js
|
||
/** @import { Equals } from '#client' */
|
||
/** @type {Equals} */
|
||
function equals(value) {
|
||
return value === this.v;
|
||
}
|
||
/**
|
||
* @param {unknown} a
|
||
* @param {unknown} b
|
||
* @returns {boolean}
|
||
*/
|
||
function safe_not_equal(a, b) {
|
||
return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
|
||
}
|
||
/** @type {Equals} */
|
||
function safe_equals(value) {
|
||
return !safe_not_equal(value, this.v);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/context.js
|
||
/** @import { ComponentContext, DevStackEntry, Effect } from '#client' */
|
||
/** @type {ComponentContext | null} */
|
||
var component_context = null;
|
||
/** @param {ComponentContext | null} context */
|
||
function set_component_context(context) {
|
||
component_context = context;
|
||
}
|
||
/**
|
||
* @param {Record<string, unknown>} props
|
||
* @param {any} runes
|
||
* @param {Function} [fn]
|
||
* @returns {void}
|
||
*/
|
||
function push(props, runes = false, fn) {
|
||
component_context = {
|
||
p: component_context,
|
||
i: false,
|
||
c: null,
|
||
e: null,
|
||
s: props,
|
||
x: null,
|
||
r: active_effect,
|
||
l: legacy_mode_flag && !runes ? {
|
||
s: null,
|
||
u: null,
|
||
$: []
|
||
} : null
|
||
};
|
||
}
|
||
/**
|
||
* @template {Record<string, any>} T
|
||
* @param {T} [component]
|
||
* @returns {T}
|
||
*/
|
||
function pop(component) {
|
||
var context = component_context;
|
||
var effects = context.e;
|
||
if (effects !== null) {
|
||
context.e = null;
|
||
for (var fn of effects) create_user_effect(fn);
|
||
}
|
||
if (component !== void 0) context.x = component;
|
||
context.i = true;
|
||
component_context = context.p;
|
||
return component ?? {};
|
||
}
|
||
/** @returns {boolean} */
|
||
function is_runes() {
|
||
return !legacy_mode_flag || component_context !== null && component_context.l === null;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/dom/task.js
|
||
/** @type {Array<() => void>} */
|
||
var micro_tasks = [];
|
||
function run_micro_tasks() {
|
||
var tasks = micro_tasks;
|
||
micro_tasks = [];
|
||
run_all(tasks);
|
||
}
|
||
/**
|
||
* @param {() => void} fn
|
||
*/
|
||
function queue_micro_task(fn) {
|
||
if (micro_tasks.length === 0 && !is_flushing_sync) {
|
||
var tasks = micro_tasks;
|
||
queueMicrotask(() => {
|
||
if (tasks === micro_tasks) run_micro_tasks();
|
||
});
|
||
}
|
||
micro_tasks.push(fn);
|
||
}
|
||
/**
|
||
* Synchronously run any queued tasks.
|
||
*/
|
||
function flush_tasks() {
|
||
while (micro_tasks.length > 0) run_micro_tasks();
|
||
}
|
||
/**
|
||
* @param {unknown} error
|
||
*/
|
||
function handle_error(error) {
|
||
var effect = active_effect;
|
||
if (effect === null) {
|
||
/** @type {Derived} */ active_reaction.f |= ERROR_VALUE;
|
||
return error;
|
||
}
|
||
if ((effect.f & 32768) === 0 && (effect.f & 4) === 0) throw error;
|
||
invoke_error_boundary(error, effect);
|
||
}
|
||
/**
|
||
* @param {unknown} error
|
||
* @param {Effect | null} effect
|
||
*/
|
||
function invoke_error_boundary(error, effect) {
|
||
while (effect !== null) {
|
||
if ((effect.f & 128) !== 0) {
|
||
if ((effect.f & 32768) === 0) throw error;
|
||
try {
|
||
/** @type {Boundary} */ effect.b.error(error);
|
||
return;
|
||
} catch (e) {
|
||
error = e;
|
||
}
|
||
}
|
||
effect = effect.parent;
|
||
}
|
||
throw error;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/reactivity/status.js
|
||
/** @import { Derived, Signal } from '#client' */
|
||
var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
|
||
/**
|
||
* @param {Signal} signal
|
||
* @param {number} status
|
||
*/
|
||
function set_signal_status(signal, status) {
|
||
signal.f = signal.f & STATUS_MASK | status;
|
||
}
|
||
/**
|
||
* Set a derived's status to CLEAN or MAYBE_DIRTY based on its connection state.
|
||
* @param {Derived} derived
|
||
*/
|
||
function update_derived_status(derived) {
|
||
if ((derived.f & 512) !== 0 || derived.deps === null) set_signal_status(derived, CLEAN);
|
||
else set_signal_status(derived, MAYBE_DIRTY);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/reactivity/utils.js
|
||
/** @import { Derived, Effect, Value } from '#client' */
|
||
/**
|
||
* @param {Value[] | null} deps
|
||
*/
|
||
function clear_marked(deps) {
|
||
if (deps === null) return;
|
||
for (const dep of deps) {
|
||
if ((dep.f & 2) === 0 || (dep.f & 65536) === 0) continue;
|
||
dep.f ^= WAS_MARKED;
|
||
clear_marked(
|
||
/** @type {Derived} */
|
||
dep.deps
|
||
);
|
||
}
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
* @param {Set<Effect>} dirty_effects
|
||
* @param {Set<Effect>} maybe_dirty_effects
|
||
*/
|
||
function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
|
||
if ((effect.f & 2048) !== 0) dirty_effects.add(effect);
|
||
else if ((effect.f & 4096) !== 0) maybe_dirty_effects.add(effect);
|
||
clear_marked(effect.deps);
|
||
set_signal_status(effect, CLEAN);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/store/shared/index.js
|
||
/** @import { Readable, StartStopNotifier, Subscriber, Unsubscriber, Updater, Writable } from '../public.js' */
|
||
/** @import { Stores, StoresValues, SubscribeInvalidateTuple } from '../private.js' */
|
||
/**
|
||
* @type {Array<SubscribeInvalidateTuple<any> | any>}
|
||
*/
|
||
var subscriber_queue = [];
|
||
/**
|
||
* Creates a `Readable` store that allows reading by subscription.
|
||
*
|
||
* @template T
|
||
* @param {T} [value] initial value
|
||
* @param {StartStopNotifier<T>} [start]
|
||
* @returns {Readable<T>}
|
||
*/
|
||
function readable(value, start) {
|
||
return { subscribe: writable(value, start).subscribe };
|
||
}
|
||
/**
|
||
* Create a `Writable` store that allows both updating and reading by subscription.
|
||
*
|
||
* @template T
|
||
* @param {T} [value] initial value
|
||
* @param {StartStopNotifier<T>} [start]
|
||
* @returns {Writable<T>}
|
||
*/
|
||
function writable(value, start = noop) {
|
||
/** @type {Unsubscriber | null} */
|
||
let stop = null;
|
||
/** @type {Set<SubscribeInvalidateTuple<T>>} */
|
||
const subscribers = /* @__PURE__ */ new Set();
|
||
/**
|
||
* @param {T} new_value
|
||
* @returns {void}
|
||
*/
|
||
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;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* @param {Updater<T>} fn
|
||
* @returns {void}
|
||
*/
|
||
function update(fn) {
|
||
set(fn(value));
|
||
}
|
||
/**
|
||
* @param {Subscriber<T>} run
|
||
* @param {() => void} [invalidate]
|
||
* @returns {Unsubscriber}
|
||
*/
|
||
function subscribe(run, invalidate = noop) {
|
||
/** @type {SubscribeInvalidateTuple<T>} */
|
||
const subscriber = [run, invalidate];
|
||
subscribers.add(subscriber);
|
||
if (subscribers.size === 1) stop = start(set, update) || noop;
|
||
run(value);
|
||
return () => {
|
||
subscribers.delete(subscriber);
|
||
if (subscribers.size === 0 && stop) {
|
||
stop();
|
||
stop = null;
|
||
}
|
||
};
|
||
}
|
||
return {
|
||
set,
|
||
update,
|
||
subscribe
|
||
};
|
||
}
|
||
/**
|
||
* Get the current value from a store by subscribing and immediately unsubscribing.
|
||
*
|
||
* @template T
|
||
* @param {Readable<T>} store
|
||
* @returns {T}
|
||
*/
|
||
function get$1(store) {
|
||
let value;
|
||
subscribe_to_store(store, (_) => value = _)();
|
||
return value;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/reactivity/store.js
|
||
/**
|
||
* We set this to `true` when updating a store so that we correctly
|
||
* schedule effects if the update takes place inside a `$:` effect
|
||
*/
|
||
var legacy_is_updating_store = false;
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/reactivity/batch.js
|
||
/** @import { Fork } from 'svelte' */
|
||
/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
|
||
/** @type {Set<Batch>} */
|
||
var batches = /* @__PURE__ */ new Set();
|
||
/** @type {Batch | null} */
|
||
var current_batch = null;
|
||
/**
|
||
* When time travelling (i.e. working in one batch, while other batches
|
||
* still have ongoing work), we ignore the real values of affected
|
||
* signals in favour of their values within the batch
|
||
* @type {Map<Value, any> | null}
|
||
*/
|
||
var batch_values = null;
|
||
/** @type {Effect | null} */
|
||
var last_scheduled_effect = null;
|
||
var is_flushing_sync = false;
|
||
var is_processing = false;
|
||
/**
|
||
* During traversal, this is an array. Newly created effects are (if not immediately
|
||
* executed) pushed to this array, rather than going through the scheduling
|
||
* rigamarole that would cause another turn of the flush loop.
|
||
* @type {Effect[] | null}
|
||
*/
|
||
var collected_effects = null;
|
||
/**
|
||
* An array of effects that are marked during traversal as a result of a `set`
|
||
* (not `internal_set`) call. These will be added to the next batch and
|
||
* trigger another `batch.process()`
|
||
* @type {Effect[] | null}
|
||
* @deprecated when we get rid of legacy mode and stores, we can get rid of this
|
||
*/
|
||
var legacy_updates = null;
|
||
var flush_count = 0;
|
||
var uid = 1;
|
||
var Batch = class Batch {
|
||
id = uid++;
|
||
/**
|
||
* The current values of any signals that are updated in this batch.
|
||
* Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
|
||
* They keys of this map are identical to `this.#previous`
|
||
* @type {Map<Value, [any, boolean]>}
|
||
*/
|
||
current = /* @__PURE__ */ new Map();
|
||
/**
|
||
* The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
|
||
* They keys of this map are identical to `this.#current`
|
||
* @type {Map<Value, any>}
|
||
*/
|
||
previous = /* @__PURE__ */ new Map();
|
||
/**
|
||
* When the batch is committed (and the DOM is updated), we need to remove old branches
|
||
* and append new ones by calling the functions added inside (if/each/key/etc) blocks
|
||
* @type {Set<(batch: Batch) => void>}
|
||
*/
|
||
#commit_callbacks = /* @__PURE__ */ new Set();
|
||
/**
|
||
* If a fork is discarded, we need to destroy any effects that are no longer needed
|
||
* @type {Set<(batch: Batch) => void>}
|
||
*/
|
||
#discard_callbacks = /* @__PURE__ */ new Set();
|
||
/**
|
||
* Callbacks that should run only when a fork is committed.
|
||
* @type {Set<(batch: Batch) => void>}
|
||
*/
|
||
#fork_commit_callbacks = /* @__PURE__ */ new Set();
|
||
/**
|
||
* Async effects that are currently in flight
|
||
* @type {Map<Effect, number>}
|
||
*/
|
||
#pending = /* @__PURE__ */ new Map();
|
||
/**
|
||
* Async effects that are currently in flight, _not_ inside a pending boundary
|
||
* @type {Map<Effect, number>}
|
||
*/
|
||
#blocking_pending = /* @__PURE__ */ new Map();
|
||
/**
|
||
* A deferred that resolves when the batch is committed, used with `settled()`
|
||
* TODO replace with Promise.withResolvers once supported widely enough
|
||
* @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
|
||
*/
|
||
#deferred = null;
|
||
/**
|
||
* The root effects that need to be flushed
|
||
* @type {Effect[]}
|
||
*/
|
||
#roots = [];
|
||
/**
|
||
* Effects created while this batch was active.
|
||
* @type {Effect[]}
|
||
*/
|
||
#new_effects = [];
|
||
/**
|
||
* Deferred effects (which run after async work has completed) that are DIRTY
|
||
* @type {Set<Effect>}
|
||
*/
|
||
#dirty_effects = /* @__PURE__ */ new Set();
|
||
/**
|
||
* Deferred effects that are MAYBE_DIRTY
|
||
* @type {Set<Effect>}
|
||
*/
|
||
#maybe_dirty_effects = /* @__PURE__ */ new Set();
|
||
/**
|
||
* A map of branches that still exist, but will be destroyed when this batch
|
||
* is committed — we skip over these during `process`.
|
||
* The value contains child effects that were dirty/maybe_dirty before being reset,
|
||
* so they can be rescheduled if the branch survives.
|
||
* @type {Map<Effect, { d: Effect[], m: Effect[] }>}
|
||
*/
|
||
#skipped_branches = /* @__PURE__ */ new Map();
|
||
/**
|
||
* Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
|
||
* @type {Set<Effect>}
|
||
*/
|
||
#unskipped_branches = /* @__PURE__ */ new Set();
|
||
is_fork = false;
|
||
#decrement_queued = false;
|
||
/** @type {Set<Batch>} */
|
||
#blockers = /* @__PURE__ */ new Set();
|
||
#is_deferred() {
|
||
return this.is_fork || this.#blocking_pending.size > 0;
|
||
}
|
||
#is_blocked() {
|
||
for (const batch of this.#blockers) for (const effect of batch.#blocking_pending.keys()) {
|
||
var skipped = false;
|
||
var e = effect;
|
||
while (e.parent !== null) {
|
||
if (this.#skipped_branches.has(e)) {
|
||
skipped = true;
|
||
break;
|
||
}
|
||
e = e.parent;
|
||
}
|
||
if (!skipped) return true;
|
||
}
|
||
return false;
|
||
}
|
||
/**
|
||
* Add an effect to the #skipped_branches map and reset its children
|
||
* @param {Effect} effect
|
||
*/
|
||
skip_effect(effect) {
|
||
if (!this.#skipped_branches.has(effect)) this.#skipped_branches.set(effect, {
|
||
d: [],
|
||
m: []
|
||
});
|
||
this.#unskipped_branches.delete(effect);
|
||
}
|
||
/**
|
||
* Remove an effect from the #skipped_branches map and reschedule
|
||
* any tracked dirty/maybe_dirty child effects
|
||
* @param {Effect} effect
|
||
* @param {(e: Effect) => void} callback
|
||
*/
|
||
unskip_effect(effect, callback = (e) => this.schedule(e)) {
|
||
var tracked = this.#skipped_branches.get(effect);
|
||
if (tracked) {
|
||
this.#skipped_branches.delete(effect);
|
||
for (var e of tracked.d) {
|
||
set_signal_status(e, DIRTY);
|
||
callback(e);
|
||
}
|
||
for (e of tracked.m) {
|
||
set_signal_status(e, MAYBE_DIRTY);
|
||
callback(e);
|
||
}
|
||
}
|
||
this.#unskipped_branches.add(effect);
|
||
}
|
||
#process() {
|
||
if (flush_count++ > 1e3) {
|
||
batches.delete(this);
|
||
infinite_loop_guard();
|
||
}
|
||
if (!this.#is_deferred()) {
|
||
for (const e of this.#dirty_effects) {
|
||
this.#maybe_dirty_effects.delete(e);
|
||
set_signal_status(e, DIRTY);
|
||
this.schedule(e);
|
||
}
|
||
for (const e of this.#maybe_dirty_effects) {
|
||
set_signal_status(e, MAYBE_DIRTY);
|
||
this.schedule(e);
|
||
}
|
||
}
|
||
const roots = this.#roots;
|
||
this.#roots = [];
|
||
this.apply();
|
||
/** @type {Effect[]} */
|
||
var effects = collected_effects = [];
|
||
/** @type {Effect[]} */
|
||
var render_effects = [];
|
||
/**
|
||
* @type {Effect[]}
|
||
* @deprecated when we get rid of legacy mode and stores, we can get rid of this
|
||
*/
|
||
var updates = legacy_updates = [];
|
||
for (const root of roots) try {
|
||
this.#traverse(root, effects, render_effects);
|
||
} catch (e) {
|
||
reset_all(root);
|
||
throw e;
|
||
}
|
||
current_batch = null;
|
||
if (updates.length > 0) {
|
||
var batch = Batch.ensure();
|
||
for (const e of updates) batch.schedule(e);
|
||
}
|
||
collected_effects = null;
|
||
legacy_updates = null;
|
||
if (this.#is_deferred() || this.#is_blocked()) {
|
||
this.#defer_effects(render_effects);
|
||
this.#defer_effects(effects);
|
||
for (const [e, t] of this.#skipped_branches) reset_branch(e, t);
|
||
} else {
|
||
if (this.#pending.size === 0) batches.delete(this);
|
||
this.#dirty_effects.clear();
|
||
this.#maybe_dirty_effects.clear();
|
||
for (const fn of this.#commit_callbacks) fn(this);
|
||
this.#commit_callbacks.clear();
|
||
flush_queued_effects(render_effects);
|
||
flush_queued_effects(effects);
|
||
this.#deferred?.resolve();
|
||
}
|
||
var next_batch = current_batch;
|
||
if (this.#roots.length > 0) {
|
||
const batch = next_batch ??= this;
|
||
batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));
|
||
}
|
||
if (next_batch !== null) {
|
||
batches.add(next_batch);
|
||
next_batch.#process();
|
||
}
|
||
if (async_mode_flag && !batches.has(this)) this.#commit();
|
||
}
|
||
/**
|
||
* Traverse the effect tree, executing effects or stashing
|
||
* them for later execution as appropriate
|
||
* @param {Effect} root
|
||
* @param {Effect[]} effects
|
||
* @param {Effect[]} render_effects
|
||
*/
|
||
#traverse(root, effects, render_effects) {
|
||
root.f ^= CLEAN;
|
||
var effect = root.first;
|
||
while (effect !== null) {
|
||
var flags = effect.f;
|
||
var is_branch = (flags & 96) !== 0;
|
||
if (!(is_branch && (flags & 1024) !== 0 || (flags & 8192) !== 0 || this.#skipped_branches.has(effect)) && effect.fn !== null) {
|
||
if (is_branch) effect.f ^= CLEAN;
|
||
else if ((flags & 4) !== 0) effects.push(effect);
|
||
else if (async_mode_flag && (flags & 16777224) !== 0) render_effects.push(effect);
|
||
else if (is_dirty(effect)) {
|
||
if ((flags & 16) !== 0) this.#maybe_dirty_effects.add(effect);
|
||
update_effect(effect);
|
||
}
|
||
var child = effect.first;
|
||
if (child !== null) {
|
||
effect = child;
|
||
continue;
|
||
}
|
||
}
|
||
while (effect !== null) {
|
||
var next = effect.next;
|
||
if (next !== null) {
|
||
effect = next;
|
||
break;
|
||
}
|
||
effect = effect.parent;
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* @param {Effect[]} effects
|
||
*/
|
||
#defer_effects(effects) {
|
||
for (var i = 0; i < effects.length; i += 1) defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
|
||
}
|
||
/**
|
||
* Associate a change to a given source with the current
|
||
* batch, noting its previous and current values
|
||
* @param {Value} source
|
||
* @param {any} value
|
||
* @param {boolean} [is_derived]
|
||
*/
|
||
capture(source, value, is_derived = false) {
|
||
if (source.v !== UNINITIALIZED && !this.previous.has(source)) this.previous.set(source, source.v);
|
||
if ((source.f & 8388608) === 0) {
|
||
this.current.set(source, [value, is_derived]);
|
||
batch_values?.set(source, value);
|
||
}
|
||
if (!this.is_fork) source.v = value;
|
||
}
|
||
activate() {
|
||
current_batch = this;
|
||
}
|
||
deactivate() {
|
||
current_batch = null;
|
||
batch_values = null;
|
||
}
|
||
flush() {
|
||
try {
|
||
is_processing = true;
|
||
current_batch = this;
|
||
this.#process();
|
||
} finally {
|
||
flush_count = 0;
|
||
last_scheduled_effect = null;
|
||
collected_effects = null;
|
||
legacy_updates = null;
|
||
is_processing = false;
|
||
current_batch = null;
|
||
batch_values = null;
|
||
old_values.clear();
|
||
}
|
||
}
|
||
discard() {
|
||
for (const fn of this.#discard_callbacks) fn(this);
|
||
this.#discard_callbacks.clear();
|
||
this.#fork_commit_callbacks.clear();
|
||
batches.delete(this);
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
*/
|
||
register_created_effect(effect) {
|
||
this.#new_effects.push(effect);
|
||
}
|
||
#commit() {
|
||
for (const batch of batches) {
|
||
var is_earlier = batch.id < this.id;
|
||
/** @type {Source[]} */
|
||
var sources = [];
|
||
for (const [source, [value, is_derived]] of this.current) {
|
||
if (batch.current.has(source)) {
|
||
var batch_value = batch.current.get(source)[0];
|
||
if (is_earlier && value !== batch_value) batch.current.set(source, [value, is_derived]);
|
||
else continue;
|
||
}
|
||
sources.push(source);
|
||
}
|
||
var others = [...batch.current.keys()].filter((s) => !this.current.has(s));
|
||
if (others.length === 0) {
|
||
if (is_earlier) batch.discard();
|
||
} else if (sources.length > 0) {
|
||
if (is_earlier) for (const unskipped of this.#unskipped_branches) batch.unskip_effect(unskipped, (e) => {
|
||
if ((e.f & 4194320) !== 0) batch.schedule(e);
|
||
else batch.#defer_effects([e]);
|
||
});
|
||
batch.activate();
|
||
/** @type {Set<Value>} */
|
||
var marked = /* @__PURE__ */ new Set();
|
||
/** @type {Map<Reaction, boolean>} */
|
||
var checked = /* @__PURE__ */ new Map();
|
||
for (var source of sources) mark_effects(source, others, marked, checked);
|
||
checked = /* @__PURE__ */ new Map();
|
||
var current_unequal = [...batch.current.keys()].filter((c) => this.current.has(c) ? this.current.get(c)[0] !== c : true);
|
||
for (const effect of this.#new_effects) if ((effect.f & 155648) === 0 && depends_on(effect, current_unequal, checked)) if ((effect.f & 4194320) !== 0) {
|
||
set_signal_status(effect, DIRTY);
|
||
batch.schedule(effect);
|
||
} else batch.#dirty_effects.add(effect);
|
||
if (batch.#roots.length > 0) {
|
||
batch.apply();
|
||
for (var root of batch.#roots) batch.#traverse(root, [], []);
|
||
batch.#roots = [];
|
||
}
|
||
batch.deactivate();
|
||
}
|
||
}
|
||
for (const batch of batches) if (batch.#blockers.has(this)) {
|
||
batch.#blockers.delete(this);
|
||
if (batch.#blockers.size === 0 && !batch.#is_deferred()) {
|
||
batch.activate();
|
||
batch.#process();
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* @param {boolean} blocking
|
||
* @param {Effect} effect
|
||
*/
|
||
increment(blocking, effect) {
|
||
let pending_count = this.#pending.get(effect) ?? 0;
|
||
this.#pending.set(effect, pending_count + 1);
|
||
if (blocking) {
|
||
let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
|
||
this.#blocking_pending.set(effect, blocking_pending_count + 1);
|
||
}
|
||
}
|
||
/**
|
||
* @param {boolean} blocking
|
||
* @param {Effect} effect
|
||
* @param {boolean} skip - whether to skip updates (because this is triggered by a stale reaction)
|
||
*/
|
||
decrement(blocking, effect, skip) {
|
||
let pending_count = this.#pending.get(effect) ?? 0;
|
||
if (pending_count === 1) this.#pending.delete(effect);
|
||
else this.#pending.set(effect, pending_count - 1);
|
||
if (blocking) {
|
||
let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
|
||
if (blocking_pending_count === 1) this.#blocking_pending.delete(effect);
|
||
else this.#blocking_pending.set(effect, blocking_pending_count - 1);
|
||
}
|
||
if (this.#decrement_queued || skip) return;
|
||
this.#decrement_queued = true;
|
||
queue_micro_task(() => {
|
||
this.#decrement_queued = false;
|
||
this.flush();
|
||
});
|
||
}
|
||
/**
|
||
* @param {Set<Effect>} dirty_effects
|
||
* @param {Set<Effect>} maybe_dirty_effects
|
||
*/
|
||
transfer_effects(dirty_effects, maybe_dirty_effects) {
|
||
for (const e of dirty_effects) this.#dirty_effects.add(e);
|
||
for (const e of maybe_dirty_effects) this.#maybe_dirty_effects.add(e);
|
||
dirty_effects.clear();
|
||
maybe_dirty_effects.clear();
|
||
}
|
||
/** @param {(batch: Batch) => void} fn */
|
||
oncommit(fn) {
|
||
this.#commit_callbacks.add(fn);
|
||
}
|
||
/** @param {(batch: Batch) => void} fn */
|
||
ondiscard(fn) {
|
||
this.#discard_callbacks.add(fn);
|
||
}
|
||
/** @param {(batch: Batch) => void} fn */
|
||
on_fork_commit(fn) {
|
||
this.#fork_commit_callbacks.add(fn);
|
||
}
|
||
run_fork_commit_callbacks() {
|
||
for (const fn of this.#fork_commit_callbacks) fn(this);
|
||
this.#fork_commit_callbacks.clear();
|
||
}
|
||
settled() {
|
||
return (this.#deferred ??= deferred()).promise;
|
||
}
|
||
static ensure() {
|
||
if (current_batch === null) {
|
||
const batch = current_batch = new Batch();
|
||
if (!is_processing) {
|
||
batches.add(current_batch);
|
||
if (!is_flushing_sync) queue_micro_task(() => {
|
||
if (current_batch !== batch) return;
|
||
batch.flush();
|
||
});
|
||
}
|
||
}
|
||
return current_batch;
|
||
}
|
||
apply() {
|
||
if (!async_mode_flag || !this.is_fork && batches.size === 1) {
|
||
batch_values = null;
|
||
return;
|
||
}
|
||
batch_values = /* @__PURE__ */ new Map();
|
||
for (const [source, [value]] of this.current) batch_values.set(source, value);
|
||
for (const batch of batches) {
|
||
if (batch === this || batch.is_fork) continue;
|
||
var intersects = false;
|
||
var differs = false;
|
||
if (batch.id < this.id) for (const [source, [, is_derived]] of batch.current) {
|
||
if (is_derived) continue;
|
||
intersects ||= this.current.has(source);
|
||
differs ||= !this.current.has(source);
|
||
}
|
||
if (intersects && differs) this.#blockers.add(batch);
|
||
else for (const [source, previous] of batch.previous) if (!batch_values.has(source)) batch_values.set(source, previous);
|
||
}
|
||
}
|
||
/**
|
||
*
|
||
* @param {Effect} effect
|
||
*/
|
||
schedule(effect) {
|
||
last_scheduled_effect = effect;
|
||
if (effect.b?.is_pending && (effect.f & 16777228) !== 0 && (effect.f & 32768) === 0) {
|
||
effect.b.defer_effect(effect);
|
||
return;
|
||
}
|
||
var e = effect;
|
||
while (e.parent !== null) {
|
||
e = e.parent;
|
||
var flags = e.f;
|
||
if (collected_effects !== null && e === active_effect) {
|
||
if (async_mode_flag) return;
|
||
if ((active_reaction === null || (active_reaction.f & 2) === 0) && !legacy_is_updating_store) return;
|
||
}
|
||
if ((flags & 96) !== 0) {
|
||
if ((flags & 1024) === 0) return;
|
||
e.f ^= CLEAN;
|
||
}
|
||
}
|
||
this.#roots.push(e);
|
||
}
|
||
};
|
||
/**
|
||
* Synchronously flush any pending updates.
|
||
* Returns void if no callback is provided, otherwise returns the result of calling the callback.
|
||
* @template [T=void]
|
||
* @param {(() => T) | undefined} [fn]
|
||
* @returns {T}
|
||
*/
|
||
function flushSync(fn) {
|
||
var was_flushing_sync = is_flushing_sync;
|
||
is_flushing_sync = true;
|
||
try {
|
||
var result;
|
||
if (fn) {
|
||
if (current_batch !== null && !current_batch.is_fork) current_batch.flush();
|
||
result = fn();
|
||
}
|
||
while (true) {
|
||
flush_tasks();
|
||
if (current_batch === null) return result;
|
||
current_batch.flush();
|
||
}
|
||
} finally {
|
||
is_flushing_sync = was_flushing_sync;
|
||
}
|
||
}
|
||
function infinite_loop_guard() {
|
||
try {
|
||
effect_update_depth_exceeded();
|
||
} catch (error) {
|
||
invoke_error_boundary(error, last_scheduled_effect);
|
||
}
|
||
}
|
||
/** @type {Set<Effect> | null} */
|
||
var eager_block_effects = null;
|
||
/**
|
||
* @param {Array<Effect>} effects
|
||
* @returns {void}
|
||
*/
|
||
function flush_queued_effects(effects) {
|
||
var length = effects.length;
|
||
if (length === 0) return;
|
||
var i = 0;
|
||
while (i < length) {
|
||
var effect = effects[i++];
|
||
if ((effect.f & 24576) === 0 && is_dirty(effect)) {
|
||
eager_block_effects = /* @__PURE__ */ new Set();
|
||
update_effect(effect);
|
||
if (effect.deps === null && effect.first === null && effect.nodes === null && effect.teardown === null && effect.ac === null) unlink_effect(effect);
|
||
if (eager_block_effects?.size > 0) {
|
||
old_values.clear();
|
||
for (const e of eager_block_effects) {
|
||
if ((e.f & 24576) !== 0) continue;
|
||
/** @type {Effect[]} */
|
||
const ordered_effects = [e];
|
||
let ancestor = e.parent;
|
||
while (ancestor !== null) {
|
||
if (eager_block_effects.has(ancestor)) {
|
||
eager_block_effects.delete(ancestor);
|
||
ordered_effects.push(ancestor);
|
||
}
|
||
ancestor = ancestor.parent;
|
||
}
|
||
for (let j = ordered_effects.length - 1; j >= 0; j--) {
|
||
const e = ordered_effects[j];
|
||
if ((e.f & 24576) !== 0) continue;
|
||
update_effect(e);
|
||
}
|
||
}
|
||
eager_block_effects.clear();
|
||
}
|
||
}
|
||
}
|
||
eager_block_effects = null;
|
||
}
|
||
/**
|
||
* This is similar to `mark_reactions`, but it only marks async/block effects
|
||
* depending on `value` and at least one of the other `sources`, so that
|
||
* these effects can re-run after another batch has been committed
|
||
* @param {Value} value
|
||
* @param {Source[]} sources
|
||
* @param {Set<Value>} marked
|
||
* @param {Map<Reaction, boolean>} checked
|
||
*/
|
||
function mark_effects(value, sources, marked, checked) {
|
||
if (marked.has(value)) return;
|
||
marked.add(value);
|
||
if (value.reactions !== null) for (const reaction of value.reactions) {
|
||
const flags = reaction.f;
|
||
if ((flags & 2) !== 0) mark_effects(reaction, sources, marked, checked);
|
||
else if ((flags & 4194320) !== 0 && (flags & 2048) === 0 && depends_on(reaction, sources, checked)) {
|
||
set_signal_status(reaction, DIRTY);
|
||
schedule_effect(reaction);
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* @param {Reaction} reaction
|
||
* @param {Source[]} sources
|
||
* @param {Map<Reaction, boolean>} checked
|
||
*/
|
||
function depends_on(reaction, sources, checked) {
|
||
const depends = checked.get(reaction);
|
||
if (depends !== void 0) return depends;
|
||
if (reaction.deps !== null) for (const dep of reaction.deps) {
|
||
if (includes.call(sources, dep)) return true;
|
||
if ((dep.f & 2) !== 0 && depends_on(dep, sources, checked)) {
|
||
checked.set(dep, true);
|
||
return true;
|
||
}
|
||
}
|
||
checked.set(reaction, false);
|
||
return false;
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
* @returns {void}
|
||
*/
|
||
function schedule_effect(effect) {
|
||
/** @type {Batch} */ current_batch.schedule(effect);
|
||
}
|
||
/**
|
||
* Mark all the effects inside a skipped branch CLEAN, so that
|
||
* they can be correctly rescheduled later. Tracks dirty and maybe_dirty
|
||
* effects so they can be rescheduled if the branch survives.
|
||
* @param {Effect} effect
|
||
* @param {{ d: Effect[], m: Effect[] }} tracked
|
||
*/
|
||
function reset_branch(effect, tracked) {
|
||
if ((effect.f & 32) !== 0 && (effect.f & 1024) !== 0) return;
|
||
if ((effect.f & 2048) !== 0) tracked.d.push(effect);
|
||
else if ((effect.f & 4096) !== 0) tracked.m.push(effect);
|
||
set_signal_status(effect, CLEAN);
|
||
var e = effect.first;
|
||
while (e !== null) {
|
||
reset_branch(e, tracked);
|
||
e = e.next;
|
||
}
|
||
}
|
||
/**
|
||
* Mark an entire effect tree clean following an error
|
||
* @param {Effect} effect
|
||
*/
|
||
function reset_all(effect) {
|
||
set_signal_status(effect, CLEAN);
|
||
var e = effect.first;
|
||
while (e !== null) {
|
||
reset_all(e);
|
||
e = e.next;
|
||
}
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/reactivity/create-subscriber.js
|
||
/**
|
||
* Returns a `subscribe` function that integrates external event-based systems with Svelte's reactivity.
|
||
* It's particularly useful for integrating with web APIs like `MediaQuery`, `IntersectionObserver`, or `WebSocket`.
|
||
*
|
||
* If `subscribe` is called inside an effect (including indirectly, for example inside a getter),
|
||
* the `start` callback will be called with an `update` function. Whenever `update` is called, the effect re-runs.
|
||
*
|
||
* If `start` returns a cleanup function, it will be called when the effect is destroyed.
|
||
*
|
||
* If `subscribe` is called in multiple effects, `start` will only be called once as long as the effects
|
||
* are active, and the returned teardown function will only be called when all effects are destroyed.
|
||
*
|
||
* It's best understood with an example. Here's an implementation of [`MediaQuery`](https://svelte.dev/docs/svelte/svelte-reactivity#MediaQuery):
|
||
*
|
||
* ```js
|
||
* import { createSubscriber } from 'svelte/reactivity';
|
||
* import { on } from 'svelte/events';
|
||
*
|
||
* export class MediaQuery {
|
||
* #query;
|
||
* #subscribe;
|
||
*
|
||
* constructor(query) {
|
||
* this.#query = window.matchMedia(`(${query})`);
|
||
*
|
||
* this.#subscribe = createSubscriber((update) => {
|
||
* // when the `change` event occurs, re-run any effects that read `this.current`
|
||
* const off = on(this.#query, 'change', update);
|
||
*
|
||
* // stop listening when all the effects are destroyed
|
||
* return () => off();
|
||
* });
|
||
* }
|
||
*
|
||
* get current() {
|
||
* // This makes the getter reactive, if read in an effect
|
||
* this.#subscribe();
|
||
*
|
||
* // Return the current state of the query, whether or not we're in an effect
|
||
* return this.#query.matches;
|
||
* }
|
||
* }
|
||
* ```
|
||
* @param {(update: () => void) => (() => void) | void} start
|
||
* @since 5.7.0
|
||
*/
|
||
function createSubscriber(start) {
|
||
let subscribers = 0;
|
||
let version = source(0);
|
||
/** @type {(() => void) | void} */
|
||
let stop;
|
||
return () => {
|
||
if (effect_tracking()) {
|
||
get(version);
|
||
render_effect(() => {
|
||
if (subscribers === 0) stop = untrack(() => start(() => increment(version)));
|
||
subscribers += 1;
|
||
return () => {
|
||
queue_micro_task(() => {
|
||
subscribers -= 1;
|
||
if (subscribers === 0) {
|
||
stop?.();
|
||
stop = void 0;
|
||
increment(version);
|
||
}
|
||
});
|
||
};
|
||
});
|
||
}
|
||
};
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/dom/blocks/boundary.js
|
||
/** @import { Effect, Source, TemplateNode, } from '#client' */
|
||
/**
|
||
* @typedef {{
|
||
* onerror?: (error: unknown, reset: () => void) => void;
|
||
* failed?: (anchor: Node, error: () => unknown, reset: () => () => void) => void;
|
||
* pending?: (anchor: Node) => void;
|
||
* }} BoundaryProps
|
||
*/
|
||
var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
|
||
/**
|
||
* @param {TemplateNode} node
|
||
* @param {BoundaryProps} props
|
||
* @param {((anchor: Node) => void)} children
|
||
* @param {((error: unknown) => unknown) | undefined} [transform_error]
|
||
* @returns {void}
|
||
*/
|
||
function boundary(node, props, children, transform_error) {
|
||
new Boundary(node, props, children, transform_error);
|
||
}
|
||
var Boundary = class {
|
||
/** @type {Boundary | null} */
|
||
parent;
|
||
is_pending = false;
|
||
/**
|
||
* API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
|
||
* Inherited from parent boundary, or defaults to identity.
|
||
* @type {(error: unknown) => unknown}
|
||
*/
|
||
transform_error;
|
||
/** @type {TemplateNode} */
|
||
#anchor;
|
||
/** @type {TemplateNode | null} */
|
||
#hydrate_open = hydrating ? hydrate_node : null;
|
||
/** @type {BoundaryProps} */
|
||
#props;
|
||
/** @type {((anchor: Node) => void)} */
|
||
#children;
|
||
/** @type {Effect} */
|
||
#effect;
|
||
/** @type {Effect | null} */
|
||
#main_effect = null;
|
||
/** @type {Effect | null} */
|
||
#pending_effect = null;
|
||
/** @type {Effect | null} */
|
||
#failed_effect = null;
|
||
/** @type {DocumentFragment | null} */
|
||
#offscreen_fragment = null;
|
||
#local_pending_count = 0;
|
||
#pending_count = 0;
|
||
#pending_count_update_queued = false;
|
||
/** @type {Set<Effect>} */
|
||
#dirty_effects = /* @__PURE__ */ new Set();
|
||
/** @type {Set<Effect>} */
|
||
#maybe_dirty_effects = /* @__PURE__ */ new Set();
|
||
/**
|
||
* A source containing the number of pending async deriveds/expressions.
|
||
* Only created if `$effect.pending()` is used inside the boundary,
|
||
* otherwise updating the source results in needless `Batch.ensure()`
|
||
* calls followed by no-op flushes
|
||
* @type {Source<number> | null}
|
||
*/
|
||
#effect_pending = null;
|
||
#effect_pending_subscriber = createSubscriber(() => {
|
||
this.#effect_pending = source(this.#local_pending_count);
|
||
return () => {
|
||
this.#effect_pending = null;
|
||
};
|
||
});
|
||
/**
|
||
* @param {TemplateNode} node
|
||
* @param {BoundaryProps} props
|
||
* @param {((anchor: Node) => void)} children
|
||
* @param {((error: unknown) => unknown) | undefined} [transform_error]
|
||
*/
|
||
constructor(node, props, children, transform_error) {
|
||
this.#anchor = node;
|
||
this.#props = props;
|
||
this.#children = (anchor) => {
|
||
var effect = active_effect;
|
||
effect.b = this;
|
||
effect.f |= 128;
|
||
children(anchor);
|
||
};
|
||
this.parent = active_effect.b;
|
||
this.transform_error = transform_error ?? this.parent?.transform_error ?? ((e) => e);
|
||
this.#effect = block(() => {
|
||
if (hydrating) {
|
||
const comment = this.#hydrate_open;
|
||
hydrate_next();
|
||
const server_rendered_pending = comment.data === "[!";
|
||
if (comment.data.startsWith("[?")) {
|
||
const serialized_error = JSON.parse(comment.data.slice(2));
|
||
this.#hydrate_failed_content(serialized_error);
|
||
} else if (server_rendered_pending) this.#hydrate_pending_content();
|
||
else this.#hydrate_resolved_content();
|
||
} else this.#render();
|
||
}, flags);
|
||
if (hydrating) this.#anchor = hydrate_node;
|
||
}
|
||
#hydrate_resolved_content() {
|
||
try {
|
||
this.#main_effect = branch(() => this.#children(this.#anchor));
|
||
} catch (error) {
|
||
this.error(error);
|
||
}
|
||
}
|
||
/**
|
||
* @param {unknown} error The deserialized error from the server's hydration comment
|
||
*/
|
||
#hydrate_failed_content(error) {
|
||
const failed = this.#props.failed;
|
||
if (!failed) return;
|
||
this.#failed_effect = branch(() => {
|
||
failed(this.#anchor, () => error, () => () => {});
|
||
});
|
||
}
|
||
#hydrate_pending_content() {
|
||
const pending = this.#props.pending;
|
||
if (!pending) return;
|
||
this.is_pending = true;
|
||
this.#pending_effect = branch(() => pending(this.#anchor));
|
||
queue_micro_task(() => {
|
||
var fragment = this.#offscreen_fragment = document.createDocumentFragment();
|
||
var anchor = create_text();
|
||
fragment.append(anchor);
|
||
this.#main_effect = this.#run(() => {
|
||
return branch(() => this.#children(anchor));
|
||
});
|
||
if (this.#pending_count === 0) {
|
||
this.#anchor.before(fragment);
|
||
this.#offscreen_fragment = null;
|
||
pause_effect(this.#pending_effect, () => {
|
||
this.#pending_effect = null;
|
||
});
|
||
this.#resolve(current_batch);
|
||
}
|
||
});
|
||
}
|
||
#render() {
|
||
try {
|
||
this.is_pending = this.has_pending_snippet();
|
||
this.#pending_count = 0;
|
||
this.#local_pending_count = 0;
|
||
this.#main_effect = branch(() => {
|
||
this.#children(this.#anchor);
|
||
});
|
||
if (this.#pending_count > 0) {
|
||
var fragment = this.#offscreen_fragment = document.createDocumentFragment();
|
||
move_effect(this.#main_effect, fragment);
|
||
const pending = this.#props.pending;
|
||
this.#pending_effect = branch(() => pending(this.#anchor));
|
||
} else this.#resolve(current_batch);
|
||
} catch (error) {
|
||
this.error(error);
|
||
}
|
||
}
|
||
/**
|
||
* @param {Batch} batch
|
||
*/
|
||
#resolve(batch) {
|
||
this.is_pending = false;
|
||
batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_effects);
|
||
}
|
||
/**
|
||
* Defer an effect inside a pending boundary until the boundary resolves
|
||
* @param {Effect} effect
|
||
*/
|
||
defer_effect(effect) {
|
||
defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
|
||
}
|
||
/**
|
||
* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
|
||
* @returns {boolean}
|
||
*/
|
||
is_rendered() {
|
||
return !this.is_pending && (!this.parent || this.parent.is_rendered());
|
||
}
|
||
has_pending_snippet() {
|
||
return !!this.#props.pending;
|
||
}
|
||
/**
|
||
* @template T
|
||
* @param {() => T} fn
|
||
*/
|
||
#run(fn) {
|
||
var previous_effect = active_effect;
|
||
var previous_reaction = active_reaction;
|
||
var previous_ctx = component_context;
|
||
set_active_effect(this.#effect);
|
||
set_active_reaction(this.#effect);
|
||
set_component_context(this.#effect.ctx);
|
||
try {
|
||
Batch.ensure();
|
||
return fn();
|
||
} catch (e) {
|
||
handle_error(e);
|
||
return null;
|
||
} finally {
|
||
set_active_effect(previous_effect);
|
||
set_active_reaction(previous_reaction);
|
||
set_component_context(previous_ctx);
|
||
}
|
||
}
|
||
/**
|
||
* Updates the pending count associated with the currently visible pending snippet,
|
||
* if any, such that we can replace the snippet with content once work is done
|
||
* @param {1 | -1} d
|
||
* @param {Batch} batch
|
||
*/
|
||
#update_pending_count(d, batch) {
|
||
if (!this.has_pending_snippet()) {
|
||
if (this.parent) this.parent.#update_pending_count(d, batch);
|
||
return;
|
||
}
|
||
this.#pending_count += d;
|
||
if (this.#pending_count === 0) {
|
||
this.#resolve(batch);
|
||
if (this.#pending_effect) pause_effect(this.#pending_effect, () => {
|
||
this.#pending_effect = null;
|
||
});
|
||
if (this.#offscreen_fragment) {
|
||
this.#anchor.before(this.#offscreen_fragment);
|
||
this.#offscreen_fragment = null;
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* Update the source that powers `$effect.pending()` inside this boundary,
|
||
* and controls when the current `pending` snippet (if any) is removed.
|
||
* Do not call from inside the class
|
||
* @param {1 | -1} d
|
||
* @param {Batch} batch
|
||
*/
|
||
update_pending_count(d, batch) {
|
||
this.#update_pending_count(d, batch);
|
||
this.#local_pending_count += d;
|
||
if (!this.#effect_pending || this.#pending_count_update_queued) return;
|
||
this.#pending_count_update_queued = true;
|
||
queue_micro_task(() => {
|
||
this.#pending_count_update_queued = false;
|
||
if (this.#effect_pending) internal_set(this.#effect_pending, this.#local_pending_count);
|
||
});
|
||
}
|
||
get_effect_pending() {
|
||
this.#effect_pending_subscriber();
|
||
return get(this.#effect_pending);
|
||
}
|
||
/** @param {unknown} error */
|
||
error(error) {
|
||
if (!this.#props.onerror && !this.#props.failed) throw error;
|
||
if (current_batch?.is_fork) {
|
||
if (this.#main_effect) current_batch.skip_effect(this.#main_effect);
|
||
if (this.#pending_effect) current_batch.skip_effect(this.#pending_effect);
|
||
if (this.#failed_effect) current_batch.skip_effect(this.#failed_effect);
|
||
current_batch.on_fork_commit(() => {
|
||
this.#handle_error(error);
|
||
});
|
||
} else this.#handle_error(error);
|
||
}
|
||
/**
|
||
* @param {unknown} error
|
||
*/
|
||
#handle_error(error) {
|
||
if (this.#main_effect) {
|
||
destroy_effect(this.#main_effect);
|
||
this.#main_effect = null;
|
||
}
|
||
if (this.#pending_effect) {
|
||
destroy_effect(this.#pending_effect);
|
||
this.#pending_effect = null;
|
||
}
|
||
if (this.#failed_effect) {
|
||
destroy_effect(this.#failed_effect);
|
||
this.#failed_effect = null;
|
||
}
|
||
if (hydrating) {
|
||
set_hydrate_node(this.#hydrate_open);
|
||
next();
|
||
set_hydrate_node(skip_nodes());
|
||
}
|
||
var onerror = this.#props.onerror;
|
||
let failed = this.#props.failed;
|
||
var did_reset = false;
|
||
var calling_on_error = false;
|
||
const reset = () => {
|
||
if (did_reset) {
|
||
svelte_boundary_reset_noop();
|
||
return;
|
||
}
|
||
did_reset = true;
|
||
if (calling_on_error) svelte_boundary_reset_onerror();
|
||
if (this.#failed_effect !== null) pause_effect(this.#failed_effect, () => {
|
||
this.#failed_effect = null;
|
||
});
|
||
this.#run(() => {
|
||
this.#render();
|
||
});
|
||
};
|
||
/** @param {unknown} transformed_error */
|
||
const handle_error_result = (transformed_error) => {
|
||
try {
|
||
calling_on_error = true;
|
||
onerror?.(transformed_error, reset);
|
||
calling_on_error = false;
|
||
} catch (error) {
|
||
invoke_error_boundary(error, this.#effect && this.#effect.parent);
|
||
}
|
||
if (failed) this.#failed_effect = this.#run(() => {
|
||
try {
|
||
return branch(() => {
|
||
var effect = active_effect;
|
||
effect.b = this;
|
||
effect.f |= 128;
|
||
failed(this.#anchor, () => transformed_error, () => reset);
|
||
});
|
||
} catch (error) {
|
||
invoke_error_boundary(error, this.#effect.parent);
|
||
return null;
|
||
}
|
||
});
|
||
};
|
||
queue_micro_task(() => {
|
||
/** @type {unknown} */
|
||
var result;
|
||
try {
|
||
result = this.transform_error(error);
|
||
} catch (e) {
|
||
invoke_error_boundary(e, this.#effect && this.#effect.parent);
|
||
return;
|
||
}
|
||
if (result !== null && typeof result === "object" && typeof result.then === "function")
|
||
/** @type {any} */ result.then(
|
||
handle_error_result,
|
||
/** @param {unknown} e */
|
||
(e) => invoke_error_boundary(e, this.#effect && this.#effect.parent)
|
||
);
|
||
else handle_error_result(result);
|
||
});
|
||
}
|
||
};
|
||
/**
|
||
* @param {Derived} derived
|
||
* @returns {void}
|
||
*/
|
||
function destroy_derived_effects(derived) {
|
||
var effects = derived.effects;
|
||
if (effects !== null) {
|
||
derived.effects = null;
|
||
for (var i = 0; i < effects.length; i += 1) destroy_effect(effects[i]);
|
||
}
|
||
}
|
||
/**
|
||
* @template T
|
||
* @param {Derived} derived
|
||
* @returns {T}
|
||
*/
|
||
function execute_derived(derived) {
|
||
var value;
|
||
var prev_active_effect = active_effect;
|
||
var parent = derived.parent;
|
||
if (!is_destroying_effect && parent !== null && (parent.f & 24576) !== 0) {
|
||
derived_inert();
|
||
return derived.v;
|
||
}
|
||
set_active_effect(parent);
|
||
try {
|
||
derived.f &= ~WAS_MARKED;
|
||
destroy_derived_effects(derived);
|
||
value = update_reaction(derived);
|
||
} finally {
|
||
set_active_effect(prev_active_effect);
|
||
}
|
||
return value;
|
||
}
|
||
/**
|
||
* @param {Derived} derived
|
||
* @returns {void}
|
||
*/
|
||
function update_derived(derived) {
|
||
var value = execute_derived(derived);
|
||
if (!derived.equals(value)) {
|
||
derived.wv = increment_write_version();
|
||
if (!current_batch?.is_fork || derived.deps === null) {
|
||
if (current_batch !== null) current_batch.capture(derived, value, true);
|
||
else derived.v = value;
|
||
if (derived.deps === null) {
|
||
set_signal_status(derived, CLEAN);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
if (is_destroying_effect) return;
|
||
if (batch_values !== null) {
|
||
if (effect_tracking() || current_batch?.is_fork) batch_values.set(derived, value);
|
||
} else update_derived_status(derived);
|
||
}
|
||
/**
|
||
* @param {Derived} derived
|
||
*/
|
||
function freeze_derived_effects(derived) {
|
||
if (derived.effects === null) return;
|
||
for (const e of derived.effects) if (e.teardown || e.ac) {
|
||
e.teardown?.();
|
||
e.ac?.abort(STALE_REACTION);
|
||
e.teardown = noop;
|
||
e.ac = null;
|
||
remove_reactions(e, 0);
|
||
destroy_effect_children(e);
|
||
}
|
||
}
|
||
/**
|
||
* @param {Derived} derived
|
||
*/
|
||
function unfreeze_derived_effects(derived) {
|
||
if (derived.effects === null) return;
|
||
for (const e of derived.effects) if (e.teardown) update_effect(e);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/reactivity/sources.js
|
||
/** @import { Derived, Effect, Source, Value } from '#client' */
|
||
/** @type {Set<any>} */
|
||
var eager_effects = /* @__PURE__ */ new Set();
|
||
/** @type {Map<Source, any>} */
|
||
var old_values = /* @__PURE__ */ new Map();
|
||
var eager_effects_deferred = false;
|
||
/**
|
||
* @template V
|
||
* @param {V} v
|
||
* @param {Error | null} [stack]
|
||
* @returns {Source<V>}
|
||
*/
|
||
function source(v, stack) {
|
||
return {
|
||
f: 0,
|
||
v,
|
||
reactions: null,
|
||
equals,
|
||
rv: 0,
|
||
wv: 0
|
||
};
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {V} v
|
||
* @param {Error | null} [stack]
|
||
*/
|
||
/* @__NO_SIDE_EFFECTS__ */
|
||
function state(v, stack) {
|
||
const s = source(v, stack);
|
||
push_reaction_value(s);
|
||
return s;
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {V} initial_value
|
||
* @param {boolean} [immutable]
|
||
* @returns {Source<V>}
|
||
*/
|
||
/* @__NO_SIDE_EFFECTS__ */
|
||
function mutable_source(initial_value, immutable = false, trackable = true) {
|
||
const s = source(initial_value);
|
||
if (!immutable) s.equals = safe_equals;
|
||
if (legacy_mode_flag && trackable && component_context !== null && component_context.l !== null) (component_context.l.s ??= []).push(s);
|
||
return s;
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {Source<V>} source
|
||
* @param {V} value
|
||
* @param {boolean} [should_proxy]
|
||
* @returns {V}
|
||
*/
|
||
function set(source, value, should_proxy = false) {
|
||
if (active_reaction !== null && (!untracking || (active_reaction.f & 131072) !== 0) && is_runes() && (active_reaction.f & 4325394) !== 0 && (current_sources === null || !includes.call(current_sources, source))) state_unsafe_mutation();
|
||
return internal_set(source, should_proxy ? proxy(value) : value, legacy_updates);
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {Source<V>} source
|
||
* @param {V} value
|
||
* @param {Effect[] | null} [updated_during_traversal]
|
||
* @returns {V}
|
||
*/
|
||
function internal_set(source, value, updated_during_traversal = null) {
|
||
if (!source.equals(value)) {
|
||
old_values.set(source, is_destroying_effect ? value : source.v);
|
||
var batch = Batch.ensure();
|
||
batch.capture(source, value);
|
||
if ((source.f & 2) !== 0) {
|
||
const derived = source;
|
||
if ((source.f & 2048) !== 0) execute_derived(derived);
|
||
if (batch_values === null) update_derived_status(derived);
|
||
}
|
||
source.wv = increment_write_version();
|
||
mark_reactions(source, DIRTY, updated_during_traversal);
|
||
if (is_runes() && active_effect !== null && (active_effect.f & 1024) !== 0 && (active_effect.f & 96) === 0) if (untracked_writes === null) set_untracked_writes([source]);
|
||
else untracked_writes.push(source);
|
||
if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) flush_eager_effects();
|
||
}
|
||
return value;
|
||
}
|
||
function flush_eager_effects() {
|
||
eager_effects_deferred = false;
|
||
for (const effect of eager_effects) {
|
||
if ((effect.f & 1024) !== 0) set_signal_status(effect, MAYBE_DIRTY);
|
||
if (is_dirty(effect)) update_effect(effect);
|
||
}
|
||
eager_effects.clear();
|
||
}
|
||
/**
|
||
* Silently (without using `get`) increment a source
|
||
* @param {Source<number>} source
|
||
*/
|
||
function increment(source) {
|
||
set(source, source.v + 1);
|
||
}
|
||
/**
|
||
* @param {Value} signal
|
||
* @param {number} status should be DIRTY or MAYBE_DIRTY
|
||
* @param {Effect[] | null} updated_during_traversal
|
||
* @returns {void}
|
||
*/
|
||
function mark_reactions(signal, status, updated_during_traversal) {
|
||
var reactions = signal.reactions;
|
||
if (reactions === null) return;
|
||
var runes = is_runes();
|
||
var length = reactions.length;
|
||
for (var i = 0; i < length; i++) {
|
||
var reaction = reactions[i];
|
||
var flags = reaction.f;
|
||
if (!runes && reaction === active_effect) continue;
|
||
var not_dirty = (flags & DIRTY) === 0;
|
||
if (not_dirty) set_signal_status(reaction, status);
|
||
if ((flags & 2) !== 0) {
|
||
var derived = reaction;
|
||
batch_values?.delete(derived);
|
||
if ((flags & 65536) === 0) {
|
||
if (flags & 512 && (active_effect === null || (active_effect.f & 2097152) === 0)) reaction.f |= WAS_MARKED;
|
||
mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
|
||
}
|
||
} else if (not_dirty) {
|
||
var effect = reaction;
|
||
if ((flags & 16) !== 0 && eager_block_effects !== null) eager_block_effects.add(effect);
|
||
if (updated_during_traversal !== null) updated_during_traversal.push(effect);
|
||
else schedule_effect(effect);
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* @template T
|
||
* @param {T} value
|
||
* @returns {T}
|
||
*/
|
||
function proxy(value) {
|
||
if (typeof value !== "object" || value === null || STATE_SYMBOL in value) return value;
|
||
const prototype = get_prototype_of(value);
|
||
if (prototype !== object_prototype && prototype !== array_prototype) return value;
|
||
/** @type {Map<any, Source<any>>} */
|
||
var sources = /* @__PURE__ */ new Map();
|
||
var is_proxied_array = is_array(value);
|
||
var version = /* @__PURE__ */ state(0);
|
||
var stack = null;
|
||
var parent_version = update_version;
|
||
/**
|
||
* Executes the proxy in the context of the reaction it was originally created in, if any
|
||
* @template T
|
||
* @param {() => T} fn
|
||
*/
|
||
var with_parent = (fn) => {
|
||
if (update_version === parent_version) return fn();
|
||
var reaction = active_reaction;
|
||
var version = update_version;
|
||
set_active_reaction(null);
|
||
set_update_version(parent_version);
|
||
var result = fn();
|
||
set_active_reaction(reaction);
|
||
set_update_version(version);
|
||
return result;
|
||
};
|
||
if (is_proxied_array) sources.set("length", /* @__PURE__ */ state(
|
||
/** @type {any[]} */
|
||
value.length,
|
||
stack
|
||
));
|
||
return new Proxy(value, {
|
||
defineProperty(_, prop, descriptor) {
|
||
if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) state_descriptors_fixed();
|
||
var s = sources.get(prop);
|
||
if (s === void 0) with_parent(() => {
|
||
var s = /* @__PURE__ */ state(descriptor.value, stack);
|
||
sources.set(prop, s);
|
||
return s;
|
||
});
|
||
else set(s, descriptor.value, true);
|
||
return true;
|
||
},
|
||
deleteProperty(target, prop) {
|
||
var s = sources.get(prop);
|
||
if (s === void 0) {
|
||
if (prop in target) {
|
||
const s = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED, stack));
|
||
sources.set(prop, s);
|
||
increment(version);
|
||
}
|
||
} else {
|
||
set(s, UNINITIALIZED);
|
||
increment(version);
|
||
}
|
||
return true;
|
||
},
|
||
get(target, prop, receiver) {
|
||
if (prop === STATE_SYMBOL) return value;
|
||
var s = sources.get(prop);
|
||
var exists = prop in target;
|
||
if (s === void 0 && (!exists || get_descriptor(target, prop)?.writable)) {
|
||
s = with_parent(() => {
|
||
return /* @__PURE__ */ state(proxy(exists ? target[prop] : UNINITIALIZED), stack);
|
||
});
|
||
sources.set(prop, s);
|
||
}
|
||
if (s !== void 0) {
|
||
var v = get(s);
|
||
return v === UNINITIALIZED ? void 0 : v;
|
||
}
|
||
return Reflect.get(target, prop, receiver);
|
||
},
|
||
getOwnPropertyDescriptor(target, prop) {
|
||
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
|
||
if (descriptor && "value" in descriptor) {
|
||
var s = sources.get(prop);
|
||
if (s) descriptor.value = get(s);
|
||
} else if (descriptor === void 0) {
|
||
var source = sources.get(prop);
|
||
var value = source?.v;
|
||
if (source !== void 0 && value !== UNINITIALIZED) return {
|
||
enumerable: true,
|
||
configurable: true,
|
||
value,
|
||
writable: true
|
||
};
|
||
}
|
||
return descriptor;
|
||
},
|
||
has(target, prop) {
|
||
if (prop === STATE_SYMBOL) return true;
|
||
var s = sources.get(prop);
|
||
var has = s !== void 0 && s.v !== UNINITIALIZED || Reflect.has(target, prop);
|
||
if (s !== void 0 || active_effect !== null && (!has || get_descriptor(target, prop)?.writable)) {
|
||
if (s === void 0) {
|
||
s = with_parent(() => {
|
||
return /* @__PURE__ */ state(has ? proxy(target[prop]) : UNINITIALIZED, stack);
|
||
});
|
||
sources.set(prop, s);
|
||
}
|
||
if (get(s) === UNINITIALIZED) return false;
|
||
}
|
||
return has;
|
||
},
|
||
set(target, prop, value, receiver) {
|
||
var s = sources.get(prop);
|
||
var has = prop in target;
|
||
if (is_proxied_array && prop === "length") for (var i = value; i < s.v; i += 1) {
|
||
var other_s = sources.get(i + "");
|
||
if (other_s !== void 0) set(other_s, UNINITIALIZED);
|
||
else if (i in target) {
|
||
other_s = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED, stack));
|
||
sources.set(i + "", other_s);
|
||
}
|
||
}
|
||
if (s === void 0) {
|
||
if (!has || get_descriptor(target, prop)?.writable) {
|
||
s = with_parent(() => /* @__PURE__ */ state(void 0, stack));
|
||
set(s, proxy(value));
|
||
sources.set(prop, s);
|
||
}
|
||
} else {
|
||
has = s.v !== UNINITIALIZED;
|
||
var p = with_parent(() => proxy(value));
|
||
set(s, p);
|
||
}
|
||
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
|
||
if (descriptor?.set) descriptor.set.call(receiver, value);
|
||
if (!has) {
|
||
if (is_proxied_array && typeof prop === "string") {
|
||
var ls = sources.get("length");
|
||
var n = Number(prop);
|
||
if (Number.isInteger(n) && n >= ls.v) set(ls, n + 1);
|
||
}
|
||
increment(version);
|
||
}
|
||
return true;
|
||
},
|
||
ownKeys(target) {
|
||
get(version);
|
||
var own_keys = Reflect.ownKeys(target).filter((key) => {
|
||
var source = sources.get(key);
|
||
return source === void 0 || source.v !== UNINITIALIZED;
|
||
});
|
||
for (var [key, source] of sources) if (source.v !== UNINITIALIZED && !(key in target)) own_keys.push(key);
|
||
return own_keys;
|
||
},
|
||
setPrototypeOf() {
|
||
state_prototype_fixed();
|
||
}
|
||
});
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/dom/operations.js
|
||
/** @type {Window} */
|
||
var $window;
|
||
/** @type {() => Node | null} */
|
||
var first_child_getter;
|
||
/** @type {() => Node | null} */
|
||
var next_sibling_getter;
|
||
/**
|
||
* Initialize these lazily to avoid issues when using the runtime in a server context
|
||
* where these globals are not available while avoiding a separate server entry point
|
||
*/
|
||
function init_operations() {
|
||
if ($window !== void 0) return;
|
||
$window = window;
|
||
/Firefox/.test(navigator.userAgent);
|
||
var element_prototype = Element.prototype;
|
||
var node_prototype = Node.prototype;
|
||
var text_prototype = Text.prototype;
|
||
first_child_getter = get_descriptor(node_prototype, "firstChild").get;
|
||
next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
|
||
if (is_extensible(element_prototype)) {
|
||
element_prototype.__click = void 0;
|
||
element_prototype.__className = void 0;
|
||
element_prototype.__attributes = null;
|
||
element_prototype.__style = void 0;
|
||
element_prototype.__e = void 0;
|
||
}
|
||
if (is_extensible(text_prototype)) text_prototype.__t = void 0;
|
||
}
|
||
/**
|
||
* @param {string} value
|
||
* @returns {Text}
|
||
*/
|
||
function create_text(value = "") {
|
||
return document.createTextNode(value);
|
||
}
|
||
/**
|
||
* @template {Node} N
|
||
* @param {N} node
|
||
*/
|
||
/* @__NO_SIDE_EFFECTS__ */
|
||
function get_first_child(node) {
|
||
return first_child_getter.call(node);
|
||
}
|
||
/**
|
||
* @template {Node} N
|
||
* @param {N} node
|
||
*/
|
||
/* @__NO_SIDE_EFFECTS__ */
|
||
function get_next_sibling(node) {
|
||
return next_sibling_getter.call(node);
|
||
}
|
||
/**
|
||
* @template {Node} N
|
||
* @param {N} node
|
||
* @returns {void}
|
||
*/
|
||
function clear_text_content(node) {
|
||
node.textContent = "";
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/dom/elements/bindings/shared.js
|
||
/**
|
||
* @template T
|
||
* @param {() => T} fn
|
||
*/
|
||
function without_reactive_context(fn) {
|
||
var previous_reaction = active_reaction;
|
||
var previous_effect = active_effect;
|
||
set_active_reaction(null);
|
||
set_active_effect(null);
|
||
try {
|
||
return fn();
|
||
} finally {
|
||
set_active_reaction(previous_reaction);
|
||
set_active_effect(previous_effect);
|
||
}
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/reactivity/effects.js
|
||
/** @import { Blocker, ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */
|
||
/**
|
||
* @param {Effect} effect
|
||
* @param {Effect} parent_effect
|
||
*/
|
||
function push_effect(effect, parent_effect) {
|
||
var parent_last = parent_effect.last;
|
||
if (parent_last === null) parent_effect.last = parent_effect.first = effect;
|
||
else {
|
||
parent_last.next = effect;
|
||
effect.prev = parent_last;
|
||
parent_effect.last = effect;
|
||
}
|
||
}
|
||
/**
|
||
* @param {number} type
|
||
* @param {null | (() => void | (() => void))} fn
|
||
* @returns {Effect}
|
||
*/
|
||
function create_effect(type, fn) {
|
||
var parent = active_effect;
|
||
if (parent !== null && (parent.f & 8192) !== 0) type |= INERT;
|
||
/** @type {Effect} */
|
||
var effect = {
|
||
ctx: component_context,
|
||
deps: null,
|
||
nodes: null,
|
||
f: type | DIRTY | 512,
|
||
first: null,
|
||
fn,
|
||
last: null,
|
||
next: null,
|
||
parent,
|
||
b: parent && parent.b,
|
||
prev: null,
|
||
teardown: null,
|
||
wv: 0,
|
||
ac: null
|
||
};
|
||
current_batch?.register_created_effect(effect);
|
||
/** @type {Effect | null} */
|
||
var e = effect;
|
||
if ((type & 4) !== 0) if (collected_effects !== null) collected_effects.push(effect);
|
||
else Batch.ensure().schedule(effect);
|
||
else if (fn !== null) {
|
||
try {
|
||
update_effect(effect);
|
||
} catch (e) {
|
||
destroy_effect(effect);
|
||
throw e;
|
||
}
|
||
if (e.deps === null && e.teardown === null && e.nodes === null && e.first === e.last && (e.f & 524288) === 0) {
|
||
e = e.first;
|
||
if ((type & 16) !== 0 && (type & 65536) !== 0 && e !== null) e.f |= EFFECT_TRANSPARENT;
|
||
}
|
||
}
|
||
if (e !== null) {
|
||
e.parent = parent;
|
||
if (parent !== null) push_effect(e, parent);
|
||
if (active_reaction !== null && (active_reaction.f & 2) !== 0 && (type & 64) === 0) {
|
||
var derived = active_reaction;
|
||
(derived.effects ??= []).push(e);
|
||
}
|
||
}
|
||
return effect;
|
||
}
|
||
/**
|
||
* Internal representation of `$effect.tracking()`
|
||
* @returns {boolean}
|
||
*/
|
||
function effect_tracking() {
|
||
return active_reaction !== null && !untracking;
|
||
}
|
||
/**
|
||
* @param {() => void | (() => void)} fn
|
||
*/
|
||
function create_user_effect(fn) {
|
||
return create_effect(4 | USER_EFFECT, fn);
|
||
}
|
||
/**
|
||
* An effect root whose children can transition out
|
||
* @param {() => void} fn
|
||
* @returns {(options?: { outro?: boolean }) => Promise<void>}
|
||
*/
|
||
function component_root(fn) {
|
||
Batch.ensure();
|
||
const effect = create_effect(64 | EFFECT_PRESERVED, fn);
|
||
return (options = {}) => {
|
||
return new Promise((fulfil) => {
|
||
if (options.outro) pause_effect(effect, () => {
|
||
destroy_effect(effect);
|
||
fulfil(void 0);
|
||
});
|
||
else {
|
||
destroy_effect(effect);
|
||
fulfil(void 0);
|
||
}
|
||
});
|
||
};
|
||
}
|
||
/**
|
||
* @param {() => void | (() => void)} fn
|
||
* @returns {Effect}
|
||
*/
|
||
function render_effect(fn, flags = 0) {
|
||
return create_effect(8 | flags, fn);
|
||
}
|
||
/**
|
||
* @param {(() => void)} fn
|
||
* @param {number} flags
|
||
*/
|
||
function block(fn, flags = 0) {
|
||
return create_effect(16 | flags, fn);
|
||
}
|
||
/**
|
||
* @param {(() => void)} fn
|
||
*/
|
||
function branch(fn) {
|
||
return create_effect(32 | EFFECT_PRESERVED, fn);
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
*/
|
||
function execute_effect_teardown(effect) {
|
||
var teardown = effect.teardown;
|
||
if (teardown !== null) {
|
||
const previously_destroying_effect = is_destroying_effect;
|
||
const previous_reaction = active_reaction;
|
||
set_is_destroying_effect(true);
|
||
set_active_reaction(null);
|
||
try {
|
||
teardown.call(null);
|
||
} finally {
|
||
set_is_destroying_effect(previously_destroying_effect);
|
||
set_active_reaction(previous_reaction);
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* @param {Effect} signal
|
||
* @param {boolean} remove_dom
|
||
* @returns {void}
|
||
*/
|
||
function destroy_effect_children(signal, remove_dom = false) {
|
||
var effect = signal.first;
|
||
signal.first = signal.last = null;
|
||
while (effect !== null) {
|
||
const controller = effect.ac;
|
||
if (controller !== null) without_reactive_context(() => {
|
||
controller.abort(STALE_REACTION);
|
||
});
|
||
var next = effect.next;
|
||
if ((effect.f & 64) !== 0) effect.parent = null;
|
||
else destroy_effect(effect, remove_dom);
|
||
effect = next;
|
||
}
|
||
}
|
||
/**
|
||
* @param {Effect} signal
|
||
* @returns {void}
|
||
*/
|
||
function destroy_block_effect_children(signal) {
|
||
var effect = signal.first;
|
||
while (effect !== null) {
|
||
var next = effect.next;
|
||
if ((effect.f & 32) === 0) destroy_effect(effect);
|
||
effect = next;
|
||
}
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
* @param {boolean} [remove_dom]
|
||
* @returns {void}
|
||
*/
|
||
function destroy_effect(effect, remove_dom = true) {
|
||
var removed = false;
|
||
if ((remove_dom || (effect.f & 262144) !== 0) && effect.nodes !== null && effect.nodes.end !== null) {
|
||
remove_effect_dom(effect.nodes.start, effect.nodes.end);
|
||
removed = true;
|
||
}
|
||
set_signal_status(effect, DESTROYING);
|
||
destroy_effect_children(effect, remove_dom && !removed);
|
||
remove_reactions(effect, 0);
|
||
var transitions = effect.nodes && effect.nodes.t;
|
||
if (transitions !== null) for (const transition of transitions) transition.stop();
|
||
execute_effect_teardown(effect);
|
||
effect.f ^= DESTROYING;
|
||
effect.f |= DESTROYED;
|
||
var parent = effect.parent;
|
||
if (parent !== null && parent.first !== null) unlink_effect(effect);
|
||
effect.next = effect.prev = effect.teardown = effect.ctx = effect.deps = effect.fn = effect.nodes = effect.ac = effect.b = null;
|
||
}
|
||
/**
|
||
*
|
||
* @param {TemplateNode | null} node
|
||
* @param {TemplateNode} end
|
||
*/
|
||
function remove_effect_dom(node, end) {
|
||
while (node !== null) {
|
||
/** @type {TemplateNode | null} */
|
||
var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
|
||
node.remove();
|
||
node = next;
|
||
}
|
||
}
|
||
/**
|
||
* Detach an effect from the effect tree, freeing up memory and
|
||
* reducing the amount of work that happens on subsequent traversals
|
||
* @param {Effect} effect
|
||
*/
|
||
function unlink_effect(effect) {
|
||
var parent = effect.parent;
|
||
var prev = effect.prev;
|
||
var next = effect.next;
|
||
if (prev !== null) prev.next = next;
|
||
if (next !== null) next.prev = prev;
|
||
if (parent !== null) {
|
||
if (parent.first === effect) parent.first = next;
|
||
if (parent.last === effect) parent.last = prev;
|
||
}
|
||
}
|
||
/**
|
||
* When a block effect is removed, we don't immediately destroy it or yank it
|
||
* out of the DOM, because it might have transitions. Instead, we 'pause' it.
|
||
* It stays around (in memory, and in the DOM) until outro transitions have
|
||
* completed, and if the state change is reversed then we _resume_ it.
|
||
* A paused effect does not update, and the DOM subtree becomes inert.
|
||
* @param {Effect} effect
|
||
* @param {() => void} [callback]
|
||
* @param {boolean} [destroy]
|
||
*/
|
||
function pause_effect(effect, callback, destroy = true) {
|
||
/** @type {TransitionManager[]} */
|
||
var transitions = [];
|
||
pause_children(effect, transitions, true);
|
||
var fn = () => {
|
||
if (destroy) destroy_effect(effect);
|
||
if (callback) callback();
|
||
};
|
||
var remaining = transitions.length;
|
||
if (remaining > 0) {
|
||
var check = () => --remaining || fn();
|
||
for (var transition of transitions) transition.out(check);
|
||
} else fn();
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
* @param {TransitionManager[]} transitions
|
||
* @param {boolean} local
|
||
*/
|
||
function pause_children(effect, transitions, local) {
|
||
if ((effect.f & 8192) !== 0) return;
|
||
effect.f ^= INERT;
|
||
var t = effect.nodes && effect.nodes.t;
|
||
if (t !== null) {
|
||
for (const transition of t) if (transition.is_global || local) transitions.push(transition);
|
||
}
|
||
var child = effect.first;
|
||
while (child !== null) {
|
||
var sibling = child.next;
|
||
if ((child.f & 64) === 0) {
|
||
var transparent = (child.f & 65536) !== 0 || (child.f & 32) !== 0 && (effect.f & 16) !== 0;
|
||
pause_children(child, transitions, transparent ? local : false);
|
||
}
|
||
child = sibling;
|
||
}
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
* @param {DocumentFragment} fragment
|
||
*/
|
||
function move_effect(effect, fragment) {
|
||
if (!effect.nodes) return;
|
||
/** @type {TemplateNode | null} */
|
||
var node = effect.nodes.start;
|
||
var end = effect.nodes.end;
|
||
while (node !== null) {
|
||
/** @type {TemplateNode | null} */
|
||
var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
|
||
fragment.append(node);
|
||
node = next;
|
||
}
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/legacy.js
|
||
/**
|
||
* @type {Set<Value> | null}
|
||
* @deprecated
|
||
*/
|
||
var captured_signals = null;
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/client/runtime.js
|
||
/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
|
||
var is_updating_effect = false;
|
||
var is_destroying_effect = false;
|
||
/** @param {boolean} value */
|
||
function set_is_destroying_effect(value) {
|
||
is_destroying_effect = value;
|
||
}
|
||
/** @type {null | Reaction} */
|
||
var active_reaction = null;
|
||
var untracking = false;
|
||
/** @param {null | Reaction} reaction */
|
||
function set_active_reaction(reaction) {
|
||
active_reaction = reaction;
|
||
}
|
||
/** @type {null | Effect} */
|
||
var active_effect = null;
|
||
/** @param {null | Effect} effect */
|
||
function set_active_effect(effect) {
|
||
active_effect = effect;
|
||
}
|
||
/**
|
||
* When sources are created within a reaction, reading and writing
|
||
* them within that reaction should not cause a re-run
|
||
* @type {null | Source[]}
|
||
*/
|
||
var current_sources = null;
|
||
/** @param {Value} value */
|
||
function push_reaction_value(value) {
|
||
if (active_reaction !== null && (!async_mode_flag || (active_reaction.f & 2) !== 0)) if (current_sources === null) current_sources = [value];
|
||
else current_sources.push(value);
|
||
}
|
||
/**
|
||
* The dependencies of the reaction that is currently being executed. In many cases,
|
||
* the dependencies are unchanged between runs, and so this will be `null` unless
|
||
* and until a new dependency is accessed — we track this via `skipped_deps`
|
||
* @type {null | Value[]}
|
||
*/
|
||
var new_deps = null;
|
||
var skipped_deps = 0;
|
||
/**
|
||
* Tracks writes that the effect it's executed in doesn't listen to yet,
|
||
* so that the dependency can be added to the effect later on if it then reads it
|
||
* @type {null | Source[]}
|
||
*/
|
||
var untracked_writes = null;
|
||
/** @param {null | Source[]} value */
|
||
function set_untracked_writes(value) {
|
||
untracked_writes = value;
|
||
}
|
||
/**
|
||
* @type {number} Used by sources and deriveds for handling updates.
|
||
* Version starts from 1 so that unowned deriveds differentiate between a created effect and a run one for tracing
|
||
**/
|
||
var write_version = 1;
|
||
/** @type {number} Used to version each read of a source of derived to avoid duplicating depedencies inside a reaction */
|
||
var read_version = 0;
|
||
var update_version = read_version;
|
||
/** @param {number} value */
|
||
function set_update_version(value) {
|
||
update_version = value;
|
||
}
|
||
function increment_write_version() {
|
||
return ++write_version;
|
||
}
|
||
/**
|
||
* Determines whether a derived or effect is dirty.
|
||
* If it is MAYBE_DIRTY, will set the status to CLEAN
|
||
* @param {Reaction} reaction
|
||
* @returns {boolean}
|
||
*/
|
||
function is_dirty(reaction) {
|
||
var flags = reaction.f;
|
||
if ((flags & 2048) !== 0) return true;
|
||
if (flags & 2) reaction.f &= ~WAS_MARKED;
|
||
if ((flags & 4096) !== 0) {
|
||
var dependencies = reaction.deps;
|
||
var length = dependencies.length;
|
||
for (var i = 0; i < length; i++) {
|
||
var dependency = dependencies[i];
|
||
if (is_dirty(dependency)) update_derived(dependency);
|
||
if (dependency.wv > reaction.wv) return true;
|
||
}
|
||
if ((flags & 512) !== 0 && batch_values === null) set_signal_status(reaction, CLEAN);
|
||
}
|
||
return false;
|
||
}
|
||
/**
|
||
* @param {Value} signal
|
||
* @param {Effect} effect
|
||
* @param {boolean} [root]
|
||
*/
|
||
function schedule_possible_effect_self_invalidation(signal, effect, root = true) {
|
||
var reactions = signal.reactions;
|
||
if (reactions === null) return;
|
||
if (!async_mode_flag && current_sources !== null && includes.call(current_sources, signal)) return;
|
||
for (var i = 0; i < reactions.length; i++) {
|
||
var reaction = reactions[i];
|
||
if ((reaction.f & 2) !== 0) schedule_possible_effect_self_invalidation(reaction, effect, false);
|
||
else if (effect === reaction) {
|
||
if (root) set_signal_status(reaction, DIRTY);
|
||
else if ((reaction.f & 1024) !== 0) set_signal_status(reaction, MAYBE_DIRTY);
|
||
schedule_effect(reaction);
|
||
}
|
||
}
|
||
}
|
||
/** @param {Reaction} reaction */
|
||
function update_reaction(reaction) {
|
||
var previous_deps = new_deps;
|
||
var previous_skipped_deps = skipped_deps;
|
||
var previous_untracked_writes = untracked_writes;
|
||
var previous_reaction = active_reaction;
|
||
var previous_sources = current_sources;
|
||
var previous_component_context = component_context;
|
||
var previous_untracking = untracking;
|
||
var previous_update_version = update_version;
|
||
var flags = reaction.f;
|
||
new_deps = null;
|
||
skipped_deps = 0;
|
||
untracked_writes = null;
|
||
active_reaction = (flags & 96) === 0 ? reaction : null;
|
||
current_sources = null;
|
||
set_component_context(reaction.ctx);
|
||
untracking = false;
|
||
update_version = ++read_version;
|
||
if (reaction.ac !== null) {
|
||
without_reactive_context(() => {
|
||
/** @type {AbortController} */ reaction.ac.abort(STALE_REACTION);
|
||
});
|
||
reaction.ac = null;
|
||
}
|
||
try {
|
||
reaction.f |= REACTION_IS_UPDATING;
|
||
var fn = reaction.fn;
|
||
var result = fn();
|
||
reaction.f |= REACTION_RAN;
|
||
var deps = reaction.deps;
|
||
var is_fork = current_batch?.is_fork;
|
||
if (new_deps !== null) {
|
||
var i;
|
||
if (!is_fork) remove_reactions(reaction, skipped_deps);
|
||
if (deps !== null && skipped_deps > 0) {
|
||
deps.length = skipped_deps + new_deps.length;
|
||
for (i = 0; i < new_deps.length; i++) deps[skipped_deps + i] = new_deps[i];
|
||
} else reaction.deps = deps = new_deps;
|
||
if (effect_tracking() && (reaction.f & 512) !== 0) for (i = skipped_deps; i < deps.length; i++) (deps[i].reactions ??= []).push(reaction);
|
||
} else if (!is_fork && deps !== null && skipped_deps < deps.length) {
|
||
remove_reactions(reaction, skipped_deps);
|
||
deps.length = skipped_deps;
|
||
}
|
||
if (is_runes() && untracked_writes !== null && !untracking && deps !== null && (reaction.f & 6146) === 0) for (i = 0; i < untracked_writes.length; i++) schedule_possible_effect_self_invalidation(untracked_writes[i], reaction);
|
||
if (previous_reaction !== null && previous_reaction !== reaction) {
|
||
read_version++;
|
||
if (previous_reaction.deps !== null) for (let i = 0; i < previous_skipped_deps; i += 1) previous_reaction.deps[i].rv = read_version;
|
||
if (previous_deps !== null) for (const dep of previous_deps) dep.rv = read_version;
|
||
if (untracked_writes !== null) if (previous_untracked_writes === null) previous_untracked_writes = untracked_writes;
|
||
else previous_untracked_writes.push(...untracked_writes);
|
||
}
|
||
if ((reaction.f & 8388608) !== 0) reaction.f ^= ERROR_VALUE;
|
||
return result;
|
||
} catch (error) {
|
||
return handle_error(error);
|
||
} finally {
|
||
reaction.f ^= REACTION_IS_UPDATING;
|
||
new_deps = previous_deps;
|
||
skipped_deps = previous_skipped_deps;
|
||
untracked_writes = previous_untracked_writes;
|
||
active_reaction = previous_reaction;
|
||
current_sources = previous_sources;
|
||
set_component_context(previous_component_context);
|
||
untracking = previous_untracking;
|
||
update_version = previous_update_version;
|
||
}
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {Reaction} signal
|
||
* @param {Value<V>} dependency
|
||
* @returns {void}
|
||
*/
|
||
function remove_reaction(signal, dependency) {
|
||
let reactions = dependency.reactions;
|
||
if (reactions !== null) {
|
||
var index = index_of.call(reactions, signal);
|
||
if (index !== -1) {
|
||
var new_length = reactions.length - 1;
|
||
if (new_length === 0) reactions = dependency.reactions = null;
|
||
else {
|
||
reactions[index] = reactions[new_length];
|
||
reactions.pop();
|
||
}
|
||
}
|
||
}
|
||
if (reactions === null && (dependency.f & 2) !== 0 && (new_deps === null || !includes.call(new_deps, dependency))) {
|
||
var derived = dependency;
|
||
if ((derived.f & 512) !== 0) {
|
||
derived.f ^= 512;
|
||
derived.f &= ~WAS_MARKED;
|
||
}
|
||
if (derived.v !== UNINITIALIZED) update_derived_status(derived);
|
||
freeze_derived_effects(derived);
|
||
remove_reactions(derived, 0);
|
||
}
|
||
}
|
||
/**
|
||
* @param {Reaction} signal
|
||
* @param {number} start_index
|
||
* @returns {void}
|
||
*/
|
||
function remove_reactions(signal, start_index) {
|
||
var dependencies = signal.deps;
|
||
if (dependencies === null) return;
|
||
for (var i = start_index; i < dependencies.length; i++) remove_reaction(signal, dependencies[i]);
|
||
}
|
||
/**
|
||
* @param {Effect} effect
|
||
* @returns {void}
|
||
*/
|
||
function update_effect(effect) {
|
||
var flags = effect.f;
|
||
if ((flags & 16384) !== 0) return;
|
||
set_signal_status(effect, CLEAN);
|
||
var previous_effect = active_effect;
|
||
var was_updating_effect = is_updating_effect;
|
||
active_effect = effect;
|
||
is_updating_effect = true;
|
||
try {
|
||
if ((flags & 16777232) !== 0) destroy_block_effect_children(effect);
|
||
else destroy_effect_children(effect);
|
||
execute_effect_teardown(effect);
|
||
var teardown = update_reaction(effect);
|
||
effect.teardown = typeof teardown === "function" ? teardown : null;
|
||
effect.wv = write_version;
|
||
} finally {
|
||
is_updating_effect = was_updating_effect;
|
||
active_effect = previous_effect;
|
||
}
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {Value<V>} signal
|
||
* @returns {V}
|
||
*/
|
||
function get(signal) {
|
||
var is_derived = (signal.f & 2) !== 0;
|
||
captured_signals?.add(signal);
|
||
if (active_reaction !== null && !untracking) {
|
||
if (!(active_effect !== null && (active_effect.f & 16384) !== 0) && (current_sources === null || !includes.call(current_sources, signal))) {
|
||
var deps = active_reaction.deps;
|
||
if ((active_reaction.f & 2097152) !== 0) {
|
||
if (signal.rv < read_version) {
|
||
signal.rv = read_version;
|
||
if (new_deps === null && deps !== null && deps[skipped_deps] === signal) skipped_deps++;
|
||
else if (new_deps === null) new_deps = [signal];
|
||
else new_deps.push(signal);
|
||
}
|
||
} else {
|
||
(active_reaction.deps ??= []).push(signal);
|
||
var reactions = signal.reactions;
|
||
if (reactions === null) signal.reactions = [active_reaction];
|
||
else if (!includes.call(reactions, active_reaction)) reactions.push(active_reaction);
|
||
}
|
||
}
|
||
}
|
||
if (is_destroying_effect && old_values.has(signal)) return old_values.get(signal);
|
||
if (is_derived) {
|
||
var derived = signal;
|
||
if (is_destroying_effect) {
|
||
var value = derived.v;
|
||
if ((derived.f & 1024) === 0 && derived.reactions !== null || depends_on_old_values(derived)) value = execute_derived(derived);
|
||
old_values.set(derived, value);
|
||
return value;
|
||
}
|
||
var should_connect = (derived.f & 512) === 0 && !untracking && active_reaction !== null && (is_updating_effect || (active_reaction.f & 512) !== 0);
|
||
var is_new = (derived.f & REACTION_RAN) === 0;
|
||
if (is_dirty(derived)) {
|
||
if (should_connect) derived.f |= 512;
|
||
update_derived(derived);
|
||
}
|
||
if (should_connect && !is_new) {
|
||
unfreeze_derived_effects(derived);
|
||
reconnect(derived);
|
||
}
|
||
}
|
||
if (batch_values?.has(signal)) return batch_values.get(signal);
|
||
if ((signal.f & 8388608) !== 0) throw signal.v;
|
||
return signal.v;
|
||
}
|
||
/**
|
||
* (Re)connect a disconnected derived, so that it is notified
|
||
* of changes in `mark_reactions`
|
||
* @param {Derived} derived
|
||
*/
|
||
function reconnect(derived) {
|
||
derived.f |= 512;
|
||
if (derived.deps === null) return;
|
||
for (const dep of derived.deps) {
|
||
(dep.reactions ??= []).push(derived);
|
||
if ((dep.f & 2) !== 0 && (dep.f & 512) === 0) {
|
||
unfreeze_derived_effects(dep);
|
||
reconnect(dep);
|
||
}
|
||
}
|
||
}
|
||
/** @param {Derived} derived */
|
||
function depends_on_old_values(derived) {
|
||
if (derived.v === UNINITIALIZED) return true;
|
||
if (derived.deps === null) return false;
|
||
for (const dep of derived.deps) {
|
||
if (old_values.has(dep)) return true;
|
||
if ((dep.f & 2) !== 0 && depends_on_old_values(dep)) return true;
|
||
}
|
||
return false;
|
||
}
|
||
/**
|
||
* When used inside a [`$derived`](https://svelte.dev/docs/svelte/$derived) or [`$effect`](https://svelte.dev/docs/svelte/$effect),
|
||
* any state read inside `fn` will not be treated as a dependency.
|
||
*
|
||
* ```ts
|
||
* $effect(() => {
|
||
* // this will run when `data` changes, but not when `time` changes
|
||
* save(data, {
|
||
* timestamp: untrack(() => time)
|
||
* });
|
||
* });
|
||
* ```
|
||
* @template T
|
||
* @param {() => T} fn
|
||
* @returns {T}
|
||
*/
|
||
function untrack(fn) {
|
||
var previous_untracking = untracking;
|
||
try {
|
||
untracking = true;
|
||
return fn();
|
||
} finally {
|
||
untracking = previous_untracking;
|
||
}
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/store/utils.js
|
||
/** @import { Readable } from './public' */
|
||
/**
|
||
* @template T
|
||
* @param {Readable<T> | null | undefined} store
|
||
* @param {(value: T) => void} run
|
||
* @param {(value: T) => void} [invalidate]
|
||
* @returns {() => void}
|
||
*/
|
||
function subscribe_to_store(store, run, invalidate) {
|
||
if (store == null) {
|
||
run(void 0);
|
||
if (invalidate) invalidate(void 0);
|
||
return noop;
|
||
}
|
||
const unsub = untrack(() => store.subscribe(run, invalidate));
|
||
return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/utils.js
|
||
/**
|
||
* Attributes that are boolean, i.e. they are present or not present.
|
||
*/
|
||
var DOM_BOOLEAN_ATTRIBUTES = [
|
||
"allowfullscreen",
|
||
"async",
|
||
"autofocus",
|
||
"autoplay",
|
||
"checked",
|
||
"controls",
|
||
"default",
|
||
"disabled",
|
||
"formnovalidate",
|
||
"indeterminate",
|
||
"inert",
|
||
"ismap",
|
||
"loop",
|
||
"multiple",
|
||
"muted",
|
||
"nomodule",
|
||
"novalidate",
|
||
"open",
|
||
"playsinline",
|
||
"readonly",
|
||
"required",
|
||
"reversed",
|
||
"seamless",
|
||
"selected",
|
||
"webkitdirectory",
|
||
"defer",
|
||
"disablepictureinpicture",
|
||
"disableremoteplayback"
|
||
];
|
||
/**
|
||
* Returns `true` if `name` is a boolean attribute
|
||
* @param {string} name
|
||
*/
|
||
function is_boolean_attribute(name) {
|
||
return DOM_BOOLEAN_ATTRIBUTES.includes(name);
|
||
}
|
||
[...DOM_BOOLEAN_ATTRIBUTES];
|
||
/**
|
||
* Subset of delegated events which should be passive by default.
|
||
* These two are already passive via browser defaults on window, document and body.
|
||
* But since
|
||
* - we're delegating them
|
||
* - they happen often
|
||
* - they apply to mobile which is generally less performant
|
||
* we're marking them as passive by default for other elements, too.
|
||
*/
|
||
var PASSIVE_EVENTS = ["touchstart", "touchmove"];
|
||
/**
|
||
* Returns `true` if `name` is a passive event
|
||
* @param {string} name
|
||
*/
|
||
function is_passive_event(name) {
|
||
return PASSIVE_EVENTS.includes(name);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/index.js
|
||
var INVALID_ATTR_NAME_CHAR_REGEX = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
|
||
/**
|
||
* Only available on the server and when compiling with the `server` option.
|
||
* Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
|
||
* @template {Record<string, any>} Props
|
||
* @param {Component<Props> | ComponentType<SvelteComponent<Props>>} component
|
||
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} [options]
|
||
* @returns {RenderOutput}
|
||
*/
|
||
function render(component, options = {}) {
|
||
if (options.csp?.hash && options.csp.nonce) invalid_csp();
|
||
return Renderer.render(component, options);
|
||
}
|
||
/**
|
||
* @param {Record<string, unknown>} attrs
|
||
* @param {string} [css_hash]
|
||
* @param {Record<string, boolean>} [classes]
|
||
* @param {Record<string, string>} [styles]
|
||
* @param {number} [flags]
|
||
* @returns {string}
|
||
*/
|
||
function attributes(attrs, css_hash, classes, styles, flags = 0) {
|
||
if (styles) attrs.style = to_style(attrs.style, styles);
|
||
if (attrs.class) attrs.class = clsx$1(attrs.class);
|
||
if (css_hash || classes) attrs.class = to_class(attrs.class, css_hash, classes);
|
||
let attr_str = "";
|
||
let name;
|
||
const is_html = (flags & 1) === 0;
|
||
const lowercase = (flags & 2) === 0;
|
||
const is_input = (flags & 4) !== 0;
|
||
for (name of Object.keys(attrs)) {
|
||
if (typeof attrs[name] === "function") continue;
|
||
if (name[0] === "$" && name[1] === "$") continue;
|
||
if (INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
|
||
var value = attrs[name];
|
||
var lower = name.toLowerCase();
|
||
if (lowercase) name = lower;
|
||
if (lower.length > 2 && lower.startsWith("on")) continue;
|
||
if (is_input) {
|
||
if (name === "defaultvalue" || name === "defaultchecked") {
|
||
name = name === "defaultvalue" ? "value" : "checked";
|
||
if (attrs[name]) continue;
|
||
}
|
||
}
|
||
attr_str += attr(name, value, is_html && is_boolean_attribute(name));
|
||
}
|
||
return attr_str;
|
||
}
|
||
/**
|
||
* @param {unknown} value
|
||
* @returns {string}
|
||
*/
|
||
function stringify(value) {
|
||
return typeof value === "string" ? value : value == null ? "" : value + "";
|
||
}
|
||
/**
|
||
* @param {any} value
|
||
* @param {string | undefined} [hash]
|
||
* @param {Record<string, boolean>} [directives]
|
||
*/
|
||
function attr_class(value, hash, directives) {
|
||
var result = to_class(value, hash, directives);
|
||
return result ? ` class="${escape_html(result, true)}"` : "";
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {Record<string, [any, any, any]>} store_values
|
||
* @param {string} store_name
|
||
* @param {Store<V> | null | undefined} store
|
||
* @returns {V}
|
||
*/
|
||
function store_get(store_values, store_name, store) {
|
||
if (store_name in store_values && store_values[store_name][0] === store) return store_values[store_name][2];
|
||
store_values[store_name]?.[1]();
|
||
store_values[store_name] = [
|
||
store,
|
||
null,
|
||
void 0
|
||
];
|
||
const unsub = subscribe_to_store(
|
||
store,
|
||
/** @param {any} v */
|
||
(v) => store_values[store_name][2] = v
|
||
);
|
||
store_values[store_name][1] = unsub;
|
||
return store_values[store_name][2];
|
||
}
|
||
/** @param {Record<string, [any, any, any]>} store_values */
|
||
function unsubscribe_stores(store_values) {
|
||
for (const store_name of Object.keys(store_values)) store_values[store_name][1]();
|
||
}
|
||
/**
|
||
* @param {Renderer} renderer
|
||
* @param {Record<string, any>} $$props
|
||
* @param {string} name
|
||
* @param {Record<string, unknown>} slot_props
|
||
* @param {null | (() => void)} fallback_fn
|
||
* @returns {void}
|
||
*/
|
||
function slot(renderer, $$props, name, slot_props, fallback_fn) {
|
||
var slot_fn = $$props.$$slots?.[name];
|
||
if (slot_fn === true) slot_fn = $$props[name === "default" ? "children" : name];
|
||
if (slot_fn !== void 0) slot_fn(renderer, slot_props);
|
||
else fallback_fn?.();
|
||
}
|
||
/**
|
||
* Legacy mode: If the prop has a fallback and is bound in the
|
||
* parent component, propagate the fallback value upwards.
|
||
* @param {Record<string, unknown>} props_parent
|
||
* @param {Record<string, unknown>} props_now
|
||
*/
|
||
function bind_props(props_parent, props_now) {
|
||
for (const key of Object.keys(props_now)) {
|
||
const initial_value = props_parent[key];
|
||
const value = props_now[key];
|
||
if (initial_value === void 0 && value !== void 0 && Object.getOwnPropertyDescriptor(props_parent, key)?.set) props_parent[key] = value;
|
||
}
|
||
}
|
||
/** @param {any} array_like_or_iterator */
|
||
function ensure_array_like(array_like_or_iterator) {
|
||
if (array_like_or_iterator) return array_like_or_iterator.length !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator);
|
||
return [];
|
||
}
|
||
/**
|
||
* @template V
|
||
* @param {() => V} get_value
|
||
*/
|
||
function once(get_value) {
|
||
let value = UNINITIALIZED;
|
||
return () => {
|
||
if (value === UNINITIALIZED) value = get_value();
|
||
return value;
|
||
};
|
||
}
|
||
/**
|
||
* @template T
|
||
* @param {()=>T} fn
|
||
* @returns {(new_value?: T) => (T | void)}
|
||
*/
|
||
function derived(fn) {
|
||
const get_value = ssr_context === null ? fn : once(fn);
|
||
/** @type {T | undefined} */
|
||
let updated_value;
|
||
return function(new_value) {
|
||
if (arguments.length === 0) return updated_value ?? get_value();
|
||
updated_value = new_value;
|
||
return updated_value;
|
||
};
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/crypto.js
|
||
var text_encoder;
|
||
var crypto;
|
||
/** @param {string} module_name */
|
||
var obfuscated_import = (module_name) => import(
|
||
/* @vite-ignore */
|
||
module_name
|
||
);
|
||
/** @param {string} data */
|
||
async function sha256(data) {
|
||
text_encoder ??= new TextEncoder();
|
||
crypto ??= globalThis.crypto?.subtle?.digest ? globalThis.crypto : (await obfuscated_import("node:crypto")).webcrypto;
|
||
return base64_encode(await crypto.subtle.digest("SHA-256", text_encoder.encode(data)));
|
||
}
|
||
/**
|
||
* @param {Uint8Array} bytes
|
||
* @returns {string}
|
||
*/
|
||
function base64_encode(bytes) {
|
||
if (globalThis.Buffer) return globalThis.Buffer.from(bytes).toString("base64");
|
||
let binary = "";
|
||
for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
|
||
return btoa(binary);
|
||
}
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/renderer.js
|
||
/** @import { Component } from 'svelte' */
|
||
/** @import { Csp, HydratableContext, RenderOutput, SSRContext, SyncRenderOutput, Sha256Source } from './types.js' */
|
||
/** @import { MaybePromise } from '#shared' */
|
||
/** @typedef {'head' | 'body'} RendererType */
|
||
/** @typedef {{ [key in RendererType]: string }} AccumulatedContent */
|
||
/**
|
||
* @typedef {string | Renderer} RendererItem
|
||
*/
|
||
/**
|
||
* Renderers are basically a tree of `string | Renderer`s, where each `Renderer` in the tree represents
|
||
* work that may or may not have completed. A renderer can be {@link collect}ed to aggregate the
|
||
* content from itself and all of its children, but this will throw if any of the children are
|
||
* performing asynchronous work. To asynchronously collect a renderer, just `await` it.
|
||
*
|
||
* The `string` values within a renderer are always associated with the {@link type} of that renderer. To switch types,
|
||
* call {@link child} with a different `type` argument.
|
||
*/
|
||
var Renderer = class Renderer {
|
||
/**
|
||
* The contents of the renderer.
|
||
* @type {RendererItem[]}
|
||
*/
|
||
#out = [];
|
||
/**
|
||
* Any `onDestroy` callbacks registered during execution of this renderer.
|
||
* @type {(() => void)[] | undefined}
|
||
*/
|
||
#on_destroy = void 0;
|
||
/**
|
||
* Whether this renderer is a component body.
|
||
* @type {boolean}
|
||
*/
|
||
#is_component_body = false;
|
||
/**
|
||
* If set, this renderer is an error boundary. When async collection
|
||
* of the children fails, the failed snippet is rendered instead.
|
||
* @type {{
|
||
* failed: (renderer: Renderer, error: unknown, reset: () => void) => void;
|
||
* transformError: (error: unknown) => unknown;
|
||
* context: SSRContext | null;
|
||
* } | null}
|
||
*/
|
||
#boundary = null;
|
||
/**
|
||
* The type of string content that this renderer is accumulating.
|
||
* @type {RendererType}
|
||
*/
|
||
type;
|
||
/** @type {Renderer | undefined} */
|
||
#parent;
|
||
/**
|
||
* Asynchronous work associated with this renderer
|
||
* @type {Promise<void> | undefined}
|
||
*/
|
||
promise = void 0;
|
||
/**
|
||
* State which is associated with the content tree as a whole.
|
||
* It will be re-exposed, uncopied, on all children.
|
||
* @type {SSRState}
|
||
* @readonly
|
||
*/
|
||
global;
|
||
/**
|
||
* State that is local to the branch it is declared in.
|
||
* It will be shallow-copied to all children.
|
||
*
|
||
* @type {{ select_value: string | undefined }}
|
||
*/
|
||
local;
|
||
/**
|
||
* @param {SSRState} global
|
||
* @param {Renderer | undefined} [parent]
|
||
*/
|
||
constructor(global, parent) {
|
||
this.#parent = parent;
|
||
this.global = global;
|
||
this.local = parent ? { ...parent.local } : { select_value: void 0 };
|
||
this.type = parent ? parent.type : "body";
|
||
}
|
||
/**
|
||
* @param {(renderer: Renderer) => void} fn
|
||
*/
|
||
head(fn) {
|
||
const head = new Renderer(this.global, this);
|
||
head.type = "head";
|
||
this.#out.push(head);
|
||
head.child(fn);
|
||
}
|
||
/**
|
||
* @param {Array<Promise<void>>} blockers
|
||
* @param {(renderer: Renderer) => void} fn
|
||
*/
|
||
async_block(blockers, fn) {
|
||
this.#out.push(BLOCK_OPEN);
|
||
this.async(blockers, fn);
|
||
this.#out.push(BLOCK_CLOSE);
|
||
}
|
||
/**
|
||
* @param {Array<Promise<void>>} blockers
|
||
* @param {(renderer: Renderer) => void} fn
|
||
*/
|
||
async(blockers, fn) {
|
||
let callback = fn;
|
||
if (blockers.length > 0) {
|
||
const context = ssr_context;
|
||
callback = (renderer) => {
|
||
return Promise.all(blockers).then(() => {
|
||
const previous_context = ssr_context;
|
||
try {
|
||
set_ssr_context(context);
|
||
return fn(renderer);
|
||
} finally {
|
||
set_ssr_context(previous_context);
|
||
}
|
||
});
|
||
};
|
||
}
|
||
this.child(callback);
|
||
}
|
||
/**
|
||
* @param {Array<() => void>} thunks
|
||
*/
|
||
run(thunks) {
|
||
const context = ssr_context;
|
||
let promise = Promise.resolve(thunks[0]());
|
||
const promises = [promise];
|
||
for (const fn of thunks.slice(1)) {
|
||
promise = promise.then(() => {
|
||
const previous_context = ssr_context;
|
||
set_ssr_context(context);
|
||
try {
|
||
return fn();
|
||
} finally {
|
||
set_ssr_context(previous_context);
|
||
}
|
||
});
|
||
promises.push(promise);
|
||
}
|
||
promise.catch(noop);
|
||
this.promise = promise;
|
||
return promises;
|
||
}
|
||
/**
|
||
* @param {(renderer: Renderer) => MaybePromise<void>} fn
|
||
*/
|
||
child_block(fn) {
|
||
this.#out.push(BLOCK_OPEN);
|
||
this.child(fn);
|
||
this.#out.push(BLOCK_CLOSE);
|
||
}
|
||
/**
|
||
* Create a child renderer. The child renderer inherits the state from the parent,
|
||
* but has its own content.
|
||
* @param {(renderer: Renderer) => MaybePromise<void>} fn
|
||
*/
|
||
child(fn) {
|
||
const child = new Renderer(this.global, this);
|
||
this.#out.push(child);
|
||
const parent = ssr_context;
|
||
set_ssr_context({
|
||
...ssr_context,
|
||
p: parent,
|
||
c: null,
|
||
r: child
|
||
});
|
||
const result = fn(child);
|
||
set_ssr_context(parent);
|
||
if (result instanceof Promise) {
|
||
result.catch(noop);
|
||
result.finally(() => set_ssr_context(null)).catch(noop);
|
||
if (child.global.mode === "sync") await_invalid();
|
||
child.promise = result;
|
||
}
|
||
return child;
|
||
}
|
||
/**
|
||
* Render children inside an error boundary. If the children throw and the API-level
|
||
* `transformError` transform handles the error (doesn't re-throw), the `failed` snippet is
|
||
* rendered instead. Otherwise the error propagates.
|
||
*
|
||
* @param {{ failed?: (renderer: Renderer, error: unknown, reset: () => void) => void }} props
|
||
* @param {(renderer: Renderer) => MaybePromise<void>} children_fn
|
||
*/
|
||
boundary(props, children_fn) {
|
||
const child = new Renderer(this.global, this);
|
||
this.#out.push(child);
|
||
const parent_context = ssr_context;
|
||
if (props.failed) child.#boundary = {
|
||
failed: props.failed,
|
||
transformError: this.global.transformError,
|
||
context: parent_context
|
||
};
|
||
set_ssr_context({
|
||
...ssr_context,
|
||
p: parent_context,
|
||
c: null,
|
||
r: child
|
||
});
|
||
try {
|
||
const result = children_fn(child);
|
||
set_ssr_context(parent_context);
|
||
if (result instanceof Promise) {
|
||
if (child.global.mode === "sync") await_invalid();
|
||
result.catch(noop);
|
||
child.promise = result;
|
||
}
|
||
} catch (error) {
|
||
set_ssr_context(parent_context);
|
||
const failed_snippet = props.failed;
|
||
if (!failed_snippet) throw error;
|
||
const result = this.global.transformError(error);
|
||
child.#out.length = 0;
|
||
child.#boundary = null;
|
||
if (result instanceof Promise) {
|
||
if (this.global.mode === "sync") await_invalid();
|
||
child.promise = result.then((transformed) => {
|
||
set_ssr_context(parent_context);
|
||
child.#out.push(Renderer.#serialize_failed_boundary(transformed));
|
||
failed_snippet(child, transformed, noop);
|
||
child.#out.push(BLOCK_CLOSE);
|
||
});
|
||
child.promise.catch(noop);
|
||
} else {
|
||
child.#out.push(Renderer.#serialize_failed_boundary(result));
|
||
failed_snippet(child, result, noop);
|
||
child.#out.push(BLOCK_CLOSE);
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* Create a component renderer. The component renderer inherits the state from the parent,
|
||
* but has its own content. It is treated as an ordering boundary for ondestroy callbacks.
|
||
* @param {(renderer: Renderer) => MaybePromise<void>} fn
|
||
* @param {Function} [component_fn]
|
||
* @returns {void}
|
||
*/
|
||
component(fn, component_fn) {
|
||
push$1(component_fn);
|
||
const child = this.child(fn);
|
||
child.#is_component_body = true;
|
||
pop$1();
|
||
}
|
||
/**
|
||
* @param {Record<string, any>} attrs
|
||
* @param {(renderer: Renderer) => void} fn
|
||
* @param {string | undefined} [css_hash]
|
||
* @param {Record<string, boolean> | undefined} [classes]
|
||
* @param {Record<string, string> | undefined} [styles]
|
||
* @param {number | undefined} [flags]
|
||
* @param {boolean | undefined} [is_rich]
|
||
* @returns {void}
|
||
*/
|
||
select(attrs, fn, css_hash, classes, styles, flags, is_rich) {
|
||
const { value, ...select_attrs } = attrs;
|
||
this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags)}>`);
|
||
this.child((renderer) => {
|
||
renderer.local.select_value = value;
|
||
fn(renderer);
|
||
});
|
||
this.push(`${is_rich ? "<!>" : ""}</select>`);
|
||
}
|
||
/**
|
||
* @param {Record<string, any>} attrs
|
||
* @param {string | number | boolean | ((renderer: Renderer) => void)} body
|
||
* @param {string | undefined} [css_hash]
|
||
* @param {Record<string, boolean> | undefined} [classes]
|
||
* @param {Record<string, string> | undefined} [styles]
|
||
* @param {number | undefined} [flags]
|
||
* @param {boolean | undefined} [is_rich]
|
||
*/
|
||
option(attrs, body, css_hash, classes, styles, flags, is_rich) {
|
||
this.#out.push(`<option${attributes(attrs, css_hash, classes, styles, flags)}`);
|
||
/**
|
||
* @param {Renderer} renderer
|
||
* @param {any} value
|
||
* @param {{ head?: string, body: any }} content
|
||
*/
|
||
const close = (renderer, value, { head, body }) => {
|
||
if (has_own_property.call(attrs, "value")) value = attrs.value;
|
||
if (value === this.local.select_value) renderer.#out.push(" selected=\"\"");
|
||
renderer.#out.push(`>${body}${is_rich ? "<!>" : ""}</option>`);
|
||
if (head) renderer.head((child) => child.push(head));
|
||
};
|
||
if (typeof body === "function") this.child((renderer) => {
|
||
const r = new Renderer(this.global, this);
|
||
body(r);
|
||
if (this.global.mode === "async") return r.#collect_content_async().then((content) => {
|
||
close(renderer, content.body.replaceAll("<!---->", ""), content);
|
||
});
|
||
else {
|
||
const content = r.#collect_content();
|
||
close(renderer, content.body.replaceAll("<!---->", ""), content);
|
||
}
|
||
});
|
||
else close(this, body, { body: escape_html(body) });
|
||
}
|
||
/**
|
||
* @param {(renderer: Renderer) => void} fn
|
||
*/
|
||
title(fn) {
|
||
const path = this.get_path();
|
||
/** @param {string} head */
|
||
const close = (head) => {
|
||
this.global.set_title(head, path);
|
||
};
|
||
this.child((renderer) => {
|
||
const r = new Renderer(renderer.global, renderer);
|
||
fn(r);
|
||
if (renderer.global.mode === "async") return r.#collect_content_async().then((content) => {
|
||
close(content.head);
|
||
});
|
||
else close(r.#collect_content().head);
|
||
});
|
||
}
|
||
/**
|
||
* @param {string | (() => Promise<string>)} content
|
||
*/
|
||
push(content) {
|
||
if (typeof content === "function") this.child(async (renderer) => renderer.push(await content()));
|
||
else this.#out.push(content);
|
||
}
|
||
/**
|
||
* @param {() => void} fn
|
||
*/
|
||
on_destroy(fn) {
|
||
(this.#on_destroy ??= []).push(fn);
|
||
}
|
||
/**
|
||
* @returns {number[]}
|
||
*/
|
||
get_path() {
|
||
return this.#parent ? [...this.#parent.get_path(), this.#parent.#out.indexOf(this)] : [];
|
||
}
|
||
/**
|
||
* @deprecated this is needed for legacy component bindings
|
||
*/
|
||
copy() {
|
||
const copy = new Renderer(this.global, this.#parent);
|
||
copy.#out = this.#out.map((item) => item instanceof Renderer ? item.copy() : item);
|
||
copy.promise = this.promise;
|
||
return copy;
|
||
}
|
||
/**
|
||
* @param {Renderer} other
|
||
* @deprecated this is needed for legacy component bindings
|
||
*/
|
||
subsume(other) {
|
||
if (this.global.mode !== other.global.mode) throw new Error("invariant: A renderer cannot switch modes. If you're seeing this, there's a compiler bug. File an issue!");
|
||
this.local = other.local;
|
||
this.#out = other.#out.map((item, i) => {
|
||
const current = this.#out[i];
|
||
if (current instanceof Renderer && item instanceof Renderer) {
|
||
current.subsume(item);
|
||
return current;
|
||
}
|
||
return item;
|
||
});
|
||
this.promise = other.promise;
|
||
this.type = other.type;
|
||
}
|
||
get length() {
|
||
return this.#out.length;
|
||
}
|
||
/**
|
||
* Creates the hydration comment that marks the start of a failed boundary.
|
||
* The error is JSON-serialized and embedded inside an HTML comment for the client
|
||
* to parse during hydration. The JSON is escaped to prevent `-->` or `<!--` sequences
|
||
* from breaking out of the comment (XSS). Uses unicode escapes which `JSON.parse()`
|
||
* handles transparently.
|
||
* @param {unknown} error
|
||
* @returns {string}
|
||
*/
|
||
static #serialize_failed_boundary(error) {
|
||
return `<!--[?${JSON.stringify(error).replace(/>/g, "\\u003e").replace(/</g, "\\u003c")}-->`;
|
||
}
|
||
/**
|
||
* Only available on the server and when compiling with the `server` option.
|
||
* Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
|
||
* @template {Record<string, any>} Props
|
||
* @param {Component<Props>} component
|
||
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} [options]
|
||
* @returns {RenderOutput}
|
||
*/
|
||
static render(component, options = {}) {
|
||
/** @type {AccumulatedContent | undefined} */
|
||
let sync;
|
||
/** @type {Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }> | undefined} */
|
||
let async;
|
||
const result = {};
|
||
Object.defineProperties(result, {
|
||
html: { get: () => {
|
||
return (sync ??= Renderer.#render(component, options)).body;
|
||
} },
|
||
head: { get: () => {
|
||
return (sync ??= Renderer.#render(component, options)).head;
|
||
} },
|
||
body: { get: () => {
|
||
return (sync ??= Renderer.#render(component, options)).body;
|
||
} },
|
||
hashes: { value: { script: "" } },
|
||
then: { value: (onfulfilled, onrejected) => {
|
||
if (!async_mode_flag) {
|
||
const result = sync ??= Renderer.#render(component, options);
|
||
const user_result = onfulfilled({
|
||
head: result.head,
|
||
body: result.body,
|
||
html: result.body,
|
||
hashes: { script: [] }
|
||
});
|
||
return Promise.resolve(user_result);
|
||
}
|
||
async ??= init_render_context().then(() => with_render_context(() => Renderer.#render_async(component, options)));
|
||
return async.then((result) => {
|
||
Object.defineProperty(result, "html", { get: () => {
|
||
html_deprecated();
|
||
} });
|
||
return onfulfilled(result);
|
||
}, onrejected);
|
||
} }
|
||
});
|
||
return result;
|
||
}
|
||
/**
|
||
* Collect all of the `onDestroy` callbacks registered during rendering. In an async context, this is only safe to call
|
||
* after awaiting `collect_async`.
|
||
*
|
||
* Child renderers are "porous" and don't affect execution order, but component body renderers
|
||
* create ordering boundaries. Within a renderer, callbacks run in order until hitting a component boundary.
|
||
* @returns {Iterable<() => void>}
|
||
*/
|
||
*#collect_on_destroy() {
|
||
for (const component of this.#traverse_components()) yield* component.#collect_ondestroy();
|
||
}
|
||
/**
|
||
* Performs a depth-first search of renderers, yielding the deepest components first, then additional components as we backtrack up the tree.
|
||
* @returns {Iterable<Renderer>}
|
||
*/
|
||
*#traverse_components() {
|
||
for (const child of this.#out) if (typeof child !== "string") yield* child.#traverse_components();
|
||
if (this.#is_component_body) yield this;
|
||
}
|
||
/**
|
||
* @returns {Iterable<() => void>}
|
||
*/
|
||
*#collect_ondestroy() {
|
||
if (this.#on_destroy) for (const fn of this.#on_destroy) yield fn;
|
||
for (const child of this.#out) if (child instanceof Renderer && !child.#is_component_body) yield* child.#collect_ondestroy();
|
||
}
|
||
/**
|
||
* Render a component. Throws if any of the children are performing asynchronous work.
|
||
*
|
||
* @template {Record<string, any>} Props
|
||
* @param {Component<Props>} component
|
||
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string }} options
|
||
* @returns {AccumulatedContent}
|
||
*/
|
||
static #render(component, options) {
|
||
var previous_context = ssr_context;
|
||
try {
|
||
const renderer = Renderer.#open_render("sync", component, options);
|
||
const content = renderer.#collect_content();
|
||
return Renderer.#close_render(content, renderer);
|
||
} finally {
|
||
abort();
|
||
set_ssr_context(previous_context);
|
||
}
|
||
}
|
||
/**
|
||
* Render a component.
|
||
*
|
||
* @template {Record<string, any>} Props
|
||
* @param {Component<Props>} component
|
||
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} options
|
||
* @returns {Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }>}
|
||
*/
|
||
static async #render_async(component, options) {
|
||
const previous_context = ssr_context;
|
||
try {
|
||
const renderer = Renderer.#open_render("async", component, options);
|
||
const content = await renderer.#collect_content_async();
|
||
const hydratables = await renderer.#collect_hydratables();
|
||
if (hydratables !== null) content.head = hydratables + content.head;
|
||
return Renderer.#close_render(content, renderer);
|
||
} finally {
|
||
set_ssr_context(previous_context);
|
||
abort();
|
||
}
|
||
}
|
||
/**
|
||
* Collect all of the code from the `out` array and return it as a string, or a promise resolving to a string.
|
||
* @param {AccumulatedContent} content
|
||
* @returns {AccumulatedContent}
|
||
*/
|
||
#collect_content(content = {
|
||
head: "",
|
||
body: ""
|
||
}) {
|
||
for (const item of this.#out) if (typeof item === "string") content[this.type] += item;
|
||
else if (item instanceof Renderer) item.#collect_content(content);
|
||
return content;
|
||
}
|
||
/**
|
||
* Collect all of the code from the `out` array and return it as a string.
|
||
* @param {AccumulatedContent} content
|
||
* @returns {Promise<AccumulatedContent>}
|
||
*/
|
||
async #collect_content_async(content = {
|
||
head: "",
|
||
body: ""
|
||
}) {
|
||
await this.promise;
|
||
for (const item of this.#out) if (typeof item === "string") content[this.type] += item;
|
||
else if (item instanceof Renderer) if (item.#boundary) {
|
||
/** @type {AccumulatedContent} */
|
||
const boundary_content = {
|
||
head: "",
|
||
body: ""
|
||
};
|
||
try {
|
||
await item.#collect_content_async(boundary_content);
|
||
content.head += boundary_content.head;
|
||
content.body += boundary_content.body;
|
||
} catch (error) {
|
||
const { context, failed, transformError } = item.#boundary;
|
||
set_ssr_context(context);
|
||
let transformed = await transformError(error);
|
||
const failed_renderer = new Renderer(item.global, item);
|
||
failed_renderer.type = item.type;
|
||
failed_renderer.#out.push(Renderer.#serialize_failed_boundary(transformed));
|
||
failed(failed_renderer, transformed, noop);
|
||
failed_renderer.#out.push(BLOCK_CLOSE);
|
||
await failed_renderer.#collect_content_async(content);
|
||
}
|
||
} else await item.#collect_content_async(content);
|
||
return content;
|
||
}
|
||
async #collect_hydratables() {
|
||
const ctx = get_render_context().hydratable;
|
||
for (const [_, key] of ctx.unresolved_promises) unresolved_hydratable(key, ctx.lookup.get(key)?.stack ?? "<missing stack trace>");
|
||
for (const comparison of ctx.comparisons) await comparison;
|
||
return await this.#hydratable_block(ctx);
|
||
}
|
||
/**
|
||
* @template {Record<string, any>} Props
|
||
* @param {'sync' | 'async'} mode
|
||
* @param {import('svelte').Component<Props>} component
|
||
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} options
|
||
* @returns {Renderer}
|
||
*/
|
||
static #open_render(mode, component, options) {
|
||
if (options.idPrefix?.includes("--")) invalid_id_prefix();
|
||
var previous_context = ssr_context;
|
||
try {
|
||
const renderer = new Renderer(new SSRState(mode, options.idPrefix ? options.idPrefix + "-" : "", options.csp, options.transformError));
|
||
set_ssr_context({
|
||
p: null,
|
||
c: options.context ?? null,
|
||
r: renderer
|
||
});
|
||
renderer.push(BLOCK_OPEN);
|
||
component(renderer, options.props ?? {});
|
||
renderer.push(BLOCK_CLOSE);
|
||
return renderer;
|
||
} finally {
|
||
set_ssr_context(previous_context);
|
||
}
|
||
}
|
||
/**
|
||
* @param {AccumulatedContent} content
|
||
* @param {Renderer} renderer
|
||
* @returns {AccumulatedContent & { hashes: { script: Sha256Source[] } }}
|
||
*/
|
||
static #close_render(content, renderer) {
|
||
for (const cleanup of renderer.#collect_on_destroy()) cleanup();
|
||
let head = content.head + renderer.global.get_title();
|
||
let body = content.body;
|
||
for (const { hash, code } of renderer.global.css) head += `<style id="${hash}">${code}</style>`;
|
||
return {
|
||
head,
|
||
body,
|
||
hashes: { script: renderer.global.csp.script_hashes }
|
||
};
|
||
}
|
||
/**
|
||
* @param {HydratableContext} ctx
|
||
*/
|
||
async #hydratable_block(ctx) {
|
||
if (ctx.lookup.size === 0) return null;
|
||
let entries = [];
|
||
let has_promises = false;
|
||
for (const [k, v] of ctx.lookup) {
|
||
if (v.promises) {
|
||
has_promises = true;
|
||
for (const p of v.promises) await p;
|
||
}
|
||
entries.push(`[${devalue.uneval(k)},${v.serialized}]`);
|
||
}
|
||
let prelude = `const h = (window.__svelte ??= {}).h ??= new Map();`;
|
||
if (has_promises) prelude = `const r = (v) => Promise.resolve(v);
|
||
${prelude}`;
|
||
const body = `
|
||
{
|
||
${prelude}
|
||
|
||
for (const [k, v] of [
|
||
${entries.join(",\n ")}
|
||
]) {
|
||
h.set(k, v);
|
||
}
|
||
}
|
||
`;
|
||
let csp_attr = "";
|
||
if (this.global.csp.nonce) csp_attr = ` nonce="${this.global.csp.nonce}"`;
|
||
else if (this.global.csp.hash) {
|
||
const hash = await sha256(body);
|
||
this.global.csp.script_hashes.push(`sha256-${hash}`);
|
||
}
|
||
return `\n\t\t<script${csp_attr}>${body}<\/script>`;
|
||
}
|
||
};
|
||
var SSRState = class {
|
||
/** @readonly @type {Csp & { script_hashes: Sha256Source[] }} */
|
||
csp;
|
||
/** @readonly @type {'sync' | 'async'} */
|
||
mode;
|
||
/** @readonly @type {() => string} */
|
||
uid;
|
||
/** @readonly @type {Set<{ hash: string; code: string }>} */
|
||
css = /* @__PURE__ */ new Set();
|
||
/**
|
||
* `transformError` passed to `render`. Called when an error boundary catches an error.
|
||
* Throws by default if unset in `render`.
|
||
* @type {(error: unknown) => unknown}
|
||
*/
|
||
transformError;
|
||
/** @type {{ path: number[], value: string }} */
|
||
#title = {
|
||
path: [],
|
||
value: ""
|
||
};
|
||
/**
|
||
* @param {'sync' | 'async'} mode
|
||
* @param {string} id_prefix
|
||
* @param {Csp} csp
|
||
* @param {((error: unknown) => unknown) | undefined} [transformError]
|
||
*/
|
||
constructor(mode, id_prefix = "", csp = { hash: false }, transformError) {
|
||
this.mode = mode;
|
||
this.csp = {
|
||
...csp,
|
||
script_hashes: []
|
||
};
|
||
this.transformError = transformError ?? ((error) => {
|
||
throw error;
|
||
});
|
||
let uid = 1;
|
||
this.uid = () => `${id_prefix}s${uid++}`;
|
||
}
|
||
get_title() {
|
||
return this.#title.value;
|
||
}
|
||
/**
|
||
* Performs a depth-first (lexicographic) comparison using the path. Rejects sets
|
||
* from earlier than or equal to the current value.
|
||
* @param {string} value
|
||
* @param {number[]} path
|
||
*/
|
||
set_title(value, path) {
|
||
const current = this.#title.path;
|
||
let i = 0;
|
||
let l = Math.min(path.length, current.length);
|
||
while (i < l && path[i] === current[i]) i += 1;
|
||
if (path[i] === void 0) return;
|
||
if (current[i] === void 0 || path[i] > current[i]) {
|
||
this.#title.path = path;
|
||
this.#title.value = value;
|
||
}
|
||
}
|
||
};
|
||
//#endregion
|
||
//#region node_modules/svelte/src/internal/server/dev.js
|
||
function get_user_code_location() {
|
||
return get_stack().filter((line) => line.trim().startsWith("at ")).map((line) => line.replace(/\((.*):\d+:\d+\)$/, (_, file) => `(${file})`)).join("\n");
|
||
}
|
||
//#endregion
|
||
export { createContext as $, component_context as A, hydration_failed as B, mutable_source as C, get$1 as D, flushSync as E, set_hydrate_node as F, async_mode_flag as G, escape_html as H, set_hydrating as I, STATE_SYMBOL as J, getAbortSignal as K, hydration_mismatch as L, push as M, hydrate_node as N, readable as O, hydrating as P, run as Q, lifecycle_double_unmount as R, init_operations as S, boundary as T, HYDRATION_ERROR as U, attr as V, get_render_context as W, define_property as X, array_from as Y, noop as Z, component_root as _, ensure_array_like as a, hydratable_clobbering as at, get_first_child as b, store_get as c, experimental_async_required as ct, is_passive_event as d, getAllContexts as et, active_effect as f, set_active_reaction as g, set_active_effect as h, derived as i, ssr_context as it, pop as j, writable as k, stringify as l, get as m, attr_class as n, hasContext as nt, render as o, hydratable_serialization_failed as ot, active_reaction as p, LEGACY_PROPS as q, bind_props as r, setContext as rt, slot as s, lifecycle_function_unavailable as st, get_user_code_location as t, getContext as tt, unsubscribe_stores as u, clear_text_content as v, set as w, get_next_sibling as x, create_text as y, state_proxy_unmount as z };
|