mongoku 2.4.7 → 2.5.0

package/build/server/chunks/{index2-DBFlGzWV.js → index-DOCFW0vv.js}

@@ -1,15 +1,311 @@
-import { s as set_ssr_context, a as ssr_context, p as push, b as pop, e as escape_html, i as is_promise, n as noop } from './context-C22hLSHK.js';
+import { s as set_ssr_context, a as ssr_context, p as push, b as pop, n as noop, d as deferred, e as escape_html, i as is_promise } from './context-8UI9xWgq.js';
 import { a as async_mode_flag } from './async-lVJA8xJZ.js';
+import { i as is_primitive, g as get_type, D as DevalueError, a as is_plain_object, e as enumerable_symbols, s as stringify_key, b as stringify_string, c as escaped } from './utils2-DrnJY_bz.js';
 
+const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
+const unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
+const reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
+function uneval(value, replacer) {
+  const counts = /* @__PURE__ */ new Map();
+  const keys = [];
+  const custom = /* @__PURE__ */ new Map();
+  function walk(thing) {
+    if (!is_primitive(thing)) {
+      if (counts.has(thing)) {
+        counts.set(thing, counts.get(thing) + 1);
+        return;
+      }
+      counts.set(thing, 1);
+      if (replacer) {
+        const str2 = replacer(thing, (value2) => uneval(value2, replacer));
+        if (typeof str2 === "string") {
+          custom.set(thing, str2);
+          return;
+        }
+      }
+      if (typeof thing === "function") {
+        throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+      }
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "BigInt":
+        case "String":
+        case "Boolean":
+        case "Date":
+        case "RegExp":
+        case "URL":
+        case "URLSearchParams":
+          return;
+        case "Array":
+          thing.forEach((value2, i) => {
+            keys.push(`[${i}]`);
+            walk(value2);
+            keys.pop();
+          });
+          break;
+        case "Set":
+          Array.from(thing).forEach(walk);
+          break;
+        case "Map":
+          for (const [key, value2] of thing) {
+            keys.push(
+              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
+            );
+            walk(value2);
+            keys.pop();
+          }
+          break;
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array":
+          walk(thing.buffer);
+          return;
+        case "ArrayBuffer":
+          return;
+        case "Temporal.Duration":
+        case "Temporal.Instant":
+        case "Temporal.PlainDate":
+        case "Temporal.PlainTime":
+        case "Temporal.PlainDateTime":
+        case "Temporal.PlainMonthDay":
+        case "Temporal.PlainYearMonth":
+        case "Temporal.ZonedDateTime":
+          return;
+        default:
+          if (!is_plain_object(thing)) {
+            throw new DevalueError(
+              `Cannot stringify arbitrary non-POJOs`,
+              keys,
+              thing,
+              value
+            );
+          }
+          if (enumerable_symbols(thing).length > 0) {
+            throw new DevalueError(
+              `Cannot stringify POJOs with symbolic keys`,
+              keys,
+              thing,
+              value
+            );
+          }
+          for (const key in thing) {
+            keys.push(stringify_key(key));
+            walk(thing[key]);
+            keys.pop();
+          }
+      }
+    }
+  }
+  walk(value);
+  const names = /* @__PURE__ */ new Map();
+  Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
+    names.set(entry[0], get_name(i));
+  });
+  function stringify2(thing) {
+    if (names.has(thing)) {
+      return names.get(thing);
+    }
+    if (is_primitive(thing)) {
+      return stringify_primitive(thing);
+    }
+    if (custom.has(thing)) {
+      return custom.get(thing);
+    }
+    const type = get_type(thing);
+    switch (type) {
+      case "Number":
+      case "String":
+      case "Boolean":
+        return `Object(${stringify2(thing.valueOf())})`;
+      case "RegExp":
+        return `new RegExp(${stringify_string(thing.source)}, "${thing.flags}")`;
+      case "Date":
+        return `new Date(${thing.getTime()})`;
+      case "URL":
+        return `new URL(${stringify_string(thing.toString())})`;
+      case "URLSearchParams":
+        return `new URLSearchParams(${stringify_string(thing.toString())})`;
+      case "Array":
+        const members = (
+          /** @type {any[]} */
+          thing.map(
+            (v, i) => i in thing ? stringify2(v) : ""
+          )
+        );
+        const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
+        return `[${members.join(",")}${tail}]`;
+      case "Set":
+      case "Map":
+        return `new ${type}([${Array.from(thing).map(stringify2).join(",")}])`;
+      case "Int8Array":
+      case "Uint8Array":
+      case "Uint8ClampedArray":
+      case "Int16Array":
+      case "Uint16Array":
+      case "Int32Array":
+      case "Uint32Array":
+      case "Float32Array":
+      case "Float64Array":
+      case "BigInt64Array":
+      case "BigUint64Array": {
+        let str2 = `new ${type}`;
+        if (counts.get(thing.buffer) === 1) {
+          const array = new thing.constructor(thing.buffer);
+          str2 += `([${array}])`;
+        } else {
+          str2 += `([${stringify2(thing.buffer)}])`;
+        }
+        const a = thing.byteOffset;
+        const b = a + thing.byteLength;
+        if (a > 0 || b !== thing.buffer.byteLength) {
+          const m = +/(\d+)/.exec(type)[1] / 8;
+          str2 += `.subarray(${a / m},${b / m})`;
+        }
+        return str2;
+      }
+      case "ArrayBuffer": {
+        const ui8 = new Uint8Array(thing);
+        return `new Uint8Array([${ui8.toString()}]).buffer`;
+      }
+      case "Temporal.Duration":
+      case "Temporal.Instant":
+      case "Temporal.PlainDate":
+      case "Temporal.PlainTime":
+      case "Temporal.PlainDateTime":
+      case "Temporal.PlainMonthDay":
+      case "Temporal.PlainYearMonth":
+      case "Temporal.ZonedDateTime":
+        return `${type}.from(${stringify_string(thing.toString())})`;
+      default:
+        const keys2 = Object.keys(thing);
+        const obj = keys2.map((key) => `${safe_key(key)}:${stringify2(thing[key])}`).join(",");
+        const proto = Object.getPrototypeOf(thing);
+        if (proto === null) {
+          return keys2.length > 0 ? `{${obj},__proto__:null}` : `{__proto__:null}`;
+        }
+        return `{${obj}}`;
+    }
+  }
+  const str = stringify2(value);
+  if (names.size) {
+    const params = [];
+    const statements = [];
+    const values = [];
+    names.forEach((name, thing) => {
+      params.push(name);
+      if (custom.has(thing)) {
+        values.push(
+          /** @type {string} */
+          custom.get(thing)
+        );
+        return;
+      }
+      if (is_primitive(thing)) {
+        values.push(stringify_primitive(thing));
+        return;
+      }
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+          values.push(`Object(${stringify2(thing.valueOf())})`);
+          break;
+        case "RegExp":
+          values.push(thing.toString());
+          break;
+        case "Date":
+          values.push(`new Date(${thing.getTime()})`);
+          break;
+        case "Array":
+          values.push(`Array(${thing.length})`);
+          thing.forEach((v, i) => {
+            statements.push(`${name}[${i}]=${stringify2(v)}`);
+          });
+          break;
+        case "Set":
+          values.push(`new Set`);
+          statements.push(
+            `${name}.${Array.from(thing).map((v) => `add(${stringify2(v)})`).join(".")}`
+          );
+          break;
+        case "Map":
+          values.push(`new Map`);
+          statements.push(
+            `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify2(k)}, ${stringify2(v)})`).join(".")}`
+          );
+          break;
+        case "ArrayBuffer":
+          values.push(
+            `new Uint8Array([${new Uint8Array(thing).join(",")}]).buffer`
+          );
+          break;
+        default:
+          values.push(
+            Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}"
+          );
+          Object.keys(thing).forEach((key) => {
+            statements.push(
+              `${name}${safe_prop(key)}=${stringify2(thing[key])}`
+            );
+          });
+      }
+    });
+    statements.push(`return ${str}`);
+    return `(function(${params.join(",")}){${statements.join(
+      ";"
+    )}}(${values.join(",")}))`;
+  } else {
+    return str;
+  }
+}
+function get_name(num) {
+  let name = "";
+  do {
+    name = chars[num % chars.length] + name;
+    num = ~~(num / chars.length) - 1;
+  } while (num >= 0);
+  return reserved.test(name) ? `${name}0` : name;
+}
+function escape_unsafe_char(c) {
+  return escaped[c] || c;
+}
+function escape_unsafe_chars(str) {
+  return str.replace(unsafe_chars, escape_unsafe_char);
+}
+function safe_key(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
+}
+function safe_prop(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
+}
+function stringify_primitive(thing) {
+  if (typeof thing === "string") return stringify_string(thing);
+  if (thing === void 0) return "void 0";
+  if (thing === 0 && 1 / thing < 0) return "-0";
+  const str = String(thing);
+  if (typeof thing === "number") return str.replace(/^(-)?0\./, "$1.");
+  if (typeof thing === "bigint") return thing + "n";
+  return str;
+}
 const DERIVED = 1 << 1;
 const EFFECT = 1 << 2;
 const RENDER_EFFECT = 1 << 3;
+const MANAGED_EFFECT = 1 << 24;
 const BLOCK_EFFECT = 1 << 4;
 const BRANCH_EFFECT = 1 << 5;
 const ROOT_EFFECT = 1 << 6;
 const BOUNDARY_EFFECT = 1 << 7;
-const UNOWNED = 1 << 8;
-const DISCONNECTED = 1 << 9;
+const CONNECTED = 1 << 9;
 const CLEAN = 1 << 10;
 const DIRTY = 1 << 11;
 const MAYBE_DIRTY = 1 << 12;
@@ -17,15 +313,16 @@ const INERT = 1 << 13;
 const DESTROYED = 1 << 14;
 const EFFECT_RAN = 1 << 15;
 const EFFECT_TRANSPARENT = 1 << 16;
-const INSPECT_EFFECT = 1 << 17;
+const EAGER_EFFECT = 1 << 17;
 const HEAD_EFFECT = 1 << 18;
 const EFFECT_PRESERVED = 1 << 19;
 const USER_EFFECT = 1 << 20;
+const WAS_MARKED = 1 << 15;
 const REACTION_IS_UPDATING = 1 << 21;
 const ASYNC = 1 << 22;
 const ERROR_VALUE = 1 << 23;
-const STATE_SYMBOL = Symbol("$state");
-const LEGACY_PROPS = Symbol("legacy props");
+const STATE_SYMBOL = /* @__PURE__ */ Symbol("$state");
+const LEGACY_PROPS = /* @__PURE__ */ Symbol("legacy props");
 const STALE_REACTION = new class StaleReactionError extends Error {
   name = "StaleReactionError";
   message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
@@ -38,7 +335,7 @@ const HYDRATION_ERROR = {};
 const ELEMENT_IS_NAMESPACED = 1;
 const ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
 const ELEMENT_IS_INPUT = 1 << 2;
-const UNINITIALIZED = Symbol();
+const UNINITIALIZED = /* @__PURE__ */ Symbol();
 const DOM_BOOLEAN_ATTRIBUTES = [
   "allowfullscreen",
   "async",
@@ -233,11 +530,19 @@ function to_style(value, styles) {
 const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
 const BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
 const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
+const EMPTY_COMMENT = `<!---->`;
 let controller = null;
 function abort() {
   controller?.abort(STALE_REACTION);
   controller = null;
 }
+function async_local_storage_unavailable() {
+  const error = 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 = new Error(`await_invalid
 Encountered asynchronous work while rendering synchronously.
@@ -252,6 +557,90 @@ https://svelte.dev/e/html_deprecated`);
   error.name = "Svelte error";
   throw error;
 }
+function invalid_csp() {
+  const error = 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 server_context_required() {
+  const error = new Error(`server_context_required
+Could not resolve \`render\` context.
+https://svelte.dev/e/server_context_required`);
+  error.name = "Svelte error";
+  throw error;
+}
+function unresolved_hydratable(key, stack) {
+  {
+    console.warn(`https://svelte.dev/e/unresolved_hydratable`);
+  }
+}
+let current_render = null;
+let 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;
+  }
+}
+let als = null;
+let 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;
+}
+let text_encoder;
+let crypto;
+async function sha256(data) {
+  text_encoder ??= new TextEncoder();
+  crypto ??= globalThis.crypto?.subtle?.digest ? globalThis.crypto : (
+    // @ts-ignore - we don't install node types in the prod build
+    (await import('node:crypto')).webcrypto
+  );
+  const hash_buffer = await crypto.subtle.digest("SHA-256", text_encoder.encode(data));
+  return base64_encode(hash_buffer);
+}
+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);
+}
 class Renderer {
   /**
    * The contents of the renderer.
@@ -314,13 +703,57 @@ class Renderer {
     head2.child(fn);
   }
   /**
+   * @param {Array<Promise<void>>} blockers
    * @param {(renderer: Renderer) => void} fn
    */
-  async(fn) {
+  async_block(blockers, fn) {
     this.#out.push(BLOCK_OPEN);
-    this.child(fn);
+    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];
+    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);
+    }
+    return promises;
+  }
   /**
    * Create a child renderer. The child renderer inherits the state from the parent,
    * but has its own content.
@@ -498,7 +931,7 @@ class Renderer {
    * 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 }} [options]
+   * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} [options]
    * @returns {RenderOutput}
    */
   static render(component, options = {}) {
@@ -524,6 +957,11 @@ class Renderer {
           return (sync ??= Renderer.#render(component, options)).body;
         }
       },
+      hashes: {
+        value: {
+          script: ""
+        }
+      },
       then: {
         value: (
           /**
@@ -540,11 +978,14 @@ class Renderer {
               const user_result = onfulfilled({
                 head: result2.head,
                 body: result2.body,
-                html: result2.body
+                html: result2.body,
+                hashes: { script: [] }
               });
               return Promise.resolve(user_result);
             }
-            async ??= Renderer.#render_async(component, options);
+            async ??= init_render_context().then(
+              () => with_render_context(() => Renderer.#render_async(component, options))
+            );
             return async.then((result2) => {
               Object.defineProperty(result2, "html", {
                 // eslint-disable-next-line getter-return
@@ -564,7 +1005,7 @@ class Renderer {
     return result;
   }
   /**
-   * Collect all of the `onDestroy` callbacks regsitered during rendering. In an async context, this is only safe to call
+   * 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
@@ -629,18 +1070,22 @@ class Renderer {
    *
    * @template {Record<string, any>} Props
    * @param {Component<Props>} component
-   * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string }} options
-   * @returns {Promise<AccumulatedContent>}
+   * @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) {
-    var previous_context = ssr_context;
+    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 {
-      abort();
       set_ssr_context(previous_context);
+      abort();
     }
   }
   /**
@@ -674,16 +1119,26 @@ class Renderer {
     }
     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 }} options
+   * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} options
    * @returns {Renderer}
    */
   static #open_render(mode, component, options) {
     const renderer = new Renderer(
-      new SSRState(mode, options.idPrefix ? options.idPrefix + "-" : "")
+      new SSRState(mode, options.idPrefix ? options.idPrefix + "-" : "", options.csp)
     );
     renderer.push(BLOCK_OPEN);
     if (options.context) {
@@ -701,6 +1156,7 @@ class Renderer {
   /**
    * @param {AccumulatedContent} content
    * @param {Renderer} renderer
+   * @returns {AccumulatedContent & { hashes: { script: Sha256Source[] } }}
    */
   static #close_render(content, renderer) {
     for (const cleanup of renderer.#collect_on_destroy()) {
@@ -713,11 +1169,58 @@ class Renderer {
     }
     return {
       head: head2,
-      body
+      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>`;
+  }
 }
 class SSRState {
+  /** @readonly @type {Csp & { script_hashes: Sha256Source[] }} */
+  csp;
   /** @readonly @type {'sync' | 'async'} */
   mode;
   /** @readonly @type {() => string} */
@@ -728,10 +1231,12 @@ class SSRState {
   #title = { path: [], value: "" };
   /**
    * @param {'sync' | 'async'} mode
-   * @param {string} [id_prefix]
+   * @param {string} id_prefix
+   * @param {Csp} csp
    */
-  constructor(mode, id_prefix = "") {
+  constructor(mode, id_prefix = "", csp = { hash: false }) {
     this.mode = mode;
+    this.csp = { ...csp, script_hashes: [] };
     let uid = 1;
     this.uid = () => `${id_prefix}s${uid++}`;
   }
@@ -758,17 +1263,20 @@ class SSRState {
 }
 const 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 render(component, options = {}) {
+  if (options.csp?.hash && options.csp.nonce) {
+    invalid_csp();
+  }
   return Renderer.render(
     /** @type {Component<Props>} */
     component,
     options
   );
 }
-function head(renderer, fn) {
+function head(hash, renderer, fn) {
   renderer.head((renderer2) => {
-    renderer2.push(BLOCK_OPEN);
+    renderer2.push(`<!--${hash}-->`);
     renderer2.child(fn);
-    renderer2.push(BLOCK_CLOSE);
+    renderer2.push(EMPTY_COMMENT);
   });
 }
 function attributes(attrs, css_hash, classes, styles, flags = 0) {
@@ -843,5 +1351,5 @@ function ensure_array_like(array_like_or_iterator) {
   return [];
 }
 
-export { ASYNC as A, BLOCK_EFFECT as B, COMMENT_NODE as C, DERIVED as D, ERROR_VALUE as E, INSPECT_EFFECT as F, STALE_REACTION as G, HYDRATION_START as H, INERT as I, HYDRATION_END as J, HYDRATION_START_ELSE as K, LEGACY_PROPS as L, MAYBE_DIRTY as M, USER_EFFECT as N, RENDER_EFFECT as R, STATE_SYMBOL as S, UNOWNED as U, attr as a, attr_class as b, clsx as c, await_block as d, ensure_array_like as e, bind_props as f, attr_style as g, head as h, HYDRATION_ERROR as i, UNINITIALIZED as j, DIRTY as k, CLEAN as l, DISCONNECTED as m, EFFECT as n, is_passive_event as o, BRANCH_EFFECT as p, ROOT_EFFECT as q, render as r, stringify as s, DESTROYED as t, REACTION_IS_UPDATING as u, EFFECT_RAN as v, EFFECT_PRESERVED as w, HEAD_EFFECT as x, BOUNDARY_EFFECT as y, EFFECT_TRANSPARENT as z };
-//# sourceMappingURL=index2-DBFlGzWV.js.map
+export { ASYNC as A, BOUNDARY_EFFECT as B, CONNECTED as C, DERIVED as D, ERROR_VALUE as E, EAGER_EFFECT as F, STALE_REACTION as G, HYDRATION_START as H, INERT as I, HYDRATION_END as J, HYDRATION_START_ELSE as K, LEGACY_PROPS as L, MAYBE_DIRTY as M, USER_EFFECT as N, uneval as O, RENDER_EFFECT as R, STATE_SYMBOL as S, UNINITIALIZED as U, WAS_MARKED as W, attr as a, attr_class as b, clsx as c, await_block as d, ensure_array_like as e, bind_props as f, attr_style as g, head as h, COMMENT_NODE as i, HYDRATION_ERROR as j, DIRTY as k, CLEAN as l, EFFECT as m, MANAGED_EFFECT as n, BLOCK_EFFECT as o, is_passive_event as p, BRANCH_EFFECT as q, render as r, stringify as s, ROOT_EFFECT as t, DESTROYED as u, HEAD_EFFECT as v, REACTION_IS_UPDATING as w, EFFECT_RAN as x, EFFECT_PRESERVED as y, EFFECT_TRANSPARENT as z };
+//# sourceMappingURL=index-DOCFW0vv.js.map