@celsoft/coordinator 0.0.0 → 0.1.0

package/build/chunk-KAYW2W7H.js

@@ -0,0 +1,1311 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  uneval
+} from "./chunk-U5BSBG4R.js";
+
+// build/server/chunks/server2.js
+var UNINITIALIZED = Symbol("uninitialized");
+var ATTR_REGEX = /[&"<]/g;
+var CONTENT_REGEX = /[&<]/g;
+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 === "&" ? "&amp;" : ch === '"' ? "&quot;" : "&lt;");
+    last = i + 1;
+  }
+  return escaped + str.substring(last);
+}
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx$1() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+var is_array = Array.isArray;
+Array.prototype.indexOf;
+Array.prototype.includes;
+Array.from;
+Array.prototype;
+var has_own_property = Object.prototype.hasOwnProperty;
+var noop = () => {
+};
+function run(fn) {
+  return fn();
+}
+function deferred() {
+  var resolve;
+  var reject;
+  return {
+    promise: new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+    resolve,
+    reject
+  };
+}
+function fallback(value, fallback2, lazy = false) {
+  return value === void 0 ? lazy ? fallback2() : fallback2 : value;
+}
+function to_array(value, n) {
+  if (Array.isArray(value)) return value;
+  if (n === void 0 || !(Symbol.iterator in value)) return Array.from(value);
+  const array = [];
+  for (const element2 of value) {
+    array.push(element2);
+    if (array.length === n) break;
+  }
+  return array;
+}
+var replacements = { translate: /* @__PURE__ */ new Map([[true, "yes"], [false, "no"]]) };
+function attr(name, value, is_boolean = false) {
+  if (name === "hidden" && value !== "until-found") is_boolean = true;
+  if (value == null || is_boolean && !value && value !== "") return "";
+  const normalized = has_own_property.call(replacements, name) && replacements[name].get(value) || value;
+  return ` ${name}${is_boolean ? `=""` : `="${escape_html(normalized, true)}"`}`;
+}
+function clsx(value) {
+  if (typeof value === "object") return clsx$1(value);
+  else return value ?? "";
+}
+var whitespace = [..." 	\n\r\f\xA0\v\uFEFF"];
+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;
+}
+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;
+}
+function to_css_name(name) {
+  if (name[0] !== "-" || name[1] !== "-") return name.toLowerCase();
+  return name;
+}
+function to_style(value, styles) {
+  if (styles) {
+    var new_style = "";
+    var normal_styles;
+    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(/\/\*.*?\*\//g, "").trim();
+      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);
+}
+var STALE_REACTION = new class StaleReactionError extends Error {
+  name = "StaleReactionError";
+  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
+}();
+globalThis.document?.contentType;
+function lifecycle_outside_component(name) {
+  throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
+}
+function set_context_after_init() {
+  throw new Error(`https://svelte.dev/e/set_context_after_init`);
+}
+var async_mode_flag = false;
+function get_parent_context(context2) {
+  let parent = context2.p;
+  while (parent !== null && parent.c === null) parent = parent.p;
+  return parent?.c ?? null;
+}
+function get_or_init_context_map(context2, name) {
+  if (context2 === null) lifecycle_outside_component(name);
+  return context2.c ??= new Map(get_parent_context(context2) || void 0);
+}
+var BLOCK_OPEN = `<!--[-->`;
+var BLOCK_CLOSE = `<!--]-->`;
+var EMPTY_COMMENT = `<!---->`;
+var VOID_ELEMENT_NAMES = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+function is_void(name) {
+  return VOID_ELEMENT_NAMES.includes(name) || name.toLowerCase() === "!doctype";
+}
+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"
+];
+function is_boolean_attribute(name) {
+  return DOM_BOOLEAN_ATTRIBUTES.includes(name);
+}
+[...DOM_BOOLEAN_ATTRIBUTES];
+var RAW_TEXT_ELEMENTS = [
+  "textarea",
+  "script",
+  "style",
+  "title"
+];
+function is_raw_text_element(name) {
+  return RAW_TEXT_ELEMENTS.includes(name);
+}
+var REGEX_VALID_TAG_NAME = /^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9.\-_\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}]*)?$/u;
+function async_local_storage_unavailable() {
+  const error = /* @__PURE__ */ new Error(`async_local_storage_unavailable
+The node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.
+https://svelte.dev/e/async_local_storage_unavailable`);
+  error.name = "Svelte error";
+  throw error;
+}
+function await_invalid() {
+  const error = /* @__PURE__ */ new Error(`await_invalid
+Encountered asynchronous work while rendering synchronously.
+https://svelte.dev/e/await_invalid`);
+  error.name = "Svelte error";
+  throw error;
+}
+function dynamic_element_invalid_tag(tag) {
+  const error = /* @__PURE__ */ new Error(`dynamic_element_invalid_tag
+\`<svelte:element this="${tag}">\` is not a valid element name \u2014 the element will not be rendered
+https://svelte.dev/e/dynamic_element_invalid_tag`);
+  error.name = "Svelte error";
+  throw error;
+}
+function html_deprecated() {
+  const error = /* @__PURE__ */ new Error(`html_deprecated
+The \`html\` property of server render results has been deprecated. Use \`body\` instead.
+https://svelte.dev/e/html_deprecated`);
+  error.name = "Svelte error";
+  throw error;
+}
+function invalid_csp() {
+  const error = /* @__PURE__ */ new Error(`invalid_csp
+\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.
+https://svelte.dev/e/invalid_csp`);
+  error.name = "Svelte error";
+  throw error;
+}
+function invalid_id_prefix() {
+  const error = /* @__PURE__ */ new Error(`invalid_id_prefix
+The \`idPrefix\` option cannot include \`--\`.
+https://svelte.dev/e/invalid_id_prefix`);
+  error.name = "Svelte error";
+  throw error;
+}
+function server_context_required() {
+  const error = /* @__PURE__ */ new Error(`server_context_required
+Could not resolve \`render\` context.
+https://svelte.dev/e/server_context_required`);
+  error.name = "Svelte error";
+  throw error;
+}
+var ssr_context = null;
+function set_ssr_context(v) {
+  ssr_context = v;
+}
+function getContext(key) {
+  return get_or_init_context_map(ssr_context, "getContext").get(key);
+}
+function setContext(key, context2) {
+  const context_map = get_or_init_context_map(ssr_context, "setContext");
+  if (ssr_context.i) set_context_after_init();
+  context_map.set(key, context2);
+  return context2;
+}
+function push(fn) {
+  ssr_context = {
+    p: ssr_context,
+    c: null,
+    r: null,
+    i: false
+  };
+}
+function pop() {
+  ssr_context = ssr_context.p;
+}
+function unresolved_hydratable(key, stack) {
+  console.warn(`https://svelte.dev/e/unresolved_hydratable`);
+}
+var current_render = null;
+var context = null;
+function get_render_context() {
+  const store = context ?? als?.getStore();
+  if (!store) server_context_required();
+  return store;
+}
+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;
+  }
+}
+var als = null;
+var als_import = null;
+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;
+}
+var text_encoder;
+var crypto;
+var obfuscated_import = (module_name) => import(
+  /* @vite-ignore */
+  module_name
+);
+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)));
+}
+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);
+}
+var RenderResult = class {
+  /** @type {() => AccumulatedContent} */
+  #render;
+  /** @type {() => Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }>} */
+  #render_async;
+  /** @type {AccumulatedContent | undefined} */
+  #sync;
+  /** @type {{ script: '' }} */
+  #hashes = { script: "" };
+  /** @type {Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }> | undefined} */
+  #promise;
+  /**
+  * @param {() => AccumulatedContent} render
+  * @param {() => Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }>} render_async
+  */
+  constructor(render2, render_async) {
+    this.#render = render2;
+    this.#render_async = render_async;
+  }
+  #get() {
+    return this.#sync ??= this.#render();
+  }
+  get html() {
+    return this.#get().body;
+  }
+  get head() {
+    return this.#get().head;
+  }
+  get body() {
+    return this.#get().body;
+  }
+  get hashes() {
+    return this.#hashes;
+  }
+  /**
+  * This is not type-safe, but honestly it's the best I can do right now, and it's a straightforward function.
+  *
+  * @template TResult1
+  * @template [TResult2=never]
+  * @param {(value: SyncRenderOutput) => TResult1} onfulfilled
+  * @param {(reason: unknown) => TResult2} onrejected
+  */
+  then(onfulfilled, onrejected) {
+    if (!async_mode_flag) {
+      const result = this.#get();
+      const user_result = onfulfilled({
+        head: result.head,
+        body: result.body,
+        html: result.body,
+        hashes: { script: [] }
+      });
+      return Promise.resolve(user_result);
+    }
+    this.#promise ??= this.#render_async().then((result) => {
+      Object.defineProperty(result, "html", { get: () => {
+        html_deprecated();
+      } });
+      return result;
+    });
+    return this.#promise.then((result) => onfulfilled(result), onrejected);
+  }
+};
+var Renderer = class Renderer2 {
+  /**
+  * 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: any, multiple: boolean }}
+  */
+  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,
+      multiple: false
+    };
+    this.type = parent ? parent.type : "body";
+  }
+  /**
+  * @param {(renderer: Renderer) => void} fn
+  */
+  head(fn) {
+    const head2 = new Renderer2(this.global, this);
+    head2.type = "head";
+    this.#out.push(head2);
+    head2.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 context2 = ssr_context;
+      callback = (renderer) => {
+        return Promise.all(blockers).then(() => {
+          const previous_context = ssr_context;
+          try {
+            set_ssr_context(context2);
+            return fn(renderer);
+          } finally {
+            set_ssr_context(previous_context);
+          }
+        });
+      };
+    }
+    this.child(callback);
+  }
+  /**
+  * @param {Array<() => void>} thunks
+  */
+  run(thunks) {
+    const context2 = ssr_context;
+    let promise = Promise.resolve(thunks[0]());
+    const promises = [promise];
+    if (context2 !== null && thunks.length > 1) context2.i = true;
+    for (const fn of thunks.slice(1)) {
+      promise = promise.then(() => {
+        const previous_context = ssr_context;
+        set_ssr_context(context2);
+        try {
+          return fn();
+        } finally {
+          set_ssr_context(previous_context);
+        }
+      });
+      promises.push(promise);
+    }
+    promise.catch(noop);
+    this.promise = this.global.track(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 Renderer2(this.global, this);
+    this.#out.push(child);
+    const parent = ssr_context;
+    set_ssr_context({
+      ...ssr_context,
+      p: parent,
+      c: null,
+      r: child,
+      i: ssr_context?.i ?? false
+    });
+    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 = child.global.track(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 Renderer2(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,
+      i: ssr_context?.i ?? false
+    });
+    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 = child.global.track(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 = child.global.track(
+          /** @type {Promise<unknown>} */
+          result.then((transformed) => {
+            set_ssr_context(parent_context);
+            child.#out.push(Renderer2.#serialize_failed_boundary(transformed));
+            failed_snippet(child, transformed, noop);
+            child.#out.push(BLOCK_CLOSE);
+          })
+        );
+        child.promise.catch(noop);
+      } else {
+        child.#out.push(Renderer2.#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(component_fn);
+    this.child((renderer) => {
+      renderer.#is_component_body = true;
+      return fn(renderer);
+    });
+    pop();
+  }
+  /**
+  * @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, defaultValue, ...select_attrs } = attrs;
+    if (select_attrs.multiple === "") select_attrs.multiple = true;
+    this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags)}>`);
+    this.child((renderer) => {
+      renderer.local.select_value = value === void 0 ? defaultValue : value;
+      renderer.local.multiple = !!select_attrs.multiple;
+      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)}`);
+    const close = (renderer, value, { head: head2, body: body2 }) => {
+      if (has_own_property.call(attrs, "value")) value = attrs.value;
+      var select_value = this.local.select_value;
+      if (this.local.multiple && is_array(select_value) ? select_value.includes(value) : value === select_value) renderer.#out.push(' selected=""');
+      renderer.#out.push(`>${body2}${is_rich ? "<!>" : ""}</option>`);
+      if (head2) renderer.head((child) => child.push(head2));
+    };
+    if (typeof body === "function") this.child((renderer) => {
+      const r2 = new Renderer2(this.global, this);
+      body(r2);
+      if (this.global.mode === "async") return r2.#collect_content_async().then((content) => {
+        close(renderer, content.body.replaceAll("<!---->", ""), content);
+      });
+      else {
+        const content = r2.#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();
+    const close = (head2) => {
+      this.global.set_title(head2, path);
+    };
+    this.child((renderer) => {
+      const r2 = new Renderer2(renderer.global, renderer);
+      fn(r2);
+      if (renderer.global.mode === "async") return r2.#collect_content_async().then((content) => {
+        close(content.head);
+      });
+      else {
+        const content = r2.#collect_content();
+        close(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 Renderer2(this.global, this.#parent);
+    copy.type = this.type;
+    copy.#out = this.#out.map((item) => item instanceof Renderer2 ? 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 Renderer2 && item instanceof Renderer2) {
+        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 = {}) {
+    return new RenderResult(() => Renderer2.#render(component, options), () => init_render_context().then(() => with_render_context(() => Renderer2.#render_async(component, options))));
+  }
+  /**
+  * 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 Renderer2 && !child.#is_component_body) yield* child.#collect_ondestroy();
+  }
+  /**
+  * Runs every `onDestroy` callback in this renderer tree. On a failed render,
+  * cleanup errors are suppressed so they do not mask the render error.
+  * @param {boolean} suppress_errors
+  */
+  #run_on_destroy(suppress_errors) {
+    let first_error;
+    let has_error = false;
+    for (const cleanup of this.#collect_on_destroy()) try {
+      cleanup();
+    } catch (error) {
+      if (!suppress_errors && !has_error) {
+        first_error = error;
+        has_error = true;
+      }
+    }
+    if (has_error) throw first_error;
+  }
+  /**
+  * @param {'sync' | 'async'} mode
+  * @param {{ idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} options
+  * @returns {Renderer}
+  */
+  static #create(mode, options) {
+    if (options.idPrefix?.includes("--")) invalid_id_prefix();
+    return new Renderer2(new SSRState(mode, options.idPrefix ? options.idPrefix + "-" : "", options.csp, options.transformError));
+  }
+  /**
+  * 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;
+    const renderer = Renderer2.#create("sync", options);
+    let result;
+    let render_error;
+    let failed = false;
+    try {
+      try {
+        Renderer2.#open_render(renderer, component, options);
+        result = Renderer2.#close_render(renderer.#collect_content(), renderer);
+      } catch (error) {
+        render_error = error;
+        failed = true;
+      }
+      renderer.#run_on_destroy(failed);
+      if (failed) throw render_error;
+      return result;
+    } finally {
+      renderer.global.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;
+    const renderer = Renderer2.#create("async", options);
+    let result;
+    let render_error;
+    let failed = false;
+    try {
+      try {
+        Renderer2.#open_render(renderer, component, options);
+        const content = await renderer.#collect_content_async();
+        const hydratables = await renderer.#collect_hydratables();
+        if (hydratables !== null) content.head = hydratables + content.head;
+        result = Renderer2.#close_render(content, renderer);
+      } catch (error) {
+        render_error = error;
+        failed = true;
+        renderer.global.abort();
+        await renderer.global.settle();
+      }
+      renderer.#run_on_destroy(failed);
+      if (failed) throw render_error;
+      return result;
+    } finally {
+      set_ssr_context(previous_context);
+      renderer.global.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 Renderer2) 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 Renderer2) {
+      if (item.#boundary) {
+        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: context2, failed, transformError } = item.#boundary;
+          set_ssr_context(context2);
+          let promise = transformError(error);
+          set_ssr_context(null);
+          let transformed = await promise;
+          set_ssr_context(context2);
+          const failed_renderer = new Renderer2(item.global, item);
+          failed_renderer.type = item.type;
+          failed_renderer.#out.push(Renderer2.#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 {Renderer} renderer
+  * @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 {void}
+  */
+  static #open_render(renderer, component, options) {
+    var previous_context = ssr_context;
+    try {
+      set_ssr_context({
+        p: null,
+        c: options.context ?? null,
+        r: renderer,
+        i: false
+      });
+      renderer.push(BLOCK_OPEN);
+      component(renderer, options.props ?? {});
+      renderer.push(BLOCK_CLOSE);
+    } finally {
+      set_ssr_context(previous_context);
+    }
+  }
+  /**
+  * @param {AccumulatedContent} content
+  * @param {Renderer} renderer
+  * @returns {AccumulatedContent & { hashes: { script: Sha256Source[] } }}
+  */
+  static #close_render(content, renderer) {
+    let head2 = content.head + renderer.global.get_title();
+    let body = content.body;
+    for (const { hash, code } of renderer.global.css) head2 += `<style id="${hash}">${code}</style>`;
+    return {
+      head: head2,
+      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(`[${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 `
+		<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();
+  /** @type {Set<Promise<unknown>>} */
+  #pending = /* @__PURE__ */ new Set();
+  /** @type {AbortController | null} */
+  #controller = null;
+  #aborted = false;
+  /**
+  * `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++}`;
+  }
+  /**
+  * @template T
+  * @param {Promise<T>} promise
+  * @returns {Promise<T>}
+  */
+  track(promise) {
+    this.#pending.add(promise);
+    promise.then(() => this.#pending.delete(promise), () => this.#pending.delete(promise));
+    return promise;
+  }
+  async settle() {
+    while (this.#pending.size > 0) await Promise.allSettled([...this.#pending]);
+  }
+  abort() {
+    if (this.#aborted) return;
+    this.#aborted = true;
+    this.#controller?.abort(STALE_REACTION);
+  }
+  get_abort_signal() {
+    const controller = this.#controller ??= new AbortController();
+    if (this.#aborted) controller.abort(STALE_REACTION);
+    return controller.signal;
+  }
+  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;
+    }
+  }
+};
+function html(value) {
+  return "<!---->" + String(value ?? "") + "<!---->";
+}
+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;
+function element(renderer, tag, attributes_fn = noop, children_fn = noop) {
+  renderer.push("<!---->");
+  if (tag) {
+    if (!REGEX_VALID_TAG_NAME.test(tag)) dynamic_element_invalid_tag(tag);
+    renderer.push(`<${tag}`);
+    attributes_fn();
+    renderer.push(`>`);
+    if (!is_void(tag)) {
+      children_fn();
+      if (!is_raw_text_element(tag)) renderer.push(EMPTY_COMMENT);
+      renderer.push(`</${tag}>`);
+    }
+  }
+  renderer.push("<!---->");
+}
+function render(component, options = {}) {
+  if (options.csp?.hash && options.csp.nonce) invalid_csp();
+  return Renderer.render(component, options);
+}
+function head(hash, renderer, fn) {
+  renderer.head((renderer2) => {
+    renderer2.push(`<!--${hash}-->`);
+    renderer2.child(fn);
+    renderer2.push(EMPTY_COMMENT);
+  });
+}
+function attributes(attrs, css_hash, classes, styles, flags = 0) {
+  if (styles) attrs.style = to_style(attrs.style, styles);
+  if (attrs.class) attrs.class = clsx(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;
+  const names = Object.keys(attrs);
+  outer: for (let i = 0; i < names.length; i++) {
+    name = names[i];
+    if (typeof attrs[name] === "function") continue;
+    if (name[0] === "$" && name[1] === "$") continue;
+    if (name === "" || 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 (name in attrs) continue;
+        for (let j = 0; j < names.length; j++) if (names[j].toLowerCase() === name) continue outer;
+      }
+    }
+    attr_str += attr(name, value, is_html && is_boolean_attribute(name));
+  }
+  return attr_str;
+}
+function spread_props(props) {
+  const merged_props = {};
+  let key;
+  for (let i = 0; i < props.length; i++) {
+    const obj = props[i];
+    if (obj == null) continue;
+    for (key of Object.keys(obj)) {
+      const desc = Object.getOwnPropertyDescriptor(obj, key);
+      if (desc) Object.defineProperty(merged_props, key, desc);
+      else merged_props[key] = obj[key];
+    }
+  }
+  return merged_props;
+}
+function stringify(value) {
+  return typeof value === "string" ? value : value == null ? "" : value + "";
+}
+function attr_class(value, hash, directives) {
+  var result = to_class(value, hash, directives);
+  return result ? ` class="${escape_html(result, true)}"` : "";
+}
+function attr_style(value, directives) {
+  var result = to_style(value, directives);
+  return result ? ` style="${escape_html(result, true)}"` : "";
+}
+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;
+  }
+}
+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 [];
+}
+function once(get_value) {
+  let value = UNINITIALIZED;
+  return () => {
+    if (value === UNINITIALIZED) value = get_value();
+    return value;
+  };
+}
+function props_id(renderer) {
+  const uid = renderer.global.uid();
+  renderer.push("<!--$" + uid + "-->");
+  return uid;
+}
+function derived(fn) {
+  const get_value = ssr_context === null ? fn : once(fn);
+  let updated_value;
+  return function(new_value) {
+    if (arguments.length === 0) return updated_value ?? get_value();
+    updated_value = new_value;
+    return updated_value;
+  };
+}
+
+export {
+  escape_html,
+  run,
+  fallback,
+  to_array,
+  attr,
+  clsx,
+  getContext,
+  setContext,
+  html,
+  element,
+  render,
+  head,
+  attributes,
+  spread_props,
+  stringify,
+  attr_class,
+  attr_style,
+  bind_props,
+  ensure_array_like,
+  props_id,
+  derived
+};