@wdprlib/render 2.0.0 → 3.0.0

package/dist/index.js

@@ -1,116 +1,77 @@
-// packages/render/src/render.ts
-import { STYLE_SLOT_PREFIX } from "@wdprlib/ast";
-
-// packages/render/src/context.ts
+// packages/render/src/context/index.ts
 import { DEFAULT_SETTINGS } from "@wdprlib/ast";
 
-// packages/render/src/escape.ts
+// packages/render/src/escape/html.ts
 function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  let start = 0;
+  let escaped = "";
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i];
+    let replacement = null;
+    if (char === "&") {
+      replacement = "&amp;";
+    } else if (char === "<") {
+      replacement = "&lt;";
+    } else if (char === ">") {
+      replacement = "&gt;";
+    }
+    if (replacement) {
+      if (start < i) {
+        escaped += text.slice(start, i);
+      }
+      escaped += replacement;
+      start = i + 1;
+    }
+  }
+  if (start === 0) {
+    return text;
+  }
+  return start < text.length ? escaped + text.slice(start) : escaped;
 }
 function escapeAttr(value) {
+  if (value.indexOf("&") === -1 && value.indexOf("<") === -1 && value.indexOf(">") === -1 && value.indexOf('"') === -1 && value.indexOf("'") === -1) {
+    return value;
+  }
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function escapeStyleContent(css) {
+  if (css.indexOf("</") === -1) {
+    return css;
+  }
   return css.replace(/<\/style/gi, "<\\/style");
 }
-var SAFE_ATTRIBUTES = new Set([
-  "accept",
-  "align",
-  "alt",
-  "autocapitalize",
-  "autoplay",
-  "background",
-  "bgcolor",
-  "border",
-  "buffered",
-  "checked",
-  "cite",
-  "class",
-  "cols",
-  "colspan",
-  "contenteditable",
-  "controls",
-  "coords",
-  "datetime",
-  "decoding",
-  "default",
-  "dir",
-  "dirname",
-  "disabled",
-  "download",
-  "draggable",
-  "for",
-  "form",
-  "headers",
-  "height",
-  "hidden",
-  "high",
-  "href",
-  "hreflang",
-  "id",
-  "inputmode",
-  "ismap",
-  "itemprop",
-  "kind",
-  "label",
-  "lang",
-  "list",
-  "loop",
-  "low",
-  "max",
-  "maxlength",
-  "min",
-  "minlength",
-  "multiple",
-  "muted",
-  "name",
-  "optimum",
-  "pattern",
-  "placeholder",
-  "poster",
-  "preload",
-  "readonly",
-  "required",
-  "reversed",
-  "role",
-  "rows",
-  "rowspan",
-  "scope",
-  "selected",
-  "shape",
-  "size",
-  "sizes",
-  "span",
-  "spellcheck",
-  "src",
-  "srclang",
-  "srcset",
-  "start",
-  "step",
-  "style",
-  "tabindex",
-  "target",
-  "title",
-  "translate",
-  "type",
-  "usemap",
-  "value",
-  "width",
-  "wrap"
-]);
-function isSafeAttribute(name) {
-  const lower = name.toLowerCase();
-  if (lower.startsWith("on"))
-    return false;
-  if (lower.startsWith("aria-") || lower.startsWith("data-"))
-    return true;
-  return SAFE_ATTRIBUTES.has(lower);
-}
+// packages/render/src/escape/url.ts
 function isDangerousUrl(value) {
-  const normalized = value.replace(/[\s\u0000-\u001f\u007f-\u009f]/g, "");
+  const normalized = stripControlAndWhitespace(value);
   return /^(javascript|data|vbscript):/i.test(normalized);
 }
+var WHITESPACE = /\s/;
+function stripControlAndWhitespace(value) {
+  let result = "";
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (WHITESPACE.test(char) || code <= 31 || code >= 127 && code <= 159) {
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+// packages/render/src/escape/css-color-functions.ts
+function isValidCssColorFunction(color) {
+  const fnMatch = color.match(/^(rgba?|hsla?)\(([^)]*)\)$/);
+  if (!fnMatch) {
+    return false;
+  }
+  const fn = fnMatch[1];
+  const args = fnMatch[2].split(",").map((s) => s.trim()).join(",");
+  if (fn.startsWith("rgb")) {
+    return /^\d{1,3},\d{1,3},\d{1,3}(,(0|1|0?\.\d+))?$/.test(args);
+  }
+  return /^\d{1,3},\d{1,3}%,\d{1,3}%(,(0|1|0?\.\d+))?$/.test(args);
+}
+
+// packages/render/src/escape/css-colors.ts
 var CSS_NAMED_COLORS = new Set([
   "aliceblue",
   "antiquewhite",
@@ -275,36 +236,58 @@ function isValidCssColor(color) {
   if (/^#[0-9a-f]{3}([0-9a-f])?$/.test(trimmed) || /^#[0-9a-f]{6}([0-9a-f]{2})?$/.test(trimmed)) {
     return true;
   }
-  const fnMatch = trimmed.match(/^(rgba?|hsla?)\(([^)]*)\)$/);
-  if (fnMatch) {
-    const fn = fnMatch[1];
-    const args = fnMatch[2].split(",").map((s) => s.trim()).join(",");
-    if (fn.startsWith("rgb")) {
-      if (/^\d{1,3},\d{1,3},\d{1,3}(,(0|1|0?\.\d+))?$/.test(args))
-        return true;
-    } else {
-      if (/^\d{1,3},\d{1,3}%,\d{1,3}%(,(0|1|0?\.\d+))?$/.test(args))
-        return true;
-    }
-  }
+  if (isValidCssColorFunction(trimmed))
+    return true;
   return false;
 }
 function sanitizeCssColor(color, fallback = "inherit") {
   return isValidCssColor(color) ? color : fallback;
 }
+// packages/render/src/escape/css-normalize.ts
 function normalizeCssValue(value) {
   let result = value;
-  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  result = stripCssComments(result);
   result = result.replace(/\\(?:\r\n|[\n\r\f])/g, "");
   result = result.replace(/\\([0-9a-f]{1,6})\s?/gi, (_, hex) => {
     const code = Number.parseInt(hex, 16);
     return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : "";
   });
   result = result.replace(/\\(.)/g, "$1");
-  result = result.replace(/[\s\u0000-\u001f\u007f-\u009f]/g, "");
+  result = stripControlAndWhitespace2(result);
   return result.toLowerCase();
 }
-function isUrlAllowed(rawUrl) {
+var WHITESPACE2 = /\s/;
+function stripCssComments(value) {
+  let result = "";
+  let cursor = 0;
+  while (cursor < value.length) {
+    const start = value.indexOf("/*", cursor);
+    if (start === -1) {
+      result += value.slice(cursor);
+      break;
+    }
+    result += value.slice(cursor, start);
+    const end = value.indexOf("*/", start + 2);
+    if (end === -1) {
+      break;
+    }
+    cursor = end + 2;
+  }
+  return result;
+}
+function stripControlAndWhitespace2(value) {
+  let result = "";
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (WHITESPACE2.test(char) || code <= 31 || code >= 127 && code <= 159) {
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+// packages/render/src/escape/css-urls.ts
+function isCssUrlAllowed(rawUrl) {
   let url = rawUrl;
   if (url.length >= 2) {
     const first = url[0];
@@ -335,7 +318,7 @@ function isUrlAllowed(rawUrl) {
   }
   return false;
 }
-function* iterateUrls(normalized) {
+function* iterateCssUrls(normalized) {
   let searchPos = 0;
   while (searchPos < normalized.length) {
     const idx = normalized.indexOf("url(", searchPos);
@@ -366,12 +349,14 @@ function* iterateUrls(normalized) {
     searchPos = i;
   }
 }
+
+// packages/render/src/escape/css-danger.ts
 function isDangerousCssValue(value) {
   const normalized = normalizeCssValue(value);
-  for (const { inner, malformed } of iterateUrls(normalized)) {
+  for (const { inner, malformed } of iterateCssUrls(normalized)) {
     if (malformed)
       return true;
-    if (!isUrlAllowed(inner))
+    if (!isCssUrlAllowed(inner))
       return true;
   }
   if (normalized.includes("expression("))
@@ -384,71 +369,164 @@ function isDangerousCssValue(value) {
     return true;
   return false;
 }
+// packages/render/src/escape/css-style.ts
+function sanitizeStyleValue(style) {
+  const endsWithSemicolon = style.trimEnd().endsWith(";");
+  if (style.indexOf(";") === -1) {
+    return sanitizeSingleDeclaration(style.trim());
+  }
+  const safe = [];
+  for (const rawDecl of splitDeclarations(style)) {
+    const decl = sanitizeSingleDeclaration(rawDecl.trim());
+    if (decl)
+      safe.push(decl);
+  }
+  if (safe.length === 0)
+    return "";
+  return endsWithSemicolon ? safe.join(";") + ";" : safe.join(";");
+}
+function sanitizeSingleDeclaration(decl) {
+  if (decl === "")
+    return "";
+  const colonIdx = decl.indexOf(":");
+  if (colonIdx === -1)
+    return "";
+  const property = decl.slice(0, colonIdx).trim();
+  const value = decl.slice(colonIdx + 1).trim();
+  if (isDangerousCssValue(value))
+    return "";
+  const normalisedProperty = normalizeCssValue(property);
+  if (normalisedProperty.startsWith("-moz-binding"))
+    return "";
+  if (normalisedProperty === "behavior")
+    return "";
+  return decl;
+}
 function splitDeclarations(style) {
   const out = [];
-  let buf = "";
+  let start = 0;
   let parenDepth = 0;
   let quoteChar = null;
-  for (const ch of style) {
+  for (let i = 0;i < style.length; i++) {
+    const ch = style[i];
     if (quoteChar !== null) {
-      buf += ch;
       if (ch === quoteChar)
         quoteChar = null;
       continue;
     }
     if (ch === '"' || ch === "'") {
       quoteChar = ch;
-      buf += ch;
       continue;
     }
     if (ch === "(") {
       parenDepth++;
-      buf += ch;
       continue;
     }
     if (ch === ")") {
       if (parenDepth > 0)
         parenDepth--;
-      buf += ch;
       continue;
     }
     if (ch === ";" && parenDepth === 0) {
-      out.push(buf);
-      buf = "";
+      out.push(style.slice(start, i));
+      start = i + 1;
       continue;
     }
-    buf += ch;
   }
-  if (buf.length > 0)
-    out.push(buf);
+  if (start < style.length)
+    out.push(style.slice(start));
   return out;
 }
-function sanitizeStyleValue(style) {
-  const endsWithSemicolon = style.trimEnd().endsWith(";");
-  const declarations = splitDeclarations(style).map((d) => d.trim()).filter(Boolean);
-  const safe = [];
-  for (const decl of declarations) {
-    const colonIdx = decl.indexOf(":");
-    if (colonIdx === -1)
-      continue;
-    const property = decl.slice(0, colonIdx).trim();
-    const value = decl.slice(colonIdx + 1).trim();
-    if (isDangerousCssValue(value))
-      continue;
-    const normalisedProperty = normalizeCssValue(property);
-    if (normalisedProperty.startsWith("-moz-binding"))
-      continue;
-    if (normalisedProperty === "behavior")
-      continue;
-    safe.push(decl);
-  }
-  if (safe.length === 0)
-    return "";
-  return endsWithSemicolon ? safe.join(";") + ";" : safe.join(";");
-}
+// packages/render/src/escape/email.ts
 function isValidEmail(email) {
   return /^[a-zA-Z0-9._+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email);
 }
+// packages/render/src/escape/attribute-allowlists.ts
+var SAFE_ATTRIBUTES = new Set([
+  "accept",
+  "align",
+  "alt",
+  "autocapitalize",
+  "autoplay",
+  "background",
+  "bgcolor",
+  "border",
+  "buffered",
+  "checked",
+  "cite",
+  "class",
+  "cols",
+  "colspan",
+  "contenteditable",
+  "controls",
+  "coords",
+  "datetime",
+  "decoding",
+  "default",
+  "dir",
+  "dirname",
+  "disabled",
+  "download",
+  "draggable",
+  "for",
+  "form",
+  "headers",
+  "height",
+  "hidden",
+  "high",
+  "href",
+  "hreflang",
+  "id",
+  "inputmode",
+  "ismap",
+  "itemprop",
+  "kind",
+  "label",
+  "lang",
+  "list",
+  "loop",
+  "low",
+  "max",
+  "maxlength",
+  "min",
+  "minlength",
+  "multiple",
+  "muted",
+  "name",
+  "optimum",
+  "pattern",
+  "placeholder",
+  "poster",
+  "preload",
+  "readonly",
+  "required",
+  "reversed",
+  "role",
+  "rows",
+  "rowspan",
+  "scope",
+  "selected",
+  "shape",
+  "size",
+  "sizes",
+  "span",
+  "spellcheck",
+  "src",
+  "srclang",
+  "srcset",
+  "start",
+  "step",
+  "style",
+  "tabindex",
+  "target",
+  "title",
+  "translate",
+  "type",
+  "usemap",
+  "value",
+  "width",
+  "wrap"
+]);
 var URL_ATTRIBUTES = new Set([
   "href",
   "src",
@@ -458,12 +536,22 @@ var URL_ATTRIBUTES = new Set([
   "poster",
   "background"
 ]);
+
+// packages/render/src/escape/attributes.ts
+function isSafeAttributeLower(lower) {
+  if (lower.startsWith("on"))
+    return false;
+  if (lower.startsWith("aria-") || lower.startsWith("data-"))
+    return true;
+  return SAFE_ATTRIBUTES.has(lower);
+}
 function sanitizeAttributes(attributes) {
   const result = {};
-  for (const [key, value] of Object.entries(attributes)) {
-    if (!isSafeAttribute(key))
-      continue;
+  for (const key in attributes) {
+    const value = attributes[key];
     const lower = key.toLowerCase();
+    if (!isSafeAttributeLower(lower))
+      continue;
     if (URL_ATTRIBUTES.has(lower) && isDangerousUrl(value))
       continue;
     if (lower === "style") {
@@ -477,1023 +565,734 @@ function sanitizeAttributes(attributes) {
   }
   return result;
 }
-
-// packages/render/src/context.ts
-class RenderContext {
-  chunks = [];
+// packages/render/src/context/attributes.ts
+function renderAttributeString(attributes) {
+  const safe = sanitizeAttributes(attributes);
+  let result = "";
+  for (const [key, value] of Object.entries(safe)) {
+    if (value !== "") {
+      result += ` ${key}="${escapeAttr(value)}"`;
+    } else {
+      result += ` ${key}=""`;
+    }
+  }
+  return result;
+}
+
+// packages/render/src/context/bibliography.ts
+class BibliographyIndex {
+  elements;
+  state = null;
+  constructor(elements) {
+    this.elements = elements;
+  }
+  getCitationNumber(label) {
+    return this.getState().map.get(label);
+  }
+  getState() {
+    if (this.state === null) {
+      this.state = collectBibliographyState(this.elements);
+    }
+    return this.state;
+  }
+}
+function collectBibliographyState(elements) {
+  const state = {
+    map: new Map
+  };
+  collectFromElements(elements, state);
+  return state;
+}
+function collectFromElements(elements, state) {
+  for (const element of elements) {
+    if (element.element === "bibliography-block") {
+      addBlockEntries(element.data, state);
+    }
+    collectFromChildren(element, state);
+  }
+}
+function addBlockEntries(data, state) {
+  for (const entry of data.entries) {
+    if (state.map.has(entry.key_string))
+      continue;
+    state.map.set(entry.key_string, state.map.size + 1);
+  }
+}
+function collectFromChildren(element, state) {
+  switch (element.element) {
+    case "list":
+      collectFromList(element.data, state);
+      return;
+    case "table":
+      collectFromTable(element.data, state);
+      return;
+    case "definition-list":
+      for (const item of element.data) {
+        collectFromElements(item.key, state);
+        collectFromElements(item.value, state);
+      }
+      return;
+    case "tab-view":
+      collectFromTabs(element.data, state);
+      return;
+    default:
+      break;
+  }
+  if (hasElementChildren(element)) {
+    collectFromElements(element.data.elements, state);
+  }
+}
+function collectFromList(data, state) {
+  for (const item of data.items) {
+    if (item["item-type"] === "elements") {
+      collectFromElements(item.elements, state);
+    } else {
+      collectFromList(item.data, state);
+    }
+  }
+}
+function collectFromTable(data, state) {
+  for (const row of data.rows) {
+    for (const cell of row.cells) {
+      collectFromElements(cell.elements, state);
+    }
+  }
+}
+function collectFromTabs(tabs, state) {
+  for (const tab of tabs) {
+    collectFromElements(tab.elements, state);
+  }
+}
+function hasElementChildren(element) {
+  if (!("data" in element))
+    return false;
+  const data = element.data;
+  return data !== null && typeof data === "object" && "elements" in data && Array.isArray(data.elements);
+}
+
+// packages/render/src/context/counters.ts
+class RenderCounters {
+  tocIndex = 0;
+  footnoteIndex = 0;
+  equationIndex = 0;
+  htmlBlockIndex = 0;
+  bibciteCounter = 0;
+  tabViewIndex = 0;
+  idSuffix;
+  constructor(useTrueIds) {
+    this.idSuffix = useTrueIds ? null : Math.random().toString(16).slice(2, 8);
+  }
+  nextTocIndex() {
+    return this.tocIndex++;
+  }
+  nextFootnoteIndex() {
+    return this.footnoteIndex++;
+  }
+  nextEquationIndex() {
+    return this.equationIndex++;
+  }
+  nextHtmlBlockIndex() {
+    return this.htmlBlockIndex++;
+  }
+  nextBibciteCounter() {
+    return ++this.bibciteCounter;
+  }
+  nextTabViewIndex() {
+    return this.tabViewIndex++;
+  }
+  generateId(prefix, index) {
+    if (this.idSuffix === null) {
+      return `${prefix}${index}`;
+    }
+    return `${prefix}${index}-${this.idSuffix}`;
+  }
+  generateFixedId(name) {
+    if (this.idSuffix === null) {
+      return name;
+    }
+    return `${name}-${this.idSuffix}`;
+  }
+}
+
+// packages/render/src/context/output.ts
+class RenderOutputBuffer {
+  chunks = [];
+  push(html) {
+    this.chunks.push(html);
+  }
+  pushEscaped(text) {
+    this.chunks.push(escapeHtml(text));
+  }
+  getOutput() {
+    return this.chunks.join("");
+  }
+}
+
+// packages/render/src/context/style-slots.ts
+class StyleSlotState {
+  activeSlotId = null;
+  contents = new Map;
+  enter(slotId) {
+    this.activeSlotId = slotId;
+    if (!this.contents.has(slotId)) {
+      this.contents.set(slotId, []);
+    }
+  }
+  exit() {
+    this.activeSlotId = null;
+  }
+  hasActiveSlot() {
+    return this.activeSlotId !== null;
+  }
+  push(css) {
+    if (this.activeSlotId !== null) {
+      this.contents.get(this.activeSlotId).push(css);
+    }
+  }
+  getContents(slotId) {
+    return this.contents.get(slotId) ?? [];
+  }
+}
+
+// packages/render/src/context/image-urls.ts
+function resolveImageSource(source, settings, page) {
+  const pageName = page?.pageName;
+  switch (source.type) {
+    case "url": {
+      const url = source.data;
+      if (url.startsWith("/") && !url.startsWith("//")) {
+        if (!settings.allowLocalPaths)
+          return null;
+        return `/local--files${url}`;
+      }
+      return url;
+    }
+    case "file1":
+      if (!settings.allowLocalPaths)
+        return null;
+      return pageName ? `/local--files/${pageName}/${source.data.file}` : `/local--files/${source.data.file}`;
+    case "file2":
+      if (!settings.allowLocalPaths)
+        return null;
+      return `/local--files/${source.data.page}/${source.data.file}`;
+    case "file3":
+      if (!settings.allowLocalPaths)
+        return null;
+      return `/local--files/${source.data.site}/${source.data.page}/${source.data.file}`;
+  }
+}
+// packages/render/src/context/page-urls.ts
+function resolvePageLink(location, pageContext) {
+  if (typeof location === "string") {
+    return location;
+  }
+  const page = location.page;
+  if (page.startsWith("//")) {
+    return page.toLowerCase();
+  }
+  const hashIdx = page.indexOf("#");
+  if (hashIdx !== -1) {
+    let pagePart = page.slice(0, hashIdx);
+    const anchor = page.slice(hashIdx);
+    if (pagePart.endsWith("/")) {
+      pagePart = pagePart.slice(0, -1);
+    }
+    return `/${pagePart.toLowerCase()}${anchor.toLowerCase()}`;
+  }
+  const normalizedPage = normalizePageName(page);
+  const safePage = normalizedPage.startsWith("/") ? normalizedPage.slice(1) : normalizedPage;
+  if (location.site) {
+    const domain = resolveSiteDomain(location.site, pageContext);
+    if (domain !== null) {
+      return `https://${domain}/${safePage}`;
+    }
+    return `/${normalizePageName(location.site)}/${safePage}`;
+  }
+  return `/${safePage}`;
+}
+function resolveSiteDomain(site, pageContext) {
+  const configuredDomain = pageContext?.resolveSiteDomain?.(site) ?? pageContext?.siteDomains?.[site] ?? (pageContext?.site === site ? pageContext.domain : undefined);
+  if (configuredDomain)
+    return normalizeDomain(configuredDomain);
+  if (site.includes(".")) {
+    return normalizeDomain(site);
+  }
+  return null;
+}
+function normalizeDomain(domain) {
+  let normalized = domain;
+  const lower = normalized.toLowerCase();
+  if (lower.startsWith("https://")) {
+    normalized = normalized.slice("https://".length);
+  } else if (lower.startsWith("http://")) {
+    normalized = normalized.slice("http://".length);
+  }
+  let end = normalized.length;
+  while (end > 0 && normalized[end - 1] === "/") {
+    end--;
+  }
+  return end === normalized.length ? normalized : normalized.slice(0, end);
+}
+function normalizePageName(page) {
+  let normalized = page.toLowerCase();
+  if (normalized.indexOf(":") !== -1) {
+    normalized = normalized.replace(/:\s+/g, ":");
+  }
+  if (/\s/.test(normalized)) {
+    normalized = normalized.replace(/\s+/g, "-").trim();
+  }
+  if (!normalized.startsWith("/") && normalized.indexOf("/") !== -1) {
+    normalized = normalized.replace(/\//g, "-");
+  }
+  return normalized;
+}
+// packages/render/src/context/index.ts
+class RenderContext {
+  output = new RenderOutputBuffer;
   renderInlineStyles = false;
-  _styleSlotId = null;
-  _styleSlotContents = new Map;
-  _tocIndex = 0;
-  _footnoteIndex = 0;
-  _equationIndex = 0;
-  _htmlBlockIndex = 0;
-  _bibciteCounter = 0;
-  _idSuffix;
+  _styleSlots = new StyleSlotState;
+  counters;
   settings;
   options;
   footnotes;
   styles;
   htmlBlocks;
   tocElements;
-  bibliographyMap;
-  bibliographyEntries;
+  bibliography;
   constructor(tree, options = {}) {
     this.settings = options.settings ?? DEFAULT_SETTINGS;
-    this._idSuffix = this.settings.useTrueIds ? null : Math.random().toString(16).slice(2, 8);
+    this.counters = new RenderCounters(this.settings.useTrueIds);
     this.options = options;
     this.footnotes = options.footnotes ?? tree.footnotes ?? [];
     this.styles = tree.styles ?? [];
     this.htmlBlocks = tree["html-blocks"] ?? [];
     this.tocElements = tree["table-of-contents"] ?? [];
-    this.bibliographyMap = new Map;
-    this.bibliographyEntries = [];
-    this.buildBibliographyMap(tree.elements);
-  }
-  buildBibliographyMap(elements) {
-    for (const el of elements) {
-      if (el.element === "bibliography-block") {
-        const data = el.data;
-        for (const entry of data.entries) {
-          if (!this.bibliographyMap.has(entry.key_string)) {
-            const index = this.bibliographyMap.size + 1;
-            this.bibliographyMap.set(entry.key_string, index);
-            this.bibliographyEntries.push(entry);
-          }
-        }
-      }
-      if ("data" in el && el.data && typeof el.data === "object") {
-        const data = el.data;
-        if ("elements" in data && Array.isArray(data.elements)) {
-          this.buildBibliographyMap(data.elements);
-        }
-      }
-    }
+    this.bibliography = new BibliographyIndex(tree.elements);
+  }
+  getBibliographyCitationNumber(label) {
+    return this.bibliography.getCitationNumber(label);
   }
   push(html) {
-    this.chunks.push(html);
+    this.output.push(html);
   }
   pushEscaped(text) {
-    this.chunks.push(escapeHtml(text));
+    this.output.pushEscaped(text);
   }
   getOutput() {
-    return this.chunks.join("");
+    return this.output.getOutput();
   }
   enterStyleSlot(slotId) {
-    this._styleSlotId = slotId;
-    if (!this._styleSlotContents.has(slotId)) {
-      this._styleSlotContents.set(slotId, []);
-    }
+    this._styleSlots.enter(slotId);
   }
   exitStyleSlot() {
-    this._styleSlotId = null;
+    this._styleSlots.exit();
   }
   hasActiveStyleSlot() {
-    return this._styleSlotId !== null;
+    return this._styleSlots.hasActiveSlot();
   }
   pushToStyleSlot(css) {
-    if (this._styleSlotId !== null) {
-      this._styleSlotContents.get(this._styleSlotId).push(css);
-    }
+    this._styleSlots.push(css);
   }
   getStyleSlotContents(slotId) {
-    return this._styleSlotContents.get(slotId) ?? [];
+    return this._styleSlots.getContents(slotId);
   }
   nextTocIndex() {
-    return this._tocIndex++;
+    return this.counters.nextTocIndex();
   }
   nextFootnoteIndex() {
-    return this._footnoteIndex++;
+    return this.counters.nextFootnoteIndex();
   }
   nextEquationIndex() {
-    return this._equationIndex++;
+    return this.counters.nextEquationIndex();
   }
   nextHtmlBlockIndex() {
-    return this._htmlBlockIndex++;
+    return this.counters.nextHtmlBlockIndex();
   }
   nextBibciteCounter() {
-    return ++this._bibciteCounter;
+    return this.counters.nextBibciteCounter();
+  }
+  nextTabViewIndex() {
+    return this.counters.nextTabViewIndex();
   }
   generateId(prefix, index) {
-    if (this._idSuffix === null) {
-      return `${prefix}${index}`;
-    }
-    return `${prefix}${index}-${this._idSuffix}`;
+    return this.counters.generateId(prefix, index);
   }
   generateFixedId(name) {
-    if (this._idSuffix === null) {
-      return name;
-    }
-    return `${name}-${this._idSuffix}`;
+    return this.counters.generateFixedId(name);
   }
   get page() {
     return this.options.page;
   }
   resolveImageSource(source) {
-    const pageName = this.page?.pageName;
-    switch (source.type) {
-      case "url": {
-        const url = source.data;
-        if (url.startsWith("/") && !url.startsWith("//")) {
-          if (!this.settings.allowLocalPaths)
-            return null;
-          return `/local--files${url}`;
-        }
-        return url;
-      }
-      case "file1":
-        if (!this.settings.allowLocalPaths)
-          return null;
-        return pageName ? `/local--files/${pageName}/${source.data.file}` : `/local--files/${source.data.file}`;
-      case "file2":
-        if (!this.settings.allowLocalPaths)
-          return null;
-        return `/local--files/${source.data.page}/${source.data.file}`;
-      case "file3":
-        if (!this.settings.allowLocalPaths)
-          return null;
-        return `/local--files/${source.data.site}/${source.data.page}/${source.data.file}`;
-    }
+    return resolveImageSource(source, this.settings, this.page);
   }
   resolvePageLink(location) {
-    if (typeof location === "string") {
-      return location;
-    }
-    const page = location.page;
-    if (page.startsWith("//")) {
-      return page.toLowerCase();
-    }
-    const hashIdx = page.indexOf("#");
-    if (hashIdx !== -1) {
-      let pagePart = page.slice(0, hashIdx);
-      const anchor = page.slice(hashIdx);
-      if (pagePart.endsWith("/")) {
-        pagePart = pagePart.slice(0, -1);
-      }
-      return `/${pagePart.toLowerCase()}${anchor.toLowerCase()}`;
-    }
-    const normalizedPage = this.normalizePageName(page);
-    const safePage = normalizedPage.startsWith("/") ? normalizedPage.slice(1) : normalizedPage;
-    if (location.site) {
-      return `https://${location.site}.wikidot.com/${safePage}`;
-    }
-    return `/${safePage}`;
-  }
-  normalizePageName(page) {
-    let normalized = page.toLowerCase();
-    normalized = normalized.replace(/:\s+/g, ":");
-    normalized = normalized.replace(/\s+/g, "-").trim();
-    if (!normalized.startsWith("/")) {
-      normalized = normalized.replace(/\//g, "-");
-    }
-    return normalized;
+    return resolvePageLink(location, this.page);
   }
   renderAttributes(attributes) {
-    const safe = sanitizeAttributes(attributes);
-    let result = "";
-    for (const [key, value] of Object.entries(safe)) {
-      if (value !== "") {
-        result += ` ${key}="${escapeAttr(value)}"`;
-      } else {
-        result += ` ${key}=""`;
-      }
+    return renderAttributeString(attributes);
+  }
+}
+
+// packages/render/src/render/collected-styles.ts
+import { STYLE_SLOT_PREFIX } from "@wdprlib/ast";
+
+// packages/render/src/render/style-tag.ts
+function pushStyleTag(ctx, css) {
+  ctx.push(`<style>${escapeStyleContent(css)}</style>`);
+}
+
+// packages/render/src/render/collected-styles.ts
+function renderCollectedStyles(ctx, styles) {
+  if (!ctx.settings.allowStyleElements || !styles?.length)
+    return;
+  for (const style of styles) {
+    if (style.startsWith(STYLE_SLOT_PREFIX)) {
+      renderStyleSlot(ctx, style);
+    } else {
+      pushStyleTag(ctx, style);
     }
-    return result;
+  }
+}
+function renderStyleSlot(ctx, marker) {
+  const slotId = parseInt(marker.slice(STYLE_SLOT_PREFIX.length), 10);
+  for (const css of ctx.getStyleSlotContents(slotId)) {
+    pushStyleTag(ctx, css);
   }
 }
 
-// packages/render/src/elements/container.ts
-import { isStringContainerType, isHeaderType, isAlignType } from "@wdprlib/ast";
-function renderContainer(ctx, data) {
-  const { type, attributes, elements } = data;
-  if (isHeaderType(type)) {
-    renderHeader(ctx, type.header.level, type.header["has-toc"], attributes, elements);
+// packages/render/src/elements/bibliography/ids.ts
+function generateBibliographyIdSuffix(label, counter) {
+  let h = 2166136261;
+  const input = label + counter;
+  for (let i = 0;i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).slice(0, 6);
+}
+
+// packages/render/src/elements/bibliography/cite.ts
+function renderBibliographyCite(ctx, data) {
+  const number = ctx.getBibliographyCitationNumber(data.label);
+  const counter = ctx.nextBibciteCounter();
+  if (number === undefined) {
+    ctx.push(escapeHtml(data.label));
     return;
   }
-  if (isAlignType(type)) {
-    ctx.push(`<div style="text-align: ${type.align};">`);
-    renderElements(ctx, elements);
-    ctx.push("</div>");
+  const idSuffix = generateBibliographyIdSuffix(data.label, counter);
+  const id = ctx.generateId(`bibcite-${number}-`, idSuffix);
+  const bibitemId = ctx.generateId("bibitem-", number);
+  const onclick = `WIKIDOT.page.utils.scrollToReference('${bibitemId}')`;
+  ctx.push(`<a href="javascript:;" class="bibcite" id="${id}" onclick="${escapeAttr(onclick)}">`);
+  ctx.push(String(number));
+  ctx.push("</a>");
+}
+// packages/render/src/elements/bibliography/block.ts
+function renderBibliographyBlock(ctx, data, renderElements) {
+  if (data.hide)
     return;
+  const title = data.title ?? "Bibliography";
+  ctx.push(`<div class="bibitems">`);
+  ctx.push(`<div class="title">${escapeHtml(title)}</div>`);
+  let index = 1;
+  for (const entry of data.entries) {
+    const itemId = ctx.generateId("bibitem-", index);
+    ctx.push(`<div class="bibitem" id="${itemId}">`);
+    ctx.push(`${index}. `);
+    renderElements(ctx, entry.value);
+    ctx.push("</div>");
+    index++;
   }
-  if (isStringContainerType(type)) {
-    renderStringContainer(ctx, type, attributes, elements);
+  ctx.push("</div>");
+}
+// packages/render/src/elements/clear-float.ts
+function renderClearFloat(ctx, direction) {
+  ctx.push(`<div style="clear:${direction}; height: 0px; font-size: 1px"></div>`);
+}
+
+// packages/render/src/libs/highlighter/engine/html.ts
+function escapeHighlightHtml(str) {
+  if (str.indexOf("&") === -1 && str.indexOf("<") === -1 && str.indexOf(">") === -1 && str.indexOf('"') === -1) {
+    return str;
   }
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function renderHeader(ctx, level, hasToc, attributes, elements) {
-  const tag = `h${level}`;
-  if (hasToc) {
-    const tocId = ctx.generateId("toc", ctx.nextTocIndex());
-    ctx.push(`<${tag} id="${tocId}"${renderAttrs(attributes)}>`);
-  } else {
-    ctx.push(`<${tag}${renderAttrs(attributes)}>`);
+
+// packages/render/src/libs/highlighter/engine/render.ts
+function renderTokens(tokens) {
+  if (tokens.length === 0)
+    return "";
+  let html = "";
+  let lastClass = "";
+  for (const token of tokens) {
+    if (token.content.length === 0)
+      continue;
+    const escaped = escapeHighlightHtml(token.content);
+    if (token.class !== lastClass) {
+      if (lastClass) {
+        html += "</span>";
+      }
+      html += `<span class="hl-${token.class}">`;
+      lastClass = token.class;
+    }
+    html += escaped;
   }
-  ctx.push("<span>");
-  renderElements(ctx, elements);
-  ctx.push("</span>");
-  ctx.push(`</${tag}>`);
+  if (lastClass) {
+    html += "</span>";
+  }
+  return `<div class="hl-main"><pre>${html}</pre></div>`;
 }
-function renderStringContainer(ctx, type, attributes, elements) {
-  switch (type) {
-    case "paragraph":
-      ctx.push(`<p${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</p>");
-      break;
-    case "bold":
-      ctx.push(`<strong${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</strong>");
-      break;
-    case "italics":
-      ctx.push(`<em${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</em>");
+// packages/render/src/libs/highlighter/engine/utils.ts
+function findGroupPosition(str, match, groupIndex, matchStart) {
+  const groupStr = match[groupIndex];
+  const idx = str.indexOf(groupStr, matchStart);
+  return idx >= 0 ? idx : matchStart;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchingBrackets(str) {
+  return str.replace(/[()<>[\]{}]/g, (char) => MATCHING_BRACKETS[char] ?? char);
+}
+var MATCHING_BRACKETS = {
+  "(": ")",
+  ")": "(",
+  "<": ">",
+  ">": "<",
+  "[": "]",
+  "]": "[",
+  "{": "}",
+  "}": "{"
+};
+
+// packages/render/src/libs/highlighter/engine/end-pattern.ts
+function buildEndPattern(def, prevState, patternIndex, count, captureIndex, match, endRe) {
+  if (!def.subst[prevState]?.[patternIndex] || !endRe) {
+    return endRe ?? null;
+  }
+  let epSource = endRe.source;
+  for (let k = 0;k <= count; k++) {
+    const subIdx = captureIndex + k;
+    if (subIdx >= match.length || match[subIdx] == null)
       break;
-    case "underline":
-      ctx.push(`<span style="text-decoration: underline;"${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</span>");
-      break;
-    case "strikethrough":
-      ctx.push(`<span style="text-decoration: line-through;"${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</span>");
-      break;
-    case "superscript":
-      ctx.push(`<sup${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</sup>");
-      break;
-    case "subscript":
-      ctx.push(`<sub${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</sub>");
-      break;
-    case "monospace":
-      ctx.push(`<tt${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</tt>");
-      break;
-    case "span":
-      ctx.push(`<span${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</span>");
-      break;
-    case "div":
-      if (elements.length === 0 && Object.keys(attributes).length === 0) {
-        break;
-      }
-      ctx.push(`<div${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</div>");
-      break;
-    case "blockquote":
-      ctx.push(`<blockquote${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</blockquote>");
-      break;
-    case "mark":
-      ctx.push(`<mark${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</mark>");
-      break;
-    case "insertion":
-      ctx.push(`<ins${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</ins>");
-      break;
-    case "deletion":
-      ctx.push(`<del${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</del>");
-      break;
-    case "size":
-      renderSizeContainer(ctx, attributes, elements);
-      break;
-    case "hidden":
-      ctx.push(`<span style="display: none"${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</span>");
-      break;
-    case "invisible":
-      ctx.push(`<span style="visibility: hidden"${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</span>");
-      break;
-    case "ruby":
-      ctx.push(`<ruby${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</ruby>");
-      break;
-    case "ruby-text":
-      ctx.push(`<rt${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</rt>");
-      break;
-    case "heading":
-      renderElements(ctx, elements);
-      break;
-    case "collapsible":
-      renderElements(ctx, elements);
-      break;
-    case "definition-list":
-      ctx.push("<dl>");
-      renderElements(ctx, elements);
-      ctx.push("</dl>");
-      break;
-    case "definition-list-item":
-      renderElements(ctx, elements);
-      break;
-    case "definition-list-key":
-      ctx.push("<dt>");
-      renderElements(ctx, elements);
-      ctx.push("</dt>");
-      break;
-    case "definition-list-value":
-      ctx.push("<dd>");
-      renderElements(ctx, elements);
-      ctx.push("</dd>");
-      break;
-    case "table-row":
-      ctx.push(`<tr${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</tr>");
-      break;
-    case "table-cell":
-      ctx.push(`<td${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</td>");
-      break;
-    default:
-      renderElements(ctx, elements);
+    const quoted = escapeRegex(match[subIdx]);
+    epSource = epSource.replace(`%${k}%`, quoted);
+    epSource = epSource.replace(`%b${k}%`, matchingBrackets(quoted));
   }
+  return new RegExp(epSource, endRe.flags);
 }
-function renderSizeContainer(ctx, attributes, elements) {
-  const style = attributes.style ?? "";
-  const existingAttrs = { ...attributes };
-  if (!style.includes("font-size")) {
-    ctx.push(`<span${renderAttrs(existingAttrs)}>`);
-  } else {
-    ctx.push(`<span${renderAttrs(existingAttrs)}>`);
+
+// packages/render/src/libs/highlighter/engine/keywords.ts
+function resolveKeywordClass(def, state, patternIndex, matchStr, fallback) {
+  let kwDef = def.keywords[state]?.[patternIndex];
+  if (!kwDef || kwDef === -1 || typeof kwDef !== "object" || Object.keys(kwDef).length === 0) {
+    kwDef = def.keywords[-1]?.[patternIndex];
+  }
+  if (kwDef && kwDef !== -1 && typeof kwDef === "object") {
+    for (const [group, re] of Object.entries(kwDef)) {
+      if (re.test(matchStr)) {
+        return def.kwmap[group] ?? fallback;
+      }
+    }
   }
-  renderElements(ctx, elements);
-  ctx.push("</span>");
+  return fallback;
 }
-function renderAttrs(attributes) {
-  const safe = sanitizeAttributes(attributes);
-  let result = "";
-  for (const [key, value] of Object.entries(safe)) {
-    if (key.startsWith("_"))
+
+// packages/render/src/libs/highlighter/engine/parts.ts
+function buildPartTokens(str, match, partDef, captureIndex, count, groupStart, matchStr, inner) {
+  const parts = [];
+  let partpos = groupStart;
+  for (let j = 1;j <= count; j++) {
+    const subIdx = j + captureIndex;
+    if (subIdx >= match.length || match[subIdx] == null || match[subIdx] === "")
       continue;
-    if (value !== "") {
-      result += ` ${key}="${escapeAttr(value)}"`;
-    } else {
-      result += ` ${key}=""`;
+    const subStr = match[subIdx];
+    const subStart = str.indexOf(subStr, partpos);
+    if (subStart < 0)
+      continue;
+    if (partDef[j]) {
+      if (subStart > partpos) {
+        parts.unshift({ class: inner, content: str.substring(partpos, subStart) });
+      }
+      parts.unshift({ class: partDef[j], content: subStr });
     }
+    partpos = subStart + subStr.length;
   }
-  return result;
+  if (partpos < groupStart + matchStr.length) {
+    parts.unshift({
+      class: inner,
+      content: str.substring(partpos, groupStart + matchStr.length)
+    });
+  }
+  return parts;
 }
 
-// packages/render/src/elements/text.ts
-function renderText(ctx, data) {
-  ctx.pushEscaped(data);
-}
-function renderRaw(ctx, data) {
-  if (data === "")
-    return;
-  ctx.push(`<span style="white-space: pre-wrap;">`);
-  ctx.push(escapeHtml(data).replace(/ /g, "&#32;"));
-  ctx.push("</span>");
-}
-function renderEmail(ctx, email) {
-  if (!isValidEmail(email)) {
-    ctx.pushEscaped(email);
-    return;
-  }
-  ctx.push(`<a href="mailto:${escapeAttr(email)}">${escapeHtml(email)}</a>`);
+// packages/render/src/libs/highlighter/engine/preprocess.ts
+function preprocessHighlightInput(input) {
+  return input.replace(/\r\n/g, `
+`).replace(/^$/gm, " ").replace(/\t/g, "    ").replace(/\s+$/, "");
 }
 
-// packages/render/src/elements/link.ts
-function renderLink(ctx, data) {
-  let href = ctx.resolvePageLink(data.link);
-  if (data.extra) {
-    href += data.extra;
-  }
-  const isAnchorJsVoid = data.type === "anchor" && href === "javascript:;";
-  if (!isAnchorJsVoid && isDangerousUrl(href)) {
-    href = "#invalid-url";
-  }
-  const attrs = [`href="${escapeAttr(href)}"`];
-  if (data.type === "page" && typeof data.link === "object") {
-    const page = data.link.page;
-    const isSpecialPage = page.startsWith("//") || page.includes("#/");
-    if (!isSpecialPage) {
-      const hashIdx = page.indexOf("#");
-      const pageToCheck = hashIdx !== -1 ? page.slice(0, hashIdx) : page;
-      const pageExists = ctx.page?.pageExists;
-      const exists = pageExists ? pageExists(pageToCheck) : false;
-      if (!exists) {
-        attrs.push(`class="newpage"`);
-      }
+// packages/render/src/libs/highlighter/engine/tokenizer.ts
+function tokenize(def, input) {
+  const str = preprocessHighlightInput(input);
+  const len = str.length;
+  if (len === 0)
+    return [];
+  let state = -1;
+  let pos = 0;
+  let lastinner = def.defClass;
+  let lastdelim = def.defClass;
+  let endpattern = null;
+  const stateStack = [];
+  const tokenStack = [];
+  const result = [];
+  function getToken() {
+    if (tokenStack.length > 0) {
+      return tokenStack.pop();
     }
-  }
-  if (data.target) {
-    const targetMap = {
-      "new-tab": "_blank",
-      parent: "_parent",
-      top: "_top",
-      same: "_self"
-    };
-    const targetValue = targetMap[data.target] ?? "_blank";
-    attrs.push(`target="${targetValue}"`);
-    if (targetValue === "_blank") {
-      attrs.push(`rel="noopener noreferrer"`);
+    if (pos >= len) {
+      return null;
     }
-  }
-  ctx.push(`<a ${attrs.join(" ")}>`);
-  renderLinkLabel(ctx, data);
-  ctx.push("</a>");
-}
-function renderLinkLabel(ctx, data) {
-  if (data.label === "page") {
-    if (typeof data.link === "string") {
-      ctx.pushEscaped(data.link);
-    } else {
-      ctx.pushEscaped(data.link.page);
+    const endStateMatch = findEndStateMatch(str, pos, state, endpattern);
+    const token2 = matchStateToken({
+      def,
+      str,
+      pos,
+      state,
+      lastinner,
+      lastdelim,
+      endpattern,
+      stateStack,
+      tokenStack,
+      endStateMatch,
+      setPosition: (nextPos) => {
+        pos = nextPos;
+      },
+      setState: (next) => {
+        state = next.state;
+        lastinner = next.lastinner;
+        lastdelim = next.lastdelim;
+        endpattern = next.endpattern;
+      }
+    });
+    if (token2) {
+      return token2;
     }
-    return;
-  }
-  if ("text" in data.label) {
-    ctx.pushEscaped(data.label.text);
-    return;
+    if (endStateMatch.endpos > -1) {
+      tokenStack.push({ class: lastdelim, content: endStateMatch.endmatch });
+      if (endStateMatch.endpos > pos) {
+        tokenStack.push({ class: lastinner, content: str.substring(pos, endStateMatch.endpos) });
+      }
+      const prev = stateStack.pop();
+      state = prev.state;
+      lastdelim = prev.lastdelim;
+      lastinner = prev.lastinner;
+      endpattern = prev.endpattern;
+      pos = endStateMatch.endpos + endStateMatch.endmatch.length;
+      if (tokenStack.length > 0) {
+        return tokenStack.pop();
+      }
+      return getToken();
+    }
+    const p = pos;
+    pos = len;
+    return { class: lastinner, content: str.substring(p) };
   }
-  if ("url" in data.label) {
-    const href = ctx.resolvePageLink(data.link);
-    ctx.pushEscaped(data.label.url ?? href);
+  let token;
+  while ((token = getToken()) !== null) {
+    result.push(token);
   }
+  return result;
 }
-function renderAnchor(ctx, data) {
-  const safe = sanitizeAttributes(data.attributes);
-  const attrs = [];
-  if (safe.href && isDangerousUrl(safe.href)) {
-    safe.href = "#invalid-url";
+function findEndStateMatch(str, pos, state, endpattern) {
+  if (state === -1 || !endpattern) {
+    return { endpos: -1, endmatch: "" };
   }
-  const href = safe.href ?? "";
-  attrs.push(`href="${escapeAttr(href)}"`);
-  if (data.target) {
-    const targetMap = {
-      "new-tab": "_blank",
-      parent: "_parent",
-      top: "_top",
-      same: "_self"
-    };
-    const targetValue = targetMap[data.target] ?? "_blank";
-    attrs.push(`target="${targetValue}"`);
-    if (targetValue === "_blank") {
-      attrs.push(`rel="noopener noreferrer"`);
+  endpattern.lastIndex = pos;
+  const match = endpattern.exec(str);
+  return match ? { endpos: match.index, endmatch: match[0] } : { endpos: -1, endmatch: "" };
+}
+function matchStateToken(args) {
+  const reg = args.def.regs[args.state];
+  if (!reg)
+    return null;
+  reg.lastIndex = args.pos;
+  const match = reg.exec(args.str);
+  if (!match)
+    return null;
+  const countsArr = args.def.counts[args.state];
+  let captureIndex = 1;
+  for (let patternIndex = 0;patternIndex < countsArr.length; patternIndex++) {
+    const count = countsArr[patternIndex];
+    if (captureIndex >= match.length)
+      break;
+    if (match[captureIndex] != null && (args.endStateMatch.endpos === -1 || match.index < args.endStateMatch.endpos)) {
+      return emitMatchedPattern(args, match, patternIndex, captureIndex, count);
     }
+    captureIndex += count + 1;
   }
-  for (const [key, value] of Object.entries(safe)) {
-    if (key === "href" || key === "target")
-      continue;
-    attrs.push(`${key}="${escapeAttr(value)}"`);
-  }
-  ctx.push(`<a ${attrs.join(" ")}>`);
-  renderElements(ctx, data.elements);
-  ctx.push("</a>");
-}
-function renderAnchorName(ctx, name) {
-  ctx.push(`<a name="${escapeAttr(name)}"></a>`);
+  return null;
 }
-
-// packages/render/src/elements/image.ts
-function renderImage(ctx, data) {
-  let src = ctx.resolveImageSource(data.source);
-  if (src === null)
-    return;
-  if (isDangerousUrl(src)) {
-    src = "#invalid-url";
-  }
-  const safeAttrs = sanitizeAttributes(data.attributes);
-  const alt = safeAttrs.alt ?? getFilenameFromSource(data.source);
-  const className = safeAttrs.class ?? "image";
-  const imgAttrs = [`src="${escapeAttr(src)}"`];
-  for (const [key, value] of Object.entries(safeAttrs)) {
-    if (key === "alt" || key === "class" || key === "src" || key === "srcset")
-      continue;
-    imgAttrs.push(`${key}="${escapeAttr(value)}"`);
-  }
-  imgAttrs.push(`alt="${escapeAttr(alt)}"`);
-  if (!safeAttrs.class) {
-    imgAttrs.push(`class="${escapeAttr(className)}"`);
+function emitMatchedPattern(args, match, patternIndex, captureIndex, count) {
+  const statesArr = args.def.states[args.state];
+  const delimArr = args.def.delim[args.state];
+  const matchStart = match.index;
+  const matchStr = match[captureIndex];
+  const groupStart = findGroupPosition(args.str, match, captureIndex, matchStart);
+  if (statesArr[patternIndex] !== -1) {
+    args.tokenStack.push({ class: delimArr[patternIndex], content: matchStr });
   } else {
-    imgAttrs.push(`class="${escapeAttr(safeAttrs.class)}"`);
+    pushNonTransitionTokens(args, match, patternIndex, captureIndex, count, groupStart, matchStr);
   }
-  const imgTag = `<img ${imgAttrs.join(" ")} />`;
-  let output = imgTag;
-  if (data.link) {
-    let href;
-    if (typeof data.link === "string") {
-      if (!data.link.startsWith("/") && !data.link.startsWith("#") && !data.link.startsWith("http://") && !data.link.startsWith("https://")) {
-        href = `/${data.link}`;
-      } else {
-        href = data.link;
-      }
-    } else {
-      href = `/${data.link.page}`;
-    }
-    if (isDangerousUrl(href)) {
-      href = "#invalid-url";
-    }
-    output = `<a href="${escapeAttr(href)}">${imgTag}</a>`;
+  if (groupStart > args.pos) {
+    args.tokenStack.push({
+      class: args.lastinner,
+      content: args.str.substring(args.pos, groupStart)
+    });
   }
-  if (data.alignment) {
-    const alignClass = getAlignmentClass(data.alignment.align, data.alignment.float);
-    ctx.push(`<div class="image-container ${alignClass}">`);
-    ctx.push(output);
-    ctx.push("</div>");
-  } else {
-    ctx.push(output);
+  args.setPosition(groupStart + matchStr.length);
+  if (statesArr[patternIndex] !== -1) {
+    enterState(args, match, patternIndex, captureIndex, count);
   }
+  return args.tokenStack.pop();
 }
-function getAlignmentClass(align, isFloat) {
-  if (isFloat) {
-    switch (align) {
-      case "left":
-        return "floatleft";
-      case "right":
-        return "floatright";
-      case "center":
-        return "floatcenter";
-      default:
-        return `float${align}`;
-    }
-  }
-  switch (align) {
-    case "left":
-      return "alignleft";
-    case "right":
-      return "alignright";
-    case "center":
-      return "aligncenter";
-    default:
-      return `align${align}`;
+function pushNonTransitionTokens(args, match, patternIndex, captureIndex, count, groupStart, matchStr) {
+  let inner = args.def.inner[args.state][patternIndex];
+  const partDef = args.def.parts[args.state]?.[patternIndex];
+  if (partDef) {
+    pushPartTokens(args, match, partDef, captureIndex, count, groupStart, matchStr, inner);
+    return;
   }
+  inner = resolveKeywordClass(args.def, args.state, patternIndex, matchStr, inner);
+  args.tokenStack.push({ class: inner, content: matchStr });
 }
-function getFilenameFromSource(source) {
-  switch (source.type) {
-    case "url": {
-      const parts = source.data.split("/");
-      return parts[parts.length - 1] ?? source.data;
-    }
-    case "file1":
-      return source.data.file;
-    case "file2":
-      return source.data.file;
-    case "file3":
-      return source.data.file;
-  }
+function pushPartTokens(args, match, partDef, captureIndex, count, groupStart, matchStr, inner) {
+  const parts = [];
+  parts.push(...buildPartTokens(args.str, match, partDef, captureIndex, count, groupStart, matchStr, inner));
+  args.tokenStack.push(...parts);
 }
-
-// packages/render/src/elements/list.ts
-function trimTextElements(elements) {
-  if (elements.length === 0)
-    return elements;
-  let start = 0;
-  let end = elements.length;
-  while (start < end) {
-    const el = elements[start];
-    if (el.element === "text" && typeof el.data === "string" && el.data.trim() === "") {
-      start++;
-    } else {
-      break;
-    }
-  }
-  while (end > start) {
-    const el = elements[end - 1];
-    if (el.element === "text" && typeof el.data === "string" && el.data.trim() === "") {
-      end--;
-    } else {
-      break;
-    }
-  }
-  return elements.slice(start, end);
-}
-function isLiCloseTextParagraph(el) {
-  if (el.element !== "container")
-    return false;
-  const data = el.data;
-  if (data.type !== "paragraph")
-    return false;
-  const texts = data.elements.filter((e) => e.element === "text").map((e) => e.data);
-  const combined = texts.join("").trim();
-  return combined === "[[/li]]";
-}
-function renderNoMarkerElements(ctx, elements) {
-  const trimmed = trimTextElements(elements);
-  if (trimmed.length === 0)
-    return;
-  const paragraphIndices = [];
-  for (let i = 0;i < trimmed.length; i++) {
-    const el = trimmed[i];
-    if (el.element === "container" && el.data.type === "paragraph") {
-      paragraphIndices.push(i);
-    }
-  }
-  if (paragraphIndices.length === 0) {
-    renderElements(ctx, trimmed);
-    return;
-  }
-  const firstParagraphIdx = paragraphIndices[0];
-  const lastParagraphIdx = paragraphIndices[paragraphIndices.length - 1];
-  for (let i = 0;i < trimmed.length; i++) {
-    const el = trimmed[i];
-    if (el.element === "container" && el.data.type === "paragraph") {
-      const data = el.data;
-      if (i === firstParagraphIdx) {
-        renderElements(ctx, data.elements);
-      } else if (i === lastParagraphIdx && isLiCloseTextParagraph(el)) {
-        renderElements(ctx, data.elements);
-      } else {
-        ctx.push("<p>");
-        renderElements(ctx, data.elements);
-        ctx.push("</p>");
-      }
-    } else {
-      renderElement(ctx, el);
-    }
-  }
-}
-function renderList(ctx, data) {
-  const hasContent = data.items.some((item) => {
-    if (item["item-type"] === "sub-list")
-      return true;
-    if (item["item-type"] === "elements") {
-      const trimmed = trimTextElements(item.elements);
-      return trimmed.length > 0;
-    }
-    return false;
+function enterState(args, match, patternIndex, captureIndex, count) {
+  const statesArr = args.def.states[args.state];
+  const delimArr = args.def.delim[args.state];
+  const innerArr = args.def.inner[args.state];
+  args.stateStack.push({
+    state: args.state,
+    lastdelim: args.lastdelim,
+    lastinner: args.lastinner,
+    endpattern: args.endpattern
   });
-  if (!hasContent) {
-    return;
-  }
-  const tag = data.type === "numbered" ? "ol" : "ul";
-  ctx.push(`<${tag}${renderListAttrs(data.attributes)}>`);
-  const items = data.items;
-  let i = 0;
-  while (i < items.length) {
-    const item = items[i];
-    if (item["item-type"] === "elements") {
-      const hasNoMarker = item.attributes._noMarker === "true";
-      const styleAttr = hasNoMarker ? ' style="list-style: none"' : "";
-      ctx.push(`<li${renderListAttrs(item.attributes)}${styleAttr}>`);
-      if (hasNoMarker) {
-        renderNoMarkerElements(ctx, item.elements);
-      } else {
-        renderElements(ctx, trimTextElements(item.elements));
-      }
-      while (i + 1 < items.length && items[i + 1]["item-type"] === "sub-list") {
-        i++;
-        const subItem = items[i];
-        renderList(ctx, subItem.data);
-      }
-      ctx.push("</li>");
-    } else {
-      const subItem = item;
-      ctx.push(`<li style="list-style: none; display: inline">`);
-      renderList(ctx, subItem.data);
-      ctx.push("</li>");
-    }
-    i++;
-  }
-  ctx.push(`</${tag}>`);
-}
-function renderListAttrs(attributes) {
-  const safe = sanitizeAttributes(attributes);
-  let result = "";
-  for (const [key, value] of Object.entries(safe)) {
-    if (key.startsWith("_"))
-      continue;
-    result += ` ${key}="${escapeAttr(value)}"`;
-  }
-  return result;
-}
-function renderDefinitionList(ctx, items) {
-  ctx.push("<dl>");
-  for (const item of items) {
-    ctx.push("<dt>");
-    renderElements(ctx, item.key);
-    ctx.push("</dt>");
-    ctx.push("<dd>");
-    renderElements(ctx, item.value);
-    ctx.push("</dd>");
-  }
-  ctx.push("</dl>");
-}
-
-// packages/render/src/elements/table.ts
-function renderTable(ctx, data) {
-  const isPipeTable = data.attributes._source === "pipe";
-  const classAttr = isPipeTable ? ' class="wiki-content-table"' : "";
-  ctx.push(`<table${classAttr}${renderTableAttrs(data.attributes)}>`);
-  for (const row of data.rows) {
-    ctx.push(`<tr${renderTableAttrs(row.attributes)}>`);
-    for (const cell of row.cells) {
-      const tag = cell.header ? "th" : "td";
-      const attrs = [];
-      const safeCellAttrs = sanitizeAttributes(cell.attributes);
-      if (cell["column-span"] > 1) {
-        attrs.push(`colspan="${cell["column-span"]}"`);
-      }
-      if (safeCellAttrs.rowspan) {
-        const rowspan = parseInt(safeCellAttrs.rowspan, 10);
-        if (rowspan > 1) {
-          attrs.push(`rowspan="${rowspan}"`);
-        }
-      }
-      if (cell.align) {
-        const existingStyle = safeCellAttrs.style ?? "";
-        const alignStyle = `text-align: ${cell.align};`;
-        if (existingStyle) {
-          attrs.push(`style="${escapeAttr(existingStyle + "; " + alignStyle)}"`);
-        } else {
-          attrs.push(`style="${alignStyle}"`);
-        }
-      }
-      for (const [key, value] of Object.entries(safeCellAttrs)) {
-        if (key === "style" && cell.align)
-          continue;
-        if (key === "rowspan")
-          continue;
-        attrs.push(`${key}="${escapeAttr(value)}"`);
-      }
-      const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
-      ctx.push(`<${tag}${attrStr}>`);
-      renderElements(ctx, cell.elements);
-      ctx.push(`</${tag}>`);
-    }
-    ctx.push("</tr>");
-  }
-  ctx.push("</table>");
-}
-function renderTableAttrs(attributes) {
-  const safe = sanitizeAttributes(attributes);
-  let result = "";
-  for (const [key, value] of Object.entries(safe)) {
-    if (key.startsWith("_"))
-      continue;
-    result += ` ${key}="${escapeAttr(value)}"`;
-  }
-  return result;
-}
-
-// packages/render/src/elements/collapsible.ts
-function renderCollapsible(ctx, data) {
-  const startOpen = data["start-open"];
-  const showTop = data["show-top"];
-  const showBottom = data["show-bottom"];
-  const showLabel = data["show-text"] ? formatLabelText(data["show-text"]) : formatCollapsibleText("+", "show block");
-  const hideLabel = data["hide-text"] ? formatLabelText(data["hide-text"]) : formatCollapsibleText("–", "hide block");
-  ctx.push(`<div class="collapsible-block">`);
-  const foldedStyle = startOpen ? ` style="display:none"` : "";
-  ctx.push(`<div class="collapsible-block-folded"${foldedStyle}>`);
-  ctx.push(`<a class="collapsible-block-link" href="javascript:;">${showLabel}</a>`);
-  ctx.push("</div>");
-  const unfoldedStyle = startOpen ? "" : ` style="display:none"`;
-  ctx.push(`<div class="collapsible-block-unfolded"${unfoldedStyle}>`);
-  if (showTop || !showTop && !showBottom) {
-    ctx.push(`<div class="collapsible-block-unfolded-link">`);
-    ctx.push(`<a class="collapsible-block-link" href="javascript:;">${hideLabel}</a>`);
-    ctx.push("</div>");
-  }
-  ctx.push(`<div class="collapsible-block-content">`);
-  renderElements(ctx, data.elements);
-  ctx.push("</div>");
-  if (showBottom) {
-    ctx.push(`<div class="collapsible-block-unfolded-link">`);
-    ctx.push(`<a class="collapsible-block-link" href="javascript:;">${hideLabel}</a>`);
-    ctx.push("</div>");
-  }
-  ctx.push("</div>");
-  ctx.push("</div>");
-}
-function formatCollapsibleText(prefix, text) {
-  const encoded = escapeHtml(text).replace(/ /g, "&nbsp;");
-  return `${prefix}&nbsp;${encoded}`;
-}
-function formatLabelText(text) {
-  return escapeHtml(text).replace(/ /g, "&nbsp;");
-}
-
-// packages/render/src/libs/highlighter/engine.ts
-function tokenize(def, input) {
-  let str = input.replace(/\r\n/g, `
-`);
-  str = str.replace(/^$/gm, " ");
-  str = str.replace(/\t/g, "    ");
-  str = str.replace(/\s+$/, "");
-  const len = str.length;
-  if (len === 0)
-    return [];
-  let state = -1;
-  let pos = 0;
-  let lastinner = def.defClass;
-  let lastdelim = def.defClass;
-  let endpattern = null;
-  const stateStack = [];
-  const tokenStack = [];
-  const result = [];
-  function getToken() {
-    if (tokenStack.length > 0) {
-      return tokenStack.pop();
-    }
-    if (pos >= len) {
-      return null;
-    }
-    let endpos = -1;
-    let endmatch = "";
-    if (state !== -1 && endpattern) {
-      endpattern.lastIndex = pos;
-      const em = endpattern.exec(str);
-      if (em) {
-        endpos = em.index;
-        endmatch = em[0];
-      }
-    }
-    const reg = def.regs[state];
-    if (reg) {
-      reg.lastIndex = pos;
-      const m = reg.exec(str);
-      if (m) {
-        const countsArr = def.counts[state];
-        const statesArr = def.states[state];
-        const delimArr = def.delim[state];
-        const innerArr = def.inner[state];
-        let n = 1;
-        for (let i = 0;i < countsArr.length; i++) {
-          const count = countsArr[i];
-          if (n >= m.length)
-            break;
-          if (m[n] != null && (endpos === -1 || m.index < endpos)) {
-            const matchStart = m.index;
-            const matchStr = m[n];
-            const groupStart = findGroupPosition(str, m, n, matchStart);
-            if (statesArr[i] !== -1) {
-              tokenStack.push({ class: delimArr[i], content: matchStr });
-            } else {
-              let inner = innerArr[i];
-              const partDef = def.parts[state]?.[i];
-              if (partDef) {
-                const parts = [];
-                let partpos = groupStart;
-                for (let j = 1;j <= count; j++) {
-                  const subIdx = j + n;
-                  if (subIdx >= m.length || m[subIdx] == null || m[subIdx] === "")
-                    continue;
-                  const subStr = m[subIdx];
-                  const subStart = str.indexOf(subStr, partpos);
-                  if (subStart < 0)
-                    continue;
-                  if (partDef[j]) {
-                    if (subStart > partpos) {
-                      parts.unshift({ class: inner, content: str.substring(partpos, subStart) });
-                    }
-                    parts.unshift({ class: partDef[j], content: subStr });
-                  }
-                  partpos = subStart + subStr.length;
-                }
-                if (partpos < groupStart + matchStr.length) {
-                  parts.unshift({
-                    class: inner,
-                    content: str.substring(partpos, groupStart + matchStr.length)
-                  });
-                }
-                tokenStack.push(...parts);
-              } else {
-                let kwDef = def.keywords[state]?.[i];
-                if (!kwDef || kwDef === -1 || typeof kwDef !== "object" || Object.keys(kwDef).length === 0) {
-                  kwDef = def.keywords[-1]?.[i];
-                }
-                if (kwDef && kwDef !== -1 && typeof kwDef === "object") {
-                  for (const [group, re] of Object.entries(kwDef)) {
-                    if (re.test(matchStr)) {
-                      inner = def.kwmap[group] ?? inner;
-                      break;
-                    }
-                  }
-                }
-                tokenStack.push({ class: inner, content: matchStr });
-              }
-            }
-            if (groupStart > pos) {
-              tokenStack.push({ class: lastinner, content: str.substring(pos, groupStart) });
-            }
-            pos = groupStart + matchStr.length;
-            if (statesArr[i] !== -1) {
-              stateStack.push({ state, lastdelim, lastinner, endpattern });
-              lastinner = innerArr[i];
-              lastdelim = delimArr[i];
-              const prevState = state;
-              state = statesArr[i];
-              const endRe = def.end[state];
-              if (def.subst[prevState]?.[i] && endRe) {
-                let epSource = endRe.source;
-                for (let k = 0;k <= count; k++) {
-                  const subIdx = n + k;
-                  if (subIdx >= m.length || m[subIdx] == null)
-                    break;
-                  const quoted = escapeRegex(m[subIdx]);
-                  epSource = epSource.replace(`%${k}%`, quoted);
-                  epSource = epSource.replace(`%b${k}%`, matchingBrackets(quoted));
-                }
-                endpattern = new RegExp(epSource, endRe.flags);
-              } else {
-                endpattern = endRe ?? null;
-              }
-            }
-            return tokenStack.pop();
-          }
-          n += count + 1;
-        }
-      }
-    }
-    if (endpos > -1) {
-      tokenStack.push({ class: lastdelim, content: endmatch });
-      if (endpos > pos) {
-        tokenStack.push({ class: lastinner, content: str.substring(pos, endpos) });
-      }
-      const prev = stateStack.pop();
-      state = prev.state;
-      lastdelim = prev.lastdelim;
-      lastinner = prev.lastinner;
-      endpattern = prev.endpattern;
-      pos = endpos + endmatch.length;
-      if (tokenStack.length > 0) {
-        return tokenStack.pop();
-      }
-      return getToken();
-    }
-    const p = pos;
-    pos = len;
-    return { class: lastinner, content: str.substring(p) };
-  }
-  let token;
-  while ((token = getToken()) !== null) {
-    result.push(token);
-  }
-  return result;
-}
-function findGroupPosition(str, m, n, matchStart) {
-  const groupStr = m[n];
-  const idx = str.indexOf(groupStr, matchStart);
-  return idx >= 0 ? idx : matchStart;
-}
-function renderTokens(tokens) {
-  if (tokens.length === 0)
-    return "";
-  let html = "";
-  let lastClass = "";
-  for (const token of tokens) {
-    if (token.content.length === 0)
-      continue;
-    const escaped = escapeHtml2(token.content);
-    if (token.class !== lastClass) {
-      if (lastClass) {
-        html += "</span>";
-      }
-      html += `<span class="hl-${token.class}">`;
-      lastClass = token.class;
-    }
-    html += escaped;
-  }
-  if (lastClass) {
-    html += "</span>";
-  }
-  return `<div class="hl-main"><pre>${html}</pre></div>`;
-}
-function escapeHtml2(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function matchingBrackets(str) {
-  return str.replace(/[()<>[\]{}]/g, (c) => {
-    const map = {
-      "(": ")",
-      ")": "(",
-      "<": ">",
-      ">": "<",
-      "[": "]",
-      "]": "[",
-      "{": "}",
-      "}": "{"
-    };
-    return map[c] ?? c;
+  const prevState = args.state;
+  const nextState = statesArr[patternIndex];
+  const endRe = args.def.end[nextState];
+  args.setState({
+    state: nextState,
+    lastinner: innerArr[patternIndex],
+    lastdelim: delimArr[patternIndex],
+    endpattern: buildEndPattern(args.def, prevState, patternIndex, count, captureIndex, match, endRe ?? undefined)
   });
 }
-
 // packages/render/src/libs/highlighter/languages/css.ts
 var cssLang = {
   language: "css",
@@ -4011,112 +3810,1190 @@ function highlight(code, language) {
   return renderTokens(tokens);
 }
 
-// packages/render/src/elements/code.ts
-function renderCode(ctx, data) {
-  ctx.push(`<div class="code">`);
-  if (data.contents === "") {
-    ctx.push("</div>");
-    return;
+// packages/render/src/elements/code/contents.ts
+function renderCodeContents(data) {
+  if (data.language) {
+    const highlighted = highlight(data.contents, data.language);
+    if (highlighted) {
+      return highlighted;
+    }
+  }
+  return renderPlainCode(data.contents);
+}
+function renderPlainCode(contents) {
+  return `<pre><code>${escapeHtml(contents)}</code></pre>`;
+}
+
+// packages/render/src/elements/code/index.ts
+function renderCode(ctx, data) {
+  ctx.push(`<div class="code">`);
+  if (data.contents !== "") {
+    ctx.push(renderCodeContents(data));
+  }
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/collapsible/labels.ts
+function getCollapsibleLabels(data) {
+  return {
+    show: data["show-text"] ? formatLabelText(data["show-text"]) : formatCollapsibleText("+", "show block"),
+    hide: data["hide-text"] ? formatLabelText(data["hide-text"]) : formatCollapsibleText("–", "hide block")
+  };
+}
+function formatCollapsibleText(prefix, text) {
+  const encoded = escapeHtml(text).replace(/ /g, "&nbsp;");
+  return `${prefix}&nbsp;${encoded}`;
+}
+function formatLabelText(text) {
+  return escapeHtml(text).replace(/ /g, "&nbsp;");
+}
+
+// packages/render/src/elements/collapsible/link.ts
+function renderCollapsibleLink(ctx, label) {
+  ctx.push(`<a class="collapsible-block-link" href="javascript:;">${label}</a>`);
+}
+function renderHideLink(ctx, label) {
+  ctx.push(`<div class="collapsible-block-unfolded-link">`);
+  renderCollapsibleLink(ctx, label);
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/collapsible/sections.ts
+function renderFoldedSection(ctx, startOpen, labels) {
+  const foldedStyle = startOpen ? ` style="display:none"` : "";
+  ctx.push(`<div class="collapsible-block-folded"${foldedStyle}>`);
+  renderCollapsibleLink(ctx, labels.show);
+  ctx.push("</div>");
+}
+function renderUnfoldedSection(ctx, data, labels) {
+  const unfoldedStyle = data["start-open"] ? "" : ` style="display:none"`;
+  ctx.push(`<div class="collapsible-block-unfolded"${unfoldedStyle}>`);
+  if (data["show-top"] || !data["show-top"] && !data["show-bottom"]) {
+    renderHideLink(ctx, labels.hide);
+  }
+  ctx.push(`<div class="collapsible-block-content">`);
+  renderElements(ctx, data.elements);
+  ctx.push("</div>");
+  if (data["show-bottom"]) {
+    renderHideLink(ctx, labels.hide);
+  }
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/collapsible/index.ts
+function renderCollapsible(ctx, data) {
+  const startOpen = data["start-open"];
+  const labels = getCollapsibleLabels(data);
+  ctx.push(`<div class="collapsible-block">`);
+  renderFoldedSection(ctx, startOpen, labels);
+  renderUnfoldedSection(ctx, data, labels);
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/container/index.ts
+import { isAlignType, isHeaderType, isStringContainerType } from "@wdprlib/ast";
+
+// packages/render/src/elements/container/attributes.ts
+function renderContainerAttrs(attributes) {
+  if (!hasAttributes(attributes)) {
+    return "";
+  }
+  const safe = sanitizeAttributes(attributes);
+  let result = "";
+  for (const key in safe) {
+    if (key.startsWith("_")) {
+      continue;
+    }
+    const value = safe[key];
+    result += value !== "" ? ` ${key}="${escapeAttr(value)}"` : ` ${key}=""`;
+  }
+  return result;
+}
+function hasAttributes(attributes) {
+  for (const _ in attributes) {
+    return true;
+  }
+  return false;
+}
+
+// packages/render/src/elements/container/header.ts
+function renderHeader(ctx, level, hasToc, attributes, elements) {
+  const tag = `h${level}`;
+  if (hasToc) {
+    const tocId = ctx.generateId("toc", ctx.nextTocIndex());
+    ctx.push(`<${tag} id="${tocId}"${renderContainerAttrs(attributes)}>`);
+  } else {
+    ctx.push(`<${tag}${renderContainerAttrs(attributes)}>`);
+  }
+  ctx.push("<span>");
+  renderElements(ctx, elements);
+  ctx.push("</span>");
+  ctx.push(`</${tag}>`);
+}
+
+// packages/render/src/elements/container/string-types.ts
+var WRAPPED_TAGS = {
+  paragraph: "p",
+  bold: "strong",
+  italics: "em",
+  superscript: "sup",
+  subscript: "sub",
+  monospace: "tt",
+  span: "span",
+  div: "div",
+  blockquote: "blockquote",
+  mark: "mark",
+  insertion: "ins",
+  deletion: "del",
+  size: "span",
+  ruby: "ruby",
+  "ruby-text": "rt",
+  "table-row": "tr",
+  "table-cell": "td"
+};
+var STYLED_SPANS = {
+  underline: "text-decoration: underline;",
+  strikethrough: "text-decoration: line-through;",
+  hidden: "display: none",
+  invisible: "visibility: hidden"
+};
+var PLAIN_WRAPPED_TAGS = {
+  "definition-list": "dl",
+  "definition-list-key": "dt",
+  "definition-list-value": "dd"
+};
+var CONTENTS_ONLY_TYPES = new Set(["heading", "collapsible", "definition-list-item"]);
+function getStringContainerRendering(type) {
+  const wrappedTag = WRAPPED_TAGS[type];
+  if (wrappedTag) {
+    return { kind: "wrapped", tag: wrappedTag };
+  }
+  const style = STYLED_SPANS[type];
+  if (style) {
+    return { kind: "styled-span", style };
+  }
+  const plainTag = PLAIN_WRAPPED_TAGS[type];
+  if (plainTag) {
+    return { kind: "plain-wrapped", tag: plainTag };
+  }
+  return { kind: "contents" };
+}
+function isContentsOnlyStringContainer(type) {
+  return CONTENTS_ONLY_TYPES.has(type);
+}
+
+// packages/render/src/elements/container/wrappers.ts
+function renderWrapped(ctx, tag, attributes, elements) {
+  ctx.push(`<${tag}${renderContainerAttrs(attributes)}>`);
+  renderElements(ctx, elements);
+  ctx.push(`</${tag}>`);
+}
+function renderPlainWrapped(ctx, tag, elements) {
+  ctx.push(`<${tag}>`);
+  renderElements(ctx, elements);
+  ctx.push(`</${tag}>`);
+}
+function renderStyledSpan(ctx, style, attributes, elements) {
+  ctx.push(`<span style="${style}"${renderContainerAttrs(attributes)}>`);
+  renderElements(ctx, elements);
+  ctx.push("</span>");
+}
+
+// packages/render/src/elements/container/string-container.ts
+function renderStringContainer(ctx, type, attributes, elements) {
+  if (type === "div" && elements.length === 0 && !hasAttributes(attributes)) {
+    return;
+  }
+  if (isContentsOnlyStringContainer(type)) {
+    renderElements(ctx, elements);
+    return;
+  }
+  const rendering = getStringContainerRendering(type);
+  switch (rendering.kind) {
+    case "wrapped":
+      renderWrapped(ctx, rendering.tag, attributes, elements);
+      return;
+    case "styled-span":
+      renderStyledSpan(ctx, rendering.style, attributes, elements);
+      return;
+    case "plain-wrapped":
+      renderPlainWrapped(ctx, rendering.tag, elements);
+      return;
+    case "contents":
+      renderElements(ctx, elements);
+  }
+}
+
+// packages/render/src/elements/container/index.ts
+function renderContainer(ctx, data) {
+  const { type, attributes, elements } = data;
+  if (isHeaderType(type)) {
+    renderHeader(ctx, type.header.level, type.header["has-toc"], attributes, elements);
+    return;
+  }
+  if (isAlignType(type)) {
+    ctx.push(`<div style="text-align: ${type.align};">`);
+    renderElements(ctx, elements);
+    ctx.push("</div>");
+    return;
+  }
+  if (isStringContainerType(type)) {
+    renderStringContainer(ctx, type, attributes, elements);
+  }
+}
+
+// packages/render/src/elements/color.ts
+function renderColor(ctx, data) {
+  const safeColor = sanitizeCssColor(data.color, "inherit");
+  ctx.push(`<span style="color: ${escapeAttr(safeColor)}">`);
+  renderElements(ctx, data.elements);
+  ctx.push("</span>");
+}
+
+// packages/render/src/elements/date/format.ts
+function formatDate(date, format) {
+  return format.replace(/%Y/g, String(date.getFullYear())).replace(/%m/g, String(date.getMonth() + 1).padStart(2, "0")).replace(/%d/g, String(date.getDate()).padStart(2, "0")).replace(/%H/g, String(date.getHours()).padStart(2, "0")).replace(/%M/g, String(date.getMinutes()).padStart(2, "0")).replace(/%S/g, String(date.getSeconds()).padStart(2, "0"));
+}
+
+// packages/render/src/elements/date/output.ts
+function renderDateOutput(formatted, hover) {
+  const escaped = escapeHtml(formatted);
+  return hover ? `<span class="odate">${escaped}</span>` : escaped;
+}
+
+// packages/render/src/elements/date/index.ts
+function renderDate(ctx, data) {
+  const date = new Date(data.value.timestamp * 1000);
+  const formatted = data.format ? formatDate(date, data.format) : date.toLocaleString();
+  ctx.push(renderDateOutput(formatted, data.hover));
+}
+
+// packages/render/src/elements/embed/iframe.ts
+function renderEmbedIframe(ctx, className, src) {
+  ctx.push(`<div class="${className}">`);
+  ctx.push(`<iframe src="${escapeAttr(src)}" frameborder="0" allowfullscreen></iframe>`);
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/embed/validation.ts
+function isValidVideoId(id) {
+  return /^[a-zA-Z0-9_-]+$/.test(id);
+}
+function isValidGithubUsername(username) {
+  return /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,37}[a-zA-Z0-9])?$/.test(username);
+}
+function isValidGistHash(hash) {
+  return /^[a-f0-9]+$/.test(hash);
+}
+function isValidGitlabSnippetId(id) {
+  return /^[0-9]+$/.test(id);
+}
+
+// packages/render/src/elements/embed/providers.ts
+function renderYoutube(ctx, videoId) {
+  if (!isValidVideoId(videoId)) {
+    ctx.push(`<!-- Invalid YouTube video ID -->`);
+    return;
+  }
+  renderEmbedIframe(ctx, "embed-youtube", `https://www.youtube.com/embed/${videoId}`);
+}
+function renderVimeo(ctx, videoId) {
+  if (!isValidVideoId(videoId)) {
+    ctx.push(`<!-- Invalid Vimeo video ID -->`);
+    return;
+  }
+  renderEmbedIframe(ctx, "embed-vimeo", `https://player.vimeo.com/video/${videoId}`);
+}
+function renderGithubGist(ctx, username, hash) {
+  if (!isValidGithubUsername(username) || !isValidGistHash(hash)) {
+    ctx.push(`<!-- Invalid GitHub Gist parameters -->`);
+    return;
+  }
+  ctx.push(`<script src="https://gist.github.com/${escapeAttr(username)}/${escapeAttr(hash)}.js"></script>`);
+}
+function renderGitlabSnippet(ctx, snippetId) {
+  if (!isValidGitlabSnippetId(snippetId)) {
+    ctx.push(`<!-- Invalid GitLab snippet ID -->`);
+    return;
+  }
+  ctx.push(`<script src="https://gitlab.com/snippets/${escapeAttr(snippetId)}.js"></script>`);
+}
+
+// packages/render/src/elements/embed/index.ts
+function renderEmbed(ctx, data) {
+  switch (data.embed) {
+    case "youtube":
+      renderYoutube(ctx, data.data["video-id"]);
+      break;
+    case "vimeo":
+      renderVimeo(ctx, data.data["video-id"]);
+      break;
+    case "github-gist":
+      renderGithubGist(ctx, data.data.username, data.data.hash);
+      break;
+    case "gitlab-snippet":
+      renderGitlabSnippet(ctx, data.data["snippet-id"]);
+      break;
+  }
+}
+
+// packages/render/src/elements/embed-block/allowlist.ts
+var DEFAULT_EMBED_ALLOWLIST = [
+  { host: "*.youtube.com", pathPrefix: "/embed/" },
+  { host: "*.youtube-nocookie.com", pathPrefix: "/embed/" },
+  { host: "player.vimeo.com", pathPrefix: "/video/" },
+  { host: "*.google.com", pathPrefix: "/maps/embed" },
+  { host: "calendar.google.com", pathPrefix: "/calendar/embed" },
+  { host: "open.spotify.com", pathPrefix: "/embed/" },
+  { host: "w.soundcloud.com", pathPrefix: "/player/" },
+  { host: "codepen.io" }
+];
+function matchesAllowlistEntry(url, entry) {
+  if (!matchesHostPattern(url.hostname, entry.host)) {
+    return false;
+  }
+  if (entry.pathPrefix) {
+    const pathLower = url.pathname.toLowerCase();
+    const prefixLower = entry.pathPrefix.toLowerCase();
+    if (!pathLower.startsWith(prefixLower)) {
+      return false;
+    }
+    if (!prefixLower.endsWith("/")) {
+      const remainder = pathLower.slice(prefixLower.length);
+      if (remainder && !/^[/?#]/.test(remainder)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function matchesHostPattern(hostname, pattern) {
+  const lowerHostname = hostname.toLowerCase();
+  const lowerPattern = pattern.toLowerCase();
+  if (lowerPattern.startsWith("*.")) {
+    const base = lowerPattern.slice(2);
+    return lowerHostname === base || lowerHostname.endsWith("." + base);
+  }
+  return lowerHostname === lowerPattern;
+}
+
+// packages/render/src/elements/embed-block/sanitize.ts
+import sanitizeHtml from "sanitize-html";
+
+// packages/render/src/elements/embed-block/iframe.ts
+import { parseDocument } from "htmlparser2";
+function findIframes(html) {
+  const doc = parseDocument(html);
+  const iframes = [];
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (node.type !== "tag") {
+        continue;
+      }
+      if (node.name === "iframe") {
+        iframes.push(node);
+      }
+      if (node.children) {
+        walk(node.children);
+      }
+    }
+  }
+  walk(doc.children);
+  return iframes;
+}
+function parseIframeUrl(src, baseUrl) {
+  try {
+    if (src.startsWith("//")) {
+      return new URL(src, baseUrl ?? "https://localhost");
+    }
+    return new URL(src);
+  } catch {
+    return null;
+  }
+}
+
+// packages/render/src/elements/embed-block/sanitize-config.ts
+var SANITIZE_CONFIG = {
+  allowedTags: ["iframe"],
+  allowedAttributes: {
+    iframe: [
+      "class",
+      "src",
+      "style",
+      "allow",
+      "allowfullscreen",
+      "frameborder",
+      "height",
+      "loading",
+      "referrerpolicy",
+      "sandbox",
+      "title",
+      "width"
+    ]
+  },
+  allowedSchemes: ["https", "http"]
+};
+
+// packages/render/src/elements/embed-block/boolean-attributes.ts
+var BOOLEAN_ATTRIBUTES = [
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "ismap",
+  "loop",
+  "multiple",
+  "muted",
+  "novalidate",
+  "open",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+];
+function normalizeBooleanAttributes(html) {
+  let result = html;
+  for (const attr of BOOLEAN_ATTRIBUTES) {
+    const standalonePattern = new RegExp(`\\s${attr}(?=\\s|>|/>)`, "gi");
+    result = result.replace(standalonePattern, ` ${attr}="${attr}"`);
+    const emptyValuePattern = new RegExp(`\\s${attr}=""`, "gi");
+    result = result.replace(emptyValuePattern, ` ${attr}="${attr}"`);
+  }
+  return result;
+}
+
+// packages/render/src/elements/embed-block/sanitize.ts
+function validateAndSanitizeEmbed(content, allowlist, baseUrl) {
+  const sanitized = sanitizeHtml(content.trim(), SANITIZE_CONFIG);
+  if (!sanitized.trim()) {
+    return null;
+  }
+  const iframes = findIframes(sanitized);
+  if (iframes.length !== 1) {
+    return null;
+  }
+  const src = iframes[0].attribs.src?.trim();
+  if (!src) {
+    return null;
+  }
+  const url = parseIframeUrl(src, baseUrl);
+  if (url === null) {
+    return null;
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    return null;
+  }
+  if (allowlist !== null && !allowlist.some((entry) => matchesAllowlistEntry(url, entry))) {
+    return null;
+  }
+  return sanitized;
+}
+
+// packages/render/src/elements/embed-block/index.ts
+function renderEmbedBlock(ctx, data) {
+  const allowlist = ctx.options.embedAllowlist !== undefined ? ctx.options.embedAllowlist : DEFAULT_EMBED_ALLOWLIST;
+  const sanitized = validateAndSanitizeEmbed(data.contents, allowlist, ctx.options.baseUrl);
+  if (sanitized === null) {
+    ctx.push('<div class="error-block">Sorry, no match for the embedded content.</div>');
+    return;
+  }
+  ctx.push(normalizeBooleanAttributes(sanitized));
+}
+
+// packages/render/src/elements/expr/index.ts
+import { isTruthy } from "@wdprlib/ast";
+
+// packages/render/src/elements/expr/branch.ts
+function renderBranchElements(ctx, elements) {
+  renderElements(ctx, elements.slice(0, findBranchRenderLength(elements)));
+}
+function findBranchRenderLength(elements) {
+  let lastIdx = elements.length - 1;
+  while (lastIdx >= 0 && isWhitespaceText(elements[lastIdx])) {
+    lastIdx--;
+  }
+  return lastIdx + 1;
+}
+function isWhitespaceText(element) {
+  return element.element === "text" && typeof element.data === "string" && element.data.trim() === "";
+}
+
+// packages/render/src/elements/expr/result.ts
+import { evaluateExpression, formatExprValue } from "@wdprlib/ast";
+function evaluateExpressionOutput(expression) {
+  const result = evaluateExpression(expression);
+  if (result.success) {
+    return formatExprValue(result.value);
+  }
+  if (result.error === "empty expression") {
+    return null;
+  }
+  return `run-time error: ${result.error}`;
+}
+function evaluateIfExpressionValue(expression) {
+  const result = evaluateExpression(expression);
+  return result.success ? result.value : `run-time error: ${result.error}`;
+}
+
+// packages/render/src/elements/expr/index.ts
+function renderExpr(ctx, data) {
+  const output = evaluateExpressionOutput(data.expression);
+  if (output !== null) {
+    ctx.pushEscaped(output);
+  }
+}
+function renderIf(ctx, data) {
+  renderBranchElements(ctx, isTruthy(data.condition) ? data.then : data.else);
+}
+function renderIfExpr(ctx, data) {
+  const value = evaluateIfExpressionValue(data.expression);
+  if (typeof value === "string") {
+    ctx.pushEscaped(value);
+    return;
+  }
+  renderBranchElements(ctx, value !== 0 ? data.then : data.else);
+}
+
+// packages/render/src/elements/footnote/body.ts
+function renderFootnoteBody(ctx, index, elements) {
+  const fnId = ctx.generateId("footnote-", index);
+  ctx.push(`<div class="footnote-footer" id="${fnId}">`);
+  ctx.push(`<a href="javascript:;">${index}</a>. `);
+  renderElements(ctx, elements);
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/footnote/ref.ts
+function renderFootnoteRef(ctx, index) {
+  const id = ctx.generateId("footnoteref-", index);
+  ctx.push(`<sup class="footnoteref">`);
+  ctx.push(`<a id="${id}" href="javascript:;" class="footnoteref">${index}</a>`);
+  ctx.push("</sup>");
+}
+
+// packages/render/src/elements/footnote/index.ts
+function renderFootnoteBlock(ctx, data) {
+  if (ctx.footnotes.length === 0)
+    return;
+  const title = data.title ?? "Footnotes";
+  ctx.push(`<div class="footnotes-footer">`);
+  ctx.push(`<div class="title">${escapeHtml(title)}</div>`);
+  for (let i = 0;i < ctx.footnotes.length; i++) {
+    renderFootnoteBody(ctx, i + 1, ctx.footnotes[i] ?? []);
+  }
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/html/attributes.ts
+function getHtmlBlockAttributes(ctx, data) {
+  return {
+    sandbox: getSandboxAttribute(ctx),
+    style: getStyleAttribute(data)
+  };
+}
+function getSandboxAttribute(ctx) {
+  const sandbox = ctx.options.htmlBlockSandbox;
+  return sandbox ? ` sandbox="${escapeAttr(sandbox)}"` : "";
+}
+function getStyleAttribute(data) {
+  return data.style ? ` style="${escapeAttr(sanitizeStyleValue(data.style))}"` : "";
+}
+
+// packages/render/src/hash.ts
+function syncHashSha1(input) {
+  return fnv1aHash(input, 40);
+}
+function syncHashMd5(input) {
+  return fnv1aHash(input, 32);
+}
+function fnv1aHash(input, hexLen) {
+  let result = "";
+  const rounds = Math.ceil(hexLen / 8);
+  for (let round = 0;round < rounds; round++) {
+    let h = 2166136261 ^ round;
+    for (let i = 0;i < input.length; i++) {
+      h ^= input.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+    result += (h >>> 0).toString(16).padStart(8, "0");
+  }
+  return result.substring(0, hexLen);
+}
+
+// packages/render/src/elements/html/url.ts
+function resolveHtmlBlockUrl(ctx, contents, index) {
+  const callbackUrl = ctx.options.resolvers?.htmlBlockUrl?.(index);
+  return callbackUrl || generateDefaultHtmlBlockUrl(ctx.page?.pageName ?? "", contents);
+}
+function generateDefaultHtmlBlockUrl(pageName, contents) {
+  const hash = syncHashSha1(contents);
+  const nonce = BigInt(contents.length) * 1000000000n + BigInt(hash.charCodeAt(0)) * 100000000n;
+  return pageName ? `/${pageName}/html/${hash}-${nonce}` : `/html/${hash}-${nonce}`;
+}
+
+// packages/render/src/elements/html/index.ts
+function renderHtmlBlock(ctx, data) {
+  if (ctx.settings.allowHtmlBlocks === false) {
+    return;
+  }
+  const index = ctx.nextHtmlBlockIndex();
+  const src = resolveHtmlBlockUrl(ctx, data.contents, index);
+  const attrs = getHtmlBlockAttributes(ctx, data);
+  ctx.push(`<p><iframe src="${escapeAttr(src)}"${attrs.sandbox} allowtransparency="true" frameborder="0" class="html-block-iframe"${attrs.style}></iframe></p>`);
+}
+
+// packages/render/src/elements/iframe/attributes.ts
+var IFRAME_ATTRIBUTES = [
+  "align",
+  "frameborder",
+  "height",
+  "scrolling",
+  "width",
+  "class",
+  "style"
+];
+function getIframeAttributes(data) {
+  const url = isDangerousUrl(data.url) ? "#invalid-url" : data.url;
+  const attrs = [`src="${escapeAttr(url)}"`];
+  for (const attr of IFRAME_ATTRIBUTES) {
+    attrs.push(`${attr}="${escapeAttr(getIframeAttributeValue(data, attr))}"`);
+  }
+  return attrs;
+}
+function getIframeAttributeValue(data, attr) {
+  const value = data.attributes[attr] ?? "";
+  return attr === "style" ? sanitizeStyleValue(value) : value;
+}
+
+// packages/render/src/elements/iframe/index.ts
+function renderIframe(ctx, data) {
+  ctx.push(`<p><iframe ${getIframeAttributes(data).join(" ")}></iframe></p>`);
+}
+
+// packages/render/src/elements/iftags/tokens.ts
+function parseIfTagsConditionTokens(condition) {
+  const tokens = {
+    required: [],
+    excluded: [],
+    optional: []
+  };
+  for (const token of condition.split(/\s+/).filter(Boolean)) {
+    if (token.startsWith("+")) {
+      addTag(tokens.required, token.slice(1));
+    } else if (token.startsWith("-")) {
+      addTag(tokens.excluded, token.slice(1));
+    } else {
+      addTag(tokens.optional, token);
+    }
+  }
+  return tokens;
+}
+function hasAnyIfTagsConditionToken(tokens) {
+  return tokens.required.length > 0 || tokens.excluded.length > 0 || tokens.optional.length > 0;
+}
+function addTag(tags, rawTag) {
+  const tag = rawTag.toLowerCase();
+  if (tag) {
+    tags.push(tag);
+  }
+}
+
+// packages/render/src/elements/iftags/condition.ts
+function evaluateIfTagsCondition(condition, pageTags) {
+  const pageTagSet = new Set(pageTags.map((tag) => tag.toLowerCase()));
+  const tokens = parseIfTagsConditionTokens(condition);
+  if (!hasAnyIfTagsConditionToken(tokens)) {
+    return false;
+  }
+  return hasRequiredTags(tokens.required, pageTagSet) && hasNoExcludedTags(tokens.excluded, pageTagSet) && hasOptionalTagIfNeeded(tokens.optional, pageTagSet);
+}
+function hasRequiredTags(required, pageTags) {
+  return required.every((tag) => pageTags.has(tag));
+}
+function hasNoExcludedTags(excluded, pageTags) {
+  return excluded.every((tag) => !pageTags.has(tag));
+}
+function hasOptionalTagIfNeeded(optional, pageTags) {
+  return optional.length === 0 || optional.some((tag) => pageTags.has(tag));
+}
+
+// packages/render/src/elements/iftags/style-slot.ts
+function withIfTagsStyleSlot(ctx, data, render) {
+  const slotId = data._styleSlot;
+  if (slotId !== undefined) {
+    ctx.enterStyleSlot(slotId);
+  }
+  render();
+  if (slotId !== undefined) {
+    ctx.exitStyleSlot();
+  }
+}
+
+// packages/render/src/elements/iftags/index.ts
+function renderIfTags(ctx, data) {
+  const pageTags = ctx.page?.tags ?? [];
+  if (!evaluateIfTagsCondition(data.condition, pageTags)) {
+    return;
+  }
+  const prev = ctx.renderInlineStyles;
+  ctx.renderInlineStyles = true;
+  withIfTagsStyleSlot(ctx, data, () => {
+    renderElements(ctx, data.elements);
+  });
+  ctx.renderInlineStyles = prev;
+}
+
+// packages/render/src/elements/image/source.ts
+function getFilenameFromSource(source) {
+  switch (source.type) {
+    case "url": {
+      const slashIndex = source.data.lastIndexOf("/");
+      return slashIndex === -1 ? source.data : source.data.slice(slashIndex + 1);
+    }
+    case "file1":
+      return source.data.file;
+    case "file2":
+      return source.data.file;
+    case "file3":
+      return source.data.file;
+  }
+}
+
+// packages/render/src/elements/image/img-attributes.ts
+function getImageAttributes(src, source, attributes) {
+  const safeAttrs = sanitizeAttributes(attributes);
+  const imgAttrs = [`src="${escapeAttr(src)}"`];
+  appendPassedImageAttributes(imgAttrs, safeAttrs);
+  imgAttrs.push(`alt="${escapeAttr(safeAttrs.alt ?? getFilenameFromSource(source))}"`);
+  imgAttrs.push(`class="${escapeAttr(safeAttrs.class ?? "image")}"`);
+  return imgAttrs;
+}
+function appendPassedImageAttributes(imgAttrs, safeAttrs) {
+  for (const key in safeAttrs) {
+    if (key === "alt" || key === "class" || key === "src" || key === "srcset")
+      continue;
+    const value = safeAttrs[key];
+    imgAttrs.push(`${key}="${escapeAttr(value)}"`);
+  }
+}
+
+// packages/render/src/elements/image/attributes.ts
+function buildImageTag(src, source, attributes) {
+  return `<img ${getImageAttributes(src, source, attributes).join(" ")} />`;
+}
+
+// packages/render/src/elements/image/alignment.ts
+function pushAlignedImage(ctx, output, alignment) {
+  if (!alignment) {
+    ctx.push(output);
+    return;
+  }
+  const alignClass = getAlignmentClass(alignment.align, alignment.float);
+  ctx.push(`<div class="image-container ${alignClass}">`);
+  ctx.push(output);
+  ctx.push("</div>");
+}
+function getAlignmentClass(align, isFloat) {
+  if (isFloat) {
+    switch (align) {
+      case "left":
+        return "floatleft";
+      case "right":
+        return "floatright";
+      case "center":
+        return "floatcenter";
+      default:
+        return `float${align}`;
+    }
+  }
+  switch (align) {
+    case "left":
+      return "alignleft";
+    case "right":
+      return "alignright";
+    case "center":
+      return "aligncenter";
+    default:
+      return `align${align}`;
+  }
+}
+
+// packages/render/src/elements/image/link-href.ts
+function resolveSafeImageLinkHref(link) {
+  const href = resolveImageLinkHref(link);
+  return isDangerousUrl(href) ? "#invalid-url" : href;
+}
+function resolveImageLinkHref(link) {
+  if (typeof link !== "string") {
+    return `/${link.page}`;
+  }
+  if (!link.startsWith("/") && !link.startsWith("#") && !link.startsWith("http://") && !link.startsWith("https://")) {
+    return `/${link}`;
+  }
+  return link;
+}
+
+// packages/render/src/elements/image/link.ts
+function wrapImageLink(imageTag, link) {
+  if (!link) {
+    return imageTag;
+  }
+  const href = resolveSafeImageLinkHref(link);
+  return `<a href="${escapeAttr(href)}">${imageTag}</a>`;
+}
+
+// packages/render/src/elements/image/index.ts
+function renderImage(ctx, data) {
+  let src = ctx.resolveImageSource(data.source);
+  if (src === null)
+    return;
+  if (isDangerousUrl(src)) {
+    src = "#invalid-url";
+  }
+  const imageTag = buildImageTag(src, data.source, data.attributes);
+  const output = wrapImageLink(imageTag, data.link);
+  pushAlignedImage(ctx, output, data.alignment);
+}
+
+// packages/render/src/elements/include/missing.ts
+function renderMissingInclude(ctx, page) {
+  const pageName = page.toLowerCase();
+  const safePath = encodeIncludeEditPath(pageName);
+  ctx.push(`<div class="error-block"><p>Included page "${escapeHtml(pageName)}" does not exist (<a href="/${escapeAttr(safePath)}/edit/true">create it now</a>)</p></div>`);
+}
+function encodeIncludeEditPath(pageName) {
+  const encodedPageName = pageName.replace(/[^a-z0-9\-_:/]/g, (c) => encodeURIComponent(c));
+  return encodedPageName.startsWith("/") ? encodedPageName.slice(1) : encodedPageName;
+}
+
+// packages/render/src/elements/include/index.ts
+function renderInclude(ctx, data) {
+  if (data.elements.length === 0) {
+    renderMissingInclude(ctx, data.location.page);
+    return;
+  }
+  renderElements(ctx, data.elements);
+}
+
+// packages/render/src/elements/line-break.ts
+function renderLineBreaks(ctx, count) {
+  for (let i = 0;i < count; i++) {
+    ctx.push("<br />");
+  }
+}
+
+// packages/render/src/elements/link/target.ts
+var TARGET_VALUES = {
+  "new-tab": "_blank",
+  parent: "_parent",
+  top: "_top",
+  same: "_self"
+};
+function renderTargetAttributes(attrs, target) {
+  if (!target) {
+    return;
+  }
+  const targetValue = TARGET_VALUES[target] ?? "_blank";
+  attrs.push(`target="${targetValue}"`);
+  if (targetValue === "_blank") {
+    attrs.push(`rel="noopener noreferrer"`);
+  }
+}
+
+// packages/render/src/elements/link/anchor.ts
+function renderAnchor(ctx, data) {
+  const safe = sanitizeAttributes(data.attributes);
+  const attrs = [];
+  if (safe.href && isDangerousUrl(safe.href)) {
+    safe.href = "#invalid-url";
   }
-  if (data.language) {
-    const highlighted = highlight(data.contents, data.language);
-    if (highlighted) {
-      ctx.push(highlighted);
+  const href = safe.href ?? "";
+  attrs.push(`href="${escapeAttr(href)}"`);
+  renderTargetAttributes(attrs, data.target);
+  for (const [key, value] of Object.entries(safe)) {
+    if (key === "href" || key === "target")
+      continue;
+    attrs.push(`${key}="${escapeAttr(value)}"`);
+  }
+  ctx.push(`<a ${attrs.join(" ")}>`);
+  renderElements(ctx, data.elements);
+  ctx.push("</a>");
+}
+
+// packages/render/src/elements/link/anchor-name.ts
+function renderAnchorName(ctx, name) {
+  ctx.push(`<a name="${escapeAttr(name)}"></a>`);
+}
+
+// packages/render/src/elements/link/attributes.ts
+function getLinkAttributes(ctx, data) {
+  const attrs = [`href="${escapeAttr(resolveSafeHref(ctx, data))}"`];
+  if (shouldAddNewPageClass(ctx, data)) {
+    attrs.push(`class="newpage"`);
+  }
+  renderTargetAttributes(attrs, data.target);
+  return attrs;
+}
+function resolveSafeHref(ctx, data) {
+  let href = ctx.resolvePageLink(data.link);
+  if (data.extra) {
+    href += data.extra;
+  }
+  const isAnchorJsVoid = data.type === "anchor" && href === "javascript:;";
+  if (!isAnchorJsVoid && isDangerousUrl(href)) {
+    return "#invalid-url";
+  }
+  return href;
+}
+function shouldAddNewPageClass(ctx, data) {
+  if (data.type !== "page" || typeof data.link !== "object") {
+    return false;
+  }
+  const page = data.link.page;
+  const isSpecialPage = page.startsWith("//") || page.includes("#/");
+  if (isSpecialPage) {
+    return false;
+  }
+  const hashIdx = page.indexOf("#");
+  const pageToCheck = hashIdx !== -1 ? page.slice(0, hashIdx) : page;
+  const pageExists = ctx.page?.pageExists;
+  return pageExists ? !pageExists(pageToCheck) : true;
+}
+
+// packages/render/src/elements/link/label.ts
+function renderLinkLabel(ctx, data) {
+  if (data.label === "page") {
+    if (typeof data.link === "string") {
+      ctx.pushEscaped(data.link);
     } else {
-      ctx.push(`<pre><code>${escapeHtml(data.contents)}</code></pre>`);
+      ctx.pushEscaped(data.link.page);
     }
-  } else {
-    ctx.push(`<pre><code>${escapeHtml(data.contents)}</code></pre>`);
+    return;
+  }
+  if ("text" in data.label) {
+    ctx.pushEscaped(data.label.text);
+    return;
+  }
+  if ("url" in data.label) {
+    const href = ctx.resolvePageLink(data.link);
+    ctx.pushEscaped(data.label.url ?? href);
   }
-  ctx.push("</div>");
 }
 
-// packages/render/src/hash.ts
-function syncHashSha1(input) {
-  return fnv1aHash(input, 40);
+// packages/render/src/elements/link/index.ts
+function renderLink(ctx, data) {
+  const attrs = getLinkAttributes(ctx, data);
+  ctx.push(`<a ${attrs.join(" ")}>`);
+  renderLinkLabel(ctx, data);
+  ctx.push("</a>");
 }
-function syncHashMd5(input) {
-  return fnv1aHash(input, 32);
+
+// packages/render/src/elements/list/definition-list.ts
+function renderDefinitionList(ctx, items) {
+  ctx.push("<dl>");
+  for (const item of items) {
+    ctx.push("<dt>");
+    renderElements(ctx, item.key);
+    ctx.push("</dt>");
+    ctx.push("<dd>");
+    renderElements(ctx, item.value);
+    ctx.push("</dd>");
+  }
+  ctx.push("</dl>");
 }
-function fnv1aHash(input, hexLen) {
+
+// packages/render/src/elements/list/attributes.ts
+function renderListAttrs(attributes) {
+  let hasAttributes2 = false;
+  for (const _ in attributes) {
+    hasAttributes2 = true;
+    break;
+  }
+  if (!hasAttributes2)
+    return "";
+  const safe = sanitizeAttributes(attributes);
   let result = "";
-  const rounds = Math.ceil(hexLen / 8);
-  for (let round = 0;round < rounds; round++) {
-    let h = 2166136261 ^ round;
-    for (let i = 0;i < input.length; i++) {
-      h ^= input.charCodeAt(i);
-      h = Math.imul(h, 16777619);
+  for (const key in safe) {
+    if (key.startsWith("_"))
+      continue;
+    const value = safe[key];
+    result += ` ${key}="${escapeAttr(value)}"`;
+  }
+  return result;
+}
+
+// packages/render/src/elements/list/item-rendering.ts
+function getListItemOpenTag(attributes) {
+  const styleAttr = hasNoMarker(attributes) ? ' style="list-style: none"' : "";
+  return `<li${renderListAttrs(attributes)}${styleAttr}>`;
+}
+function hasNoMarker(attributes) {
+  return attributes._noMarker === "true";
+}
+function renderFollowingSubLists(items, index, renderNestedList) {
+  let nextIndex = index;
+  while (nextIndex + 1 < items.length) {
+    const nextItem = getSubListItem(items[nextIndex + 1]);
+    if (!nextItem) {
+      break;
     }
-    result += (h >>> 0).toString(16).padStart(8, "0");
+    nextIndex++;
+    renderNestedList(nextItem.data);
   }
-  return result.substring(0, hexLen);
+  return nextIndex;
+}
+function getSubListItem(item) {
+  return item?.["item-type"] === "sub-list" ? item : null;
 }
 
-// packages/render/src/elements/tab-view.ts
-function renderTabView(ctx, tabs) {
-  const labelString = tabs.map((t) => t.label).join("");
-  const hash = md5Hash(labelString);
-  const widgetId = ctx.generateFixedId(`wiki-tabview-${hash}`);
-  ctx.push(`<div id="${widgetId}" class="yui-navset">`);
-  ctx.push(`<ul class="yui-nav">`);
-  for (let i = 0;i < tabs.length; i++) {
-    const tab = tabs[i];
-    const selectedClass = i === 0 ? ` class="selected"` : "";
-    ctx.push(`<li${selectedClass}>`);
-    ctx.push(`<a href="javascript:;"><em>${escapeHtml(tab.label)}</em></a>`);
-    ctx.push("</li>");
+// packages/render/src/elements/list/paragraphs.ts
+function getParagraphIndices(elements) {
+  const indices = [];
+  for (let i = 0;i < elements.length; i++) {
+    if (isParagraphElement(elements[i])) {
+      indices.push(i);
+    }
   }
-  ctx.push("</ul>");
-  ctx.push(`<div class="yui-content">`);
-  for (let i = 0;i < tabs.length; i++) {
-    const tab = tabs[i];
-    const displayStyle = i === 0 ? "" : ` style="display:none"`;
-    const tabId = ctx.generateId("wiki-tab-0-", i);
-    ctx.push(`<div id="${tabId}"${displayStyle}>`);
-    renderElements(ctx, tab.elements);
-    ctx.push("</div>");
+  return indices;
+}
+function isParagraphElement(element) {
+  return element?.element === "container" && element.data.type === "paragraph";
+}
+function isLiCloseTextParagraph(element) {
+  let combined = "";
+  for (const child of element.data.elements) {
+    if (child.element === "text") {
+      combined += child.data;
+    }
   }
-  ctx.push("</div>");
-  ctx.push("</div>");
+  return combined.trim() === "[[/li]]";
+}
+
+// packages/render/src/elements/list/trim.ts
+function trimTextElements(elements) {
+  if (elements.length === 0)
+    return elements;
+  let start = 0;
+  let end = elements.length;
+  while (start < end) {
+    const el = elements[start];
+    if (el.element === "text" && typeof el.data === "string" && el.data.trim() === "") {
+      start++;
+    } else {
+      break;
+    }
+  }
+  while (end > start) {
+    const el = elements[end - 1];
+    if (el.element === "text" && typeof el.data === "string" && el.data.trim() === "") {
+      end--;
+    } else {
+      break;
+    }
+  }
+  if (start === 0 && end === elements.length)
+    return elements;
+  return elements.slice(start, end);
 }
-function md5Hash(input) {
-  return syncHashMd5(input);
+function hasNonWhitespaceElement(elements) {
+  for (const el of elements) {
+    if (el.element !== "text" || typeof el.data !== "string" || el.data.trim() !== "") {
+      return true;
+    }
+  }
+  return false;
 }
 
-// packages/render/src/elements/footnote.ts
-function renderFootnoteRef(ctx, index) {
-  const id = ctx.generateId("footnoteref-", index);
-  ctx.push(`<sup class="footnoteref">`);
-  ctx.push(`<a id="${id}" href="javascript:;" class="footnoteref">${index}</a>`);
-  ctx.push("</sup>");
+// packages/render/src/elements/list/no-marker.ts
+function renderNoMarkerElements(ctx, elements) {
+  const trimmed = trimTextElements(elements);
+  if (trimmed.length === 0)
+    return;
+  const paragraphIndices = getParagraphIndices(trimmed);
+  if (paragraphIndices.length === 0) {
+    renderElements(ctx, trimmed);
+    return;
+  }
+  const firstParagraphIdx = paragraphIndices[0];
+  const lastParagraphIdx = paragraphIndices[paragraphIndices.length - 1];
+  for (let i = 0;i < trimmed.length; i++) {
+    const el = trimmed[i];
+    if (isParagraphElement(el)) {
+      renderNoMarkerParagraph(ctx, el, i, firstParagraphIdx, lastParagraphIdx);
+    } else {
+      renderElement(ctx, el);
+    }
+  }
 }
-function renderFootnoteBlock(ctx, data) {
-  if (ctx.footnotes.length === 0)
+function renderNoMarkerParagraph(ctx, element, index, firstParagraphIdx, lastParagraphIdx) {
+  if (index === firstParagraphIdx || index === lastParagraphIdx && isLiCloseTextParagraph(element)) {
+    renderElements(ctx, element.data.elements);
     return;
-  const title = data.title ?? "Footnotes";
-  ctx.push(`<div class="footnotes-footer">`);
-  ctx.push(`<div class="title">${escapeHtml(title)}</div>`);
-  for (let i = 0;i < ctx.footnotes.length; i++) {
-    const index = i + 1;
-    const elements = ctx.footnotes[i] ?? [];
-    const fnId = ctx.generateId("footnote-", index);
-    ctx.push(`<div class="footnote-footer" id="${fnId}">`);
-    ctx.push(`<a href="javascript:;">${index}</a>. `);
-    renderElements(ctx, elements);
-    ctx.push("</div>");
   }
-  ctx.push("</div>");
+  ctx.push("<p>");
+  renderElements(ctx, element.data.elements);
+  ctx.push("</p>");
 }
 
-// packages/render/src/elements/math.ts
-import temml from "temml";
-function needsAlignedWrapper(latex) {
-  if (/\\begin\s*\{/.test(latex)) {
+// packages/render/src/elements/list/items.ts
+function renderListItems(ctx, items, renderNestedList) {
+  let i = 0;
+  while (i < items.length) {
+    const item = items[i];
+    if (item["item-type"] === "elements") {
+      i = renderElementsListItem(ctx, item, items, i, renderNestedList);
+    } else {
+      renderOrphanSubListItem(ctx, item, renderNestedList);
+    }
+    i++;
+  }
+}
+function renderElementsListItem(ctx, item, items, index, renderNestedList) {
+  const noMarker = hasNoMarker(item.attributes);
+  ctx.push(getListItemOpenTag(item.attributes));
+  if (noMarker) {
+    renderNoMarkerElements(ctx, item.elements);
+  } else {
+    renderElements(ctx, trimTextElements(item.elements));
+  }
+  const nextIndex = renderFollowingSubLists(items, index, (data) => renderNestedList(ctx, data));
+  ctx.push("</li>");
+  return nextIndex;
+}
+function renderOrphanSubListItem(ctx, item, renderNestedList) {
+  ctx.push(`<li style="list-style: none; display: inline">`);
+  renderNestedList(ctx, item.data);
+  ctx.push("</li>");
+}
+
+// packages/render/src/elements/list/index.ts
+function renderList(ctx, data) {
+  const hasContent = data.items.some((item) => {
+    if (item["item-type"] === "sub-list")
+      return true;
+    if (item["item-type"] === "elements") {
+      return hasNonWhitespaceElement(item.elements);
+    }
     return false;
+  });
+  if (!hasContent) {
+    return;
   }
-  const withoutEscaped = latex.replace(/\\&/g, "");
-  return withoutEscaped.includes("&");
+  const tag = data.type === "numbered" ? "ol" : "ul";
+  ctx.push(`<${tag}${renderListAttrs(data.attributes)}>`);
+  renderListItems(ctx, data.items, renderList);
+  ctx.push(`</${tag}>`);
 }
+
+// packages/render/src/elements/math/latex.ts
+import temml from "temml";
 function renderLatexToMathML(latex, displayMode) {
   try {
     let processedLatex = latex;
@@ -4134,6 +5011,31 @@ ${latex}
     return "";
   }
 }
+function needsAlignedWrapper(latex) {
+  if (/\\begin\s*\{/.test(latex)) {
+    return false;
+  }
+  const withoutEscaped = latex.replace(/\\&/g, "");
+  return withoutEscaped.includes("&");
+}
+
+// packages/render/src/elements/math/source.ts
+function pushHiddenLatexSource(ctx, latex) {
+  ctx.push(`<code class="math-source" hidden aria-hidden="true">`);
+  ctx.push(escapeHtml(latex));
+  ctx.push(`</code>`);
+}
+function pushMathRender(ctx, mathml, fallback) {
+  ctx.push(`<span class="math-render">`);
+  if (mathml) {
+    ctx.push(mathml);
+  } else {
+    fallback();
+  }
+  ctx.push(`</span>`);
+}
+
+// packages/render/src/elements/math/block.ts
 function renderMath(ctx, data) {
   const index = ctx.nextEquationIndex() + 1;
   const latex = data["latex-source"];
@@ -4144,38 +5046,28 @@ function renderMath(ctx, data) {
   if (data.name) {
     ctx.push(`<span class="equation-number">(${index})</span>`);
   }
-  ctx.push(`<code class="math-source" hidden aria-hidden="true">`);
-  ctx.push(escapeHtml(latex));
-  ctx.push(`</code>`);
-  ctx.push(`<span class="math-render">`);
-  if (mathml) {
-    ctx.push(mathml);
-  } else {
+  pushHiddenLatexSource(ctx, latex);
+  pushMathRender(ctx, mathml, () => {
     ctx.push(`<span class="math-error">`);
     ctx.push(escapeHtml(latex));
     ctx.push(`</span>`);
-  }
-  ctx.push(`</span>`);
+  });
   ctx.push("</div>");
 }
+// packages/render/src/elements/math/inline.ts
 function renderMathInline(ctx, data) {
   const latex = data["latex-source"];
   const mathml = renderLatexToMathML(latex, false);
   ctx.push(`<span class="math-inline">`);
-  ctx.push(`<code class="math-source" hidden aria-hidden="true">`);
-  ctx.push(escapeHtml(latex));
-  ctx.push(`</code>`);
-  ctx.push(`<span class="math-render">`);
-  if (mathml) {
-    ctx.push(mathml);
-  } else {
+  pushHiddenLatexSource(ctx, latex);
+  pushMathRender(ctx, mathml, () => {
     ctx.push(`<span class="math-error">$`);
     ctx.push(escapeHtml(latex));
     ctx.push(`$</span>`);
-  }
-  ctx.push(`</span>`);
+  });
   ctx.push("</span>");
 }
+// packages/render/src/elements/math/equation-ref.ts
 function renderEquationRef(ctx, name) {
   const id = ctx.generateId("equation-", name);
   ctx.push(`<span class="eref" data-target="${escapeAttr(id)}">`);
@@ -4185,62 +5077,82 @@ function renderEquationRef(ctx, name) {
   ctx.push(`<span class="eref-tooltip" aria-hidden="true"></span>`);
   ctx.push("</span>");
 }
+// packages/render/src/elements/module/empty-container.ts
+function renderEmptyModuleContainer(ctx, className) {
+  ctx.push(`<div class="${className}">`);
+  ctx.push("</div>");
+}
+function renderIndentedEmptyModuleContainer(ctx, className) {
+  ctx.push(`<div class="${className}">
+	</div>`);
+}
 
 // packages/render/src/elements/module/backlinks.ts
 function renderBacklinks(ctx, _data) {
-  ctx.push(`<div class="backlinks-module-box">
-	</div>`);
+  renderIndentedEmptyModuleContainer(ctx, "backlinks-module-box");
 }
 
 // packages/render/src/elements/module/categories.ts
 function renderCategories(ctx, _data) {
-  ctx.push(`<div class="categories-module-box">`);
-  ctx.push("</div>");
+  renderEmptyModuleContainer(ctx, "categories-module-box");
+}
+
+// packages/render/src/elements/module/join-markup.ts
+function renderJoinMarkup(data) {
+  const buttonText = data["button-text"] ?? "Join";
+  const className = data.attributes?.class ?? "join-box";
+  return `<div class="${escapeAttr(className)}"><a href="javascript:;">${escapeHtml(buttonText)}</a></div>`;
 }
 
 // packages/render/src/elements/module/join.ts
 function renderJoin(ctx, data) {
-  const buttonText = data["button-text"] ?? "Join";
-  const attrs = data.attributes ?? {};
-  const className = attrs.class ?? "join-box";
-  ctx.push(`<div class="${escapeAttr(className)}">`);
-  ctx.push(`<a href="javascript:;">${escapeHtml(buttonText)}</a>`);
-  ctx.push("</div>");
+  ctx.push(renderJoinMarkup(data));
 }
 
 // packages/render/src/elements/module/page-tree.ts
 function renderPageTree(ctx, _data) {
-  ctx.push(`<div class="page-tree-module-box">`);
-  ctx.push("</div>");
+  renderEmptyModuleContainer(ctx, "page-tree-module-box");
+}
+
+// packages/render/src/elements/module/rate-markup.ts
+function getRateWidgetParts() {
+  return [
+    `<div class="page-rate-widget-box">`,
+    `<span class="rate-points">rating:&nbsp;<span class="number prw54353">0</span></span>`,
+    `<span class="rateup btn btn-default"><a title="I like it" href="javascript:;">+</a></span>`,
+    `<span class="ratedown btn btn-default"><a title="I don't like it" href="javascript:;">&#8211;</a></span>`,
+    `<span class="cancel btn btn-default"><a title="Cancel my vote" href="javascript:;">x</a></span>`,
+    "</div>"
+  ];
 }
 
 // packages/render/src/elements/module/rate.ts
 function renderRate(ctx) {
-  ctx.push(`<div class="page-rate-widget-box">`);
-  ctx.push(`<span class="rate-points">rating:&nbsp;<span class="number prw54353">0</span></span>`);
-  ctx.push(`<span class="rateup btn btn-default"><a title="I like it" href="javascript:;">+</a></span>`);
-  ctx.push(`<span class="ratedown btn btn-default"><a title="I don't like it" href="javascript:;">&#8211;</a></span>`);
-  ctx.push(`<span class="cancel btn btn-default"><a title="Cancel my vote" href="javascript:;">x</a></span>`);
-  ctx.push("</div>");
+  for (const part of getRateWidgetParts()) {
+    ctx.push(part);
+  }
 }
 
 // packages/render/src/elements/module/listusers.ts
 function renderListUsers(ctx, _data) {
-  ctx.push(`<div class="list-users-module-box">`);
-  ctx.push("</div>");
+  renderEmptyModuleContainer(ctx, "list-users-module-box");
 }
 
 // packages/render/src/elements/module/listpages.ts
 function renderListPages(ctx, _data) {
-  ctx.push(`<div class="list-pages-box">`);
-  ctx.push("</div>");
+  renderEmptyModuleContainer(ctx, "list-pages-box");
+}
+
+// packages/render/src/elements/module/unknown.ts
+function renderUnknownModule(ctx, data) {
+  ctx.push(`<div class="error-block">[[module <em>${data.name}</em>]] No such module, please <a href="https://www.wikidot.com/doc:modules" target="_blank" rel="noopener noreferrer">check available modules</a> and fix this page.</div>`);
 }
 
 // packages/render/src/elements/module/index.ts
 function renderModule(ctx, data) {
   switch (data.module) {
     case "unknown":
-      ctx.push(`<div class="error-block">[[module <em>${data.name}</em>]] No such module, please <a href="https://www.wikidot.com/doc:modules" target="_blank" rel="noopener noreferrer">check available modules</a> and fix this page.</div>`);
+      renderUnknownModule(ctx, data);
       break;
     case "backlinks":
       renderBacklinks(ctx, data);
@@ -4266,306 +5178,166 @@ function renderModule(ctx, data) {
   }
 }
 
-// packages/render/src/elements/embed.ts
-function isValidVideoId(id) {
-  return /^[a-zA-Z0-9_-]+$/.test(id);
-}
-function isValidGithubUsername(username) {
-  return /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,37}[a-zA-Z0-9])?$/.test(username);
-}
-function isValidGistHash(hash) {
-  return /^[a-f0-9]+$/.test(hash);
-}
-function isValidGitlabSnippetId(id) {
-  return /^[0-9]+$/.test(id);
+// packages/render/src/elements/table/cell-attributes.ts
+function renderTableCellAttrs(cell) {
+  const attrs = [];
+  const safeCellAttrs = sanitizeAttributes(cell.attributes);
+  appendColumnSpan(attrs, cell);
+  appendRowSpan(attrs, safeCellAttrs);
+  appendAlignmentStyle(attrs, cell, safeCellAttrs);
+  appendRemainingCellAttributes(attrs, cell, safeCellAttrs);
+  return attrs.length > 0 ? " " + attrs.join(" ") : "";
 }
-function renderEmbed(ctx, data) {
-  switch (data.embed) {
-    case "youtube":
-      renderYoutube(ctx, data.data["video-id"]);
-      break;
-    case "vimeo":
-      renderVimeo(ctx, data.data["video-id"]);
-      break;
-    case "github-gist":
-      renderGithubGist(ctx, data.data.username, data.data.hash);
-      break;
-    case "gitlab-snippet":
-      renderGitlabSnippet(ctx, data.data["snippet-id"]);
-      break;
+function appendColumnSpan(attrs, cell) {
+  if (cell["column-span"] > 1) {
+    attrs.push(`colspan="${cell["column-span"]}"`);
   }
 }
-function renderYoutube(ctx, videoId) {
-  if (!isValidVideoId(videoId)) {
-    ctx.push(`<!-- Invalid YouTube video ID -->`);
+function appendRowSpan(attrs, safeCellAttrs) {
+  if (!safeCellAttrs.rowspan) {
     return;
   }
-  ctx.push(`<div class="embed-youtube">`);
-  ctx.push(`<iframe src="https://www.youtube.com/embed/${escapeAttr(videoId)}" ` + `frameborder="0" allowfullscreen></iframe>`);
-  ctx.push("</div>");
-}
-function renderVimeo(ctx, videoId) {
-  if (!isValidVideoId(videoId)) {
-    ctx.push(`<!-- Invalid Vimeo video ID -->`);
-    return;
+  const rowspan = parseInt(safeCellAttrs.rowspan, 10);
+  if (rowspan > 1) {
+    attrs.push(`rowspan="${rowspan}"`);
   }
-  ctx.push(`<div class="embed-vimeo">`);
-  ctx.push(`<iframe src="https://player.vimeo.com/video/${escapeAttr(videoId)}" ` + `frameborder="0" allowfullscreen></iframe>`);
-  ctx.push("</div>");
 }
-function renderGithubGist(ctx, username, hash) {
-  if (!isValidGithubUsername(username) || !isValidGistHash(hash)) {
-    ctx.push(`<!-- Invalid GitHub Gist parameters -->`);
+function appendAlignmentStyle(attrs, cell, safeCellAttrs) {
+  if (!cell.align) {
     return;
   }
-  ctx.push(`<script src="https://gist.github.com/${escapeAttr(username)}/${escapeAttr(hash)}.js"></script>`);
+  const existingStyle = safeCellAttrs.style ?? "";
+  const alignStyle = `text-align: ${cell.align};`;
+  if (existingStyle) {
+    attrs.push(`style="${escapeAttr(existingStyle + "; " + alignStyle)}"`);
+  } else {
+    attrs.push(`style="${alignStyle}"`);
+  }
 }
-function renderGitlabSnippet(ctx, snippetId) {
-  if (!isValidGitlabSnippetId(snippetId)) {
-    ctx.push(`<!-- Invalid GitLab snippet ID -->`);
-    return;
+function appendRemainingCellAttributes(attrs, cell, safeCellAttrs) {
+  for (const key in safeCellAttrs) {
+    if (key === "style" && cell.align)
+      continue;
+    if (key === "rowspan")
+      continue;
+    const value = safeCellAttrs[key];
+    attrs.push(`${key}="${escapeAttr(value)}"`);
   }
-  ctx.push(`<script src="https://gitlab.com/snippets/${escapeAttr(snippetId)}.js"></script>`);
 }
 
-// packages/render/src/elements/embed-block.ts
-import { parseDocument } from "htmlparser2";
-import sanitizeHtml from "sanitize-html";
-var BOOLEAN_ATTRIBUTES = [
-  "allowfullscreen",
-  "async",
-  "autofocus",
-  "autoplay",
-  "checked",
-  "controls",
-  "default",
-  "defer",
-  "disabled",
-  "formnovalidate",
-  "hidden",
-  "ismap",
-  "loop",
-  "multiple",
-  "muted",
-  "novalidate",
-  "open",
-  "readonly",
-  "required",
-  "reversed",
-  "selected"
-];
-var DEFAULT_EMBED_ALLOWLIST = [
-  { host: "*.youtube.com", pathPrefix: "/embed/" },
-  { host: "*.youtube-nocookie.com", pathPrefix: "/embed/" },
-  { host: "player.vimeo.com", pathPrefix: "/video/" },
-  { host: "*.google.com", pathPrefix: "/maps/embed" },
-  { host: "calendar.google.com", pathPrefix: "/calendar/embed" },
-  { host: "open.spotify.com", pathPrefix: "/embed/" },
-  { host: "w.soundcloud.com", pathPrefix: "/player/" },
-  { host: "codepen.io" }
-];
-var SANITIZE_CONFIG = {
-  allowedTags: ["iframe"],
-  allowedAttributes: {
-    iframe: [
-      "class",
-      "src",
-      "style",
-      "allow",
-      "allowfullscreen",
-      "frameborder",
-      "height",
-      "loading",
-      "referrerpolicy",
-      "sandbox",
-      "title",
-      "width"
-    ]
-  },
-  allowedSchemes: ["https", "http"]
-};
-function findIframes(html) {
-  const doc = parseDocument(html);
-  const iframes = [];
-  function walk(nodes) {
-    for (const node of nodes) {
-      if (node.type === "tag") {
-        if (node.name === "iframe") {
-          iframes.push(node);
-        }
-        if (node.children) {
-          walk(node.children);
-        }
-      }
+// packages/render/src/elements/table/attributes.ts
+function renderTableAttrs(attributes) {
+  let hasRenderableAttributes = false;
+  for (const key in attributes) {
+    if (!key.startsWith("_")) {
+      hasRenderableAttributes = true;
+      break;
     }
   }
-  walk(doc.children);
-  return iframes;
-}
-function matchesHostPattern(hostname, pattern) {
-  const lowerHostname = hostname.toLowerCase();
-  const lowerPattern = pattern.toLowerCase();
-  if (lowerPattern.startsWith("*.")) {
-    const base = lowerPattern.slice(2);
-    return lowerHostname === base || lowerHostname.endsWith("." + base);
+  if (!hasRenderableAttributes)
+    return "";
+  const safe = sanitizeAttributes(attributes);
+  let result = "";
+  for (const key in safe) {
+    if (key.startsWith("_"))
+      continue;
+    const value = safe[key];
+    result += ` ${key}="${escapeAttr(value)}"`;
   }
-  return lowerHostname === lowerPattern;
+  return result;
 }
-function matchesAllowlistEntry(url, entry) {
-  if (!matchesHostPattern(url.hostname, entry.host)) {
-    return false;
-  }
-  if (entry.pathPrefix) {
-    const pathLower = url.pathname.toLowerCase();
-    const prefixLower = entry.pathPrefix.toLowerCase();
-    if (!pathLower.startsWith(prefixLower)) {
-      return false;
-    }
-    if (!prefixLower.endsWith("/")) {
-      const remainder = pathLower.slice(prefixLower.length);
-      if (remainder && !/^[/?#]/.test(remainder)) {
-        return false;
-      }
-    }
-  }
-  return true;
+
+// packages/render/src/elements/table/cell.ts
+function renderTableCell(ctx, cell) {
+  const tag = cell.header ? "th" : "td";
+  const attrStr = renderTableCellAttrs(cell);
+  ctx.push(`<${tag}${attrStr}>`);
+  renderElements(ctx, cell.elements);
+  ctx.push(`</${tag}>`);
 }
-function validateAndSanitizeEmbed(content, allowlist, baseUrl) {
-  const sanitized = sanitizeHtml(content.trim(), SANITIZE_CONFIG);
-  if (!sanitized.trim()) {
-    return null;
-  }
-  const iframes = findIframes(sanitized);
-  if (iframes.length !== 1) {
-    return null;
-  }
-  const iframe = iframes[0];
-  const src = iframe.attribs.src?.trim();
-  if (!src) {
-    return null;
-  }
-  let url;
-  try {
-    if (src.startsWith("//")) {
-      const base = baseUrl ?? "https://localhost";
-      url = new URL(src, base);
-    } else {
-      url = new URL(src);
-    }
-  } catch {
-    return null;
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    return null;
-  }
-  if (allowlist !== null) {
-    const matched = allowlist.some((entry) => matchesAllowlistEntry(url, entry));
-    if (!matched) {
-      return null;
+
+// packages/render/src/elements/table/index.ts
+function renderTable(ctx, data) {
+  const isPipeTable = data.attributes._source === "pipe";
+  const classAttr = isPipeTable ? ' class="wiki-content-table"' : "";
+  ctx.push(`<table${classAttr}${renderTableAttrs(data.attributes)}>`);
+  for (const row of data.rows) {
+    ctx.push(`<tr${renderTableAttrs(row.attributes)}>`);
+    for (const cell of row.cells) {
+      renderTableCell(ctx, cell);
     }
+    ctx.push("</tr>");
   }
-  return sanitized;
+  ctx.push("</table>");
 }
-function normalizeBooleanAttributes(html) {
-  let result = html;
-  for (const attr of BOOLEAN_ATTRIBUTES) {
-    const standalonePattern = new RegExp(`\\s${attr}(?=\\s|>|/>)`, "gi");
-    result = result.replace(standalonePattern, ` ${attr}="${attr}"`);
-    const emptyValuePattern = new RegExp(`\\s${attr}=""`, "gi");
-    result = result.replace(emptyValuePattern, ` ${attr}="${attr}"`);
-  }
-  return result;
+
+// packages/render/src/elements/tab-view/ids.ts
+function getTabViewWidgetId(ctx, tabs, tabViewIndex) {
+  const labelString = tabs.map((tab) => tab.label).join("");
+  return ctx.generateFixedId(`wiki-tabview-${tabViewIndex}-${syncHashMd5(labelString)}`);
 }
-function renderEmbedBlock(ctx, data) {
-  const allowlist = ctx.options.embedAllowlist !== undefined ? ctx.options.embedAllowlist : DEFAULT_EMBED_ALLOWLIST;
-  const sanitized = validateAndSanitizeEmbed(data.contents, allowlist, ctx.options.baseUrl);
-  if (sanitized === null) {
-    ctx.push('<div class="error-block">Sorry, no match for the embedded content.</div>');
-    return;
-  }
-  const normalized = normalizeBooleanAttributes(sanitized);
-  ctx.push(normalized);
+function getTabPanelId(ctx, tabViewIndex, tabIndex) {
+  return ctx.generateId(`wiki-tab-${tabViewIndex}-`, tabIndex);
 }
 
-// packages/render/src/elements/user.ts
-function renderUser(ctx, data) {
-  const normalized = data.name.toLowerCase().trim();
-  if (normalized === "anonymous") {
-    ctx.push("Anonymous");
-    return;
-  }
-  const resolved = ctx.options.resolvers?.user?.(data.name) ?? null;
-  if (resolved === null) {
-    ctx.push(escapeHtml(data.name));
-    return;
-  }
-  const displayName = resolved.name ?? data.name;
-  const hrefAttr = resolved.url ? ` href="${escapeAttr(resolved.url)}"` : "";
-  const showAvatar = data["show-avatar"] && resolved.url && resolved.avatarUrl;
-  if (showAvatar) {
-    const styleAttr = resolved.karmaUrl ? ` style="background-image:url(${escapeAttr(resolved.karmaUrl)})"` : "";
-    ctx.push(`<span class="printuser avatarhover">`);
-    ctx.push(`<a${hrefAttr}>`);
-    ctx.push(`<img class="small" src="${escapeAttr(resolved.avatarUrl)}" alt="${escapeAttr(displayName)}"${styleAttr} />`);
-    ctx.push("</a>");
-    ctx.push(`<a${hrefAttr}>`);
-    ctx.push(escapeHtml(displayName));
-    ctx.push("</a>");
-    ctx.push("</span>");
-  } else {
-    ctx.push(`<span class="printuser">`);
-    ctx.push(`<a${hrefAttr}>`);
-    ctx.push(escapeHtml(displayName));
-    ctx.push("</a>");
-    ctx.push("</span>");
+// packages/render/src/elements/tab-view/panels.ts
+function renderTabPanels(ctx, tabs, tabViewIndex) {
+  ctx.push(`<div class="yui-content">`);
+  for (let i = 0;i < tabs.length; i++) {
+    const tab = tabs[i];
+    const displayStyle = i === 0 ? "" : ` style="display:none"`;
+    ctx.push(`<div id="${getTabPanelId(ctx, tabViewIndex, i)}"${displayStyle}>`);
+    renderElements(ctx, tab.elements);
+    ctx.push("</div>");
   }
+  ctx.push("</div>");
 }
 
-// packages/render/src/elements/bibliography.ts
-function generateIdSuffix(label, counter) {
-  let h = 2166136261;
-  const input = label + counter;
-  for (let i = 0;i < input.length; i++) {
-    h ^= input.charCodeAt(i);
-    h = Math.imul(h, 16777619);
+// packages/render/src/elements/tab-view/navigation.ts
+function renderTabNavigation(ctx, tabs) {
+  ctx.push(`<ul class="yui-nav">`);
+  for (let i = 0;i < tabs.length; i++) {
+    const tab = tabs[i];
+    const selectedClass = i === 0 ? ` class="selected"` : "";
+    ctx.push(`<li${selectedClass}>`);
+    ctx.push(`<a href="javascript:;"><em>${escapeHtml(tab.label)}</em></a>`);
+    ctx.push("</li>");
   }
-  return (h >>> 0).toString(16).slice(0, 6);
+  ctx.push("</ul>");
 }
-function renderBibliographyCite(ctx, data) {
-  const number = ctx.bibliographyMap.get(data.label);
-  const counter = ctx.nextBibciteCounter();
-  if (number === undefined) {
-    ctx.push(escapeHtml(data.label));
+
+// packages/render/src/elements/tab-view/index.ts
+function renderTabView(ctx, tabs) {
+  const tabViewIndex = ctx.nextTabViewIndex();
+  const widgetId = getTabViewWidgetId(ctx, tabs, tabViewIndex);
+  ctx.push(`<div id="${widgetId}" class="yui-navset">`);
+  renderTabNavigation(ctx, tabs);
+  renderTabPanels(ctx, tabs, tabViewIndex);
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/text/email.ts
+function renderEmail(ctx, email) {
+  if (!isValidEmail(email)) {
+    ctx.pushEscaped(email);
     return;
   }
-  const idSuffix = generateIdSuffix(data.label, counter);
-  const id = ctx.generateId(`bibcite-${number}-`, idSuffix);
-  const bibitemId = ctx.generateId("bibitem-", number);
-  const onclick = `WIKIDOT.page.utils.scrollToReference('${bibitemId}')`;
-  ctx.push(`<a href="javascript:;" class="bibcite" id="${id}" onclick="${escapeAttr(onclick)}">`);
-  ctx.push(String(number));
-  ctx.push("</a>");
+  ctx.push(`<a href="mailto:${escapeAttr(email)}">${escapeHtml(email)}</a>`);
 }
-function renderBibliographyBlock(ctx, data, renderElements2) {
-  if (data.hide)
+// packages/render/src/elements/text/raw.ts
+function renderRaw(ctx, data) {
+  if (data === "")
     return;
-  const title = data.title ?? "Bibliography";
-  ctx.push(`<div class="bibitems">`);
-  ctx.push(`<div class="title">${escapeHtml(title)}</div>`);
-  let index = 1;
-  for (const entry of data.entries) {
-    const itemId = ctx.generateId("bibitem-", index);
-    ctx.push(`<div class="bibitem" id="${itemId}">`);
-    ctx.push(`${index}. `);
-    renderElements2(ctx, entry.value);
-    ctx.push("</div>");
-    index++;
-  }
-  ctx.push("</div>");
+  ctx.push(`<span style="white-space: pre-wrap;">`);
+  ctx.push(escapeHtml(data).replace(/ /g, "&#32;"));
+  ctx.push("</span>");
 }
-
-// packages/render/src/elements/toc.ts
-function extractLinkText(element) {
+// packages/render/src/elements/text/plain.ts
+function renderText(ctx, data) {
+  ctx.pushEscaped(data);
+}
+// packages/render/src/elements/toc/link.ts
+function extractTocLink(element) {
   if (element.element !== "link")
     return null;
   const label = element.data.label;
@@ -4576,6 +5348,14 @@ function extractLinkText(element) {
   const href = typeof element.data.link === "string" ? element.data.link : "";
   return { href, text };
 }
+function rewriteTocAnchor(ctx, href) {
+  const match = /^#toc(\d+)$/.exec(href);
+  if (!match)
+    return href;
+  return `#${ctx.generateId("toc", Number(match[1]))}`;
+}
+
+// packages/render/src/elements/toc/entries.ts
 function renderTocEntries(ctx, elements) {
   for (const element of elements) {
     if (element.element === "list") {
@@ -4588,16 +5368,10 @@ function renderTocList(ctx, listData, depth) {
     renderTocItem(ctx, item, depth);
   }
 }
-function rewriteTocAnchor(ctx, href) {
-  const match = /^#toc(\d+)$/.exec(href);
-  if (!match)
-    return href;
-  return `#${ctx.generateId("toc", Number(match[1]))}`;
-}
 function renderTocItem(ctx, item, depth) {
   if (item["item-type"] === "elements") {
     for (const el of item.elements) {
-      const link = extractLinkText(el);
+      const link = extractTocLink(el);
       if (link) {
         const href = rewriteTocAnchor(ctx, link.href);
         ctx.push(`<div style="margin-left: ${depth}em;"><a href="${escapeAttr(href)}">${escapeHtml(link.text)}</a></div>`);
@@ -4607,598 +5381,122 @@ function renderTocItem(ctx, item, depth) {
     renderTocList(ctx, item.data, depth + 1);
   }
 }
-function renderTableOfContents(ctx, data) {
-  const isFloat = data.align === "left" || data.align === "right";
-  if (!isFloat) {
+
+// packages/render/src/elements/toc/body.ts
+function renderTocBody(ctx) {
+  ctx.push(`<div id="toc-action-bar"><a href="javascript:;">Fold</a><a style="display: none" href="javascript:;">Unfold</a></div>`);
+  ctx.push(`<div class="title">Table of Contents</div>`);
+  ctx.push(`<div id="toc-list">`);
+  renderTocEntries(ctx, ctx.tocElements);
+  ctx.push("</div>");
+}
+
+// packages/render/src/elements/toc/frame.ts
+function isFloatingToc(align) {
+  return align === "left" || align === "right";
+}
+function openTocFrame(ctx, align) {
+  if (!isFloatingToc(align)) {
     ctx.push(`<table style="margin:0; padding:0"><tr><td style="margin:0; padding:0">`);
   }
-  if (isFloat) {
-    const floatClass = data.align === "left" ? "floatleft" : "floatright";
+  if (isFloatingToc(align)) {
+    const floatClass = align === "left" ? "floatleft" : "floatright";
     ctx.push(`<div id="toc" class="${floatClass}">`);
   } else {
     ctx.push(`<div id="toc">`);
   }
-  ctx.push(`<div id="toc-action-bar"><a href="javascript:;">Fold</a><a style="display: none" href="javascript:;">Unfold</a></div>`);
-  ctx.push(`<div class="title">Table of Contents</div>`);
-  ctx.push(`<div id="toc-list">`);
-  renderTocEntries(ctx, ctx.tocElements);
-  ctx.push("</div>");
+}
+function closeTocFrame(ctx, align) {
   ctx.push("</div>");
-  if (!isFloat) {
+  if (!isFloatingToc(align)) {
     ctx.push(`</td></tr></table>`);
   }
 }
 
-// packages/render/src/elements/line-break.ts
-function renderLineBreaks(ctx, count) {
-  for (let i = 0;i < count; i++) {
-    ctx.push("<br />");
-  }
-}
-
-// packages/render/src/elements/clear-float.ts
-function renderClearFloat(ctx, direction) {
-  ctx.push(`<div style="clear:${direction}; height: 0px; font-size: 1px"></div>`);
+// packages/render/src/elements/toc/index.ts
+function renderTableOfContents(ctx, data) {
+  openTocFrame(ctx, data.align);
+  renderTocBody(ctx);
+  closeTocFrame(ctx, data.align);
 }
 
-// packages/render/src/elements/iframe.ts
-function renderIframe(ctx, data) {
-  const url = isDangerousUrl(data.url) ? "#invalid-url" : data.url;
-  const attrs = [`src="${escapeAttr(url)}"`];
-  const iframeAttrs = ["align", "frameborder", "height", "scrolling", "width", "class", "style"];
-  for (const attr of iframeAttrs) {
-    let value = data.attributes[attr] ?? "";
-    if (attr === "style") {
-      value = sanitizeStyleValue(value);
-    }
-    attrs.push(`${attr}="${escapeAttr(value)}"`);
-  }
-  ctx.push(`<p><iframe ${attrs.join(" ")}></iframe></p>`);
+// packages/render/src/elements/user/resolve.ts
+function getResolvedUser(ctx, username) {
+  return ctx.options.resolvers?.user?.(username) ?? null;
 }
 
-// packages/render/src/elements/html.ts
-function generateDefaultUrl(pageName, contents) {
-  const hash = syncHashSha1(contents);
-  const nonce = BigInt(contents.length) * 1000000000n + BigInt(hash.charCodeAt(0)) * 100000000n;
-  const path = pageName ? `/${pageName}/html/${hash}-${nonce}` : `/html/${hash}-${nonce}`;
-  return path;
+// packages/render/src/elements/user/markup.ts
+function renderLinkedUser(ctx, username, user) {
+  const displayName = user.name ?? username;
+  const hrefAttr = user.url ? ` href="${escapeAttr(user.url)}"` : "";
+  ctx.push(`<span class="printuser">`);
+  ctx.push(`<a${hrefAttr}>`);
+  ctx.push(escapeHtml(displayName));
+  ctx.push("</a>");
+  ctx.push("</span>");
 }
-function renderHtmlBlock(ctx, data) {
-  if (ctx.settings.allowHtmlBlocks === false) {
-    return;
-  }
-  const index = ctx.nextHtmlBlockIndex();
-  const pageName = ctx.page?.pageName ?? "";
-  const callbackUrl = ctx.options.resolvers?.htmlBlockUrl?.(index);
-  const src = callbackUrl || generateDefaultUrl(pageName, data.contents);
-  const sandbox = ctx.options.htmlBlockSandbox;
-  const sandboxAttr = sandbox ? ` sandbox="${escapeAttr(sandbox)}"` : "";
-  const styleAttr = data.style ? ` style="${escapeAttr(sanitizeStyleValue(data.style))}"` : "";
-  ctx.push(`<p><iframe src="${escapeAttr(src)}"${sandboxAttr} allowtransparency="true" frameborder="0" class="html-block-iframe"${styleAttr}></iframe></p>`);
+function renderAvatarUser(ctx, username, user) {
+  const displayName = user.name ?? username;
+  const hrefAttr = user.url ? ` href="${escapeAttr(user.url)}"` : "";
+  const avatarUrl = user.avatarUrl ?? "";
+  const styleAttr = user.karmaUrl ? ` style="background-image:url(${escapeAttr(user.karmaUrl)})"` : "";
+  ctx.push(`<span class="printuser avatarhover">`);
+  ctx.push(`<a${hrefAttr}>`);
+  ctx.push(`<img class="small" src="${escapeAttr(avatarUrl)}" alt="${escapeAttr(displayName)}"${styleAttr} />`);
+  ctx.push("</a>");
+  ctx.push(`<a${hrefAttr}>`);
+  ctx.push(escapeHtml(displayName));
+  ctx.push("</a>");
+  ctx.push("</span>");
 }
 
-// packages/render/src/elements/include.ts
-function renderInclude(ctx, data) {
-  if (data.elements.length === 0) {
-    const pageName = data.location.page.toLowerCase();
-    const encodedPageName = pageName.replace(/[^a-z0-9\-_:/]/g, (c) => encodeURIComponent(c));
-    const safePath = encodedPageName.startsWith("/") ? encodedPageName.slice(1) : encodedPageName;
-    ctx.push(`<div class="error-block"><p>Included page "${escapeHtml(pageName)}" does not exist (<a href="/${escapeAttr(safePath)}/edit/true">create it now</a>)</p></div>`);
+// packages/render/src/elements/user/index.ts
+function renderUser(ctx, data) {
+  const normalized = data.name.toLowerCase().trim();
+  if (normalized === "anonymous") {
+    ctx.push("Anonymous");
     return;
   }
-  renderElements(ctx, data.elements);
-}
-
-// packages/render/src/elements/iftags.ts
-function evaluateIfTagsCondition(condition, pageTags) {
-  const pageTagSet = new Set(pageTags.map((t) => t.toLowerCase()));
-  const tokens = condition.split(/\s+/).filter(Boolean);
-  if (tokens.length === 0) {
-    return false;
-  }
-  const required = [];
-  const excluded = [];
-  const optional = [];
-  for (const token of tokens) {
-    if (token.startsWith("+")) {
-      const tag = token.slice(1).toLowerCase();
-      if (tag)
-        required.push(tag);
-    } else if (token.startsWith("-")) {
-      const tag = token.slice(1).toLowerCase();
-      if (tag)
-        excluded.push(tag);
-    } else {
-      optional.push(token.toLowerCase());
-    }
-  }
-  if (required.length === 0 && excluded.length === 0 && optional.length === 0) {
-    return false;
-  }
-  for (const tag of required) {
-    if (!pageTagSet.has(tag))
-      return false;
-  }
-  for (const tag of excluded) {
-    if (pageTagSet.has(tag))
-      return false;
-  }
-  if (optional.length > 0) {
-    const hasAnyOptional = optional.some((tag) => pageTagSet.has(tag));
-    if (!hasAnyOptional)
-      return false;
-  }
-  return true;
-}
-function renderIfTags(ctx, data) {
-  const pageTags = ctx.page?.tags ?? [];
-  if (evaluateIfTagsCondition(data.condition, pageTags)) {
-    const prev = ctx.renderInlineStyles;
-    ctx.renderInlineStyles = true;
-    const slotId = data._styleSlot;
-    if (slotId !== undefined) {
-      ctx.enterStyleSlot(slotId);
-    }
-    renderElements(ctx, data.elements);
-    if (slotId !== undefined) {
-      ctx.exitStyleSlot();
-    }
-    ctx.renderInlineStyles = prev;
+  const resolved = getResolvedUser(ctx, data.name);
+  if (resolved === null) {
+    ctx.push(escapeHtml(data.name));
+    return;
   }
-}
-
-// packages/render/src/elements/color.ts
-function renderColor(ctx, data) {
-  const safeColor = sanitizeCssColor(data.color, "inherit");
-  ctx.push(`<span style="color: ${escapeAttr(safeColor)}">`);
-  renderElements(ctx, data.elements);
-  ctx.push("</span>");
-}
-
-// packages/render/src/elements/date.ts
-function renderDate(ctx, data) {
-  const date = new Date(data.value.timestamp * 1000);
-  const formatted = data.format ? formatDate(date, data.format) : date.toLocaleString();
-  if (data.hover) {
-    ctx.push(`<span class="odate">${escapeHtml(formatted)}</span>`);
+  const showAvatar = data["show-avatar"] && resolved.url && resolved.avatarUrl;
+  if (showAvatar) {
+    renderAvatarUser(ctx, data.name, resolved);
   } else {
-    ctx.push(escapeHtml(formatted));
+    renderLinkedUser(ctx, data.name, resolved);
   }
 }
-function formatDate(date, format) {
-  return format.replace(/%Y/g, String(date.getFullYear())).replace(/%m/g, String(date.getMonth() + 1).padStart(2, "0")).replace(/%d/g, String(date.getDate()).padStart(2, "0")).replace(/%H/g, String(date.getHours()).padStart(2, "0")).replace(/%M/g, String(date.getMinutes()).padStart(2, "0")).replace(/%S/g, String(date.getSeconds()).padStart(2, "0"));
-}
 
-// packages/render/src/utils/expr-eval.ts
-var FALSE_VALUES = new Set(["false", "null", "", "0"]);
-function isTruthy(value) {
-  return !FALSE_VALUES.has(value.toLowerCase().trim());
+// packages/render/src/render/primitives.ts
+function renderTextNode(ctx, text) {
+  ctx.pushEscaped(text);
 }
-var MAX_EXPRESSION_LENGTH = 256;
-function isTruthyNum(n) {
-  return n !== 0 && !Number.isNaN(n);
-}
-function evaluateExpression(expr) {
-  try {
-    if (expr.length > MAX_EXPRESSION_LENGTH) {
-      return { success: false, error: "expression too long" };
-    }
-    if (expr.trim() === "") {
-      return { success: false, error: "empty expression" };
-    }
-    const tokens = tokenize2(expr);
-    if (tokens.length <= 1) {
-      return { success: false, error: "empty expression" };
-    }
-    const parser = new ExprParser(tokens);
-    const result = parser.parse();
-    if (!Number.isFinite(result)) {
-      return { success: false, error: "division by zero" };
-    }
-    return { success: true, value: result };
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "unknown error";
-    return { success: false, error: msg };
-  }
+function renderLineBreak(ctx) {
+  ctx.push("<br />");
 }
-function tokenize2(expr) {
-  const tokens = [];
-  let i = 0;
-  while (i < expr.length) {
-    const ch = expr[i];
-    if (/\s/.test(ch)) {
-      i++;
-      continue;
-    }
-    if (/\d/.test(ch) || ch === "." && /\d/.test(expr[i + 1] ?? "")) {
-      let numStr = "";
-      let hasDot = false;
-      while (i < expr.length) {
-        const c = expr[i];
-        if (c === ".") {
-          if (hasDot)
-            break;
-          hasDot = true;
-        } else if (!/\d/.test(c)) {
-          break;
-        }
-        numStr += c;
-        i++;
-      }
-      const num = parseFloat(numStr);
-      if (!Number.isFinite(num)) {
-        throw new Error("Invalid number");
-      }
-      tokens.push({ kind: "NUMBER", value: num });
-      continue;
-    }
-    if (/[a-zA-Z_]/.test(ch)) {
-      let id = "";
-      while (i < expr.length) {
-        const c = expr[i];
-        if (!/[a-zA-Z0-9_]/.test(c))
-          break;
-        id += c;
-        i++;
-      }
-      tokens.push({ kind: "IDENTIFIER", value: id.toLowerCase() });
-      continue;
-    }
-    if (ch === "<" && expr[i + 1] === "=") {
-      tokens.push({ kind: "LE", value: "<=" });
-      i += 2;
-      continue;
-    }
-    if (ch === ">" && expr[i + 1] === "=") {
-      tokens.push({ kind: "GE", value: ">=" });
-      i += 2;
-      continue;
-    }
-    if (ch === "!" && expr[i + 1] === "=") {
-      tokens.push({ kind: "NE", value: "!=" });
-      i += 2;
-      continue;
-    }
-    if (ch === "<" && expr[i + 1] === ">") {
-      tokens.push({ kind: "NE", value: "<>" });
-      i += 2;
-      continue;
-    }
-    switch (ch) {
-      case "+":
-        tokens.push({ kind: "PLUS", value: "+" });
-        break;
-      case "-":
-        tokens.push({ kind: "MINUS", value: "-" });
-        break;
-      case "*":
-        tokens.push({ kind: "STAR", value: "*" });
-        break;
-      case "/":
-        tokens.push({ kind: "SLASH", value: "/" });
-        break;
-      case "%":
-        tokens.push({ kind: "PERCENT", value: "%" });
-        break;
-      case "^":
-        tokens.push({ kind: "CARET", value: "^" });
-        break;
-      case "(":
-        tokens.push({ kind: "LPAREN", value: "(" });
-        break;
-      case ")":
-        tokens.push({ kind: "RPAREN", value: ")" });
-        break;
-      case ",":
-        tokens.push({ kind: "COMMA", value: "," });
-        break;
-      case "<":
-        tokens.push({ kind: "LT", value: "<" });
-        break;
-      case ">":
-        tokens.push({ kind: "GT", value: ">" });
-        break;
-      case "=":
-        tokens.push({ kind: "EQ", value: "=" });
-        break;
-      default:
-        throw new Error(`Unknown character: ${ch}`);
-    }
-    i++;
-  }
-  tokens.push({ kind: "EOF", value: "" });
-  return tokens;
+function renderHorizontalRule(ctx) {
+  ctx.push("<hr />");
 }
-
-class ExprParser {
-  tokens;
-  pos = 0;
-  constructor(tokens) {
-    this.tokens = tokens;
-  }
-  parse() {
-    const result = this.parseOr();
-    if (this.current().kind !== "EOF") {
-      throw new Error("too many values in the stack");
-    }
-    return result;
-  }
-  current() {
-    return this.tokens[this.pos] ?? { kind: "EOF", value: "" };
-  }
-  advance() {
-    const token = this.current();
-    this.pos++;
-    return token;
-  }
-  parseOr() {
-    let left = this.parseAnd();
-    while (this.current().kind === "IDENTIFIER" && this.current().value === "or") {
-      this.advance();
-      const right = this.parseAnd();
-      left = isTruthyNum(left) || isTruthyNum(right) ? 1 : 0;
-    }
-    return left;
-  }
-  parseAnd() {
-    let left = this.parseNot();
-    while (this.current().kind === "IDENTIFIER" && this.current().value === "and") {
-      this.advance();
-      const right = this.parseNot();
-      left = isTruthyNum(left) && isTruthyNum(right) ? 1 : 0;
-    }
-    return left;
-  }
-  parseNot() {
-    if (this.current().kind === "IDENTIFIER" && this.current().value === "not") {
-      this.advance();
-      const value = this.parseNot();
-      return isTruthyNum(value) ? 0 : 1;
-    }
-    return this.parseComparison();
-  }
-  parseComparison() {
-    let left = this.parseAddition();
-    const kind = this.current().kind;
-    if (kind === "LT" || kind === "GT" || kind === "LE" || kind === "GE" || kind === "EQ" || kind === "NE") {
-      this.advance();
-      const right = this.parseAddition();
-      switch (kind) {
-        case "LT":
-          return left < right ? 1 : 0;
-        case "GT":
-          return left > right ? 1 : 0;
-        case "LE":
-          return left <= right ? 1 : 0;
-        case "GE":
-          return left >= right ? 1 : 0;
-        case "EQ":
-          return left === right ? 1 : 0;
-        case "NE":
-          return left !== right ? 1 : 0;
-      }
-    }
-    return left;
-  }
-  parseAddition() {
-    let left = this.parseMultiplication();
-    while (true) {
-      const kind = this.current().kind;
-      if (kind === "PLUS") {
-        this.advance();
-        left = left + this.parseMultiplication();
-      } else if (kind === "MINUS") {
-        this.advance();
-        left = left - this.parseMultiplication();
-      } else {
-        break;
-      }
-    }
-    return left;
-  }
-  parseMultiplication() {
-    let left = this.parsePower();
-    while (true) {
-      const kind = this.current().kind;
-      if (kind === "STAR") {
-        this.advance();
-        left = left * this.parsePower();
-      } else if (kind === "SLASH") {
-        this.advance();
-        left = left / this.parsePower();
-      } else if (kind === "PERCENT") {
-        this.advance();
-        left = left % this.parsePower();
-      } else {
-        break;
-      }
-    }
-    return left;
-  }
-  parsePower() {
-    const left = this.parseUnary();
-    if (this.current().kind === "CARET") {
-      this.advance();
-      const right = this.parsePower();
-      return Math.pow(left, right);
-    }
-    return left;
-  }
-  parseUnary() {
-    const kind = this.current().kind;
-    if (kind === "MINUS") {
-      this.advance();
-      return -this.parseUnary();
-    }
-    if (kind === "PLUS") {
-      this.advance();
-      return +this.parseUnary();
-    }
-    return this.parsePrimary();
-  }
-  parsePrimary() {
-    const token = this.current();
-    if (token.kind === "NUMBER") {
-      this.advance();
-      return token.value;
-    }
-    if (token.kind === "LPAREN") {
-      this.advance();
-      const value = this.parseOr();
-      if (this.current().kind !== "RPAREN") {
-        throw new Error("Expected )");
-      }
-      this.advance();
-      return value;
-    }
-    if (token.kind === "IDENTIFIER") {
-      const name = token.value;
-      this.advance();
-      if (this.current().kind === "LPAREN") {
-        return this.parseFunctionCall(name);
-      }
-      throw new Error(`undefined constant "${name}"`);
-    }
-    throw new Error("Expected expression");
-  }
-  parseFunctionCall(name) {
-    if (this.current().kind !== "LPAREN") {
-      throw new Error("Expected (");
-    }
-    this.advance();
-    const args = [];
-    if (this.current().kind !== "RPAREN") {
-      args.push(this.parseOr());
-      while (this.current().kind === "COMMA") {
-        this.advance();
-        args.push(this.parseOr());
-      }
-    }
-    if (this.current().kind !== "RPAREN") {
-      throw new Error("Expected )");
-    }
-    this.advance();
-    return this.callFunction(name, args);
-  }
-  callFunction(name, args) {
-    switch (name) {
-      case "abs":
-        this.checkArgs(name, args, 1);
-        return Math.abs(args[0]);
-      case "min":
-        this.checkArgsMin(name, args, 1);
-        return Math.min(...args);
-      case "max":
-        this.checkArgsMin(name, args, 1);
-        return Math.max(...args);
-      case "floor":
-        this.checkArgs(name, args, 1);
-        return Math.floor(args[0]);
-      case "ceil":
-        this.checkArgs(name, args, 1);
-        return Math.ceil(args[0]);
-      case "round":
-        this.checkArgs(name, args, 1);
-        return Math.round(args[0]);
-      case "sqrt":
-        this.checkArgs(name, args, 1);
-        return Math.sqrt(args[0]);
-      case "sin":
-        this.checkArgs(name, args, 1);
-        return Math.sin(args[0]);
-      case "cos":
-        this.checkArgs(name, args, 1);
-        return Math.cos(args[0]);
-      case "tan":
-        this.checkArgs(name, args, 1);
-        return Math.tan(args[0]);
-      case "ln":
-        this.checkArgs(name, args, 1);
-        return Math.log(args[0]);
-      case "log":
-        this.checkArgs(name, args, 1);
-        return Math.log10(args[0]);
-      case "exp":
-        this.checkArgs(name, args, 1);
-        return Math.exp(args[0]);
-      case "pow":
-        this.checkArgs(name, args, 2);
-        return Math.pow(args[0], args[1]);
-      default:
-        throw new Error(`undefined function "${name}"`);
-    }
-  }
-  checkArgs(name, args, expected) {
-    if (args.length !== expected) {
-      throw new Error(`${name}() expects ${expected} argument(s), got ${args.length}`);
-    }
-  }
-  checkArgsMin(name, args, min) {
-    if (args.length < min) {
-      throw new Error(`${name}() expects at least ${min} argument(s), got ${args.length}`);
-    }
-  }
+function renderContentSeparator(ctx) {
+  ctx.push(`<div class="content-separator" style="display: none:"></div>`);
 }
 
-// packages/render/src/elements/expr.ts
-function renderExpr(ctx, data) {
-  const result = evaluateExpression(data.expression);
-  if (result.success) {
-    ctx.pushEscaped(formatNumber(result.value));
-  } else if (result.error !== "empty expression") {
-    ctx.pushEscaped(`run-time error: ${result.error}`);
-  }
-}
-function renderIf(ctx, data) {
-  const elements = isTruthy(data.condition) ? data.then : data.else;
-  renderBranchElements(ctx, elements);
-}
-function renderIfExpr(ctx, data) {
-  const result = evaluateExpression(data.expression);
-  if (!result.success) {
-    ctx.pushEscaped(`run-time error: ${result.error}`);
+// packages/render/src/render/style.ts
+function renderStyleElement(ctx, css) {
+  if (!ctx.renderInlineStyles || !ctx.settings.allowStyleElements) {
     return;
   }
-  const elements = result.value !== 0 ? data.then : data.else;
-  renderBranchElements(ctx, elements);
-}
-function renderBranchElements(ctx, elements) {
-  let lastIdx = elements.length - 1;
-  while (lastIdx >= 0) {
-    const el = elements[lastIdx];
-    if (el.element === "text" && typeof el.data === "string" && el.data.trim() === "") {
-      lastIdx--;
-    } else {
-      break;
-    }
-  }
-  renderElements(ctx, elements.slice(0, lastIdx + 1));
-}
-function formatNumber(n) {
-  if (Number.isInteger(n)) {
-    return String(n);
+  if (ctx.hasActiveStyleSlot()) {
+    ctx.pushToStyleSlot(css);
+    return;
   }
-  return n.toFixed(6).replace(/\.?0+$/, "");
+  pushStyleTag(ctx, css);
 }
 
-// packages/render/src/render.ts
-function renderToHtml(tree, options = {}) {
-  const ctx = new RenderContext(tree, options);
-  renderElements(ctx, tree.elements);
-  if (ctx.settings.allowStyleElements && tree.styles?.length) {
-    for (const style of tree.styles) {
-      if (style.startsWith(STYLE_SLOT_PREFIX)) {
-        const slotId = parseInt(style.slice(STYLE_SLOT_PREFIX.length), 10);
-        for (const css of ctx.getStyleSlotContents(slotId)) {
-          ctx.push(`<style>${escapeStyleContent(css)}</style>`);
-        }
-      } else {
-        ctx.push(`<style>${escapeStyleContent(style)}</style>`);
-      }
-    }
-  }
-  return ctx.getOutput();
-}
+// packages/render/src/render/dispatch.ts
 function renderElements(ctx, elements) {
   for (const element of elements) {
     renderElement(ctx, element);
@@ -5207,7 +5505,7 @@ function renderElements(ctx, elements) {
 function renderElement(ctx, element) {
   switch (element.element) {
     case "text":
-      ctx.pushEscaped(element.data);
+      renderTextNode(ctx, element.data);
       break;
     case "raw":
       renderRaw(ctx, element.data);
@@ -5306,16 +5604,10 @@ function renderElement(ctx, element) {
       renderIfTags(ctx, element.data);
       break;
     case "style":
-      if (ctx.renderInlineStyles && ctx.settings.allowStyleElements) {
-        if (ctx.hasActiveStyleSlot()) {
-          ctx.pushToStyleSlot(element.data);
-        } else {
-          ctx.push(`<style>${escapeStyleContent(element.data)}</style>`);
-        }
-      }
+      renderStyleElement(ctx, element.data);
       break;
     case "line-break":
-      ctx.push("<br />");
+      renderLineBreak(ctx);
       break;
     case "line-breaks":
       renderLineBreaks(ctx, element.data);
@@ -5324,10 +5616,10 @@ function renderElement(ctx, element) {
       renderClearFloat(ctx, element.data);
       break;
     case "horizontal-rule":
-      ctx.push("<hr />");
+      renderHorizontalRule(ctx);
       break;
     case "content-separator":
-      ctx.push(`<div class="content-separator" style="display: none:"></div>`);
+      renderContentSeparator(ctx);
       break;
     case "expr":
       renderExpr(ctx, element.data);
@@ -5344,6 +5636,14 @@ function renderElement(ctx, element) {
   }
 }
 
+// packages/render/src/render/index.ts
+function renderToHtml(tree, options = {}) {
+  const ctx = new RenderContext(tree, options);
+  renderElements(ctx, tree.elements);
+  renderCollectedStyles(ctx, tree.styles);
+  return ctx.getOutput();
+}
+
 // packages/render/src/index.ts
 import { createSettings, DEFAULT_SETTINGS as DEFAULT_SETTINGS2 } from "@wdprlib/ast";
 export {