@relyio/sdk 0.11.0 → 0.13.0

package/dist/chunk-3NPPMGB6.js

@@ -0,0 +1,1092 @@
+import { __name } from './chunk-XQ4QHWZE.js';
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// src/rich-text/anchors.ts
+function richTextHeadingSlug(text) {
+  return text.trim().toLowerCase().replace(/[^\p{L}\p{M}\p{N}\s_-]/gu, "").replace(/\s/gu, "-");
+}
+__name(richTextHeadingSlug, "richTextHeadingSlug");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+var BUILT_IN_CONTAINERS = /* @__PURE__ */ new Set([
+  "paragraph",
+  "heading",
+  "quote",
+  "list",
+  "listItem",
+  "codeGroup",
+  "table",
+  "tableRow",
+  "tableCell"
+]);
+function headingText(heading) {
+  if (!Array.isArray(heading.children)) return "";
+  let text = "";
+  for (const child of heading.children) {
+    if (!isRecord(child)) continue;
+    if (child._type === "lineBreak") text += " ";
+    else if (child._type === "text" && typeof child.text === "string") text += child.text;
+  }
+  return text;
+}
+__name(headingText, "headingText");
+function richTextHeadingAnchors(value) {
+  return anchorsAcross([value]);
+}
+__name(richTextHeadingAnchors, "richTextHeadingAnchors");
+function entryHeadingAnchors(entry) {
+  return anchorsAcross(isRecord(entry) ? Object.values(entry) : []);
+}
+__name(entryHeadingAnchors, "entryHeadingAnchors");
+function anchorsAcross(values) {
+  const anchors = /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Map();
+  const unique = /* @__PURE__ */ __name((slug) => {
+    let anchor = slug;
+    const seen = taken.get(slug);
+    if (seen !== void 0) {
+      let count = seen;
+      do {
+        count += 1;
+        anchor = `${slug}-${count}`;
+      } while (taken.has(anchor));
+      taken.set(slug, count);
+    }
+    taken.set(anchor, 0);
+    return anchor;
+  }, "unique");
+  const visit = /* @__PURE__ */ __name((nodes) => {
+    for (const node of nodes) {
+      if (!isRecord(node) || typeof node._type !== "string") continue;
+      if (node._type === "heading") {
+        const slug = richTextHeadingSlug(headingText(node));
+        if (slug !== "") anchors.set(node, unique(slug));
+        continue;
+      }
+      if (BUILT_IN_CONTAINERS.has(node._type) && Array.isArray(node.children)) visit(node.children);
+    }
+  }, "visit");
+  for (const value of values) {
+    if (isRecord(value) && value._type === "richText" && Array.isArray(value.children)) {
+      visit(value.children);
+    }
+  }
+  return anchors;
+}
+__name(anchorsAcross, "anchorsAcross");
+
+// src/binding/key-path.ts
+var ITEM_SELECTOR = "[_key==";
+function formatKeyPath(listPath, key, field) {
+  const item = `${listPath}${ITEM_SELECTOR}${JSON.stringify(key)}]`;
+  return field === void 0 ? item : `${item}.${field}`;
+}
+__name(formatKeyPath, "formatKeyPath");
+function parseKeyPath(path) {
+  const segments = [];
+  let at = 0;
+  let expectField = true;
+  while (at < path.length) {
+    if (path.startsWith(ITEM_SELECTOR, at)) {
+      const previous = segments[segments.length - 1];
+      if (expectField || previous === void 0 || !("field" in previous)) return null;
+      const quoted = readQuoted(path, at + ITEM_SELECTOR.length);
+      if (quoted === null || path[quoted.end] !== "]") return null;
+      segments.push({ key: quoted.value });
+      at = quoted.end + 1;
+      if (at < path.length && path[at] !== "." && !path.startsWith(ITEM_SELECTOR, at)) return null;
+      if (path[at] === ".") {
+        at += 1;
+        expectField = true;
+      }
+      continue;
+    }
+    let end = at;
+    while (end < path.length && path[end] !== "." && path[end] !== "[") end += 1;
+    const field = path.slice(at, end);
+    if (field.length === 0) return null;
+    segments.push({ field });
+    expectField = false;
+    at = end;
+    if (path[at] === ".") {
+      at += 1;
+      expectField = true;
+      if (at === path.length) return null;
+    } else if (at < path.length && !path.startsWith(ITEM_SELECTOR, at)) {
+      return null;
+    }
+  }
+  return segments.length === 0 || expectField ? null : segments;
+}
+__name(parseKeyPath, "parseKeyPath");
+function readQuoted(path, start) {
+  if (path[start] !== '"') return null;
+  for (let end = start + 1; end < path.length; end += 1) {
+    if (path[end] === "\\") {
+      end += 1;
+      continue;
+    }
+    if (path[end] !== '"') continue;
+    try {
+      const value = JSON.parse(path.slice(start, end + 1));
+      return typeof value === "string" && value.length > 0 ? { value, end: end + 1 } : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+__name(readQuoted, "readQuoted");
+
+// src/binding/relyio-field.ts
+var BINDING_VERSION = "1";
+function relyioField(subject, path) {
+  if (subject === void 0) return void 0;
+  if (isBindingShaped(subject)) return continued(subject, path);
+  const field = typeof path === "string" ? path : String(path);
+  const metadata = subject._metadata;
+  const attributes = {
+    "data-relyio-entry": requireMetadata(metadata, "id", field),
+    "data-relyio-type": requireMetadata(metadata, "type", field),
+    "data-relyio-field": field,
+    "data-relyio-locale": requireMetadata(metadata, "locale", field),
+    "data-relyio-v": BINDING_VERSION
+  };
+  requireKeyPath("entry", field, field);
+  return attributes;
+}
+__name(relyioField, "relyioField");
+function isBindingShaped(value) {
+  return "data-relyio-field" in value;
+}
+__name(isBindingShaped, "isBindingShaped");
+function continued(binding, path) {
+  const spelled = typeof path === "string" ? path : `{ _key: ${JSON.stringify(path._key)} }`;
+  const complete = binding["data-relyio-v"] === BINDING_VERSION && [
+    binding["data-relyio-entry"],
+    binding["data-relyio-type"],
+    binding["data-relyio-field"],
+    binding["data-relyio-locale"]
+  ].every((value) => typeof value === "string" && value.length > 0);
+  if (!complete) {
+    throw new TypeError(
+      `relyioField(binding, '${spelled}'): the binding is not one relyioField returned \u2014 continue the attributes relyioField(entry, field) gave, or a renderer handed you.`
+    );
+  }
+  const field = typeof path === "string" ? `${binding["data-relyio-field"]}.${path}` : formatKeyPath(binding["data-relyio-field"], path._key);
+  requireKeyPath("binding", spelled, field);
+  return {
+    "data-relyio-entry": binding["data-relyio-entry"],
+    "data-relyio-type": binding["data-relyio-type"],
+    "data-relyio-field": field,
+    "data-relyio-locale": binding["data-relyio-locale"],
+    "data-relyio-v": BINDING_VERSION
+  };
+}
+__name(continued, "continued");
+function requireKeyPath(form, given, field) {
+  if (parseKeyPath(field) !== null) return;
+  throw new TypeError(
+    `relyioField(${form}, '${given}'): '${field}' is not a field or a key path. Name a field (\`title\`), or a value inside one by its items\u2019 keys (\`sections[_key=="k1"].heading\`).`
+  );
+}
+__name(requireKeyPath, "requireKeyPath");
+function requireMetadata(metadata, key, field) {
+  const value = metadata?.[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(
+      `relyioField(entry, '${field}'): the entry has no _metadata.${key}, so the field cannot be bound. Pass an entry as the RelyIO API returned it.`
+    );
+  }
+  return value;
+}
+__name(requireMetadata, "requireMetadata");
+
+// src/rich-text/render.ts
+var RICH_TEXT_VOID_TAGS = /* @__PURE__ */ new Set([
+  "hr",
+  "br",
+  "input"
+]);
+var BUILT_IN_NODES = {
+  paragraph: true,
+  heading: true,
+  quote: true,
+  list: true,
+  listItem: true,
+  codeBlock: true,
+  codeGroup: true,
+  table: true,
+  tableRow: true,
+  tableCell: true,
+  divider: true,
+  text: true,
+  lineBreak: true
+};
+function isDeclaredRichTextNode(node) {
+  if (typeof node !== "object" || node === null) return false;
+  const type = node._type;
+  return typeof type === "string" && type !== "" && !Object.prototype.hasOwnProperty.call(BUILT_IN_NODES, type);
+}
+__name(isDeclaredRichTextNode, "isDeclaredRichTextNode");
+var PLAIN = Object.freeze({ header: false });
+var HEADER = Object.freeze({ header: true });
+var headingAnchors = /* @__PURE__ */ new Map();
+function renderRichText(value, target, options = {}) {
+  const held = value;
+  if (held._type !== "richText") {
+    const drawn = block(held, target);
+    return drawn === void 0 ? [] : [drawn];
+  }
+  const outer = headingAnchors;
+  headingAnchors = options.anchors ?? richTextHeadingAnchors(held);
+  try {
+    return Array.isArray(held.children) ? blocks(held.children, target) : [];
+  } finally {
+    headingAnchors = outer;
+  }
+}
+__name(renderRichText, "renderRichText");
+function blocks(nodes, target) {
+  const out = [];
+  for (const node of nodes) {
+    const drawn = block(node, target);
+    if (drawn !== void 0) out.push(drawn);
+  }
+  return out;
+}
+__name(blocks, "blocks");
+var HEADING_TAGS = {
+  1: "h1",
+  2: "h2",
+  3: "h3",
+  4: "h4",
+  5: "h5",
+  6: "h6"
+};
+function block(node, target) {
+  if (isDeclaredRichTextNode(node)) {
+    return target.declared(node, "block");
+  }
+  switch (node._type) {
+    case "paragraph": {
+      return target.node(
+        node,
+        inline(node.children, target),
+        (contents) => target.element("p", void 0, contents, node._key),
+        PLAIN
+      );
+    }
+    case "heading": {
+      const tag = HEADING_TAGS[node.level] ?? "p";
+      const anchor = headingAnchors.get(node);
+      return target.node(
+        node,
+        inline(node.children, target),
+        (contents) => target.element(
+          tag,
+          anchor === void 0 ? void 0 : { id: anchor },
+          contents,
+          node._key
+        ),
+        PLAIN
+      );
+    }
+    case "quote": {
+      return target.node(
+        node,
+        blocks(node.children, target),
+        (contents) => target.element("blockquote", void 0, contents, node._key),
+        PLAIN
+      );
+    }
+    case "list": {
+      return list(node, target);
+    }
+    case "codeBlock": {
+      return code(node, target);
+    }
+    case "codeGroup": {
+      const tabs = [];
+      for (const tab of node.children) {
+        if (tab._type === "codeBlock") tabs.push(code(tab, target));
+      }
+      return target.node(
+        node,
+        tabs,
+        (contents) => target.element("div", void 0, contents, node._key),
+        PLAIN
+      );
+    }
+    case "table": {
+      return table(node, target);
+    }
+    case "divider": {
+      return target.node(node, [], () => target.element("hr", void 0, [], node._key), PLAIN);
+    }
+    default: {
+      return void 0;
+    }
+  }
+}
+__name(block, "block");
+function list(node, target) {
+  let tag;
+  switch (node.style) {
+    case "bullet":
+    case "task": {
+      tag = "ul";
+      break;
+    }
+    case "numbered": {
+      tag = "ol";
+      break;
+    }
+    default: {
+      node.style;
+      tag = "ul";
+    }
+  }
+  const start = node.style === "numbered" && Number.isSafeInteger(node.start) && node.start !== 1 ? node.start : void 0;
+  const items = [];
+  for (const item of node.children) {
+    if (item._type === "listItem") items.push(listItem(item, node.style === "task", target));
+  }
+  return target.node(
+    node,
+    items,
+    (contents) => target.element(tag, start === void 0 ? void 0 : { start }, contents, node._key),
+    PLAIN
+  );
+}
+__name(list, "list");
+function listItem(item, task, target) {
+  return target.node(
+    item,
+    blocks(item.children, target),
+    (contents) => {
+      if (!task) return target.element("li", void 0, contents, item._key);
+      const box = target.element(
+        "input",
+        item.checked === true ? { type: "checkbox", disabled: true, checked: true } : { type: "checkbox", disabled: true },
+        [],
+        void 0
+      );
+      return target.element("li", void 0, [box, ...contents], item._key);
+    },
+    PLAIN
+  );
+}
+__name(listItem, "listItem");
+function code(node, target) {
+  const language = typeof node.language === "string" && node.language !== "" ? node.language : void 0;
+  const caption = nonEmpty(node.filename) ?? nonEmpty(node.label);
+  return target.node(
+    node,
+    [target.text(node.text)],
+    (contents) => {
+      const pre = /* @__PURE__ */ __name((key) => target.element(
+        "pre",
+        void 0,
+        [
+          target.element(
+            "code",
+            language === void 0 ? void 0 : { class: `language-${language}` },
+            contents,
+            void 0
+          )
+        ],
+        key
+      ), "pre");
+      if (caption === void 0) return pre(node._key);
+      return target.element(
+        "figure",
+        void 0,
+        [
+          target.element("figcaption", void 0, [target.text(caption)], void 0),
+          pre(void 0)
+        ],
+        node._key
+      );
+    },
+    PLAIN
+  );
+}
+__name(code, "code");
+function nonEmpty(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+__name(nonEmpty, "nonEmpty");
+function table(node, target) {
+  const rows = node.children.filter((row) => row._type === "tableRow");
+  const [first, ...rest] = rows;
+  const header = node.headerRow === true ? first : void 0;
+  const body = header === void 0 ? rows : rest;
+  const sections = [];
+  if (header !== void 0) {
+    sections.push(target.element("thead", void 0, [tableRow(header, true, target)], void 0));
+  }
+  if (body.length > 0) {
+    sections.push(
+      target.element(
+        "tbody",
+        void 0,
+        body.map((row) => tableRow(row, false, target)),
+        void 0
+      )
+    );
+  }
+  return target.node(
+    node,
+    sections,
+    (contents) => target.element("table", void 0, contents, node._key),
+    PLAIN
+  );
+}
+__name(table, "table");
+function tableRow(row, header, target) {
+  const cells = [];
+  for (const cell of row.children) {
+    if (cell._type === "tableCell") cells.push(tableCell(cell, header, target));
+  }
+  return target.node(
+    row,
+    cells,
+    (contents) => target.element("tr", void 0, contents, row._key),
+    header ? HEADER : PLAIN
+  );
+}
+__name(tableRow, "tableRow");
+function tableCell(cell, header, target) {
+  let attributes;
+  switch (cell.align) {
+    case "left":
+    case "center":
+    case "right": {
+      attributes = { style: `text-align:${cell.align}` };
+      break;
+    }
+    case void 0: {
+      attributes = void 0;
+      break;
+    }
+    default: {
+      cell.align;
+      attributes = void 0;
+    }
+  }
+  return target.node(
+    cell,
+    blocks(cell.children, target),
+    (contents) => target.element(header ? "th" : "td", attributes, contents, cell._key),
+    header ? HEADER : PLAIN
+  );
+}
+__name(tableCell, "tableCell");
+function inline(nodes, target) {
+  const out = [];
+  let runs = [];
+  const flush = /* @__PURE__ */ __name(() => {
+    if (runs.length > 0) out.push(...marked(runs, target));
+    runs = [];
+  }, "flush");
+  for (const node of nodes) {
+    if (isDeclaredRichTextNode(node)) {
+      flush();
+      const drawn = target.declared(node, "inline");
+      if (drawn !== void 0) out.push(drawn);
+      continue;
+    }
+    switch (node._type) {
+      case "text": {
+        runs.push({ span: node, drawn: 0 });
+        break;
+      }
+      case "lineBreak": {
+        flush();
+        out.push(target.node(node, [], () => target.element("br", void 0, [], node._key), PLAIN));
+        break;
+      }
+      default: {
+        flush();
+      }
+    }
+  }
+  flush();
+  return out;
+}
+__name(inline, "inline");
+function marked(runs, target) {
+  const out = [];
+  let index = 0;
+  while (index < runs.length) {
+    const run = runs[index];
+    const mark = run.span.marks?.[run.drawn];
+    if (mark === void 0) {
+      out.push(target.text(run.span.text));
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < runs.length && sameMark(nextMark(runs[end]), mark)) end += 1;
+    const inner = marked(
+      runs.slice(index, end).map((each) => ({ span: each.span, drawn: each.drawn + 1 })),
+      target
+    );
+    out.push(...applyMark(mark, inner, target));
+    index = end;
+  }
+  return out;
+}
+__name(marked, "marked");
+function nextMark(run) {
+  return run.span.marks?.[run.drawn];
+}
+__name(nextMark, "nextMark");
+function sameMark(a, b) {
+  if (a?._type !== b._type) return false;
+  if (a._type === "link" && b._type === "link") return a.href === b.href;
+  if (a._type === "entryLink" && b._type === "entryLink") {
+    return linkedEntryId(a) === linkedEntryId(b) && a.anchor === b.anchor;
+  }
+  return true;
+}
+__name(sameMark, "sameMark");
+function linkedEntryId(link) {
+  const to = link.to;
+  if (typeof to === "object" && to !== null && "_metadata" in to) {
+    const metadata = to._metadata;
+    return metadata?.id ?? to;
+  }
+  return to;
+}
+__name(linkedEntryId, "linkedEntryId");
+var MARK_TAGS = {
+  bold: "strong",
+  italic: "em",
+  underline: "u",
+  strike: "s",
+  code: "code",
+  highlight: "mark",
+  subscript: "sub",
+  superscript: "sup"
+};
+function applyMark(mark, inner, target) {
+  switch (mark._type) {
+    case "entryLink": {
+      return [target.entryLink(mark, inner)];
+    }
+    case "link": {
+      const href = safeRichTextHref(mark.href);
+      if (href === void 0) return inner;
+      return [
+        target.mark(mark, inner, (contents) => target.element("a", { href }, contents, void 0))
+      ];
+    }
+    case "bold":
+    case "italic":
+    case "underline":
+    case "strike":
+    case "code":
+    case "highlight":
+    case "subscript":
+    case "superscript": {
+      const tag = MARK_TAGS[mark._type];
+      return [
+        target.mark(mark, inner, (contents) => target.element(tag, void 0, contents, void 0))
+      ];
+    }
+    default: {
+      return inner;
+    }
+  }
+}
+__name(applyMark, "applyMark");
+var SAFE_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto", "tel"]);
+var SCHEME = /^([a-z][a-z\d+.-]*):/i;
+function safeRichTextHref(href) {
+  if (typeof href !== "string") return void 0;
+  let read = "";
+  for (const character of href) {
+    const code3 = character.codePointAt(0);
+    if (code3 === 9 || code3 === 10 || code3 === 13) continue;
+    read += character;
+  }
+  read = trimControls(read);
+  if (read === "") return void 0;
+  const scheme = SCHEME.exec(read);
+  if (scheme === null) return href;
+  return SAFE_SCHEMES.has(scheme[1].toLowerCase()) ? href : void 0;
+}
+__name(safeRichTextHref, "safeRichTextHref");
+function trimControls(text) {
+  let start = 0;
+  let end = text.length;
+  while (start < end && text.charCodeAt(start) <= 32) start += 1;
+  while (end > start && text.charCodeAt(end - 1) <= 32) end -= 1;
+  return text.slice(start, end);
+}
+__name(trimControls, "trimControls");
+
+// src/rich-text/html.ts
+function escapeHtml(text) {
+  return String(text).replace(/["&'<>]/g, (character) => HTML_ESCAPES[character] ?? character);
+}
+__name(escapeHtml, "escapeHtml");
+var HTML_ESCAPES = {
+  '"': "&quot;",
+  "&": "&amp;",
+  "'": "&#x27;",
+  "<": "&lt;",
+  ">": "&gt;"
+};
+function attributesOf(attributes) {
+  if (attributes === void 0) return "";
+  let written = "";
+  for (const [name, value] of Object.entries(attributes)) {
+    written += value === true ? ` ${name}=""` : ` ${name}="${escapeHtml(String(value))}"`;
+  }
+  return written;
+}
+__name(attributesOf, "attributesOf");
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
+var BOUND = /\sdata-relyio-entry(?:[\s=/>]|$)/i;
+function tagEnd(html, start) {
+  let quote;
+  for (let index = start + 1; index < html.length; index++) {
+    const character = html[index];
+    if (quote !== void 0) {
+      if (character === quote) quote = void 0;
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === ">") {
+      return index + 1;
+    }
+  }
+  return -1;
+}
+__name(tagEnd, "tagEnd");
+var TAG_NAME = /^<\/?([A-Za-z][\w:-]*)/;
+function soleElementStartTag(html) {
+  const from = html.length - html.trimStart().length;
+  const to = html.trimEnd().length;
+  const root = TAG_NAME.exec(html.slice(from));
+  if (root === null || html[from + 1] === "/") return void 0;
+  let depth = 0;
+  let index = from;
+  let startTag;
+  while (index < to) {
+    if (depth === 0 && startTag !== void 0) return void 0;
+    const open = html.indexOf("<", index);
+    if (open !== index) {
+      if (depth === 0) return void 0;
+      if (open === -1 || open >= to) return void 0;
+      index = open;
+      continue;
+    }
+    if (html.startsWith("<!--", index)) {
+      if (depth === 0) return void 0;
+      const close = html.indexOf("-->", index + 4);
+      if (close === -1) return void 0;
+      index = close + 3;
+      continue;
+    }
+    const name = TAG_NAME.exec(html.slice(index));
+    if (name === null) {
+      if (depth === 0) return void 0;
+      index += 1;
+      continue;
+    }
+    const end = tagEnd(html, index);
+    if (end === -1 || end > to) return void 0;
+    const tag = (name[1] ?? "").toLowerCase();
+    if (html[index + 1] === "/") {
+      depth -= 1;
+      if (depth < 0) return void 0;
+      index = end;
+      continue;
+    }
+    const selfClosing = html[end - 2] === "/";
+    if (startTag === void 0) {
+      let insertAt = selfClosing ? end - 2 : end - 1;
+      while (insertAt > index && /\s/.test(html[insertAt - 1] ?? "")) insertAt -= 1;
+      startTag = { insertAt, tag: html.slice(index, end) };
+    }
+    if (selfClosing || VOID_ELEMENTS.has(tag)) {
+      index = end;
+      continue;
+    }
+    if (RAW_TEXT_ELEMENTS.has(tag)) {
+      const close = html.toLowerCase().indexOf(`</${tag}`, end);
+      if (close === -1) return void 0;
+      depth += 1;
+      index = close;
+      continue;
+    }
+    depth += 1;
+    index = end;
+  }
+  return depth === 0 ? startTag : void 0;
+}
+__name(soleElementStartTag, "soleElementStartTag");
+function stamped(html, binding) {
+  if (binding === void 0) return html;
+  const root = soleElementStartTag(html);
+  if (root === void 0) return html;
+  if (BOUND.test(root.tag)) return html;
+  return `${html.slice(0, root.insertAt)}${attributesOf(binding)}${html.slice(root.insertAt)}`;
+}
+__name(stamped, "stamped");
+function htmlTarget(declared2, entryLink, field) {
+  return {
+    element(tag, attributes, children) {
+      return RICH_TEXT_VOID_TAGS.has(tag) ? `<${tag}${attributesOf(attributes)}/>` : `<${tag}${attributesOf(attributes)}>${children.join("")}</${tag}>`;
+    },
+    text: escapeHtml,
+    node: /* @__PURE__ */ __name((_node, contents, draw) => draw(contents), "node"),
+    mark: /* @__PURE__ */ __name((_mark, contents, draw) => draw(contents), "mark"),
+    // A value built by hand holding an entry link no writer draws: its text, with no anchor
+    entryLink: /* @__PURE__ */ __name((link, contents) => entryLink === void 0 ? contents.join("") : entryLink(link, contents.join("")), "entryLink"),
+    // A declared node's writer (REL-1807), handed the node's key path below the field's binding and
+    // stamped with it (REL-2142); no binding asks the core nothing
+    declared(node) {
+      const write = Object.prototype.hasOwnProperty.call(declared2, node._type) ? declared2[node._type] : void 0;
+      if (write === void 0) return void 0;
+      const binding = field === void 0 ? void 0 : relyioField(field, node);
+      return stamped(write(node, binding), binding);
+    }
+  };
+}
+__name(htmlTarget, "htmlTarget");
+function richTextToHtml(value, ...[options]) {
+  if (value === void 0) return "";
+  const declared2 = options?.declared ?? {};
+  const entryLink = options?.entryLink;
+  return renderRichText(
+    value,
+    htmlTarget(declared2, entryLink, options?.field),
+    options?.anchors === void 0 ? {} : { anchors: options.anchors }
+  ).join("");
+}
+__name(richTextToHtml, "richTextToHtml");
+
+// src/rich-text/markdown.ts
+var entryLinkWriter;
+var writers = {};
+function declared(node) {
+  const type = node._type;
+  const write = Object.prototype.hasOwnProperty.call(writers, type) ? writers[type] : void 0;
+  return write === void 0 ? void 0 : write(node);
+}
+__name(declared, "declared");
+function richTextToMarkdown(value, ...[options]) {
+  if (value === void 0) return "";
+  const tree = value;
+  const held = tree._type === "richText" ? tree.children : [tree];
+  if (!Array.isArray(held)) return "";
+  const outer = writers;
+  const outerLink = entryLinkWriter;
+  writers = options?.declared ?? {};
+  entryLinkWriter = options?.entryLink;
+  try {
+    const written = blocks2(held);
+    return written.length === 0 ? "" : `${written.join("\n\n")}
+`;
+  } finally {
+    writers = outer;
+    entryLinkWriter = outerLink;
+  }
+}
+__name(richTextToMarkdown, "richTextToMarkdown");
+function blocks2(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    const written = block2(node);
+    if (written !== void 0 && written !== "") out.push(written);
+  }
+  return out;
+}
+__name(blocks2, "blocks");
+function block2(node) {
+  if (isDeclaredRichTextNode(node)) return declared(node);
+  switch (node._type) {
+    case "paragraph": {
+      return escapeLineStarts(inline2(node.children, "\\\n"));
+    }
+    case "heading": {
+      const text = inline2(node.children, " ").trim();
+      if (text === "") return void 0;
+      const level = Number.isInteger(node.level) ? Math.min(Math.max(node.level, 1), 6) : 1;
+      return `${"#".repeat(level)} ${text.replace(/ (#+)$/, " \\$1")}`;
+    }
+    case "quote": {
+      const inner = blocks2(node.children).join("\n\n");
+      if (inner === "") return void 0;
+      return inner.split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+    }
+    case "list": {
+      return list2(node);
+    }
+    case "codeBlock": {
+      return code2(node);
+    }
+    case "codeGroup": {
+      const tabs = node.children.filter((tab) => tab._type === "codeBlock").map((tab) => code2(tab));
+      return tabs.length === 0 ? void 0 : tabs.join("\n\n");
+    }
+    case "table": {
+      return table2(node);
+    }
+    case "divider": {
+      return "---";
+    }
+    default: {
+      return void 0;
+    }
+  }
+}
+__name(block2, "block");
+function list2(node) {
+  const items = node.children.filter((item) => item._type === "listItem");
+  if (items.length === 0) return void 0;
+  const first = node.style === "numbered" && Number.isSafeInteger(node.start) ? node.start : 1;
+  return items.map((item, index) => {
+    let marker;
+    switch (node.style) {
+      case "numbered": {
+        marker = `${first + index}.`;
+        break;
+      }
+      case "task": {
+        marker = item.checked === true ? "- [x]" : "- [ ]";
+        break;
+      }
+      case "bullet": {
+        marker = "-";
+        break;
+      }
+      default: {
+        node.style;
+        marker = "-";
+      }
+    }
+    const indent = " ".repeat(node.style === "task" ? 2 : marker.length + 1);
+    let body = "";
+    for (const child of item.children) {
+      const part = block2(child);
+      if (part === void 0 || part === "") continue;
+      if (body !== "") body += interruptsParagraph(child) ? "\n" : "\n\n";
+      body += part;
+    }
+    if (body === "") return marker;
+    return `${marker} ${body.split("\n").map((line, at) => at === 0 || line === "" ? line : `${indent}${line}`).join("\n")}`;
+  }).join("\n");
+}
+__name(list2, "list");
+function interruptsParagraph(node) {
+  if (node._type !== "list") return false;
+  return node.style !== "numbered" || node.start === void 0 || node.start === 1;
+}
+__name(interruptsParagraph, "interruptsParagraph");
+function code2(node) {
+  const text = typeof node.text === "string" ? node.text : "";
+  const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map((run) => run[0].length));
+  const fence = "`".repeat(Math.max(3, longest + 1));
+  const language = typeof node.language === "string" ? node.language.split(/\s/)[0] ?? "" : "";
+  const info = language.includes("`") ? "" : language;
+  return text === "" ? `${fence}${info}
+${fence}` : `${fence}${info}
+${text}
+${fence}`;
+}
+__name(code2, "code");
+function table2(node) {
+  const rows = node.children.filter((row) => row._type === "tableRow").map((row) => row.children.filter((cell) => cell._type === "tableCell"));
+  if (rows.length === 0) return void 0;
+  const columns = Math.max(...rows.map((cells) => cells.length));
+  if (columns === 0) return void 0;
+  const text = rows.map(
+    (cells) => Array.from({ length: columns }, (_, at) => {
+      const cell = cells[at];
+      if (cell === void 0) return "";
+      const paragraphs = cell.children.filter((paragraph) => paragraph._type === "paragraph").map((paragraph) => inline2(paragraph.children, " ").trim()).filter((paragraph) => paragraph !== "");
+      return paragraphs.join(" ").replace(/\|/g, "\\|");
+    })
+  );
+  const alignments = Array.from({ length: columns }, (_, at) => rows[0][at]?.align);
+  const header = node.headerRow === true ? text[0] : Array.from({ length: columns }, () => "");
+  const body = node.headerRow === true ? text.slice(1) : text;
+  const widths = Array.from(
+    { length: columns },
+    (_, at) => Math.max(3, ...[header, ...body].map((cells) => cells[at].length))
+  );
+  const line = /* @__PURE__ */ __name((cells) => `| ${cells.map((cell, at) => cell.padEnd(widths[at])).join(" | ")} |`, "line");
+  const delimiter = `| ${alignments.map((align, at) => {
+    const width = widths[at];
+    switch (align) {
+      case "left": {
+        return `:${"-".repeat(width - 1)}`;
+      }
+      case "center": {
+        return `:${"-".repeat(width - 2)}:`;
+      }
+      case "right": {
+        return `${"-".repeat(width - 1)}:`;
+      }
+      case void 0: {
+        return "-".repeat(width);
+      }
+      default: {
+        return "-".repeat(width);
+      }
+    }
+  }).join(" | ")} |`;
+  return [line(header), delimiter, ...body.map((cells) => line(cells))].join("\n");
+}
+__name(table2, "table");
+function inline2(nodes, lineBreak) {
+  let out = "";
+  let runs = [];
+  const flush = /* @__PURE__ */ __name(() => {
+    out += marked2(runs);
+    runs = [];
+  }, "flush");
+  for (const node of nodes) {
+    if (isDeclaredRichTextNode(node)) {
+      flush();
+      out += declared(node) ?? "";
+      continue;
+    }
+    switch (node._type) {
+      case "text": {
+        runs.push({ span: node, drawn: 0 });
+        break;
+      }
+      case "lineBreak": {
+        flush();
+        out += lineBreak;
+        break;
+      }
+      default: {
+        flush();
+      }
+    }
+  }
+  flush();
+  return out;
+}
+__name(inline2, "inline");
+function marked2(runs) {
+  let out = "";
+  let index = 0;
+  while (index < runs.length) {
+    const run = runs[index];
+    const mark = run.span.marks?.[run.drawn];
+    if (mark === void 0) {
+      out += escapeText(run.span.text);
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < runs.length && sameMark(runs[end].span.marks?.[runs[end].drawn], mark)) end += 1;
+    if (mark._type === "code") {
+      out += codeSpan(
+        runs.slice(index, end).map((each) => each.span.text).join("")
+      );
+      index = end;
+      continue;
+    }
+    const inner = marked2(
+      runs.slice(index, end).map((each) => ({ span: each.span, drawn: each.drawn + 1 }))
+    );
+    out += applyMark2(mark, inner);
+    index = end;
+  }
+  return out;
+}
+__name(marked2, "marked");
+function applyMark2(mark, inner) {
+  switch (mark._type) {
+    case "entryLink": {
+      return entryLinkWriter === void 0 || inner === "" ? inner : entryLinkWriter(mark, inner);
+    }
+    case "link": {
+      const href = safeRichTextHref(mark.href);
+      if (href === void 0 || inner === "") return inner;
+      return `[${inner}](${destination(href)})`;
+    }
+    case "bold": {
+      return delimit("**", inner);
+    }
+    case "italic": {
+      return delimit("*", inner);
+    }
+    case "strike": {
+      return delimit("~~", inner);
+    }
+    case "code": {
+      return inner;
+    }
+    case "underline":
+    case "highlight":
+    case "subscript":
+    case "superscript": {
+      return inner;
+    }
+    default: {
+      return inner;
+    }
+  }
+}
+__name(applyMark2, "applyMark");
+function delimit(delimiter, inner) {
+  const match = /^(\s*)([\s\S]*?)(\s*)$/.exec(inner);
+  const [, before = "", core = "", after = ""] = match;
+  if (core === "") return inner;
+  return `${before}${delimiter}${core}${delimiter}${after}`;
+}
+__name(delimit, "delimit");
+function codeSpan(text) {
+  const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map((run) => run[0].length));
+  const fence = "`".repeat(longest + 1);
+  const padded = /^`|`$/.test(text) || /^ .*[^ ].* $/.test(text) ? ` ${text} ` : text;
+  return `${fence}${padded}${fence}`;
+}
+__name(codeSpan, "codeSpan");
+function destination(href) {
+  if (!/[\s()<>]/.test(href)) return href;
+  return `<${href.replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\s/g, "%20")}>`;
+}
+__name(destination, "destination");
+function escapeText(text) {
+  return String(text).replace(/[\\`*_[\]<>~]/g, "\\$&").replace(/&(?=#?[\da-z]+;)/gi, "\\&");
+}
+__name(escapeText, "escapeText");
+function escapeLineStarts(paragraph) {
+  return paragraph.split("\n").map(
+    (line) => line.replace(/^(#{1,6})(?=\s|$)/, "\\$1").replace(/^([+=-])/, "\\$1").replace(/^(\d+)([).])/, "$1\\$2")
+  ).join("\n");
+}
+__name(escapeLineStarts, "escapeLineStarts");
+
+export { RICH_TEXT_VOID_TAGS, entryHeadingAnchors, escapeHtml, formatKeyPath, isDeclaredRichTextNode, parseKeyPath, relyioField, renderRichText, richTextHeadingAnchors, richTextHeadingSlug, richTextToHtml, richTextToMarkdown, safeRichTextHref };
+//# sourceMappingURL=chunk-3NPPMGB6.js.map
+//# sourceMappingURL=chunk-3NPPMGB6.js.map