@heycys/gallery 0.0.0-stage → 0.1.1

package/kit/runtime.js

@@ -0,0 +1,1782 @@
+"use strict";
+(() => {
+  // <define:__COMPONENT_FLOWS__>
+  var define_COMPONENT_FLOWS_default = [".doc-page", ".doc-section", ".doc-summary", ".doc-panel", ".doc-callout", ".doc-details-content", ".doc-dialog-content", "[data-doc-sheet]", ".doc-column", "[data-doc-slot]"];
+
+  // <define:__COMPONENT_RUNTIME__>
+  var define_COMPONENT_RUNTIME_default = [{ id: "page", match: "main.doc-page", runtime: { generated: [".doc-display", "script[data-doc-state]"], root: { attrs: ["data-doc-ready", "data-doc-drawn", "data-doc-controls"] }, state: { html: ["data-doc-theme", "data-doc-width", "data-doc-font", "data-doc-size", "data-doc-spacing", "data-doc-measure"] }, internal: ["doc-display*", "data-doc-export-copy", "data-theme", "doc-export-id", "doc-reveal", "doc-kit-error"] } }, { id: "text", runtime: { classes: { ".doc-range": ["doc-range"], ".doc-long-run": ["doc-long-run"] } } }, { id: "mention", runtime: { attrs: { "a.doc-link-mention": ["data-doc-gone"] } } }, { id: "paragraph", match: "p" }, { id: "heading", match: "h1, h2, h3, h4" }, { id: "list", match: "ul, ol", runtime: { attrs: { "ol.doc-flow": ["data-doc-flow-key", "data-doc-flow-recount"] }, generated: ["br.doc-item-line"] } }, { id: "quote", match: "blockquote" }, { id: "code", match: ".doc-code", runtime: { generated: [".doc-code-fold", ".doc-code-range", ".doc-code-tools"], internal: ["doc-code-lines", "doc-code-line*", "doc-code-content", "doc-code-toolbar", "doc-code-language", "doc-code-separator", "doc-code-copy*", "doc-code-wrap*", "data-line-number"] } }, { id: "divider", match: "hr" }, { id: "math", match: ".doc-math-inline, .doc-math-block", runtime: { generated: [".doc-math-break", ".doc-math-joiner"], classes: { ".doc-math-tie": ["doc-math-tie"], ".doc-math-skip": ["doc-math-skip"] } } }, { id: "section", match: "section.doc-section" }, { id: "highlight", match: ".doc-panel, .doc-summary" }, { id: "callout", match: ".doc-callout" }, { id: "details", match: "details.doc-details" }, { id: "dialog", match: "dialog.doc-dialog", runtime: { attrs: { "dialog.doc-dialog": ["data-doc-dialog-ready", "open", "aria-label"], ".doc-dialog-content": ["tabindex"] }, root: { classes: ["doc-dialog-open", "doc-dialog-gutter"] }, internal: ["doc-dialog-in", "doc-dialog-fade"] } }, { id: "sheets", match: "[data-doc-sheets]", runtime: { state: { "[data-doc-sheets]": ["data-active-sheet"], "[data-sheet-tab]": ["aria-selected", "tabindex", "is-active"], "[data-doc-sheet]": ["hidden", "aria-hidden"] }, internal: ["doc-sheets"] } }, { id: "table", match: "table.doc-table", runtime: { generated: ["colgroup[data-doc-columns]", ".doc-scrollbars"], attrs: { "table.doc-table": ["data-doc-sortable-ready", "data-doc-filled"], ".doc-table-wrap": ["data-doc-min-width", "data-doc-layout", "data-doc-whole"], "th, td": ["data-column-kind", "data-column-wrap", "data-run-wrap", "data-doc-edge"] }, classes: { "table.doc-table": ["doc-table--auto"] }, internal: ["doc-code-run", "doc-table-sort-button", "doc-scrollbar*", "data-doc-sort-arrow", "data-active", "data-drag", "data-x", "data-y", "data-more"] } }, { id: "columns", match: ".doc-columns" }, { id: "figure", match: "figure" }, { id: "chart", match: "[data-doc-chart]", runtime: { attrs: { "[data-doc-chart]": ["data-doc-layout"] }, classes: { "[data-doc-chart]": ["doc-chart"] }, internal: ["doc-chart-message", "data-missing"] } }, { id: "image", match: "figure.doc-image", runtime: { generated: ["dialog.doc-zoom"], attrs: { "img[data-doc-zoom]": ["data-doc-zoom", "tabindex", "role", "aria-haspopup", "aria-label"] }, root: { classes: ["doc-zoom-open", "doc-zoom-gutter", "doc-zoom-hover"] }, internal: ["doc-zoom-*"] } }, { id: "file", match: "figure.doc-file" }, { id: "bookmark", match: "figure.doc-bookmark" }, { id: "embed", match: "figure.doc-embed", runtime: { attrs: { "iframe.doc-embed-frame": ["data-doc-blob"] } } }, { id: "diff", match: ".doc-diff", runtime: { generated: [".doc-diff-body", ".doc-diff-stats"], internal: ["doc-diff-added", "doc-diff-removed"] } }, { id: "icon", match: ".doc-icon", runtime: { internal: ["data-doc-tab-icon"] } }, { id: "installed", match: "div[data-doc-component], section[data-doc-component]", runtime: { generated: [".doc-component-note", ".doc-component-data"], attrs: { "[data-doc-fallback]": ["data-doc-fallback"], "[data-doc-fallback-control]": ["data-doc-fallback-control", "inert"] }, internal: ["data-doc-package", "doc-component-more", "doc-component-one", "doc-component-line", "doc-component-short"] } }, { id: "state", match: "[data-doc-bind], [data-doc-show]", runtime: { attrs: { "[data-doc-show]": ["hidden"] }, state: { "button[data-doc-bind]": ["aria-pressed"] } } }];
+
+  // src/render/kit/runtime/bindings.js
+  var global = globalThis;
+  var CONTROLS = "input[data-doc-bind], select[data-doc-bind], textarea[data-doc-bind], button[data-doc-bind][value], details[data-doc-bind]";
+  function initial(element) {
+    if (element.localName === "details") return element.hasAttribute("open");
+    if (element.localName === "button") return element.getAttribute("aria-pressed") === "true" ? element.value : void 0;
+    if (element.localName === "input" && (element.type === "checkbox" || element.type === "radio")) return element.type === "checkbox" ? element.checked : element.checked ? element.value : void 0;
+    if (element.localName === "table") return { sort: null };
+    if (element.matches("input, select, textarea")) return element.value;
+    return "";
+  }
+  function showOf(element) {
+    const text = element.getAttribute("data-doc-show") ?? "";
+    const at = text.indexOf(":");
+    return at < 0 ? { key: text.trim(), value: "" } : { key: text.slice(0, at).trim(), value: text.slice(at + 1).trim() };
+  }
+  function createBindings() {
+    let state = null;
+    const later = /* @__PURE__ */ new Map();
+    const listeners = /* @__PURE__ */ new Set();
+    function open() {
+      if (state) return state;
+      if (!global.DocState) throw new Error("State bindings require /kit/state.js to be loaded.");
+      const defaults = {};
+      const transient = /* @__PURE__ */ new Set();
+      for (const element of document.querySelectorAll("[data-doc-bind]")) {
+        const key = element.getAttribute("data-doc-bind").trim();
+        if (!key) continue;
+        const value = initial(element);
+        if (!(key in defaults) || defaults[key] === "" && value !== void 0 && value !== "") defaults[key] = value ?? "";
+        if (element.hasAttribute("data-doc-transient")) transient.add(key);
+      }
+      for (const element of document.querySelectorAll("[data-doc-show]")) {
+        const { key } = showOf(element);
+        if (key && !(key in defaults)) defaults[key] = "";
+      }
+      state = global.DocState.create({ id: "bound", version: 1, defaults, transientKeys: [...transient] });
+      state.subscribe((snapshot, change) => {
+        const keys = change.type === "set" ? [change.key] : Object.keys(snapshot);
+        for (const listener of listeners) for (const key of keys) listener(key);
+      });
+      return state;
+    }
+    const known = (key) => later.has(key) || Object.prototype.hasOwnProperty.call(open().snapshot(), key);
+    const store = {
+      get(key) {
+        if (later.has(key)) return later.get(key);
+        return open().get(key, "");
+      },
+      set(key, value) {
+        if (!known(key)) later.set(key, value);
+        if (later.has(key)) {
+          later.set(key, value);
+          for (const listener of listeners) listener(key);
+          return;
+        }
+        if (JSON.stringify(open().get(key)) !== JSON.stringify(value)) open().set(key, value);
+      },
+      /** Calls listener(key) when a key changes; returns what stops it. */
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      listeners: () => listeners.size
+    };
+    function bindControl(element, { signal }) {
+      const key = element.getAttribute("data-doc-bind").trim();
+      if (!key) return null;
+      if (!known(key)) later.set(key, initial(element) ?? "");
+      const show = () => {
+        const value = store.get(key);
+        if (element.localName === "details") {
+          if (element.open !== Boolean(value)) element.open = Boolean(value);
+        } else if (element.localName === "button") {
+          element.setAttribute("aria-pressed", String(value === element.value));
+        } else if (element.type === "checkbox") {
+          element.checked = Boolean(value);
+        } else if (element.type === "radio") {
+          element.checked = value === element.value;
+        } else if (element.value !== String(value ?? "")) {
+          element.value = String(value ?? "");
+        }
+      };
+      const write = () => {
+        if (element.localName === "details") store.set(key, element.open);
+        else if (element.localName === "button") store.set(key, element.value);
+        else if (element.type === "checkbox") store.set(key, element.checked);
+        else if (element.type === "radio") {
+          if (element.checked) store.set(key, element.value);
+        } else store.set(key, element.value);
+      };
+      const event = element.localName === "details" ? "toggle" : element.localName === "button" ? "click" : element.localName === "select" || element.type === "checkbox" || element.type === "radio" ? "change" : "input";
+      element.addEventListener(event, write, { signal });
+      const stop = store.subscribe((changed) => changed === key && show());
+      show();
+      return { destroy: stop };
+    }
+    function bindShow(element) {
+      const { key, value } = showOf(element);
+      if (!key) return null;
+      const show = () => {
+        const chosen = store.get(key);
+        const hidden = chosen !== "" && chosen !== null && chosen !== void 0 && String(chosen) !== value;
+        if (element.hidden !== hidden) element.hidden = hidden;
+      };
+      const stop = store.subscribe((changed) => changed === key && show());
+      show();
+      return { destroy: stop };
+    }
+    return { store, bindControl, bindShow, CONTROLS };
+  }
+
+  // src/render/kit/runtime/embeds.js
+  var sources = /* @__PURE__ */ new Map();
+  function showEmbed(figure) {
+    const frame = figure.querySelector(":scope > iframe.doc-embed-frame");
+    const source = frame?.getAttribute("src") ?? "";
+    const match = /^data:application\/pdf;base64,([\s\S]*)$/.exec(source);
+    if (!match) return null;
+    const text = atob(match[1]);
+    const bytes = new Uint8Array(text.length);
+    for (let index = 0; index < text.length; index++) bytes[index] = text.charCodeAt(index);
+    const url = URL.createObjectURL(new Blob([bytes], { type: "application/pdf" }));
+    sources.set(url, source);
+    frame.setAttribute("data-doc-blob", "");
+    frame.src = url;
+    return {
+      destroy() {
+        sources.delete(url);
+        URL.revokeObjectURL(url);
+        frame.removeAttribute("data-doc-blob");
+        frame.setAttribute("src", source);
+      }
+    };
+  }
+  function dehydrateEmbed(figure) {
+    const frame = figure.querySelector(":scope > iframe.doc-embed-frame[data-doc-blob]");
+    const source = frame && sources.get(frame.getAttribute("src"));
+    if (!source) return;
+    frame.setAttribute("src", source);
+    frame.removeAttribute("data-doc-blob");
+  }
+
+  // src/shared/components/list.mjs
+  var FLOW = "doc-flow";
+  var TODO = "doc-todo";
+  var HELD_TAGS = /* @__PURE__ */ new Set(["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "div", "figure", "blockquote", "details", "hr", "table", "pre"]);
+  var ITEM_LINE = "doc-item-line";
+  var kitList = (node) => Boolean(node?.matches(`ul:not([class]), ol:not([class]), ul.${TODO}`));
+  var BLANK = /^[\s\p{Cf}]*$/u;
+  var SHOWS = "img, picture, svg, video, audio, canvas, iframe, object, input, br";
+  var isHeld = (node) => node.nodeType === 1 && HELD_TAGS.has(node.localName);
+  var blank = (node) => node.nodeType === 3 ? BLANK.test(node.data) : node.nodeType !== 1;
+  var textless = (node) => blank(node) || node.nodeType === 1 && BLANK.test(node.textContent) && !node.matches(SHOWS) && !node.querySelector(SHOWS);
+  function drawnList(list2, flows) {
+    for (let at = list2; kitList(at) || at !== list2 && at?.matches(`ol.${FLOW}`); ) {
+      const holder = at.parentElement;
+      if (holder?.localName !== "li") return Boolean(holder?.matches(flows));
+      at = holder.parentElement;
+    }
+    return false;
+  }
+  function keepsLine(item2, flows) {
+    const nodes = [...item2.childNodes];
+    const first = nodes.findIndex(isHeld);
+    return first >= 0 && nodes.slice(0, first).every(textless) && nodes.slice(first).every((node) => isHeld(node) || blank(node)) && drawnList(item2.parentElement, flows);
+  }
+  function giveLine(item2, flows) {
+    if (!keepsLine(item2, flows)) return false;
+    const line = item2.ownerDocument.createElement("br");
+    line.className = ITEM_LINE;
+    [...item2.childNodes].find(isHeld).before(line);
+    return true;
+  }
+  var FLOW_DIRECTION = "data-direction";
+  var FLOW_RATIO = "--doc-flow-ratio";
+  var FLOW_KEY = "data-doc-flow-key";
+  var FLOW_RECOUNT = "data-doc-flow-recount";
+  var FLOW_LABEL = { zh: "\u6D41\u7A0B\u56FE", en: "Flowchart" };
+  var isFlowLabel = (value) => Object.values(FLOW_LABEL).includes(value);
+  var FLOW_ROW = /* @__PURE__ */ Object.freeze({ most: 5, least: 116, narrow: 520, gap: 28, title: 2 });
+  function flowShares(weights) {
+    if (weights.length === 1) return [1];
+    const given = weights.filter((weight) => weight > 0);
+    const fill = given.length ? given.reduce((sum, weight) => sum + weight, 0) / given.length : 1;
+    const each = weights.map((weight) => weight > 0 ? weight : fill);
+    const all = each.reduce((sum, weight) => sum + weight, 0);
+    return each.map((weight) => weight / all);
+  }
+
+  // src/shared/long-runs.mjs
+  var LONG_RUN = 20;
+  var RUNS = /[^\s\u2000-\u206f\u2e80-\u9fff\uac00-\ud7af\uf900-\ufaff\ufe30-\ufe4f\uff00-\uffef]+/gu;
+  var PIECES = /(?<=[-?])/u;
+  var long = (run) => run.length > LONG_RUN && run.split(PIECES).some((piece) => [...piece].length > LONG_RUN);
+  function longRuns(text) {
+    const found = [];
+    if (text.length <= LONG_RUN) return found;
+    for (const match of text.matchAll(RUNS)) if (long(match[0])) found.push({ index: match.index, length: match[0].length });
+    return found;
+  }
+  function holdsLongRun(text) {
+    if (text.length <= LONG_RUN) return false;
+    for (const match of text.matchAll(RUNS)) if (long(match[0])) return true;
+    return false;
+  }
+
+  // src/render/kit/words.js
+  var RUNTIME = {
+    "component-missing": { zh: "\u7EC4\u4EF6 {0} \u7684\u7EC4\u4EF6\u5305\u4E0D\u5728\u8FD9\u4E2A\u5DE5\u4F5C\u533A\u91CC\uFF0C\u8FD9\u91CC\u53EA\u663E\u793A\u5B83\u7684\u5185\u5BB9\u3002", en: "The package of component {0} is not in this workspace: only what it holds is shown." },
+    "component-broken": { zh: "\u7EC4\u4EF6 {0} \u7684\u7EC4\u4EF6\u5305\u6CA1\u6709\u52A0\u8F7D\uFF0C\u8FD9\u91CC\u53EA\u663E\u793A\u5B83\u7684\u5185\u5BB9\u3002\u539F\u56E0\uFF1A{1}", en: "The package of component {0} did not load: only what it holds is shown. Why: {1}" },
+    "component-silent": { zh: "\u7EC4\u4EF6 {0} \u7684\u811A\u672C\u6CA1\u6709\u542F\u52A8\u5B83\uFF0C\u8FD9\u91CC\u53EA\u663E\u793A\u5B83\u7684\u5185\u5BB9\uFF1A\u770B\u63A7\u5236\u53F0\u91CC\u7684\u9519\u8BEF\u3002", en: "The script of component {0} did not start it: only what it holds is shown. See the console for the error." },
+    "value-true": { zh: "\u662F", en: "Yes" },
+    "value-false": { zh: "\u5426", en: "No" },
+    "value-empty": { zh: "\uFF08\u7A7A\uFF09", en: "(empty)" },
+    "value-deeper": { zh: "\uFF08{0} \u9879\uFF0C\u6CA1\u6709\u5C55\u5F00\uFF09", en: "(not shown: {0} in it)" },
+    "value-more": { zh: "\u8FD8\u6709 {0} \u9879\u6CA1\u6709\u663E\u793A", en: "{0} more not shown" },
+    "rows-more": { zh: "\u8FD8\u6709 {0} \u884C\u6CA1\u6709\u663E\u793A", en: "{0} more rows not shown" },
+    "columns-more": { zh: "\u8FD8\u6709 {0} \u5217\u6CA1\u6709\u663E\u793A", en: "{0} more columns not shown" },
+    "not-json": { zh: "\u8FD9\u6BB5\u6570\u636E\u4E0D\u662F JSON\uFF1A{0}", en: "This data is not JSON: {0}" },
+    "view-image": { zh: "\u67E5\u770B\u56FE\u7247", en: "Image viewer" },
+    "open-image": { zh: "\u653E\u5927\u67E5\u770B\u56FE\u7247", en: "View the image larger" },
+    "open-image-named": { zh: "\u653E\u5927\u67E5\u770B\uFF1A{0}", en: "View larger: {0}" },
+    "close": { zh: "\u5173\u95ED", en: "Close" },
+    "flowchart": FLOW_LABEL
+  };
+  var UI_LANGUAGE = "data-ge-language";
+  function kitLanguage(root = globalThis.document?.documentElement) {
+    const ui = root?.getAttribute(UI_LANGUAGE) ?? null;
+    const english = ui !== null ? ui === "en" : /^en(?:-|$)/i.test(root?.getAttribute("lang") ?? "");
+    return english ? "en" : "zh";
+  }
+  function wordIn(table2, language, key, ...values) {
+    const entry = table2[key];
+    if (!entry) throw new Error(`The kit has no word "${key}" here (src/render/kit/words.js).`);
+    const text = entry[language] ?? entry.zh;
+    return values.length === 0 ? text : text.replace(/\{(\d+)\}/g, (whole, index) => index < values.length ? String(values[index]) : whole);
+  }
+  var sayer = (table2) => (key, ...values) => wordIn(table2, kitLanguage(), key, ...values);
+  var sayRuntime = /* @__PURE__ */ sayer(RUNTIME);
+  var ENGLISH_ROOT = `:root[${UI_LANGUAGE}="en"], :root:not([${UI_LANGUAGE}])[lang|="en" i]`;
+
+  // src/render/kit/runtime/flowchart.js
+  var CJK = "\\u2e80-\\u9fff\\uac00-\\ud7af\\uf900-\\ufaff\\uff00-\\uffef";
+  var WORDS = new RegExp(`[${CJK}]|[^\\s${CJK}]+`, "g");
+  var PIECES2 = new RegExp(`[${CJK}]|[^\\s${CJK}]+|\\s+`, "g");
+  var WIDE = new RegExp(`[${CJK}]`);
+  function linesOf(pieces, width) {
+    let lines = 0;
+    let used = 0;
+    let pending = 0;
+    for (const piece of pieces) {
+      if (piece.space) {
+        if (used > 0) pending += piece.width;
+        continue;
+      }
+      if (lines === 0) lines = 1;
+      if (used > 0 && used + pending + piece.width > width + 0.5) {
+        lines++;
+        used = 0;
+      } else used += pending;
+      pending = 0;
+      if (used === 0 && piece.width > width) {
+        lines += Math.ceil(piece.width / width) - 1;
+        used = piece.width - (Math.ceil(piece.width / width) - 1) * width;
+      } else used += piece.width;
+    }
+    return lines;
+  }
+  function blockHeight(block, width) {
+    const inner = width - (block.indent ?? 0);
+    if (block.pieces) return Math.max(1, linesOf(block.pieces, inner)) * block.line;
+    if (block.items) return block.items.reduce((sum, item2, index) => sum + (index > 0 ? item2.gap : 0) + Math.max(1, linesOf(item2.pieces, inner)) * item2.line + stackHeight(item2.blocks, inner), 0);
+    if (block.blocks) return block.down + stackHeight(block.blocks, inner);
+    return block.height ?? Infinity;
+  }
+  function stackHeight(blocks, width) {
+    let height = 0;
+    let below = 0;
+    blocks.forEach((block, index) => {
+      height += (index === 0 ? block.gap : Math.max(below, block.gap)) + blockHeight(block, width);
+      below = block.after ?? 0;
+    });
+    return height + below;
+  }
+  function cardHeight(step, content) {
+    return step.down + Math.max(1, linesOf(step.title.pieces, content)) * step.title.line + stackHeight(step.blocks, content);
+  }
+  var fits = (step, width) => width >= Math.max(FLOW_ROW.least, step.word);
+  var reads = (step, width) => linesOf(step.title.pieces, width - step.across) <= FLOW_ROW.title && cardHeight(step, width - step.across) <= width;
+  var sharesOf = (row, ratios = []) => flowShares(row.map((index) => ratios[index] ?? null));
+  function flowLayout({ width, steps, direction = null, directions = [], ratios = [] }) {
+    const rows = [];
+    if (steps.length > 0) {
+      let row = [0];
+      for (let next = 1; next < steps.length; next++) {
+        const way = directions[next - 1] ?? direction;
+        const candidate = [...row, next];
+        const each = (test, weighed) => {
+          const shares = weighed ? sharesOf(candidate, ratios) : candidate.map(() => 1 / candidate.length);
+          return candidate.every((index, place) => test(steps[index], (width - FLOW_ROW.gap * (candidate.length - 1)) * shares[place]));
+        };
+        const join = width > 0 && way !== "column" && each(fits, true) && (way === "row" || width >= FLOW_ROW.narrow && candidate.length <= FLOW_ROW.most && each(reads, false));
+        if (join) row = candidate;
+        else {
+          rows.push(row);
+          row = [next];
+        }
+      }
+      rows.push(row);
+    }
+    const nodes = [];
+    rows.forEach((row, at) => {
+      const shares = sharesOf(row, ratios);
+      let before = 0;
+      row.forEach((step, index) => {
+        const last = step === steps.length - 1;
+        const out = last ? null : index < row.length - 1 ? "right" : index === 0 ? "down" : "turn";
+        nodes[step] = { row: at, index, count: row.length, share: shares[index], before, out, short: Boolean(steps[step].short) };
+        before += shares[index];
+      });
+    });
+    return { rows, nodes };
+  }
+  function reachOf(node, px = null) {
+    const gaps = node.index * FLOW_ROW.gap;
+    if (px !== null) return (px - FLOW_ROW.gap * (node.count - 1)) * node.before + gaps;
+    return `calc((100% + 2px) * ${number(node.before / node.share)} + ${gaps}px)`;
+  }
+  var number = (value) => String(Math.round(value * 1e5) / 1e5);
+  function flowRules(key, { rows, nodes }, { cut: cut2 = [], keep = false } = {}) {
+    const list2 = `ol.${FLOW}[${FLOW_KEY}="${key}"]`;
+    const at = (step) => `${list2} > li:nth-of-type(${step + 1})`;
+    const rules2 = [];
+    if (rows.some((row) => row.length > 1)) {
+      rules2.push(`${list2} { flex-flow: row wrap; column-gap: ${FLOW_ROW.gap}px; }`);
+      nodes.forEach((node, step) => {
+        const basis = node.count === 1 ? "100%" : `calc((100% - ${(node.count - 1) * FLOW_ROW.gap}px) * ${number(node.share)} - 1px)`;
+        rules2.push(`${at(step)} { flex: 1 1 ${basis}; }`);
+        if (node.out === "right") rules2.push(`${at(step)}::after { top: calc(9px + var(--doc-flow-mid) - 5px); left: calc(100% + 5px); width: 20px; height: 10px; clip-path: var(--doc-flow-right); }`);
+        if (node.out === "turn") rules2.push(`${at(step)}::after { --doc-flow-reach: ${reachOf(node)}; left: calc(18px - var(--doc-flow-reach)); width: calc(var(--doc-flow-reach) + 10px); clip-path: var(--doc-flow-turn-shape, none); -webkit-mask: var(--doc-flow-turn-mask, var(--doc-flow-turn)); mask: var(--doc-flow-turn-mask, var(--doc-flow-turn)); }`);
+      });
+    }
+    nodes.forEach((node, step) => {
+      if (node.short) rules2.push(`${at(step)} > :is(:first-child, .doc-icon + *):not(.doc-icon, div, figure, details, table, pre) { margin-top: var(--doc-list-gap); }`);
+    });
+    if (keep) rules2.push(`@media print { ${list2} { break-inside: avoid; } }`);
+    for (const step of cut2) rules2.push(`${at(step)}::after { content: none; }`);
+    return rules2.join("\n");
+  }
+  function pagedApart(rows, rects, gap) {
+    const shown2 = (row) => row.filter((step) => rects[step]?.width > 0);
+    const cut2 = [];
+    for (let at = 0; at + 1 < rows.length; at++) {
+      const here = shown2(rows[at]);
+      const next = shown2(rows[at + 1]);
+      if (here.length === 0 || next.length === 0) continue;
+      const bottom = Math.max(...here.map((step) => rects[step].bottom));
+      const top = Math.min(...next.map((step) => rects[step].top));
+      if (Math.abs(top - bottom - gap) > 1) cut2.push(rows[at].at(-1));
+    }
+    return cut2;
+  }
+  var BLOCKS = /* @__PURE__ */ new Set(["P", "H1", "H2", "H3", "H4", "H5", "H6", "UL", "OL", "DIV", "FIGURE", "BLOCKQUOTE", "DETAILS", "HR", "TABLE", "PRE"]);
+  var TEXTS = /* @__PURE__ */ new Set(["P", "H1", "H2", "H3", "H4", "H5", "H6"]);
+  var ICON = "doc-icon";
+  var ownNodes = (item2) => [...item2.childNodes].filter((node) => node.nodeType === 3 || node.nodeType === 1 && !BLOCKS.has(node.tagName));
+  var ownText = (item2) => ownNodes(item2).map((node) => node.textContent).join("");
+  var pixels = (value) => parseFloat(value) || 0;
+  var across = (style) => pixels(style.paddingLeft) + pixels(style.paddingRight) + pixels(style.borderLeftWidth) + pixels(style.borderRightWidth);
+  var down = (style) => pixels(style.paddingTop) + pixels(style.paddingBottom) + pixels(style.borderTopWidth) + pixels(style.borderBottomWidth);
+  var lineOf = (style) => pixels(style.lineHeight) || (pixels(style.fontSize) || 16) * 1.2;
+  var context;
+  function measurer(style) {
+    context ??= document.createElement("canvas").getContext?.("2d") ?? null;
+    const size = pixels(style.fontSize) || 16;
+    if (!context) return (text) => [...text].reduce((sum, character) => sum + size * (WIDE.test(character) ? 1 : 0.6), 0);
+    const font = `${style.fontStyle} ${style.fontWeight} ${style.fontSize} ${style.fontFamily}`;
+    return (text) => {
+      context.font = font;
+      return context.measureText(text).width;
+    };
+  }
+  function piecesOf(text, style, split = true) {
+    const measure = measurer(style);
+    const space = measure(" ");
+    const anywhere = split && style.wordBreak === "break-all";
+    const pieces = [];
+    let widest = 0;
+    for (const piece of String(text).match(PIECES2) ?? []) {
+      if (/^\s/.test(piece)) {
+        pieces.push({ width: space, space: true });
+        continue;
+      }
+      const width = measure(piece);
+      widest = Math.max(widest, width);
+      if (split && !WIDE.test(piece) && (anywhere || holdsLongRun(piece))) for (const character of piece) pieces.push({ width: measure(character) });
+      else pieces.push({ width });
+    }
+    return { pieces, widest };
+  }
+  function inlinePieces(nodes, style) {
+    const holds = (node) => node.nodeType === 1 && (node.tagName === "CODE" || node.querySelector("code"));
+    if (!nodes.some(holds)) return piecesOf(nodes.map((node) => node.textContent).join(""), style);
+    const segments = [];
+    const walk = (node, code) => {
+      if (node.nodeType === 3) {
+        const last = segments.at(-1);
+        if (last && last.code === code) last.text += node.textContent;
+        else segments.push({ text: node.textContent, code });
+      } else if (node.nodeType === 1) node.childNodes.forEach((child) => walk(child, code ?? (node.tagName === "CODE" ? node : null)));
+    };
+    nodes.forEach((node) => walk(node, null));
+    const collect = (split) => {
+      const pieces = [];
+      let joins = false;
+      for (const { text, code } of segments) {
+        if (!text) continue;
+        const look = code ? getComputedStyle(code) : style;
+        const own = piecesOf(text, look, split).pieces;
+        if (code && own.length) {
+          own[0].width += pixels(look.paddingLeft) + pixels(look.borderLeftWidth);
+          own.at(-1).width += pixels(look.paddingRight) + pixels(look.borderRightWidth);
+        }
+        own.forEach((piece, at) => {
+          if (at === 0 && joins && !piece.space && !WIDE.test(text[0])) pieces.at(-1).width += piece.width;
+          else pieces.push(piece);
+        });
+        joins = !/\s$/.test(text) && !WIDE.test(text.at(-1));
+      }
+      return { pieces, widest: Math.max(0, ...pieces.filter((piece) => !piece.space).map((piece) => piece.width)) };
+    };
+    const whole = collect(false);
+    return { pieces: collect(true).pieces, widest: whole.widest };
+  }
+  function contentOf(elements) {
+    const blocks = [];
+    let word = 0;
+    for (const block of elements) {
+      if (!BLOCKS.has(block.tagName)) continue;
+      const look = getComputedStyle(block);
+      if (look.display === "none") continue;
+      const measured = blockShape(block, look);
+      blocks.push(measured.block);
+      word = Math.max(word, measured.word);
+    }
+    return { blocks, word };
+  }
+  function blockShape(block, look) {
+    const margins = { gap: pixels(look.marginTop), after: pixels(look.marginBottom) };
+    if (TEXTS.has(block.tagName)) {
+      const words = inlinePieces([...block.childNodes], look);
+      return { block: { ...margins, pieces: words.pieces, line: lineOf(look) }, word: words.widest };
+    }
+    if ((block.tagName === "UL" || block.tagName === "OL") && !block.classList.contains(FLOW)) {
+      const indent = pixels(look.paddingLeft) + pixels(look.borderLeftWidth);
+      const items = [];
+      let word = 0;
+      for (const item2 of block.children) {
+        if (item2.tagName !== "LI") continue;
+        const style = getComputedStyle(item2);
+        const words = inlinePieces(ownNodes(item2), style);
+        const held = contentOf(item2.children);
+        items.push({ gap: pixels(style.marginTop), pieces: words.pieces, line: lineOf(style), blocks: held.blocks });
+        word = Math.max(word, words.widest, held.word);
+      }
+      return { block: { ...margins, indent, items }, word: word + indent };
+    }
+    if (block.tagName === "BLOCKQUOTE") {
+      const indent = pixels(look.paddingLeft) + pixels(look.borderLeftWidth);
+      const held = contentOf(block.children);
+      return { block: { ...margins, indent, down: down(look), blocks: held.blocks }, word: held.word + indent };
+    }
+    if (block.tagName === "HR") return { block: { ...margins, height: pixels(look.height) + down(look) }, word: 0 };
+    return { block: margins, word: 0 };
+  }
+  function titleOf(item2, style) {
+    const blocks = [...item2.children].filter((child) => BLOCKS.has(child.tagName) && !child.classList.contains(ICON));
+    const own = ownText(item2);
+    const short = /\S/.test(own);
+    const [first] = blocks;
+    if (short || first?.tagName !== "P") return { nodes: ownNodes(item2), style, line: lineOf(style), content: blocks, short };
+    const look = getComputedStyle(first);
+    const whole = first.children.length === 1 && first.textContent === first.firstElementChild.textContent ? getComputedStyle(first.firstElementChild) : look;
+    return { nodes: [...first.childNodes], style: whole, line: lineOf(look), content: blocks.slice(1), short };
+  }
+  function stepShape(item2) {
+    const style = getComputedStyle(item2);
+    const title = titleOf(item2, style);
+    const words = inlinePieces(title.nodes, title.style);
+    const content = contentOf(title.content);
+    return { word: Math.ceil(Math.max(words.widest, content.word) + across(style)), across: across(style), down: down(style), title: { pieces: words.pieces, line: title.line }, blocks: content.blocks, short: title.short };
+  }
+  var DIRECTIONS = ["row", "column"];
+  var directionOf = (element) => DIRECTIONS.includes(element.getAttribute(FLOW_DIRECTION)) ? element.getAttribute(FLOW_DIRECTION) : null;
+  var RATIO = new RegExp(`(?:^|;)\\s*${FLOW_RATIO}\\s*:\\s*([^;]*)`);
+  var ratioOf = (step) => {
+    const value = Number(RATIO.exec(step.getAttribute("style") ?? "")?.[1].trim());
+    return value > 0 && Number.isFinite(value) ? value : null;
+  };
+  var stepsOf = (list2) => [...list2.children].filter((child) => child.tagName === "LI");
+  function layoutOf(list2) {
+    const steps = stepsOf(list2);
+    return flowLayout({ width: list2.clientWidth, steps: steps.map(stepShape), direction: directionOf(list2), directions: steps.map(directionOf), ratios: steps.map(ratioOf) });
+  }
+  var PAGE = 840;
+  var sheet = null;
+  var rules = /* @__PURE__ */ new Map();
+  var live = /* @__PURE__ */ new Map();
+  function writeRules(document2, key, text) {
+    if ((rules.get(key) ?? "") === text) return;
+    if (text) rules.set(key, text);
+    else rules.delete(key);
+    if (!sheet) {
+      sheet = new document2.defaultView.CSSStyleSheet();
+      document2.adoptedStyleSheets = [...document2.adoptedStyleSheets ?? [], sheet];
+    }
+    sheet.replaceSync([...rules.values()].join("\n"));
+  }
+  function keyFor(list2) {
+    const own = list2.getAttribute(FLOW_KEY);
+    if (own && !live.has(own)) return own;
+    let next = live.size + 1;
+    while (live.has(String(next))) next++;
+    list2.setAttribute(FLOW_KEY, String(next));
+    return String(next);
+  }
+  function recount(list2) {
+    const first = list2.querySelector(":scope > li");
+    if (!first) return;
+    list2.setAttribute(FLOW_RECOUNT, "");
+    void getComputedStyle(first, "::before").content;
+    list2.removeAttribute(FLOW_RECOUNT);
+  }
+  function startFlowchart(list2, { signal, frame }) {
+    const named = !list2.hasAttribute("aria-label") && !list2.hasAttribute("aria-labelledby");
+    if (named) list2.setAttribute("aria-label", sayRuntime("flowchart"));
+    const key = keyFor(list2);
+    live.set(key, list2);
+    let moved = false;
+    let keep = true;
+    const lay = () => frame(() => {
+      if (moved) recount(list2);
+      moved = false;
+      const layout = layoutOf(list2);
+      writeRules(list2.ownerDocument, key, flowRules(key, layout, { keep }));
+      const fits2 = list2.getBoundingClientRect().height <= PAGE;
+      if (fits2 === keep) return;
+      keep = fits2;
+      writeRules(list2.ownerDocument, key, flowRules(key, layout, { keep }));
+    });
+    const forPaper = () => {
+      const layout = layoutOf(list2);
+      const document2 = list2.ownerDocument;
+      const apart = () => pagedApart(layout.rows, stepsOf(list2).map((step) => step.getBoundingClientRect()), pixels(getComputedStyle(list2).rowGap));
+      writeRules(document2, key, flowRules(key, layout, { keep: true }));
+      if (apart().length === 0) return;
+      writeRules(document2, key, flowRules(key, layout));
+      const cut2 = apart();
+      if (cut2.length > 0) writeRules(document2, key, flowRules(key, layout, { cut: cut2 }));
+    };
+    const paper = list2.ownerDocument.defaultView?.matchMedia?.("print") ?? null;
+    paper?.addEventListener("change", (event) => event.matches ? forPaper() : lay(), { signal });
+    const directions = new MutationObserver(lay);
+    directions.observe(list2, { attributes: true, attributeFilter: [FLOW_DIRECTION, "style"], subtree: true });
+    signal.addEventListener("abort", () => directions.disconnect());
+    lay();
+    return {
+      update(reason, records) {
+        if (reason === "content" && records.some((record) => record.type === "childList")) moved = true;
+        lay();
+      },
+      // Gone from the page (turned into another kind of list, deleted): its rules go, and the name it
+      // was given with it; its key stays on it, so put back (an undo) it is laid out by the same.
+      destroy() {
+        if (live.get(key) === list2) live.delete(key);
+        writeRules(list2.ownerDocument, key, "");
+        if (named && isFlowLabel(list2.getAttribute("aria-label"))) list2.removeAttribute("aria-label");
+      }
+    };
+  }
+  function dehydrateFlowchart(list2) {
+    if (isFlowLabel(list2.getAttribute("aria-label"))) list2.removeAttribute("aria-label");
+  }
+  var FLOWCHART = `ol.${FLOW}`;
+
+  // src/shared/components/installed.mjs
+  var ATTRIBUTE = "data-doc-component";
+  var PACKAGE_ID = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
+  var INSTANCE = `div[${ATTRIBUTE}], section[${ATTRIBUTE}]`;
+  var SLOT = "data-doc-slot";
+  var SLOT_PART = `div[${SLOT}], section[${SLOT}]`;
+  var REGION = `${INSTANCE}, ${SLOT_PART}`;
+  var edgeAround = (node) => node?.parentElement?.closest(REGION) ?? null;
+  function heldBy(node) {
+    const edge = edgeAround(node);
+    if (!edge) return null;
+    const owner = heldBy(edge);
+    if (edge.matches(INSTANCE)) return owner ?? edge;
+    return owner !== null && edgeAround(edge) === owner ? null : owner;
+  }
+  var opensDocument = (node) => node.matches(SLOT_PART) && heldBy(node) !== null && edgeAround(node) === heldBy(node);
+  var componentAt = (node) => node?.nodeType === 1 && heldBy(node) !== null && !opensDocument(node);
+  var FALLBACK = "data-doc-fallback";
+  var CONTROLS2 = "input, select, textarea, button";
+  var CONTROL_MARK = "data-doc-fallback-control";
+  var ARRIVING = "data-ge-arriving";
+  var NOTE = "doc-component-note";
+  var DATA_SHOWN = "doc-component-data";
+  var DATA_ONE = "doc-component-one";
+  var DATA_LINE = "doc-component-line";
+  var DATA_SHORT = "doc-component-short";
+  var NO_CODE = /^application\/(?:\S+\+)?json$/i;
+  var isDataScript = (tag, attributes) => tag.toLowerCase() === "script" && NO_CODE.test((attributes.find(({ name }) => name.toLowerCase() === "type")?.value ?? "").trim());
+  var DATA_MOST = 1024 * 1024;
+  var SCHEMA = "data-doc-schema";
+  var schemaAhead = (value, schema = 1) => value !== null && value !== void 0 && !(String(value).trim() !== "" && Number(value) <= schema);
+
+  // src/render/kit/runtime/shown-data.js
+  var DEPTH = 3;
+  var ITEMS = 20;
+  var COLUMNS = 8;
+  var TEXT = 200;
+  var MOST = 400;
+  var SHORT = 20;
+  var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+  var isValue = (value) => value === null || typeof value !== "object";
+  var cut = (text) => text.length > TEXT ? `${text.slice(0, TEXT)}\u2026` : text;
+  var sizeOf = (value) => Array.isArray(value) ? value.length : Object.keys(value).length;
+  function made(doc, tag, text = null, className = null) {
+    const node = doc.createElement(tag);
+    if (text !== null) node.textContent = text;
+    if (className) node.className = className;
+    return node;
+  }
+  function scalar(value) {
+    if (value === null) return "\u2014";
+    if (value === true) return sayRuntime("value-true");
+    if (value === false) return sayRuntime("value-false");
+    return cut(String(value));
+  }
+  function drawn(doc, value, depth, left) {
+    left.values--;
+    if (isValue(value)) return doc.createTextNode(scalar(value));
+    if (sizeOf(value) === 0) return doc.createTextNode(sayRuntime("value-empty"));
+    if (depth >= DEPTH || left.values <= 0) return doc.createTextNode(sayRuntime("value-deeper", String(sizeOf(value))));
+    if (Array.isArray(value) && value.every(isObject)) return table(doc, value, depth, left);
+    if (Array.isArray(value)) return list(doc, value, depth, left);
+    return pairs(doc, value, depth, left);
+  }
+  function table(doc, rows, depth, left) {
+    const keys = [...new Set(rows.slice(0, ITEMS).flatMap((row) => Object.keys(row)))];
+    const columns = keys.slice(0, COLUMNS);
+    const node = made(doc, "table");
+    const head = node.createTHead().insertRow();
+    for (const key of columns) head.append(made(doc, "th", cut(key)));
+    const body = node.createTBody();
+    let shown2 = 0;
+    for (const row of rows.slice(0, ITEMS)) {
+      if (left.values <= 0) break;
+      const line = body.insertRow();
+      for (const key of columns) {
+        const cell = line.insertCell();
+        if (!Object.hasOwn(row, key)) continue;
+        const inner = drawn(doc, row[key], depth + 1, left);
+        if (inner.nodeType === 3 && inner.data.length <= SHORT) cell.className = DATA_SHORT;
+        cell.append(inner);
+      }
+      shown2++;
+    }
+    const said = [shown2 < rows.length && sayRuntime("rows-more", String(rows.length - shown2)), keys.length > COLUMNS && sayRuntime("columns-more", String(keys.length - COLUMNS))].filter(Boolean);
+    if (said.length > 0) {
+      const cell = made(doc, "td", said.join(" "), "doc-component-more");
+      cell.colSpan = columns.length;
+      node.createTFoot().insertRow().append(cell);
+    }
+    return node;
+  }
+  function item(doc, inner) {
+    const node = made(doc, "li");
+    node.append(inner);
+    return node;
+  }
+  function list(doc, items, depth, left) {
+    const node = made(doc, "ul", null, depth > 0 && items.every(isValue) ? DATA_LINE : null);
+    let shown2 = 0;
+    for (const value of items.slice(0, ITEMS)) {
+      if (left.values <= 0) break;
+      node.append(item(doc, drawn(doc, value, depth + 1, left)));
+      shown2++;
+    }
+    if (shown2 < items.length) node.append(made(doc, "li", sayRuntime("value-more", String(items.length - shown2)), "doc-component-more"));
+    return node;
+  }
+  function pairs(doc, object, depth, left) {
+    const node = made(doc, "dl");
+    const entries = Object.entries(object);
+    let shown2 = 0;
+    for (const [key, value] of entries.slice(0, ITEMS)) {
+      if (left.values <= 0) break;
+      const said = made(doc, "dd");
+      said.append(drawn(doc, value, depth + 1, left));
+      node.append(made(doc, "dt", cut(key)), said);
+      shown2++;
+    }
+    if (shown2 < entries.length) node.append(made(doc, "dd", sayRuntime("value-more", String(entries.length - shown2)), "doc-component-more"));
+    return node;
+  }
+  function drawData(script, { writing = false } = {}) {
+    const doc = script.ownerDocument;
+    const text = script.textContent.trim();
+    let root;
+    try {
+      root = text === "" ? doc.createTextNode(sayRuntime("value-empty")) : drawn(doc, JSON.parse(text), 0, { values: MOST });
+    } catch {
+      root = doc.createTextNode(writing ? sayRuntime("not-json", cut(text)) : cut(text));
+    }
+    if (root.nodeType !== 1) {
+      const one = made(doc, "ul", null, DATA_ONE);
+      one.append(item(doc, root));
+      root = one;
+    }
+    root.classList.add(DATA_SHOWN);
+    return root;
+  }
+
+  // src/render/kit/runtime/kernel.js
+  function createKit({ descriptions }) {
+    const global2 = globalThis;
+    const defs = /* @__PURE__ */ new Map();
+    const instances = /* @__PURE__ */ new Map();
+    const counters = { mounted: 0, destroyed: 0, failed: 0 };
+    const preview = () => !document.querySelector('meta[name="generator"][content="Gallery"], meta[name="generator"][content="HTML Report Studio"], meta[name="doc-export-id"]');
+    const writing = () => preview() && !new URLSearchParams(location.search).has("present");
+    const selectorOf = (def) => def.selector ?? descriptions.get(def.id)?.match;
+    const ofPackage = (def) => PACKAGE_ID.test(def.id);
+    const listening = (signal) => [...instances.entries()].filter(([, instance]) => instance.def.on?.includes(signal));
+    let owned = "";
+    function logged(id, error) {
+      counters.failed += 1;
+      console.error(`[DocKit] ${id}:`, error);
+    }
+    function report(def, host, error) {
+      logged(def.id, error);
+      const instance = instances.get(host);
+      if (instance && ofPackage(def)) giveUp(instance, host);
+      if (!writing() || !host?.isConnected) return;
+      const note = instance?.note ?? document.createElement("div");
+      note.className = "doc-kit-error";
+      note.setAttribute("data-doc-dev", "");
+      note.setAttribute("role", "alert");
+      note.textContent = `${def.id}: ${error?.message ?? error}`;
+      if (!note.isConnected) host.after(note);
+      if (instance) instance.note = note;
+    }
+    function clearNote(instance) {
+      instance.note?.remove();
+      instance.note = null;
+    }
+    const queued = /* @__PURE__ */ new Map();
+    let frame = 0;
+    let asked = 0;
+    function runFrame() {
+      frame = 0;
+      const work = [...queued];
+      queued.clear();
+      for (const [host, run] of work) {
+        const instance = instances.get(host);
+        if (!instance) continue;
+        try {
+          run();
+          clearNote(instance);
+        } catch (error) {
+          report(instance.def, host, error);
+        }
+      }
+      asked = queued.size > 0 ? asked + 1 : 0;
+      settle();
+    }
+    function schedule(host, run) {
+      if (instances.get(host)?.failed) return;
+      queued.set(host, run);
+      if (!frame) frame = requestAnimationFrame(runFrame);
+    }
+    const ENDLESS = 30;
+    let drawn2 = false;
+    let fontsIn = !document.fonts;
+    const still = () => !drawn2 && (asked >= ENDLESS || !frame && queued.size === 0);
+    function settle() {
+      if (drawn2 || !fontsIn || document.readyState === "loading") return;
+      requestAnimationFrame(() => {
+        if (!still()) return;
+        requestAnimationFrame(() => {
+          if (!still()) return;
+          drawn2 = true;
+          document.documentElement.setAttribute("data-doc-drawn", "");
+        });
+      });
+    }
+    if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", settle, { once: true });
+    else settle();
+    document.fonts?.ready.then(() => {
+      fontsIn = true;
+      settle();
+    });
+    function tell(host, reason, detail, options) {
+      const instance = instances.get(host);
+      if (!instance?.handle?.update) return;
+      try {
+        instance.handle.update(reason, detail, options);
+      } catch (error) {
+        report(instance.def, host, error);
+      }
+    }
+    const tellAll = (signal, detail) => listening(signal).forEach(([host]) => tell(host, signal, detail));
+    const resize = new ResizeObserver((entries) => {
+      for (const { target, contentRect } of entries) {
+        const instance = instances.get(target);
+        if (!instance) continue;
+        const width = Math.round(contentRect.width);
+        if (width === instance.width) continue;
+        instance.width = width;
+        tell(target, "resize");
+      }
+    });
+    global2.addEventListener("doc-theme-change", () => tellAll("theme"));
+    global2.addEventListener("doc-layout-change", () => tellAll("layout"));
+    let editable = false;
+    global2.addEventListener("doc-editable", () => {
+      editable = true;
+      tellAll("editable");
+    });
+    global2.addEventListener("resize", () => tellAll("viewport"));
+    document.fonts?.ready.then(() => tellAll("fonts"));
+    document.fonts?.addEventListener?.("loadingdone", (event) => tellAll("fonts", [...event.fontfaces ?? []]));
+    const ownedBy = (node, host) => node.parentElement.closest(INSTANCE) === host && heldBy(node) === host;
+    const partsIn = (host, at, edit = null) => [...host.querySelectorAll(at)].filter((node) => !node.matches(INSTANCE) && ownedBy(node, host) && edit === "flow" === node.matches(SLOT_PART));
+    const instanceName = (def, host) => host.getAttribute("data-block-id") ?? String(hostsIn(document, selectorOf(def)).indexOf(host));
+    const canEdit = (def, host) => editable && instances.get(host)?.failed === false && !schemaAhead(host.getAttribute(SCHEMA), descriptions.get(def.id)?.schema);
+    const partNamed = (def, name) => {
+      const part = descriptions.get(def.id)?.parts?.[name];
+      if (!part) throw new Error(`no part "${name}" in ${def.id}'s manifest`);
+      return part;
+    };
+    const packageContext = (def, host) => ({
+      part: (name) => partsIn(host, partNamed(def, name).at, partNamed(def, name).edit)[0] ?? null,
+      state: ({ version, defaults, transientKeys }) => global2.DocState.getOrCreate({ id: `${def.id}:${instanceName(def, host)}`, version, defaults, transientKeys }),
+      canEdit: () => canEdit(def, host),
+      edit(names, change) {
+        if (!canEdit(def, host)) return false;
+        const several = Array.isArray(names);
+        const parts = (several ? names : [names]).map((name) => {
+          const { at, edit } = partNamed(def, name);
+          if (edit !== "data") throw new Error(`the part "${name}" of ${def.id} is not edited as data`);
+          return { name, part: partsIn(host, at, edit)[0] };
+        });
+        const apart = parts.find(({ part }, index) => parts.some((other, at) => at !== index && part && other.part && (part === other.part || other.part.contains(part))));
+        if (apart) throw new Error(`the part "${apart.name}" of ${def.id} is in another this edit names, or is it: name the one around it`);
+        if (parts.length === 0 || parts.some(({ part }) => !part)) return false;
+        const run = (drafts) => {
+          try {
+            if (typeof change(several ? drafts : drafts[names])?.then === "function") throw new Error(`a change of ${several ? names.map((name) => `"${name}"`).join(", ") : `"${names}"`} runs at once: context.edit does not wait for it`);
+            return true;
+          } catch (error) {
+            logged(def.id, error);
+            return false;
+          }
+        };
+        return !host.dispatchEvent(new CustomEvent("doc-component-edit", { bubbles: true, cancelable: true, detail: { parts, run } }));
+      }
+    });
+    function takeRuntime(description, root) {
+      const { generated = [], attrs = {} } = description?.runtime ?? {};
+      const own = (selector) => hostsIn(root, selector).filter((node) => node === root || heldBy(node) === root);
+      for (const selector of generated) own(selector).forEach((node) => node.remove());
+      for (const [selector, names] of Object.entries(attrs)) own(selector).forEach((node) => names.forEach((name) => node.removeAttribute(name)));
+    }
+    function clear(def, host) {
+      try {
+        def.dehydrate?.(host);
+      } catch (error) {
+        logged(def.id, error);
+      }
+      takeRuntime(descriptions.get(def.id), host);
+      takeFallback(host);
+    }
+    function takeFallback(host) {
+      host.removeAttribute(FALLBACK);
+      for (const control of host.querySelectorAll(`[${CONTROL_MARK}]`)) {
+        control.removeAttribute("inert");
+        control.removeAttribute(CONTROL_MARK);
+      }
+      host.querySelector(`:scope > .${NOTE}`)?.remove();
+      dataShownIn(host).forEach((node) => node.remove());
+    }
+    function giveUp(instance, host) {
+      if (instance.failed) return;
+      instance.failed = true;
+      queued.delete(host);
+      resize.unobserve(host);
+      instance.controller.abort();
+      const { handle } = instance;
+      instance.handle = null;
+      takeBack(instance, host, handle);
+    }
+    function takeBack({ def }, host, handle) {
+      for (const undo of [() => handle?.destroy?.(), () => def.dehydrate?.(host)]) {
+        try {
+          undo();
+        } catch {
+        }
+      }
+      takeRuntime(descriptions.get(def.id), host);
+      showAsItStands(host);
+    }
+    function keep(def, host, make) {
+      const controller = new AbortController();
+      const instance = { def, handle: null, context: null, controller, width: -1, note: null, failed: false };
+      instances.set(host, instance);
+      const packaged = ofPackage(def);
+      const context2 = {
+        host,
+        signal: controller.signal,
+        frame: (run) => schedule(host, run),
+        fail: (error) => report(def, host, error),
+        ...packaged ? packageContext(def, host) : {}
+      };
+      instance.context = context2;
+      let failure = null;
+      let made2 = null;
+      try {
+        made2 = make(context2);
+      } catch (error) {
+        failure = error;
+      }
+      if (packaged && (failure || instance.failed)) {
+        const failedAsItRan = instance.failed;
+        if (failure) report(def, host, failure);
+        if (failedAsItRan) takeBack(instance, host, made2);
+        return null;
+      }
+      if (packaged && typeof made2?.then === "function") made2 = whenMade(made2, instance, host, context2);
+      instance.handle = made2 ?? (packaged ? {} : null);
+      if (!instance.handle) {
+        controller.abort();
+        if (instances.get(host) === instance) instances.delete(host);
+        if (failure) report(def, host, failure);
+        return null;
+      }
+      counters.mounted += 1;
+      if (def.on?.includes("resize")) resize.observe(host);
+      return instance.handle;
+    }
+    function whenMade(promise, instance, host, context2) {
+      const current = () => instances.get(host) === instance && !instance.failed;
+      const couldEdit = editable;
+      promise.then((handle) => {
+        if (!current()) return void handle?.destroy?.();
+        instance.handle = handle ?? {};
+        if (editable && !couldEdit && instance.def.on?.includes("editable")) tell(host, "editable");
+      }, (error) => {
+        if (current()) context2.fail(error);
+      }).catch((error) => logged(instance.def.id, error));
+      return {};
+    }
+    function mount(def, host) {
+      if (instances.has(host)) return instances.get(host).handle;
+      return keep(def, host, (context2) => {
+        if (ofPackage(def)) clear(def, host);
+        return def.mount(host, context2);
+      });
+    }
+    function destroy(host) {
+      const instance = instances.get(host);
+      if (!instance) return;
+      instances.delete(host);
+      queued.delete(host);
+      counters.destroyed += 1;
+      resize.unobserve(host);
+      instance.controller.abort();
+      clearNote(instance);
+      try {
+        instance.handle?.destroy?.();
+      } catch (error) {
+        report(instance.def, host, error);
+      }
+    }
+    const hostsIn = (root, selector) => [...root.matches?.(selector) ? [root] : [], ...root.querySelectorAll?.(selector) ?? []];
+    const outsidePage = (node) => Boolean(node.closest?.("[data-doc-dev]"));
+    const inOther = (def, host) => host.matches(INSTANCE) && host.getAttribute(ATTRIBUTE) !== def.id || (heldBy(host)?.getAttribute(ATTRIBUTE) ?? def.id) !== def.id;
+    function scan(root, only, { later = false } = {}) {
+      for (const def of only ? [only] : defs.values()) {
+        if (!def.started || later && def.added === false) continue;
+        for (const host of hostsIn(root, selectorOf(def))) if (!outsidePage(host) && !inOther(def, host)) mount(def, host);
+      }
+    }
+    function component(def) {
+      if (!def?.id || typeof def.mount !== "function") throw new Error("DocKit.component requires an id and a mount function.");
+      if (def.on !== void 0 && !Array.isArray(def.on)) throw new Error(`DocKit: "${def.id}": \`on\` is a list of signals.`);
+      if (defs.has(def.id)) throw new Error(`DocKit: "${def.id}" is registered already.`);
+      if (!selectorOf(def)) throw new Error(`DocKit: "${def.id}" has no description with a match (src/shared/components/).`);
+      const registered = { ...def, owns: def.owns ?? ofPackage(def), started: false };
+      defs.set(def.id, registered);
+      if (registered.owns) owned = [...defs.values()].filter((entry) => entry.owns).map(selectorOf).join(", ");
+      const start = () => {
+        registered.started = true;
+        scan(document, registered);
+      };
+      if (def.when === "now" || document.readyState !== "loading") start();
+      else document.addEventListener("DOMContentLoaded", start, { once: true });
+      return registered;
+    }
+    function showAsItStands(host) {
+      host.setAttribute(FALLBACK, "");
+      for (const control of host.querySelectorAll(CONTROLS2)) {
+        if (control.hasAttribute("inert") || heldBy(control) !== host) continue;
+        control.setAttribute("inert", "");
+        control.setAttribute(CONTROL_MARK, "");
+      }
+      showData(host);
+    }
+    const drawnFrom = /* @__PURE__ */ new WeakMap();
+    const dataShownIn = (host) => [...host.querySelectorAll(`.${DATA_SHOWN}`)].filter((node) => ownedBy(node, host));
+    function showData(host) {
+      const kept = /* @__PURE__ */ new Set();
+      for (const script of host.querySelectorAll("script")) {
+        if (!ownedBy(script, host) || !isDataScript(script.localName, [...script.attributes])) continue;
+        const next = script.nextElementSibling;
+        if (next && drawnFrom.get(next) === script.textContent) {
+          kept.add(next);
+          continue;
+        }
+        const drawing = drawData(script, { writing: writing() });
+        drawnFrom.set(drawing, script.textContent);
+        script.after(drawing);
+        kept.add(drawing);
+      }
+      for (const node of dataShownIn(host)) if (!kept.has(node)) node.remove();
+    }
+    const silent = /* @__PURE__ */ new Set();
+    function fallback(root) {
+      const loaded2 = document.readyState === "complete";
+      for (const host of hostsIn(root, INSTANCE)) {
+        const id = host.getAttribute(ATTRIBUTE);
+        const told = descriptions.get(id);
+        if (outsidePage(host) || heldBy(host) || defs.has(id) || [...document.querySelectorAll(`script[${ARRIVING}]`)].some((script) => script.getAttribute(ARRIVING) === id)) continue;
+        if (told?.match && !(told.script && loaded2)) {
+          if (host.hasAttribute(FALLBACK)) takeFallback(host);
+          continue;
+        }
+        showAsItStands(host);
+        if (told?.match && !silent.has(id)) {
+          silent.add(id);
+          logged(id, new Error("its script ran and started no component: no DocKit.component call of this id"));
+        }
+        if (!writing() || host.querySelector(`:scope > .${NOTE}`)) continue;
+        const note = document.createElement("div");
+        note.className = NOTE;
+        note.setAttribute("data-doc-dev", "");
+        note.textContent = told?.problem ? sayRuntime("component-broken", id, told.problem[kitLanguage()]) : sayRuntime(told?.match ? "component-silent" : "component-missing", id);
+        host.prepend(note);
+      }
+    }
+    if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", () => fallback(document), { once: true });
+    else fallback(document);
+    if (document.readyState !== "complete") global2.addEventListener("load", () => fallback(document), { once: true });
+    const sourceParts = (host, id) => Object.values(descriptions.get(id)?.parts ?? {}).filter(({ edit }) => edit === "text" || edit === "data" || edit === "flow").flatMap(({ at, edit }) => partsIn(host, at, edit));
+    const ownedHere = (target) => {
+      const host = target.closest(owned);
+      if (!host) return false;
+      if (!host.matches(INSTANCE)) return true;
+      return target === host || componentAt(target) && heldBy(target) === host;
+    };
+    function changes(records, options) {
+      if (!global2.document?.defaultView) return;
+      const changed = [];
+      const revealed = /* @__PURE__ */ new Set();
+      const sourced = options?.quiet ? [] : listening("source");
+      const written = [];
+      let removed = false;
+      const later = [...defs.values()].filter((def) => def.started && def.added !== false).map(selectorOf).concat(INSTANCE).join(", ");
+      for (const record of records) {
+        const target = record.target.nodeType === 1 ? record.target : record.target.parentElement;
+        if (!target || outsidePage(target)) continue;
+        if (sourced.length > 0 && record.type !== "attributes") written.push([target, record]);
+        if (owned && ownedHere(target)) continue;
+        if (record.type === "attributes") {
+          revealed.add(target);
+          continue;
+        }
+        if (record.removedNodes.length > 0) removed = true;
+        for (const node of record.addedNodes) {
+          if (node.nodeType !== 1 || !node.isConnected || outsidePage(node) || !(node.matches(later) || node.querySelector(later))) continue;
+          scan(node, null, { later: true });
+          fallback(node);
+        }
+        changed.push([target, record]);
+      }
+      if (removed) {
+        for (const host of [...instances.keys()]) if (!host.isConnected) destroy(host);
+      }
+      const hosts = listening("content").map(([host]) => host);
+      if (hosts.length > 0 && changed.length > 0) {
+        const heard = new Map(hosts.map((host) => [host, []]));
+        for (const [target, record] of changed) for (let node = target; node; node = node.parentElement) heard.get(node)?.push(record);
+        for (const host of hosts) if (heard.get(host).length > 0) tell(host, "content", heard.get(host), options);
+      }
+      for (const [host, { def }] of sourced) {
+        const parts = sourceParts(host, def.id);
+        const heard = written.filter(([target]) => parts.some((part) => part.contains(target))).map(([, record]) => record);
+        if (heard.length > 0) tell(host, "source", heard);
+      }
+      for (const [host] of listening("reveal")) {
+        for (const target of revealed) if (target.contains(host)) {
+          tell(host, "reveal");
+          break;
+        }
+      }
+    }
+    const observer = new MutationObserver((records) => changes(records));
+    observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true, attributes: true, attributeFilter: ["hidden", "open"] });
+    function quietly(change) {
+      changes(observer.takeRecords());
+      try {
+        return change();
+      } finally {
+        for (let pass = 0, records; pass < 3 && (records = observer.takeRecords()).length > 0; pass++) changes(records, { quiet: true });
+      }
+    }
+    function dehydrate(root) {
+      const all = (selector) => hostsIn(root, selector);
+      for (const def of defs.values()) {
+        if (!def.dehydrate) continue;
+        for (const host of all(selectorOf(def))) {
+          try {
+            def.dehydrate(host);
+          } catch (error) {
+            report(def, host, error);
+          }
+        }
+      }
+      for (const [id, description] of descriptions) {
+        const marks = description.runtime ?? {};
+        const of = (selector) => PACKAGE_ID.test(id) ? all(selector).filter((node) => (node.matches(INSTANCE) ? node : heldBy(node))?.getAttribute(ATTRIBUTE) === id) : all(selector);
+        for (const selector of marks.generated ?? []) of(selector).forEach((node) => node.remove());
+        for (const [selector, names] of Object.entries(marks.attrs ?? {})) of(selector).forEach((node) => names.forEach((name) => node.removeAttribute(name)));
+        for (const [selector, names] of Object.entries(marks.classes ?? {})) {
+          all(selector).forEach((node) => {
+            node.classList.remove(...names);
+            if (node.classList.length === 0) node.removeAttribute("class");
+          });
+        }
+        (marks.root?.attrs ?? []).forEach((name) => root.removeAttribute(name));
+        (marks.root?.classes ?? []).forEach((name) => root.classList.remove(name));
+        if (root.classList.length === 0) root.removeAttribute("class");
+      }
+      return root;
+    }
+    return Object.freeze({
+      component,
+      /** What the server says of a package (src/shared/component-catalog.mjs): where its instances are and its parts, before its component registers, or why it does not load (`problem`, { zh, en }). */
+      describe: (told) => void descriptions.set(told.id, told),
+      /** What was told of a package, or a component's own description: where its instances are and its parts; null when nothing was. */
+      description: (id) => descriptions.get(id) ?? null,
+      destroy,
+      /** Start what a root holds now (a report's script added it), as if it had been added. */
+      mount(root = document) {
+        scan(root, null, { later: root !== document });
+        fallback(root);
+      },
+      quietly,
+      dehydrate,
+      /** The component on `host` makes its `example` of an edit, as gallery component check asks it. Whether it has one. */
+      example(host) {
+        const instance = instances.get(host);
+        if (!instance?.def.example) return false;
+        instance.def.example(host, instance.context);
+        return true;
+      },
+      /** Counts for tests and the console: instances live (by component), mounted, destroyed, failed. */
+      stats() {
+        const live2 = {};
+        for (const { def, failed } of instances.values()) if (!failed) live2[def.id] = (live2[def.id] ?? 0) + 1;
+        return { ...counters, live: live2, components: [...defs.keys()] };
+      }
+    });
+  }
+
+  // src/shared/reading-place.mjs
+  var rootOf = (doc) => doc.querySelector("main") ?? doc.body;
+  var cssString = (win, value) => win?.CSS?.escape ? win.CSS.escape(value) : String(value).replace(/["\\]/g, "\\$&").replace(/\n/g, "\\a ");
+  var blockOf = (element) => element.closest("[data-block-id]")?.getAttribute("data-block-id") ?? null;
+  var tabsIn = (win) => {
+    const tabs = {};
+    for (const area of win.document.querySelectorAll("[data-doc-sheets]")) {
+      const key = win.DocSheets?.get(area)?.get();
+      if (typeof key === "string") tabs[area.getAttribute("data-doc-sheets")] = key;
+    }
+    return tabs;
+  };
+  function placeIn(win) {
+    const doc = win.document;
+    const root = rootOf(doc);
+    let top = null;
+    if (root) {
+      const walker = doc.createTreeWalker(root, 1, (element) => {
+        if (element.localName === "dialog") return 2;
+        const box = element.getBoundingClientRect();
+        if (box.bottom <= 0 && box.height > 0) return 2;
+        const { position } = win.getComputedStyle(element);
+        return position === "fixed" || position === "sticky" ? 2 : 1;
+      });
+      for (let element = walker.nextNode(); element; element = walker.nextNode()) {
+        const box = element.getBoundingClientRect();
+        if (box.height === 0 || box.top < 0) continue;
+        const path = [];
+        for (let node = element; node !== root; node = node.parentElement) path.unshift([...node.parentElement.children].indexOf(node));
+        top = { path, id: blockOf(element), at: Math.round(box.top) };
+        break;
+      }
+    }
+    return { x: Math.round(win.scrollX), y: Math.round(win.scrollY), top, tabs: tabsIn(win) };
+  }
+  function elementOf(doc, top) {
+    const root = rootOf(doc);
+    if (!root || !top) return null;
+    let element = root;
+    for (const index of Array.isArray(top.path) ? top.path : [null]) element = Number.isInteger(index) ? element?.children[index] ?? null : null;
+    const id = typeof top.id === "string" ? top.id : null;
+    if (element && (id === null || blockOf(element) === id)) return element;
+    return id ? doc.querySelector(`[data-block-id="${cssString(doc.defaultView, id)}"]`) : null;
+  }
+  function goBackTo(win, place) {
+    const tabs = place?.tabs && typeof place.tabs === "object" ? place.tabs : {};
+    for (const area of win.document.querySelectorAll("[data-doc-sheets]")) {
+      const key = tabs[area.getAttribute("data-doc-sheets")];
+      if (typeof key === "string" && win.DocSheets?.get(area)?.get() !== key) win.DocSheets?.get(area)?.set(key);
+    }
+    const element = elementOf(win.document, place?.top);
+    const box = element && !element.closest("dialog") ? element.getBoundingClientRect() : null;
+    const x = Number(place?.x) || 0;
+    if (box && box.height > 0 && Number.isFinite(place.top.at)) win.scrollTo(x, win.scrollY + box.top - place.top.at);
+    else win.scrollTo(x, Number(place?.y) || 0);
+  }
+  function unmoved(win, place, put) {
+    const at = (x, y) => Math.abs(win.scrollX - x) < 1 && Math.abs(win.scrollY - y) < 1;
+    return at(put[0], put[1]) || at(Number(place?.x) || 0, Number(place?.y) || 0);
+  }
+
+  // src/render/kit/runtime/reveal.js
+  var CARD = "dialog.doc-dialog";
+  var shown = (panel) => {
+    const area = panel.parentElement;
+    const key = panel.getAttribute("data-doc-sheet");
+    globalThis.DocSheets?.get(area)?.set(key);
+    if (panel.hidden) [...area.querySelectorAll("[data-sheet-tab]")].find((tab) => tab.getAttribute("data-sheet-tab") === key)?.click();
+  };
+  function reveal(target) {
+    for (const card of [...document.querySelectorAll(`${CARD}[open]`)].reverse()) {
+      if (card.contains(target)) continue;
+      if (globalThis.DocDialogs) globalThis.DocDialogs.close(card, "outside");
+      else card.close();
+    }
+    const around = [];
+    for (let node = target; node; node = node.parentElement) around.unshift(node);
+    for (const node of around) {
+      if (node.hasAttribute("data-doc-sheet") && node.hidden && node.parentElement?.matches("[data-doc-sheets]")) shown(node);
+      else if (node.matches(`${CARD}:not([open])`)) {
+        if (globalThis.DocDialogs) globalThis.DocDialogs.open(node);
+        else node.showModal();
+      } else if (node !== target && node.localName === "details" && !node.open) node.open = true;
+    }
+  }
+  function startBlockLinks(doc) {
+    const win = doc.defaultView;
+    const root = doc.documentElement;
+    const editing2 = () => root.hasAttribute("data-ge-editing");
+    const idOf = (hash) => {
+      try {
+        return decodeURIComponent(hash.slice(1));
+      } catch {
+        return hash.slice(1);
+      }
+    };
+    const blockNamed = (hash) => idOf(hash) ? doc.querySelector(`[data-block-id="${cssString(win, idOf(hash))}"]`) : null;
+    const named = (hash) => blockNamed(hash) ?? (idOf(hash) ? doc.getElementById(idOf(hash)) : null);
+    const go = (hash) => {
+      putting += 1;
+      const target = named(hash);
+      if (!target) return;
+      reveal(target);
+      target.scrollIntoView({ block: "center" });
+    };
+    let order = [...doc.querySelectorAll(`${CARD}[open]`)];
+    new win.MutationObserver((records) => {
+      for (const { target } of records) {
+        if (!target.matches?.(CARD)) continue;
+        order = order.filter((card) => card !== target);
+        if (target.open) order.push(target);
+      }
+    }).observe(root, { subtree: true, attributes: true, attributeFilter: ["open"] });
+    const contentOf2 = (card) => card.querySelector(".doc-dialog-content");
+    const cards = () => {
+      const open = [...doc.querySelectorAll(`${CARD}[open]`)];
+      return [...order.filter((card) => card.open), ...open.filter((card) => !order.includes(card))].filter((card) => card.id).map((card) => ({ id: card.id, top: contentOf2(card)?.scrollTop ?? 0 }));
+    };
+    let putting = 0;
+    let seen = win.location.hash;
+    let stepped = null;
+    const jump = (hash) => {
+      if (hash !== win.location.hash) {
+        const state = win.history.state;
+        try {
+          win.history.replaceState({ ...state && typeof state === "object" ? state : {}, docPlace: { ...placeIn(win), cards: cards() } }, "");
+          win.history.pushState({ docBlock: hash.slice(1) }, "", hash);
+          seen = hash;
+        } catch {
+          win.location.hash = hash;
+          return;
+        }
+      }
+      go(hash);
+    };
+    const back = (place) => {
+      const kept = (Array.isArray(place.cards) ? place.cards : []).filter((card) => typeof card?.id === "string");
+      const keep = new Set(kept.map((card) => card.id));
+      for (const card of [...cards()].reverse().map(({ id }) => doc.getElementById(id))) {
+        if (!card || keep.has(card.id)) continue;
+        if (globalThis.DocDialogs) globalThis.DocDialogs.close(card, "outside");
+        else card.close();
+      }
+      const scrolled = () => kept.forEach(({ id, top }) => {
+        const content = contentOf2(doc.getElementById(id) ?? doc.body);
+        if (content && Number.isFinite(top)) content.scrollTop = top;
+      });
+      for (const { id } of kept) {
+        const card = doc.getElementById(id);
+        if (!card?.matches(`${CARD}:not([open])`)) continue;
+        if (globalThis.DocDialogs) globalThis.DocDialogs.open(card);
+        else card.showModal();
+      }
+      const mine = ++putting;
+      goBackTo(win, place);
+      scrolled();
+      const put = [win.scrollX, win.scrollY];
+      win.requestAnimationFrame(() => {
+        if (mine !== putting) return;
+        if (!unmoved(win, place, put)) return;
+        goBackTo(win, place);
+        scrolled();
+      });
+    };
+    doc.addEventListener("click", (event) => {
+      if (event.defaultPrevented || editing2() || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
+      const hash = event.target.closest?.("a[href^='#']:not([download]):not([target])")?.getAttribute("href");
+      const block = hash ? blockNamed(hash) : null;
+      if (!block || block instanceof win.HTMLDialogElement) return;
+      event.preventDefault();
+      jump(hash);
+    });
+    win.addEventListener("doc-jump-request", (event) => {
+      const hash = event.detail?.hash;
+      if (!editing2() && typeof hash === "string" && hash.startsWith("#") && blockNamed(hash)) jump(hash);
+    });
+    win.addEventListener("popstate", (event) => {
+      const state = event.state;
+      const moved = win.location.hash !== seen;
+      seen = win.location.hash;
+      if (editing2() || !state || typeof state !== "object") return;
+      if (state.docPlace && typeof state.docPlace === "object") back(state.docPlace);
+      else if (typeof state.docBlock === "string") go(win.location.hash);
+      else return;
+      stepped = moved ? win.location.hash : null;
+    });
+    win.addEventListener("hashchange", () => {
+      const took = stepped !== null && stepped === win.location.hash;
+      stepped = null;
+      seen = win.location.hash;
+      if (!took && !editing2()) go(win.location.hash);
+    });
+    const arrive = () => {
+      if (win.location.hash && !editing2()) go(win.location.hash);
+    };
+    if (root.hasAttribute("data-doc-drawn")) return arrive();
+    const observer = new win.MutationObserver(() => {
+      if (!root.hasAttribute("data-doc-drawn")) return;
+      observer.disconnect();
+      arrive();
+    });
+    observer.observe(root, { attributes: true, attributeFilter: ["data-doc-drawn"] });
+  }
+
+  // src/shared/inline-spacing.mjs
+  var UNITS = /* @__PURE__ */ new Set([..."\u4E2A\u4E07\u4EBF\u5343\u767E\u5341\u5143\u89D2\u5206\u5398\u6BDB\u500D\u5E74\u6708\u65E5\u53F7\u65F6\u70B9\u79D2\u5929\u5468\u5C81\u4EBA\u4F4D\u540D\u6B21\u5BB6\u6761\u9879\u79CD\u53F0\u53EA\u4EF6\u7BC7\u9875\u5F20\u5957\u4EFD\u7EC4\u6279\u671F\u5C4A\u4EE3\u7EA7\u5C42\u8F6E\u6B65\u7C73\u514B\u65A4\u5428\u5EA6\u91CC\u516C\u6BEB\u5FAE\u5BF8\u5C3A\u4E24\u5347\u6237\u6240\u5EA7\u680B\u8F86\u67B6\u8258\u672C\u90E8\u7AE0\u8282\u573A\u5C40\u9996\u53E5\u5B57\u884C\u5217\u904D\u56DE\u756A\u6210"]);
+  var ZWSP = String.fromCharCode(8203);
+  var WORD = /[\p{L}\p{N}]/u;
+  var ITEM = "code, .doc-math-inline, .katex";
+  var LINE = /^(P|LI|H[1-6]|TD|TH|DT|DD|DIV|SECTION|ARTICLE|ASIDE|HEADER|FOOTER|MAIN|NAV|FIGURE|FIGCAPTION|CAPTION|SUMMARY|DETAILS|BLOCKQUOTE|UL|OL|TABLE|THEAD|TBODY|TR|PRE|BR|HR|DIALOG|BODY|BUTTON|svg)$/;
+  var emptyFormula = (element) => element.matches(".doc-math-inline") && (element.getAttribute("data-ge-empty") === "formula" || !element.textContent.replace(/\\[()]/g, "").trim());
+  var isInlineItem = (node) => node?.nodeType === 1 && node.matches(ITEM) && !emptyFormula(node);
+  function inlineItems(root) {
+    const items = root.nodeType === 1 && root.matches(ITEM) ? [root, ...root.querySelectorAll(ITEM)] : [...root.querySelectorAll(ITEM)];
+    return items.filter((item2) => isInlineItem(item2) && !item2.parentElement?.closest(".doc-math-inline, .katex, .katex-display, code"));
+  }
+  function endOf(node, after) {
+    if (node.nodeType === 3) {
+      const characters = [...node.data.replaceAll(ZWSP, "")];
+      return characters.length === 0 ? void 0 : after ? characters[0] : characters.at(-1);
+    }
+    if (node.nodeType !== 1) return void 0;
+    if (LINE.test(node.tagName)) return null;
+    if (node.matches(ITEM)) return emptyFormula(node) ? void 0 : true;
+    if (node.hasAttribute("data-ge-empty")) return void 0;
+    const children = [...node.childNodes];
+    for (const child of after ? children : children.reverse()) {
+      const found = endOf(child, after);
+      if (found !== void 0) return found;
+    }
+    return void 0;
+  }
+  function sideOf(node, after) {
+    for (let at = node; at; ) {
+      const next = after ? at.nextSibling : at.previousSibling;
+      if (!next) {
+        at = at.parentElement;
+        if (!at || LINE.test(at.tagName) || at.hasAttribute("contenteditable")) return null;
+        continue;
+      }
+      const found = endOf(next, after);
+      if (found !== void 0) return found;
+      at = next;
+    }
+    return null;
+  }
+  function spaceAround(element) {
+    const put = { before: null, after: null };
+    for (const after of [false, true]) {
+      const side = sideOf(element, after);
+      if (side !== true && !(typeof side === "string" && WORD.test(side))) continue;
+      const space = element.ownerDocument.createTextNode(" ");
+      if (after) element.after(space);
+      else element.before(space);
+      put[after ? "after" : "before"] = space;
+    }
+    return put;
+  }
+
+  // src/render/kit/runtime/spacing.js
+  var inert = (element) => element.closest("pre, svg, [contenteditable], [data-doc-dev], script, style, textarea") || element.matches(INSTANCE) || componentAt(element);
+  var NUMBER = String.raw`\d(?:[\d.,]*\d)?(?:%|[A-Za-z]{1,3})?`;
+  var DASH = "[\u2013\u2014~\uFF5E]";
+  var CLOSING = new RegExp(String.raw`^(?:${DASH}${NUMBER})?[，。、；：！？）」』》】〉〕”’,.;:!?)\]]*`);
+  var RANGE = new RegExp(`${NUMBER} ?${DASH} ?${NUMBER}`);
+  var OWN_TEXT = "code, kbd, samp, .katex, .doc-range, .doc-long-run, option";
+  var TEX = /\\[()[\]]|\$\$/;
+  var WRAPPER = /^(STRONG|B|EM|I|U|S|MARK|SPAN|A|SUB|SUP|SMALL)$/;
+  function tieClosing(formula) {
+    let at = formula;
+    while (!at.nextSibling && at.parentElement && WRAPPER.test(at.parentElement.tagName) && !at.parentElement.classList.contains("doc-math-tie")) at = at.parentElement;
+    if (at.parentElement?.classList.contains("doc-math-tie")) return null;
+    const next = at.nextSibling;
+    const marks = next?.nodeType === 3 ? CLOSING.exec(next.data)?.[0] : null;
+    if (!marks) return null;
+    if (next.data.length > marks.length) next.splitText(marks.length);
+    const tie = formula.ownerDocument.createElement("span");
+    tie.className = "doc-math-tie";
+    at.before(tie);
+    const joiner = formula.ownerDocument.createElement("span");
+    joiner.className = "doc-math-joiner";
+    tie.append(at, joiner, next);
+    tie.querySelectorAll(".katex-html").forEach(breakBetweenBoxes);
+    return tie;
+  }
+  function breakBetweenBoxes(html) {
+    if (html.querySelector(":scope > .doc-math-break")) return;
+    const boxes = [...html.children].filter((child) => child.classList.contains("katex-base"));
+    for (const box of boxes.slice(0, -1)) {
+      const gap = html.ownerDocument.createElement("span");
+      gap.className = "doc-math-break";
+      gap.textContent = ZWSP;
+      box.after(gap);
+    }
+  }
+  function untie(tie) {
+    tie.querySelectorAll(":scope > .doc-math-joiner, .doc-math-break").forEach((added) => added.remove());
+    const parent = tie.parentNode;
+    tie.replaceWith(...tie.childNodes);
+    parent?.normalize();
+  }
+  function holdRanges(text) {
+    const held = [];
+    for (let rest = text; rest; ) {
+      const found = RANGE.exec(rest.data);
+      if (!found) break;
+      const range = found.index > 0 ? rest.splitText(found.index) : rest;
+      rest = range.data.length > found[0].length ? range.splitText(found[0].length) : null;
+      const span = range.ownerDocument.createElement("span");
+      span.className = "doc-range";
+      range.before(span);
+      span.append(range);
+      held.push(span);
+    }
+    return held;
+  }
+  function holdRuns(text) {
+    const held = [];
+    for (const { index, length } of longRuns(text.data).reverse()) {
+      if (index + length < text.data.length) text.splitText(index + length);
+      held.unshift(breaking(index > 0 ? text.splitText(index) : text));
+    }
+    return held;
+  }
+  function breaking(node) {
+    const span = node.ownerDocument.createElement("span");
+    span.className = "doc-long-run";
+    node.before(span);
+    span.append(node);
+    return span;
+  }
+  function textsIn(root) {
+    const texts = [];
+    const walker = root.ownerDocument.createTreeWalker(root, 4);
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) texts.push(node);
+    return texts;
+  }
+  function looked(text) {
+    const parent = text.parentElement;
+    return Boolean(parent?.closest("main")) && !TEX.test(text.data) && !inert(parent) && !parent.closest(OWN_TEXT) && !(text.data.includes("$") && parent.closest("[data-doc-math-dollar]"));
+  }
+  function holdIn(root) {
+    for (const text of textsIn(root)) if (RANGE.test(text.data) && looked(text)) holdRanges(text);
+    for (const text of textsIn(root)) if (holdsLongRun(text.data) && looked(text)) holdRuns(text);
+    for (const code of [...root.matches("code") ? [root] : [], ...root.querySelectorAll("code")]) {
+      if (code.closest("main") && !inert(code) && !code.parentElement?.closest(`${OWN_TEXT}, td, th`) && holdsLongRun(code.textContent)) breaking(code);
+    }
+  }
+  function keepLines(root, flows) {
+    const items = [...root.matches("li") ? [root] : [], ...root.parentElement?.matches("li") ? [root.parentElement] : [], ...root.querySelectorAll("li")];
+    for (const item2 of items) if (item2.closest("main") && !inert(item2)) giveLine(item2, flows);
+  }
+  function spaceIn(root, flows) {
+    for (const element of inlineItems(root)) {
+      if (inert(element)) continue;
+      spaceAround(element);
+      if (element.matches(".doc-math-inline, .katex")) tieClosing(element);
+    }
+    for (const html of [root, ...root.querySelectorAll(".katex-html")]) if (html.matches(".katex-html") && html.closest(".doc-math-tie")) breakBetweenBoxes(html);
+    holdIn(root);
+    keepLines(root, flows);
+  }
+  function startSpacing(document2, flows) {
+    const run = () => spaceIn(document2.body, flows);
+    if (document2.readyState === "loading") document2.addEventListener("DOMContentLoaded", run, { once: true });
+    else run();
+    new MutationObserver((records) => {
+      for (const record of records) for (const node of record.addedNodes) if (node.nodeType === 1 && node.isConnected) spaceIn(node, flows);
+    }).observe(document2.documentElement, { childList: true, subtree: true });
+  }
+
+  // src/shared/zoom.mjs
+  var ZOOM_SKIP = [
+    "a[href]",
+    "button",
+    "summary",
+    "label",
+    "select",
+    "[role=button]",
+    "[role=link]",
+    "[role=tab]",
+    "[data-doc-dialog-open]",
+    ".doc-icon",
+    ".doc-link-mention",
+    ".doc-bookmark",
+    ".doc-file",
+    ".doc-zoom",
+    "[data-doc-dev]"
+  ].join(", ");
+  var ZOOM_PICTURES = ".doc-page img";
+  var ZOOM_MARK = "data-doc-zoom";
+  var ZOOM_LEAST = 48;
+  var loaded = (img) => img.complete && (img.naturalWidth > 0 || /^data:image\/svg|\.svg(?:[?#]|$)/i.test(img.currentSrc || img.src));
+  function zoomable(img) {
+    const holder = img?.hasAttribute?.(ZOOM_MARK) ? img.parentElement : img;
+    if (img?.localName !== "img" || !img.closest(".doc-page") || holder?.closest(ZOOM_SKIP) || holder.matches(INSTANCE) || componentAt(holder) || !loaded(img)) return false;
+    const box = img.getBoundingClientRect();
+    return box.width >= ZOOM_LEAST || box.height >= ZOOM_LEAST;
+  }
+  function zoomCaption(img) {
+    const figure = img.closest("figure");
+    if (!figure || [...figure.querySelectorAll("img")].filter((each) => each.closest("figure") === figure).length !== 1) return null;
+    const caption = figure.querySelector(":scope > figcaption, :scope > .doc-figure-caption");
+    return caption && caption.textContent.trim() ? caption : null;
+  }
+
+  // src/render/kit/runtime/zoom.js
+  var OPEN = "doc-zoom-open";
+  var GUTTER = "doc-zoom-gutter";
+  var HOVER = "doc-zoom-hover";
+  var viewer = null;
+  var editing = (doc) => doc.documentElement.hasAttribute("data-ge-editing");
+  var unmark = (root, ...names) => {
+    root.classList.remove(...names);
+    if (root.classList.length === 0) root.removeAttribute("class");
+  };
+  var printing = (win) => Boolean(win.matchMedia?.("print")?.matches);
+  var KEYED = ["tabindex", "role", "aria-haspopup", "aria-label"];
+  var watched = /* @__PURE__ */ new Set();
+  function judgeZoom(img) {
+    const offered = img.hasAttribute(ZOOM_MARK);
+    if (!offered && KEYED.some((name) => img.hasAttribute(name))) return;
+    if (img.isConnected && !editing(img.ownerDocument) && zoomable(img)) {
+      const alt = img.getAttribute("alt")?.trim();
+      const label = alt ? sayRuntime("open-image-named", alt) : sayRuntime("open-image");
+      if (!offered) {
+        img.setAttribute(ZOOM_MARK, "");
+        img.setAttribute("tabindex", "0");
+        img.setAttribute("role", "button");
+        img.setAttribute("aria-haspopup", "dialog");
+      }
+      if (img.getAttribute("aria-label") !== label) img.setAttribute("aria-label", label);
+    } else if (offered) {
+      for (const name of [ZOOM_MARK, ...KEYED]) img.removeAttribute(name);
+    }
+  }
+  function watchZoom(img, context2) {
+    watched.add(img);
+    const again = () => judgeZoom(img);
+    img.addEventListener("load", again, { signal: context2.signal });
+    again();
+    return { update: again, destroy: () => watched.delete(img) };
+  }
+  function zoomFit({ natural, shown: shown2, window: room, caption = 0 }) {
+    const gap = room.width >= 1020 ? 48 : 16;
+    const width = Math.max(1, room.width - 2 * gap);
+    const height = Math.max(1, room.height - 2 * gap - (caption > 0 ? caption + 12 : 0));
+    if (!(natural.width > 0 && natural.height > 0)) {
+      const ratio = shown2.width > 0 && shown2.height > 0 ? shown2.width / shown2.height : 1;
+      const across2 = Math.min(width, height * ratio);
+      return { width: Math.round(across2), height: Math.round(across2 / ratio) };
+    }
+    const scale = Math.min(1, width / natural.width, height / natural.height);
+    return { width: Math.round(natural.width * scale), height: Math.round(natural.height * scale) };
+  }
+  function openZoom(img) {
+    closeZoom();
+    const doc = img.ownerDocument;
+    const win = doc.defaultView;
+    const root = doc.documentElement;
+    const dialog = doc.createElement("dialog");
+    dialog.className = "doc-zoom";
+    const words = zoomCaption(img);
+    dialog.setAttribute("aria-label", img.getAttribute("alt")?.trim() || words?.textContent.trim() || sayRuntime("view-image"));
+    const picture = doc.createElement("img");
+    picture.className = "doc-zoom-picture";
+    picture.alt = img.getAttribute("alt") ?? "";
+    picture.draggable = false;
+    for (const name of ["crossorigin", "referrerpolicy"]) if (img.hasAttribute(name)) picture.setAttribute(name, img.getAttribute(name));
+    picture.src = img.currentSrc || img.src;
+    let caption = null;
+    if (words) {
+      caption = doc.createElement("div");
+      caption.className = "doc-zoom-caption";
+      for (const node of words.childNodes) caption.append(node.cloneNode(true));
+      caption.querySelectorAll("[id]").forEach((node) => node.removeAttribute("id"));
+    }
+    const close = doc.createElement("button");
+    close.type = "button";
+    close.className = "doc-zoom-close";
+    close.setAttribute("aria-label", sayRuntime("close"));
+    dialog.tabIndex = -1;
+    dialog.append(picture, ...caption ? [caption] : [], close);
+    const v = { dialog, picture, caption, from: img, focus: doc.activeElement, keys: null, fit: null };
+    viewer = v;
+    v.fit = () => {
+      const box = img.getBoundingClientRect();
+      const size = zoomFit({
+        natural: { width: picture.naturalWidth, height: picture.naturalHeight },
+        shown: { width: box.width, height: box.height },
+        window: { width: win.innerWidth, height: win.innerHeight },
+        caption: caption ? caption.offsetHeight : 0
+      });
+      picture.style.width = `${size.width}px`;
+      picture.style.height = `${size.height}px`;
+    };
+    v.keys = (event) => {
+      if (event.key !== "Escape" || event.isComposing) return;
+      event.preventDefault();
+      event.stopPropagation();
+      closeZoom();
+    };
+    dialog.addEventListener("click", (event) => {
+      if (event.target === picture || event.target.closest?.(".doc-zoom-caption a[href]")) return;
+      closeZoom();
+    });
+    dialog.addEventListener("close", () => finish(v));
+    picture.addEventListener("load", v.fit);
+    win.addEventListener("keydown", v.keys, true);
+    win.addEventListener("resize", v.fit);
+    const scrollbar = win.innerWidth - root.clientWidth > 0;
+    unmark(root, HOVER);
+    root.classList.add(OPEN);
+    if (scrollbar) root.classList.add(GUTTER);
+    doc.body.append(dialog);
+    if (typeof dialog.showModal === "function") dialog.showModal();
+    else dialog.setAttribute("open", "");
+    dialog.focus({ preventScroll: true });
+    v.fit();
+    return dialog;
+  }
+  function closeZoom() {
+    const v = viewer;
+    if (!v) return;
+    if (v.dialog.open && typeof v.dialog.close === "function") v.dialog.close();
+    else finish(v);
+  }
+  function finish(v) {
+    if (viewer !== v) return;
+    viewer = null;
+    const doc = v.dialog.ownerDocument;
+    const win = doc.defaultView;
+    win?.removeEventListener("keydown", v.keys, true);
+    win?.removeEventListener("resize", v.fit);
+    v.dialog.remove();
+    unmark(doc.documentElement, OPEN, GUTTER);
+    const back = v.focus;
+    if (back && back !== doc.body && back.isConnected && typeof back.focus === "function") back.focus({ preventScroll: true });
+  }
+  function startZoom(doc) {
+    const win = doc.defaultView;
+    const root = doc.documentElement;
+    doc.addEventListener("click", (event) => {
+      if (event.defaultPrevented || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
+      const img = event.target;
+      if (img?.localName !== "img" || editing(doc) || printing(win) || !zoomable(img)) return;
+      event.preventDefault();
+      openZoom(img);
+    });
+    doc.addEventListener("keydown", (event) => {
+      if (event.defaultPrevented || event.isComposing || event.repeat || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
+      if (event.key !== "Enter" && event.key !== " ") return;
+      const img = event.target;
+      if (img?.localName !== "img" || !img.hasAttribute(ZOOM_MARK) || viewer || editing(doc) || printing(win) || !zoomable(img)) return;
+      event.preventDefault();
+      openZoom(img);
+    });
+    new win.MutationObserver(() => watched.forEach(judgeZoom)).observe(root, { attributes: true, attributeFilter: ["data-ge-editing"] });
+    doc.addEventListener("pointerover", (event) => {
+      const img = event.target;
+      if (img?.localName === "img" && !viewer && !editing(doc) && zoomable(img)) root.classList.add(HOVER);
+    });
+    doc.addEventListener("pointerout", (event) => {
+      if (event.target?.localName === "img" && root.classList.contains(HOVER)) unmark(root, HOVER);
+    });
+    win.addEventListener("beforeprint", () => closeZoom());
+  }
+
+  // src/render/kit/runtime/index.js
+  if (!globalThis.DocKit) {
+    const kit = createKit({ descriptions: new Map(define_COMPONENT_RUNTIME_default.map((component) => [component.id, component])) });
+    const { store, bindControl, bindShow, CONTROLS: CONTROLS3 } = createBindings();
+    kit.component({ id: "bind", selector: CONTROLS3, mount: (element, context2) => bindControl(element, context2) });
+    kit.component({ id: "show", selector: "[data-doc-show]", mount: (element) => bindShow(element) });
+    kit.component({ id: "embed", mount: (figure) => showEmbed(figure), dehydrate: (figure) => dehydrateEmbed(figure) });
+    kit.component({ id: "flowchart", selector: FLOWCHART, on: ["resize", "fonts", "content", "layout"], mount: (list2, context2) => startFlowchart(list2, context2), dehydrate: (list2) => dehydrateFlowchart(list2) });
+    globalThis.DocKit = Object.freeze({ ...kit, bindings: store, flows: define_COMPONENT_FLOWS_default, reveal });
+    globalThis.ReportKit = globalThis.DocKit;
+    globalThis.DocKit.component({ id: "range", selector: ".doc-range", added: false, mount: () => null, dehydrate: untie });
+    globalThis.DocKit.component({ id: "long-run", selector: ".doc-long-run", added: false, mount: () => null, dehydrate: untie });
+    startSpacing(document, ".doc-page, .doc-section, .doc-summary, .doc-panel, .doc-callout, .doc-details-content, .doc-dialog-content, [data-doc-sheet], .doc-column, [data-doc-slot], :is(.doc-section, .doc-summary, .doc-panel, .doc-callout, .doc-details-content, .doc-dialog-content, .doc-column, [data-doc-slot]) > div:not([class])");
+    startZoom(document);
+    globalThis.DocKit.component({ id: "zoom", selector: ZOOM_PICTURES, on: ["resize", "reveal"], mount: (img, context2) => watchZoom(img, context2) });
+    startBlockLinks(document);
+  }
+})();