@gmb/bitmark-parser-generator 5.39.0 → 5.41.0

package/dist/browser/cjs/index.cjs

@@ -67,6 +67,8 @@ var BitType2 = {
   // Used to indicate a bit is commented out
   _standard: "_standard",
   // Not to be used as a bit, but as a base for other bit types
+  _standardLight: "_standard-light",
+  // PLAN-021: lightweight base (minimal tag set), not to be used as a bit
   advertising: "advertising",
   advertisingAdvertorial: "advertising-advertorial",
   advertisingAdvertorialPage: "advertising-advertorial-page",
@@ -354,6 +356,7 @@ var BitType2 = {
   handInSystemMedia: "hand-in-system-media",
   handInVideo: "hand-in-video",
   handInVoice: "hand-in-voice",
+  h: "h",
   help: "help",
   helpAlt: "help-alt",
   highlightText: "highlight-text",
@@ -439,6 +442,7 @@ var BitType2 = {
   leWatchVideoEmbed: "le-watch-video-embed",
   lifeSkillSticker: "life-skill-sticker",
   list: "list",
+  listAlt: "list-alt",
   listItem: "list-item",
   mark: "mark",
   match: "match",
@@ -469,6 +473,8 @@ var BitType2 = {
   notebookArticle: "notebook-article",
   noteCollapsible: "note-collapsible",
   output: "output",
+  p: "p",
+  pAlt: "p-alt",
   page: "page",
   pageAcademy: "page-academy",
   pageArticle: "page-article",
@@ -591,6 +597,7 @@ var BitType2 = {
   smartStandardNoteNonNormativeCollapsible: "smart-standard-note-non-normative-collapsible",
   smartStandardNoteNormative: "smart-standard-note-normative",
   smartStandardNoteNormativeCollapsible: "smart-standard-note-normative-collapsible",
+  smartStandardP: "smart-standard-p",
   smartStandardRemarkLegend: "smart-standard-remark-legend",
   smartStandardRemarkLegendNonNormative: "smart-standard-remark-legend-non-normative",
   smartStandardRemarkLegendNormative: "smart-standard-remark-legend-normative",
@@ -1560,6 +1567,8 @@ var import_superenum12 = require("@ncoderz/superenum");
 var groupKeys = {
   group_accessibilityDecorative: "group_accessibilityDecorative",
   group_standardAllBits: "group_standardAllBits",
+  group_standardExample: "group_standardExample",
+  group_standardItem: "group_standardItem",
   group_standardItemLead: "group_standardItemLead",
   group_standardItemLeadInstructionHint: "group_standardItemLeadInstructionHint",
   group_standardInstructionHint: "group_standardInstructionHint",
@@ -5059,6 +5068,34 @@ var GROUPS = {
       }
     ]
   },
+  [ConfigKey.group_standardExample]: {
+    type: GroupConfigType.standard,
+    description: "PLAN-021: Standard group for the bit-level example property only. Mirror of the group_standardTags property_example entry, used by the lightweight bits (_standardLight).",
+    tags: [
+      {
+        key: ConfigKey.property_example,
+        exportJsonKey: [{ "@keyonly": {} }, { "@absent": { isExample: true } }, { example: "$" }],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
+      }
+    ]
+  },
+  [ConfigKey.group_standardItem]: {
+    type: GroupConfigType.standard,
+    description: "PLAN-021: Standard group for the item tag ONLY (no lead/pageNumber/marginNumber chain). Used by the lightweight bits (_standardLight).",
+    tags: [
+      {
+        key: ConfigKey.tag_item,
+        jsonKey: "item",
+        exportJsonKey: { item: "$" },
+        // PLAN-140 W3 (NISO import): the clause/note label of a mapped
+        // source element ([%1], [%ANMERKUNG 1]) — same as group_standardItemLead.
+        mappingKeys: { "xml-niso-iec": { "@el": "label", "@text": "$" } },
+        description: "The item for the bit"
+      }
+    ]
+  },
   [ConfigKey.group_standardItemLead]: {
     type: GroupConfigType.standard,
     description: "Standard group for item, lead, page number, and margin number tags",
@@ -7862,6 +7899,25 @@ var BITS = {
       }
     ]
   },
+  [BitType2._standardLight]: {
+    since: "5.40.0",
+    description: "PLAN-021: Lightweight standard base bit with a minimal tag set (item + example only \u2014 no instruction/hint/lead, no resource attachments), used as a base for other bits, should not be used directly",
+    resourceAttachmentAllowed: false,
+    tags: [
+      {
+        key: ConfigKey.group_standardAllBits,
+        description: "Standard tags for all bits"
+      },
+      {
+        key: ConfigKey.group_standardItem,
+        description: "The item tag (no lead/pageNumber/marginNumber chain)"
+      },
+      {
+        key: ConfigKey.group_standardExample,
+        description: "The bit-level example property"
+      }
+    ]
+  },
   [BitType2.appFlashcards]: {
     since: "1.3.0",
     title: "Flashcards",
@@ -10689,6 +10745,23 @@ var BITS = {
     baseBitType: BitType2.article,
     description: "Glossary term bit, used to define glossary terms in articles or books"
   },
+  [BitType2.h]: {
+    since: "5.40.0",
+    title: "Heading",
+    bitGroups: [BitGroup.static],
+    baseBitType: BitType2._standardLight,
+    description: "Lightweight heading bit with chapter-style title levels 1-7; title/level + item only \u2014 no body, no footer",
+    bodyAllowed: false,
+    footerAllowed: false,
+    tags: [
+      {
+        key: ConfigKey.tag_title,
+        description: "The title of the heading",
+        jsonKey: "title|setMulti(level)",
+        exportJsonKey: { title: "$", level: "$level" }
+      }
+    ]
+  },
   [BitType2.help]: {
     since: "1.3.0",
     title: "Help",
@@ -10875,13 +10948,22 @@ var BITS = {
     since: "1.22.0",
     title: "List",
     bitGroups: [BitGroup.static],
-    baseBitType: BitType2.article,
+    // PLAN-021: rebased from article onto the lightweight base
+    baseBitType: BitType2._standardLight,
     description: "List bit, used to create lists in articles or books"
   },
+  [BitType2.listAlt]: {
+    since: "5.40.0",
+    title: "List Alt",
+    bitGroups: [BitGroup.static],
+    baseBitType: BitType2.list,
+    description: "Lightweight list bit (alternative), based on list"
+  },
   [BitType2.standardList]: {
     since: "1.22.0",
     bitGroups: [BitGroup.static],
-    baseBitType: BitType2.article,
+    // PLAN-021: re-rooted from article onto the lightweight list
+    baseBitType: BitType2.list,
     description: "Standard list bit, used to create standard lists in articles or books"
   },
   [BitType2.smartStandardList]: {
@@ -10897,6 +10979,13 @@ var BITS = {
       "xml-niso-iec": { "@el": "ref-list", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" }
     }
   },
+  [BitType2.smartStandardP]: {
+    since: "5.40.0",
+    title: "Smart Standard Paragraph",
+    bitGroups: [BitGroup.static],
+    baseBitType: BitType2.p,
+    description: "Smart standard paragraph bit, based on p"
+  },
   [BitType2.smartStandardListCollapsible]: {
     since: "1.28.0",
     deprecated: "5.37.0",
@@ -13478,7 +13567,8 @@ var BITS = {
   [BitType2.listItem]: {
     since: "1.22.0",
     bitGroups: [BitGroup.static],
-    baseBitType: BitType2.article,
+    // PLAN-021: rebased from article onto the lightweight base
+    baseBitType: BitType2._standardLight,
     description: "List item bit, used to create list items in articles or books",
     tags: [
       {
@@ -13883,6 +13973,20 @@ var BITS = {
     baseBitType: BitType2.multipleResponse,
     description: "Coach self-reflection multiple response bit, used for self-reflection in coaching"
   },
+  [BitType2.p]: {
+    since: "5.40.0",
+    title: "Paragraph",
+    bitGroups: [BitGroup.static],
+    baseBitType: BitType2._standardLight,
+    description: "Lightweight paragraph bit with a minimal tag set"
+  },
+  [BitType2.pAlt]: {
+    since: "5.40.0",
+    title: "Paragraph Alt",
+    bitGroups: [BitGroup.static],
+    baseBitType: BitType2.p,
+    description: "Lightweight paragraph bit (alternative), based on p"
+  },
   [BitType2.page]: {
     since: "1.3.0",
     title: "Page",
@@ -16613,7 +16717,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.39.0",
+  "version": "5.41.0",
   "author": "Get More Brain Ltd",
   "license": "ISC",
   "description": "A bitmark parser and generator using Peggy.js"
@@ -18467,6 +18571,752 @@ var AstWalkerGenerator = class {
   }
 };
 
+// src/generator/text/TextGrammarConstraints.ts
+var COLORS = [
+  "aqua",
+  "black",
+  "blue",
+  "brown",
+  "fuchsia",
+  "lightgrey",
+  "gray",
+  "darkgray",
+  "green",
+  "lime",
+  "magenta",
+  "maroon",
+  "navy",
+  "olive",
+  "orange",
+  "pink",
+  "purple",
+  "red",
+  "silver",
+  "teal",
+  "violet",
+  "white",
+  "yellow"
+];
+var HIGHLIGHT_COLORS = [
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "brown",
+  "white",
+  "black",
+  "gray"
+];
+var ALTERNATIVE_STYLE_TAGS = [
+  "bold",
+  "italic",
+  "light",
+  "highlightOrange",
+  "highlightYellow",
+  "highlightGreen",
+  "highlightBlue",
+  "highlightPurple",
+  "highlightPink",
+  "highlightBrown",
+  "highlightBlack",
+  "highlightWhite",
+  "highlightGray",
+  "highlight",
+  "strike",
+  "subscript",
+  "superscript",
+  "ins",
+  "del",
+  "underline",
+  "doubleUnderline",
+  "smallcaps",
+  "circle",
+  "languageEmRed",
+  "languageEmOrange",
+  "languageEmYellow",
+  "languageEmGreen",
+  "languageEmBlue",
+  "languageEmPurple",
+  "languageEmPink",
+  "languageEmBrown",
+  "languageEmBlack",
+  "languageEmWhite",
+  "languageEmGray",
+  "languageEm",
+  "userUnderline",
+  "userDoubleUnderline",
+  "userStrike",
+  "userCircle",
+  "userHighlight",
+  "notranslate"
+];
+var MEDIA_ALIGNMENTS = ["left", "center", "right"];
+var INLINE_MEDIA_ALIGNMENTS = [
+  "top",
+  "middle",
+  "bottom",
+  "baseline",
+  "sub",
+  "super",
+  "text-bottom",
+  "text-top"
+];
+var INLINE_MEDIA_SIZES = [
+  "line-height",
+  "font-height",
+  "super",
+  "sub",
+  "explicit"
+];
+var LINE_TERMINATOR_REGEX = /[\n\r\u2028\u2029]/;
+var CHAIN_STRING_INVALID_REGEX = /[|\n\r\u2028\u2029]/;
+var URL_CHAR_CLASS = "a-zA-Z0-9!*'()=+,\\-./_?#@[\\]$&;%:{}~^";
+var URL_CHAR_REGEX = new RegExp(`^[${URL_CHAR_CLASS}]$`);
+var URL_HTTP_REGEX = new RegExp(`^https?://[${URL_CHAR_CLASS}]*$`);
+var URL_REGEX = new RegExp(`^(https?://|mailto:)[${URL_CHAR_CLASS}]*$`);
+function isChainString(v) {
+  return typeof v === "string" && !CHAIN_STRING_INVALID_REGEX.test(v);
+}
+function isSingleLine(v) {
+  return typeof v === "string" && !LINE_TERMINATOR_REGEX.test(v);
+}
+function hasLineTerminator(v) {
+  return LINE_TERMINATOR_REGEX.test(v);
+}
+function isColor(v) {
+  return typeof v === "string" && COLORS.indexOf(v) !== -1;
+}
+function isHighlightColor(v) {
+  return typeof v === "string" && HIGHLIGHT_COLORS.indexOf(v) !== -1;
+}
+function isMediaAlignment(v) {
+  return typeof v === "string" && MEDIA_ALIGNMENTS.indexOf(v) !== -1;
+}
+function isInlineMediaAlignment(v) {
+  return typeof v === "string" && INLINE_MEDIA_ALIGNMENTS.indexOf(v) !== -1;
+}
+function isInlineMediaSize(v) {
+  return typeof v === "string" && INLINE_MEDIA_SIZES.indexOf(v) !== -1;
+}
+function toUInt(v) {
+  if (typeof v === "number") return Number.isInteger(v) && v >= 0 ? v : void 0;
+  if (typeof v === "string" && /^[0-9]+$/.test(v)) return parseInt(v, 10);
+  return void 0;
+}
+function toBoolean(v) {
+  if (typeof v === "boolean") return v;
+  if (v === "true") return true;
+  if (v === "false") return false;
+  return void 0;
+}
+function isDuration(v) {
+  return isChainString(v) && v.trim().startsWith("P");
+}
+function isUrlHttp(v) {
+  return typeof v === "string" && URL_HTTP_REGEX.test(v);
+}
+function isUrl(v) {
+  return typeof v === "string" && URL_REGEX.test(v);
+}
+function isUrlChar(c) {
+  return URL_CHAR_REGEX.test(c);
+}
+function bareUrlText(href) {
+  return href.replace(/^(https?:\/\/|mailto:)/, "");
+}
+function isInlineAlt(v) {
+  return typeof v === "string" && v.length > 0 && v.indexOf("==") === -1 && !v.startsWith("=") && !v.endsWith("=");
+}
+function isHeadingLevel(v) {
+  return typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= 3;
+}
+function normalizeInlineCodeLanguage(v) {
+  if (!isChainString(v)) return void 0;
+  return v.trim().toLowerCase();
+}
+function normalizeBlockCodeLanguage(v) {
+  if (!isSingleLine(v)) return void 0;
+  return v.trim().toLowerCase();
+}
+
+// src/generator/text/TextMediaAttrs.ts
+var uint = (v) => toUInt(v);
+var bool = (v) => toBoolean(v);
+var alignment = (v) => isMediaAlignment(v) ? v : void 0;
+var chainString = (v) => isChainString(v) ? v.trim() : void 0;
+var inlineAlignment = (v) => isInlineMediaAlignment(v) ? v : void 0;
+var inlineSize = (v) => isInlineMediaSize(v) ? v : void 0;
+var VALIDATORS = {
+  image: {
+    alt: chainString,
+    title: chainString,
+    alignment,
+    textAlign: alignment,
+    zoomDisabled: bool,
+    width: uint,
+    height: uint,
+    comment: chainString
+  },
+  imageInline: {
+    srcAlt: chainString,
+    alignmentVertical: inlineAlignment,
+    size: inlineSize,
+    width: uint,
+    height: uint,
+    comment: chainString
+  },
+  symbol: {
+    alt: chainString,
+    title: chainString,
+    caption: chainString,
+    alignment,
+    textAlign: alignment,
+    captionAlign: alignment,
+    zoomDisabled: bool,
+    width: uint,
+    height: uint,
+    comment: chainString
+  }
+};
+var TAG_NAMES = {
+  textAlign: "captionAlign",
+  title: "caption"
+};
+var DEFAULTS = {
+  image: { alignment: "center", textAlign: "left", zoomDisabled: true },
+  imageInline: { alignmentVertical: "top", size: "line-height" },
+  symbol: {}
+};
+function sanitizeMediaAttrs(kind, attrs) {
+  const result = {};
+  if (!attrs || typeof attrs !== "object") return result;
+  const validators = VALIDATORS[kind];
+  for (const [k, v] of Object.entries(attrs)) {
+    const validator = validators[k];
+    if (!validator || v == null) continue;
+    const valid = validator(v);
+    if (valid !== void 0) result[k] = valid;
+  }
+  if (kind === "symbol") {
+    if ("caption" in result) delete result.title;
+    if ("captionAlign" in result) delete result.textAlign;
+  }
+  return result;
+}
+function serializeMediaChain(kind, attrs) {
+  const defaults = DEFAULTS[kind];
+  let s = "";
+  for (const k of Object.keys(VALIDATORS[kind])) {
+    const v = attrs[k];
+    if (v == null) continue;
+    if (k in defaults && defaults[k] === v) continue;
+    if (k === "comment") {
+      if (v) s += `|#${v}`;
+    } else if (typeof v === "string" && v === "") {
+      continue;
+    } else {
+      s += `|${TAG_NAMES[k] ?? k}:${v}`;
+    }
+  }
+  return s;
+}
+
+// src/generator/text/TextMarkSanitizer.ts
+var STANDARD_SHORT_FORM_MARKS = [
+  TextMarkType.bold,
+  TextMarkType.italic,
+  TextMarkType.light,
+  TextMarkType.highlight
+];
+function attrsOf(mark2) {
+  const a = mark2.attrs;
+  return a && typeof a === "object" && !Array.isArray(a) ? a : {};
+}
+function chainValue(v) {
+  if (v == null) return "";
+  return isChainString(v) ? v.trim() : void 0;
+}
+function mark(type, attrs) {
+  return attrs ? { type, attrs } : { type };
+}
+function sanitizeMark(m, options) {
+  const attrs = attrsOf(m);
+  switch (m.type) {
+    case TextMarkType.highlight:
+    case TextMarkType.userHighlight: {
+      const color = attrs.color;
+      return isHighlightColor(color) ? mark(m.type, { color }) : mark(m.type);
+    }
+    case TextMarkType.textStyle:
+    case TextMarkType.color: {
+      const color = attrs.color;
+      return isColor(color) ? mark(TextMarkType.textStyle, { color }) : void 0;
+    }
+    case TextMarkType.link: {
+      const href = chainValue(attrs.href);
+      return href === void 0 ? void 0 : mark(m.type, { href });
+    }
+    case TextMarkType.ref: {
+      const reference = chainValue(attrs.reference);
+      return reference === void 0 ? void 0 : mark(m.type, { reference });
+    }
+    case TextMarkType.xref: {
+      const xref = chainValue(attrs.xref);
+      if (xref === void 0) return void 0;
+      const reference = chainValue(attrs.reference) ?? "";
+      return mark(m.type, { xref, reference });
+    }
+    case TextMarkType.extref: {
+      const extref = chainValue(attrs.extref);
+      const provider = chainValue(attrs.provider);
+      if (extref === void 0 || provider === void 0) return void 0;
+      const refs = Array.isArray(attrs.references) ? attrs.references : [];
+      const references = refs.map((r) => chainValue(r)).filter((r) => r !== void 0);
+      return mark(m.type, { extref, references, provider });
+    }
+    case TextMarkType.footnote:
+    case TextMarkType.footnoteStar: {
+      const content = options.normalizeChainValue ? options.normalizeChainValue(attrs.content) : Array.isArray(attrs.content) ? attrs.content : [];
+      return content === void 0 ? void 0 : mark(m.type, { content });
+    }
+    case TextMarkType.symbol: {
+      const src = chainValue(attrs.src);
+      if (src === void 0) return void 0;
+      return mark(m.type, { src, ...sanitizeMediaAttrs("symbol", attrs) });
+    }
+    case TextMarkType.var: {
+      const name = chainValue(attrs.name);
+      return name === void 0 ? void 0 : mark(m.type, { name });
+    }
+    case TextMarkType.code: {
+      const language = normalizeInlineCodeLanguage(attrs.language);
+      return language === void 0 ? mark(m.type) : mark(m.type, { language });
+    }
+    case TextMarkType.timer: {
+      const duration = attrs.duration;
+      if (!isDuration(duration)) return void 0;
+      const name = chainValue(attrs.name) ?? "";
+      return mark(m.type, { name, duration: duration.trim() });
+    }
+    case TextMarkType.colorPicker: {
+      const propertyRef = chainValue(attrs.propertyRef);
+      return propertyRef === void 0 ? void 0 : mark(m.type, { propertyRef });
+    }
+    case TextMarkType.comment: {
+      const comment = chainValue(m.comment);
+      return comment === void 0 ? void 0 : { type: m.type, comment };
+    }
+    default:
+      if (ALTERNATIVE_STYLE_TAGS.indexOf(m.type) !== -1) return mark(m.type);
+      return void 0;
+  }
+}
+function mergeLegacyTimer(marks) {
+  const timer = marks.find((m) => m.type === TextMarkType.timer);
+  const duration = marks.find((m) => m.type === TextMarkType.duration);
+  if (!timer || !duration || attrsOf(timer).duration) return marks;
+  return marks.map(
+    (m) => m === timer ? { ...timer, attrs: { ...attrsOf(timer), duration: attrsOf(duration).duration } } : m
+  );
+}
+function orderMarks(marks) {
+  const a = (m) => m.attrs ?? {};
+  const isBareHighlight = (m) => (m.type === TextMarkType.highlight || m.type === TextMarkType.userHighlight) && !a(m).color;
+  const isHighlightColorStyle = (m) => m.type === TextMarkType.textStyle && isHighlightColor(a(m).color);
+  const isEmptyXref = (m) => m.type === TextMarkType.xref && !a(m).reference;
+  const result = [];
+  for (const m of marks) {
+    if (m.type === TextMarkType.ref) {
+      const xrefIdx = result.findIndex(isEmptyXref);
+      if (xrefIdx !== -1) {
+        result.splice(xrefIdx, 0, m);
+        continue;
+      }
+    }
+    result.push(m);
+  }
+  for (let i = 0; i < result.length - 1; i++) {
+    if (isBareHighlight(result[i]) && isHighlightColorStyle(result[i + 1])) {
+      [result[i], result[i + 1]] = [result[i + 1], result[i]];
+    }
+  }
+  const symbols = result.filter((m) => m.type === TextMarkType.symbol);
+  if (symbols.length === 0) return result;
+  return [...result.filter((m) => m.type !== TextMarkType.symbol), symbols[0]];
+}
+function sanitizeMarks(marks, options = {}) {
+  if (!Array.isArray(marks)) return [];
+  let loose = marks.filter(
+    (m) => !!m && typeof m === "object" && typeof m.type === "string"
+  );
+  loose = mergeLegacyTimer(loose);
+  const result = [];
+  for (const m of loose) {
+    const s = sanitizeMark(m, options);
+    if (s) result.push(s);
+  }
+  if (options.chainValue) {
+    if (result.length === 1 && STANDARD_SHORT_FORM_MARKS.indexOf(result[0].type) !== -1) {
+      return [mark(result[0].type)];
+    }
+    if (result.length === 1 && result[0].type === TextMarkType.link) return result;
+    return [];
+  }
+  return orderMarks(result);
+}
+
+// src/generator/text/TextAstNormalizer.ts
+var LIST_TYPES = [
+  TextNodeType.noBulletList,
+  TextNodeType.bulletList,
+  TextNodeType.orderedList,
+  TextNodeType.orderedListRoman,
+  TextNodeType.orderedListRomanLower,
+  TextNodeType.letteredList,
+  TextNodeType.letteredListLower,
+  TextNodeType.taskList
+];
+var ORDERED_LIST_TYPES = [
+  TextNodeType.orderedList,
+  TextNodeType.orderedListRoman,
+  TextNodeType.orderedListRomanLower
+];
+var BODY_BIT_TYPES = [
+  TextNodeType.gap,
+  TextNodeType.select,
+  TextNodeType.highlight,
+  TextNodeType.mark
+];
+var LEADING_TAB_REGEX = /(^|[\n\r\u2028\u2029])\t+/g;
+var isList = (n) => LIST_TYPES.indexOf(n.type) !== -1;
+var isListItem = (n) => n.type === TextNodeType.listItem || n.type === TextNodeType.taskItem;
+var isBodyBit = (n) => BODY_BIT_TYPES.indexOf(n.type) !== -1;
+var isNode = (n) => !!n && typeof n === "object" && typeof n.type === "string";
+var contentOf = (n) => Array.isArray(n.content) ? n.content.filter(isNode) : [];
+var attrsOf2 = (n) => n.attrs && typeof n.attrs === "object" ? n.attrs : {};
+var asNode = (n) => n;
+var paragraph = (content) => asNode({ type: TextNodeType.paragraph, attrs: {}, content });
+var hardBreak = () => ({ type: TextNodeType.hardBreak });
+var isHardBreak = (n) => n?.type === TextNodeType.hardBreak;
+var hasText = (nodes) => nodes.some(
+  (n) => n.type !== TextNodeType.hardBreak && (n.type !== TextNodeType.text || typeof n.text === "string" && n.text.trim() !== "")
+);
+function canFollowBareUrl(next) {
+  if (!next) return true;
+  if (next.type === TextNodeType.hardBreak) return true;
+  if (next.type !== TextNodeType.text) return false;
+  if (next.marks && next.marks.length > 0) return false;
+  const first = (next.text ?? "").charAt(0);
+  return first === "" || !isUrlChar(first);
+}
+function isSimpleLinkNode(node, next) {
+  if (node.type !== TextNodeType.text || node.marks?.length !== 1) return false;
+  const m = node.marks[0];
+  if (m.type !== TextMarkType.link) return false;
+  const href = m.attrs?.href;
+  return isUrl(href) && bareUrlText(href) === node.text && canFollowBareUrl(next);
+}
+var FLATTENED_BLOCK_TYPES = [
+  TextNodeType.paragraph,
+  TextNodeType.heading,
+  TextNodeType.section,
+  TextNodeType.listItem,
+  TextNodeType.taskItem,
+  TextNodeType.codeBlock
+];
+var TextAstNormalizer = class {
+  constructor(options) {
+    __publicField(this, "options");
+    this.options = options;
+  }
+  normalize(ast) {
+    if (!Array.isArray(ast)) return [];
+    const nodes = ast.filter(isNode);
+    if (this.options.chainValue) return this.inline(nodes, { plain: true, chainValue: true });
+    if (this.options.location === TextLocation2.tag) {
+      return nodes.flatMap((n) => this.inlineRootNode(n, {}));
+    }
+    return nodes.flatMap((n) => this.block(n));
+  }
+  //
+  // Block context
+  //
+  block(n) {
+    switch (n.type) {
+      case TextNodeType.paragraph:
+        return [{ ...n, content: this.inline(contentOf(n)) }];
+      case TextNodeType.heading:
+        return this.heading(n);
+      case TextNodeType.section:
+        return [paragraph(this.inline(contentOf(n)))];
+      case TextNodeType.image: {
+        const image = this.image(n);
+        return image ? [image] : [];
+      }
+      case TextNodeType.codeBlock:
+        return [{ ...n, content: this.code(contentOf(n)) }];
+      case TextNodeType.text:
+      case TextNodeType.hardBreak:
+      case TextNodeType.imageInline:
+      case TextNodeType.latex:
+        return this.inline([n]);
+      default:
+        if (isList(n)) return this.list(n);
+        if (isListItem(n)) return [paragraph(this.inline(contentOf(n)))];
+        if (isBodyBit(n)) return [n];
+        if (Array.isArray(n.content))
+          return [{ ...n, content: this.blocks(contentOf(n)) }];
+        return [n];
+    }
+  }
+  blocks(nodes) {
+    return nodes.flatMap((n) => this.block(n));
+  }
+  heading(n) {
+    const level = attrsOf2(n).level;
+    if (level != null && !isHeadingLevel(level)) {
+      return [paragraph(this.inline(contentOf(n)))];
+    }
+    const content = this.inline(contentOf(n), { singleLine: true });
+    if (!hasText(content)) return [];
+    return [{ ...n, content }];
+  }
+  image(n) {
+    const attrs = attrsOf2(n);
+    if (!isUrlHttp(attrs.src)) return void 0;
+    return asNode({ ...n, attrs: { src: attrs.src, ...sanitizeMediaAttrs("image", attrs) } });
+  }
+  code(nodes) {
+    const result = [];
+    for (const n of nodes) {
+      if (n.type === TextNodeType.text) {
+        if (typeof n.text === "string" && n.text) {
+          result.push({ type: TextNodeType.text, text: n.text });
+        }
+      } else if (n.type === TextNodeType.hardBreak) {
+        result.push(hardBreak());
+      } else {
+        result.push(...this.code(contentOf(n)));
+      }
+    }
+    return result;
+  }
+  //
+  // List context
+  //
+  list(n) {
+    const attrs = attrsOf2(n);
+    const ordered = ORDERED_LIST_TYPES.indexOf(n.type) !== -1;
+    let start;
+    if (ordered && attrs.start != null) {
+      start = toUInt(attrs.start);
+      if (start === void 0) {
+        return contentOf(n).map(
+          (item) => paragraph(this.inline([item], { stripLeadingTabs: true }))
+        );
+      }
+    }
+    const items = [];
+    for (const child of contentOf(n)) {
+      if (isListItem(child)) {
+        items.push(...this.listItem(child));
+      } else {
+        items.push(...this.listItem({ type: TextNodeType.listItem, content: [child] }));
+      }
+    }
+    if (items.length === 0) return [];
+    const newAttrs = { ...attrs };
+    if (ordered && start !== void 0) newAttrs.start = start;
+    return [asNode({ ...n, attrs: newAttrs, content: items })];
+  }
+  /**
+   * A list item holds a paragraph, then at most one sublist. Everything else is merged into the
+   * paragraph; further sublists become new items (with an empty paragraph, which keeps them
+   * attached). Returns the resulting item(s).
+   */
+  listItem(item) {
+    const inlineOpts = { stripLeadingTabs: true };
+    const acc = {};
+    let sublist;
+    const extraItems = [];
+    const merge = (inline) => {
+      if (!acc.para) acc.para = inline;
+      else if (inline.length > 0) acc.para.push(hardBreak(), ...inline);
+    };
+    for (const child of contentOf(item)) {
+      if (isList(child)) {
+        for (const list of this.list(child)) {
+          if (list.type === TextNodeType.paragraph) {
+            merge(list.content ?? []);
+          } else if (!sublist) {
+            sublist = list;
+          } else {
+            extraItems.push({ ...item, content: [paragraph([]), list] });
+          }
+        }
+      } else if (child.type === TextNodeType.image) {
+      } else {
+        merge(this.inline([child], inlineOpts));
+      }
+    }
+    const paraContent = acc.para ?? [];
+    if (!hasText(paraContent) && !sublist) return extraItems;
+    const content = [paragraph(paraContent)];
+    if (sublist) content.push(sublist);
+    return [{ ...item, content }, ...extraItems];
+  }
+  //
+  // Inline context
+  //
+  /** A root node at tag location: paragraphs of inline content only */
+  inlineRootNode(n, opts) {
+    switch (n.type) {
+      case TextNodeType.text:
+      case TextNodeType.hardBreak:
+      case TextNodeType.imageInline:
+      case TextNodeType.latex:
+        return this.inline([n], opts);
+      case TextNodeType.image:
+        return [];
+      default:
+        if (isBodyBit(n)) return [n];
+        if (isList(n)) {
+          return contentOf(n).map(
+            (item) => paragraph(this.inline([item], { ...opts, stripLeadingTabs: true }))
+          );
+        }
+        return [paragraph(this.inline(contentOf(n), opts))];
+    }
+  }
+  inline(nodes, opts = {}) {
+    const result = [];
+    const separator = () => opts.singleLine ? this.spaceText() : hardBreak();
+    const separate = () => {
+      if (result.length > 0 && !isHardBreak(result[result.length - 1])) result.push(separator());
+    };
+    for (const n of nodes) {
+      switch (n.type) {
+        case TextNodeType.text: {
+          const text = this.text(n, opts);
+          if (text) result.push(text);
+          break;
+        }
+        case TextNodeType.hardBreak:
+          result.push(separator());
+          break;
+        case TextNodeType.imageInline: {
+          if (opts.plain) break;
+          const image = this.imageInline(n);
+          if (image) result.push(image);
+          break;
+        }
+        case TextNodeType.latex:
+          if (opts.plain) break;
+          if (typeof attrsOf2(n).formula === "string") result.push(n);
+          break;
+        case TextNodeType.image:
+          break;
+        default:
+          if (isBodyBit(n)) {
+            result.push(n);
+          } else if (isList(n)) {
+            for (const item of contentOf(n)) {
+              separate();
+              result.push(...this.inline([item], opts));
+            }
+          } else if (FLATTENED_BLOCK_TYPES.indexOf(n.type) !== -1) {
+            separate();
+            result.push(...this.inline(contentOf(n), opts));
+          } else if (Array.isArray(n.content)) {
+            result.push({ ...n, content: this.inline(contentOf(n), opts) });
+          } else {
+            result.push(n);
+          }
+      }
+    }
+    return this.dropSymbolsBeforePipes(result);
+  }
+  /**
+   * A symbol's media chain swallows every following `...|` segment on its line (even when sealed
+   * with `^`), so a symbol mark has no representable form when the rest of the line contains `|`.
+   */
+  dropSymbolsBeforePipes(nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      const n = nodes[i];
+      if (!n.marks?.some((m) => m.type === TextMarkType.symbol)) continue;
+      let pipeFollows = false;
+      for (let j = i + 1; j < nodes.length && !isHardBreak(nodes[j]); j++) {
+        const text = nodes[j].text;
+        if (typeof text !== "string") continue;
+        const firstLine = text.split(/[\n\r\u2028\u2029]/, 1)[0];
+        if (firstLine.indexOf("|") !== -1) pipeFollows = true;
+        if (hasLineTerminator(text)) break;
+      }
+      if (pipeFollows) {
+        const marks = n.marks.filter((m) => m.type !== TextMarkType.symbol);
+        const { marks: _m, ...rest } = n;
+        nodes[i] = marks.length > 0 ? { ...rest, marks } : rest;
+      }
+    }
+    return nodes;
+  }
+  text(n, opts) {
+    if (typeof n.text !== "string") return void 0;
+    let text = n.text;
+    if (opts.stripLeadingTabs) text = text.replace(LEADING_TAB_REGEX, "$1");
+    if (opts.singleLine) text = text.replace(/[\n\r\u2028\u2029]+/g, " ");
+    if (!text) return void 0;
+    const marks = sanitizeMarks(n.marks, {
+      chainValue: opts.chainValue,
+      normalizeChainValue: (content) => this.chainValue(content)
+    });
+    const { marks: _m, ...rest } = n;
+    return marks.length > 0 ? { ...rest, text, marks } : { ...rest, text };
+  }
+  spaceText() {
+    return { type: TextNodeType.text, text: " " };
+  }
+  imageInline(n) {
+    const attrs = attrsOf2(n);
+    if (!isUrl(attrs.src)) return void 0;
+    const alt = attrs.alt;
+    if (!isInlineAlt(alt)) return void 0;
+    return asNode({
+      ...n,
+      attrs: { src: attrs.src, alt, ...sanitizeMediaAttrs("imageInline", attrs) }
+    });
+  }
+  /**
+   * Footnote content: a `|`-free single line of plain text with short-form standard marks.
+   * Returns undefined when the content cannot be represented.
+   */
+  chainValue(content) {
+    if (!Array.isArray(content)) return [];
+    const nodes = this.inline(content.filter(isNode), {
+      plain: true,
+      chainValue: true,
+      singleLine: true
+    });
+    for (let i = 0; i < nodes.length; i++) {
+      const n = nodes[i];
+      const text = n.text;
+      if (typeof text === "string" && (text.indexOf("|") !== -1 || hasLineTerminator(text))) {
+        return void 0;
+      }
+      if (n.marks?.some((m) => m.type === TextMarkType.link) && !isSimpleLinkNode(n, nodes[i + 1])) {
+        const { marks: _m, ...rest } = n;
+        nodes[i] = rest;
+      }
+    }
+    return nodes;
+  }
+};
+function normalizeTextAst(ast, options) {
+  return new TextAstNormalizer(options).normalize(ast);
+}
+
 // src/generator/text/TextGenerator.ts
 var DEFAULT_OPTIONS = {
   bodyBitCallback: void 0,
@@ -18559,21 +19409,9 @@ var INLINE_MARK_TYPES = [
   TextMarkType.colorPicker,
   TextMarkType.comment
 ];
-var HIGHLIGHT_COLORS = [
-  "orange",
-  "yellow",
-  "green",
-  "blue",
-  "purple",
-  "pink",
-  "brown",
-  "white",
-  "black",
-  "gray"
-];
 var INDENTATION_REGEX = new RegExp(/(\n|\r\n)/, "g");
-var LINK_REGEX = new RegExp(/https?:\/\/|mailto:(.*)/, "g");
 var LINK_BREAKSCAPE_REGEX = new RegExp(/\]/, "g");
+var CHAIN_CONTINUATION_REGEX = /^[^\n\r\u2028\u2029]*\|/;
 var Stage = {
   enter: "enter",
   between: "between",
@@ -18610,6 +19448,8 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     __publicField(this, "textDepth", 0);
     __publicField(this, "placeholderIndex", 0);
     __publicField(this, "placeholders", {});
+    __publicField(this, "chainJustClosed", false);
+    __publicField(this, "simpleLinkAllowed", true);
     // For pre-text
     __publicField(this, "rootParagraphNodeContentIndex", 0);
     __publicField(this, "previousRootParagraphContextType", TextNodeType.text);
@@ -18655,6 +19495,11 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
   generateSync(ast, textFormat, textLocation, options) {
     if (!ast || !Array.isArray(ast)) return "";
     this.generateOptions = Object.assign({}, options);
+    ast = normalizeTextAst(ast, {
+      format: textFormat ?? TextFormat2.bitmarkText,
+      location: textLocation,
+      chainValue: this.generateOptions.chainValueContext
+    });
     this.validateGenerateOptions(ast);
     if (!this.generateOptions.plainTextDividerAllowed) {
       this.resetState(textFormat, textLocation);
@@ -18698,6 +19543,8 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     this.textDepth = 0;
     this.placeholderIndex = 0;
     this.placeholders = {};
+    this.chainJustClosed = false;
+    this.simpleLinkAllowed = true;
     this.rootParagraphNodeContentIndex = 0;
     this.previousRootParagraphContextType = TextNodeType.hardBreak;
     this.inPreText = false;
@@ -18763,6 +19610,7 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
         this.writeHardBreak(node);
         break;
       case TextNodeType.text: {
+        this.simpleLinkAllowed = this.isSimpleLinkAllowedAfter(route);
         this.writeMarks(node, Stage.enter);
         this.writeText(node);
         this.writeMarks(node, Stage.between);
@@ -18776,9 +19624,6 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
         this.writeHeading(node);
         this.inHeading = true;
         break;
-      case TextNodeType.section:
-        this.writeSection(node);
-        break;
       case TextNodeType.listItem:
       case TextNodeType.taskItem:
         this.writeBullet(node, route);
@@ -18836,7 +19681,6 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
         break;
       case TextNodeType.heading:
         this.inHeading = false;
-      case TextNodeType.section:
       case TextNodeType.image:
         if (!this.inParagraph) {
           this.writeNL();
@@ -18948,9 +19792,9 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
    */
   getLinkHref(node) {
     if (node.type === TextNodeType.text && node.marks) {
-      const href = node.marks.reduce((acc, mark) => {
-        if (mark.type === TextMarkType.link) {
-          const linkMark = mark;
+      const href = node.marks.reduce((acc, mark2) => {
+        if (mark2.type === TextMarkType.link) {
+          const linkMark = mark2;
           const href2 = linkMark.attrs?.href;
           if (href2) return href2;
         }
@@ -19015,6 +19859,9 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
       const indentationString = this.getIndentationString();
       s = s.replace(INDENTATION_REGEX, `$1${indentationString}`);
     }
+    if (this.chainJustClosed && CHAIN_CONTINUATION_REGEX.test(s)) {
+      s = `^${s}`;
+    }
     if (this.havePreText && this.rootParagraphNodeContentIndex === this.preTextIndex) {
       this.writePlainTextDivider();
       this.writeNL();
@@ -19044,14 +19891,14 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
    * @returns true if a simple link, otherwise false
    */
   isSimpleLink(node) {
-    if (node.text == null) return false;
-    if (node.marks?.length !== 1) return false;
-    const href = this.getLinkHref(node);
-    if (href) {
-      const hrefText = href.replace(LINK_REGEX, "$1");
-      return hrefText === node.text;
-    }
-    return false;
+    return this.simpleLinkAllowed && isSimpleLinkNode(node, void 0);
+  }
+  /**
+   * The bare-URL link short form is only safe when whatever is written next cannot be read as
+   * part of the URL (the parser's Url rule consumes every following UrlChar).
+   */
+  isSimpleLinkAllowedAfter(route) {
+    return canFollowBareUrl(this.getSiblingNodes(route).right);
   }
   /**
    * Get the link text if the node is a link, otherwise return false
@@ -19063,15 +19910,8 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     if (node.text == null) return false;
     const href = this.getLinkHref(node);
     if (href) {
-      let res;
-      const hrefText = href.replace(LINK_REGEX, "$1");
-      if (hrefText === node.text) {
-        res = href;
-      } else {
-        res = node.text;
-      }
-      res = (res ?? "").replace(LINK_BREAKSCAPE_REGEX, "^]");
-      return res;
+      const res = this.isSimpleLink(node) ? href : node.text;
+      return res.replace(LINK_BREAKSCAPE_REGEX, "^]");
     }
     return false;
   }
@@ -19128,22 +19968,17 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
   writeMarks(node, stage) {
     if (node.marks) {
       const forceSingleMark = this.generateOptions.forceInline || !!(this.inInline || this.inHeading);
-      this.thisNodeIsPreText = false;
-      const emptyMarks = node.marks.length === 0;
-      if (emptyMarks) {
-        this.writeMarkTextWrapper(INLINE_MARK);
-        return;
-      }
-      const marks = this.getWritableMarks(node.marks);
+      const marks = node.marks;
       if (marks.length === 0) return;
+      this.thisNodeIsPreText = false;
       const singleMark = marks.length === 1 && forceSingleMark;
       const markStartEnd = marks.reduce(
-        (acc, mark) => {
+        (acc, mark2) => {
           if (acc) return acc;
-          if (this.isStandardMark(mark)) {
-            if (singleMark) return STANDARD_MARKS[mark.type];
+          if (this.isStandardMark(mark2)) {
+            if (singleMark) return STANDARD_MARKS[mark2.type];
             return INLINE_MARK;
-          } else if (this.isInlineMark(mark)) {
+          } else if (this.isInlineMark(mark2)) {
             return INLINE_MARK;
           } else {
           }
@@ -19158,56 +19993,59 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
           this.writeMarkTextWrapper(markStartEnd);
         }
         if (stage == Stage.between) {
-          for (const mark of marks) {
-            if (this.isStandardMark(mark)) {
+          for (const mark2 of marks) {
+            if (this.isStandardMark(mark2)) {
               if (!singleMark) {
                 this.writeInlineMarkStartEnd();
-                this.writeInlineMark(mark);
+                this.writeInlineMark(mark2);
               }
-            } else if (TextMarkType.comment === mark.type) {
+            } else if (TextMarkType.comment === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeCommentMark(mark);
-            } else if (TextMarkType.link === mark.type) {
+              this.writeCommentMark(mark2);
+            } else if (TextMarkType.link === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeLinkMark(mark);
-            } else if (TextMarkType.ref === mark.type) {
+              this.writeLinkMark(mark2);
+            } else if (TextMarkType.ref === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeRefMark(mark);
-            } else if (TextMarkType.xref === mark.type) {
+              this.writeRefMark(mark2);
+            } else if (TextMarkType.xref === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeXRefMark(mark);
-            } else if (TextMarkType.extref === mark.type) {
+              this.writeXRefMark(mark2);
+            } else if (TextMarkType.extref === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeExtRefMark(mark);
-            } else if (TextMarkType.footnote === mark.type) {
+              this.writeExtRefMark(mark2);
+            } else if (TextMarkType.footnote === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeFootnoteMark(mark);
-            } else if (TextMarkType.footnoteStar === mark.type) {
+              this.writeFootnoteMark(mark2);
+            } else if (TextMarkType.footnoteStar === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeFootnoteStarMark(mark);
-            } else if (TextMarkType.symbol === mark.type) {
+              this.writeFootnoteStarMark(mark2);
+            } else if (TextMarkType.symbol === mark2.type) {
               this.writeInlineMarkStartEnd();
-              this.writeSymbolMark(mark);
-            } else if (this.isInlineMark(mark)) {
+              this.writeSymbolMark(mark2);
+            } else if (this.isInlineMark(mark2)) {
               this.writeInlineMarkStartEnd();
-              this.writeInlineMark(mark);
+              this.writeInlineMark(mark2);
             } else {
             }
           }
         }
         if (stage == Stage.exit) {
           let inlineMarkWritten = false;
-          for (const mark of marks) {
-            if (this.isStandardMark(mark)) {
+          for (const mark2 of marks) {
+            if (this.isStandardMark(mark2)) {
               if (!singleMark) {
                 inlineMarkWritten = true;
               }
-            } else if (TextMarkType.comment === mark.type || TextMarkType.link === mark.type || TextMarkType.ref === mark.type || TextMarkType.xref === mark.type || TextMarkType.footnote === mark.type || TextMarkType.footnoteStar === mark.type || this.isInlineMark(mark)) {
+            } else if (TextMarkType.comment === mark2.type || TextMarkType.link === mark2.type || TextMarkType.ref === mark2.type || TextMarkType.xref === mark2.type || TextMarkType.footnote === mark2.type || TextMarkType.footnoteStar === mark2.type || this.isInlineMark(mark2)) {
               inlineMarkWritten = true;
             } else {
             }
           }
-          if (inlineMarkWritten) this.writeInlineMarkStartEnd();
+          if (inlineMarkWritten) {
+            this.writeInlineMarkStartEnd();
+            this.chainJustClosed = true;
+          }
         }
       }
     }
@@ -19243,15 +20081,6 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     s += " ";
     this.write(s);
   }
-  writeSection(node) {
-    let s = "";
-    if (node.section) {
-      s = `|${node.section}: `;
-    } else {
-      s = "|";
-    }
-    this.write(s);
-  }
   writeBullet(node, route) {
     let bullet = this.getIndentationString();
     const listParent = this.getParentNode(route, 2);
@@ -19274,7 +20103,7 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
       bullet += "\u2022a ";
     } else if (listType === TextNodeType.taskList) {
       const taskList = node;
-      const checked = taskList.attrs?.checked ?? false;
+      const checked = taskList.attrs?.checked === true;
       bullet += checked ? "\u2022+ " : "\u2022- ";
     }
     if (bullet) this.write(bullet);
@@ -19283,28 +20112,20 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     if (node.attrs == null || !node.attrs.src) return;
     const attrs = node.attrs;
     const inlineImage = node.type === TextNodeType.imageInline;
-    let ignoreAttributes;
-    if (inlineImage) {
-      ignoreAttributes = /* @__PURE__ */ new Set(["alt", "zoomDisabled", "title"]);
-      const a = attrs;
-      if (a.alignmentVertical === "top") ignoreAttributes.add("alignmentVertical");
-      if (a.size === "line-height") ignoreAttributes.add("size");
-    }
-    const mediaAttrs = this.getMediaAttrs(inlineImage ? "imageInline" : "image", attrs, {
-      ignoreAttributes
-    });
+    const kind = inlineImage ? "imageInline" : "image";
+    const chain = serializeMediaChain(kind, attrs);
     let s = "";
     if (inlineImage) {
       s = `==${attrs.alt ?? ""}==`;
     }
-    s += mediaAttrs ? `|${mediaAttrs}|` : "";
+    s += `|${kind}:${attrs.src}${chain}|`;
     this.write(s);
   }
   writeCodeBlock(node) {
-    if (node.attrs == null || !node.attrs.language) return;
-    const attrs = node.attrs;
-    const s = `|code:${attrs.language}
-`;
+    const raw = node.attrs?.language ?? node.language;
+    const language = normalizeBlockCodeLanguage(raw) ?? "";
+    const s = language ? `|code:${language}
+` : "|code\n";
     this.write(s);
   }
   writeLatex(node) {
@@ -19320,10 +20141,10 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
   writeMarkTextWrapper(s) {
     if (s) this.write(s);
   }
-  writeInlineMark(mark) {
-    const attrs = mark.attrs ?? {};
+  writeInlineMark(mark2) {
+    const attrs = mark2.attrs ?? {};
     let s;
-    switch (mark.type) {
+    switch (mark2.type) {
       case TextMarkType.textStyle:
       case TextMarkType.color:
         s = `color:${attrs.color ?? ""}`;
@@ -19334,10 +20155,10 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
         break;
       case TextMarkType.highlight:
       case TextMarkType.userHighlight:
-        s = attrs.color ? `${mark.type}|color:${attrs.color}` : `${mark.type}`;
+        s = attrs.color ? `${mark2.type}|color:${attrs.color}` : `${mark2.type}`;
         break;
       default: {
-        s = `${mark.type}`;
+        s = `${mark2.type}`;
         for (const [k, v] of Object.entries(attrs)) {
           if (k === "language" && v !== "plain text" || k === "propertyRef" || k === "name") {
             s = `${s}:${v}`;
@@ -19347,88 +20168,49 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     }
     this.write(s);
   }
-  /**
-   * Resolve the marks of a text node into the marks that will actually be written.
-   *
-   * - Merges a legacy standalone 'duration' mark into its sibling 'timer' mark.
-   * - Drops marks the current grammar cannot express (standalone 'duration', 'timer'
-   *   without a duration).
-   * - Moves a 'textStyle'/'color' mark before a preceding bare 'highlight'/'userHighlight'
-   *   mark when its color is a valid highlight color; written in the original order the
-   *   output would re-parse as a highlight-with-color compound mark and change meaning.
-   */
-  getWritableMarks(nodeMarks) {
-    const attrsOf = (m) => m.attrs ?? {};
-    let marks = [...nodeMarks];
-    const timer = marks.find((m) => m.type === TextMarkType.timer);
-    const duration = marks.find((m) => m.type === TextMarkType.duration);
-    if (timer && duration && !attrsOf(timer).duration) {
-      marks = marks.map(
-        (m) => m === timer ? {
-          ...timer,
-          attrs: { ...attrsOf(timer), duration: attrsOf(duration).duration }
-        } : m
-      );
-    }
-    marks = marks.filter((m) => {
-      if (m.type === TextMarkType.duration) return false;
-      if (m.type === TextMarkType.timer) return !!attrsOf(m).duration;
-      return true;
-    });
-    const isBareHighlight = (m) => (m.type === TextMarkType.highlight || m.type === TextMarkType.userHighlight) && !attrsOf(m).color;
-    const isHighlightColorStyle = (m) => (m.type === TextMarkType.textStyle || m.type === TextMarkType.color) && HIGHLIGHT_COLORS.indexOf(attrsOf(m).color) !== -1;
-    for (let i = 0; i < marks.length - 1; i++) {
-      if (isBareHighlight(marks[i]) && isHighlightColorStyle(marks[i + 1])) {
-        const tmp = marks[i];
-        marks[i] = marks[i + 1];
-        marks[i + 1] = tmp;
-      }
-    }
-    return marks;
-  }
   /**
    * True if the mark is written using its standard form (e.g. **bold**, !!highlight!!)
    * when it is the only mark. A highlight mark with a color attribute is excluded - it
    * can only be expressed using the inline chain form (==text==|highlight|color:x|).
    */
-  isStandardMark(mark) {
-    if (STANDARD_MARK_TYPES.indexOf(mark.type) === -1) return false;
-    return !(mark.attrs && mark.attrs.color);
+  isStandardMark(mark2) {
+    if (STANDARD_MARK_TYPES.indexOf(mark2.type) === -1) return false;
+    return !(mark2.attrs && mark2.attrs.color);
   }
   /**
    * True if the mark is written using the inline chain form (==text==|mark|).
    */
-  isInlineMark(mark) {
-    if (INLINE_MARK_TYPES.indexOf(mark.type) !== -1) return true;
-    return mark.type === TextMarkType.highlight && !!(mark.attrs && mark.attrs.color);
+  isInlineMark(mark2) {
+    if (INLINE_MARK_TYPES.indexOf(mark2.type) !== -1) return true;
+    return mark2.type === TextMarkType.highlight && !!(mark2.attrs && mark2.attrs.color);
   }
-  writeCommentMark(mark) {
-    const comment = mark.comment || "";
+  writeCommentMark(mark2) {
+    const comment = mark2.comment || "";
     const s = `#${comment}`;
     this.write(s);
   }
-  writeLinkMark(mark) {
-    const href = mark.attrs?.href || "";
+  writeLinkMark(mark2) {
+    const href = mark2.attrs?.href || "";
     const linkText = (href ?? "").replace(LINK_BREAKSCAPE_REGEX, "^]");
     const s = `link:${linkText}`;
     this.write(s);
   }
-  writeRefMark(mark) {
-    const ref = mark.attrs?.reference ?? "";
+  writeRefMark(mark2) {
+    const ref = mark2.attrs?.reference ?? "";
     const s = `\u25BA${ref}`;
     this.write(s);
   }
-  writeXRefMark(mark) {
-    const xref = mark.attrs?.xref ?? "";
-    const ref = mark.attrs?.reference ?? "";
+  writeXRefMark(mark2) {
+    const xref = mark2.attrs?.xref ?? "";
+    const ref = mark2.attrs?.reference ?? "";
     let s = `xref:${xref}`;
     if (ref) s += `|\u25BA${ref}`;
     this.write(s);
   }
-  writeExtRefMark(mark) {
-    const extref = mark.attrs?.extref ?? "";
-    const refs = mark.attrs?.references ?? [];
-    const provider = mark.attrs?.provider ?? "";
+  writeExtRefMark(mark2) {
+    const extref = mark2.attrs?.extref ?? "";
+    const refs = mark2.attrs?.references ?? [];
+    const provider = mark2.attrs?.provider ?? "";
     let s = `extref:${extref}`;
     for (const ref of refs) {
       s += `|\u25BA${ref ?? ""}`;
@@ -19436,39 +20218,39 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     s += `|provider:${provider}`;
     this.write(s);
   }
-  writeFootnoteMark(mark) {
+  writeFootnoteMark(mark2) {
     const s = `footnote:`;
     this.write(s);
     const text = this.internalTextGenerator?.generateSync(
-      mark.attrs?.content,
+      mark2.attrs?.content,
       this.textFormat,
       this.textLocation,
       {
         ...this.generateOptions,
-        forceInline: true
+        forceInline: true,
+        chainValueContext: true
       }
     ) ?? "";
     this.write(text);
   }
-  writeFootnoteStarMark(mark) {
+  writeFootnoteStarMark(mark2) {
     const s = `footnote*:`;
     this.write(s);
     const text = this.internalTextGenerator?.generateSync(
-      mark.attrs?.content,
+      mark2.attrs?.content,
       this.textFormat,
       this.textLocation,
       {
         ...this.generateOptions,
-        forceInline: true
+        forceInline: true,
+        chainValueContext: true
       }
     ) ?? "";
     this.write(text);
   }
-  writeSymbolMark(mark) {
-    if (mark.attrs == null) return;
-    const attrs = mark.attrs;
-    const mediaAttrs = this.getMediaAttrs("symbol", attrs);
-    const s = mediaAttrs ?? "";
+  writeSymbolMark(mark2) {
+    const attrs = mark2.attrs ?? {};
+    const s = `symbol:${attrs.src ?? ""}${serializeMediaChain("symbol", attrs)}`;
     this.write(s);
   }
   writeInlineMarkStartEnd() {
@@ -19498,52 +20280,6 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
     }
     this.writeString(tag);
   }
-  getMediaAttrs(mediaType, attrs, options) {
-    if (!mediaType) return void 0;
-    const opts = Object.assign({}, options);
-    const ignoreAttributes = opts.ignoreAttributes ?? /* @__PURE__ */ new Set();
-    let s = `${mediaType}:${attrs?.src ?? ""}`;
-    const entries = Object.entries(attrs).filter(([k, _v]) => k !== "src");
-    for (let i = 0; i < entries.length; i++) {
-      const [k, v] = entries[i];
-      if (ignoreAttributes.has(k)) continue;
-      switch (k) {
-        case "textAlign":
-          if (v !== "left") s += `|captionAlign:${v}`;
-          break;
-        case "alignment":
-          if (v !== "center") {
-            if (v) s += `|alignment:${v}`;
-          }
-          break;
-        case "title":
-          if (v) s += `|caption:${v}`;
-          break;
-        case "class":
-          if (v !== "center") {
-            if (v) s += `|align:${v}`;
-          }
-          break;
-        case "comment":
-          if (v) s += `|#${v}`;
-          break;
-        case "":
-          if (stringUtils.isString(v)) s += `|:${v}`;
-          else s += `|`;
-          break;
-        case "zoomDisabled":
-          if (!v) s += "|zoomDisabled:false";
-          break;
-        case "alt":
-        case "width":
-        case "height":
-        default:
-          if (k && v) s += `|${k}:${v}`;
-          break;
-      }
-    }
-    return s;
-  }
   //
   // Helper functions
   //
@@ -19569,6 +20305,7 @@ var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
    */
   write(value) {
     value = this.getInterTextBreakscape(value) + value;
+    this.chainJustClosed = false;
     if (this.options.writeCallback) {
       this.options.writeCallback(value);
     }
@@ -33754,8 +34491,8 @@ var Builder = class extends BaseBuilder {
             break;
           }
           case BodyBitType.mark: {
-            const mark = part;
-            instance7.fillBooleanExample([mark], __isDefaultExample, example, false);
+            const mark2 = part;
+            instance7.fillBooleanExample([mark2], __isDefaultExample, example, false);
             break;
           }
           case BodyBitType.select: {
@@ -34536,10 +35273,10 @@ var BitmarkGenerator = class extends AstWalkerGenerator {
     const markConfig = node.value;
     const parent = this.getParentNode(route);
     if (parent?.key !== NodeType.markConfig) return true;
-    const { mark, color, emphasis } = markConfig;
-    if (mark) {
+    const { mark: mark2, color, emphasis } = markConfig;
+    if (mark2) {
       this.writeNL();
-      this.writeProperty("mark", mark, route, {
+      this.writeProperty("mark", mark2, route, {
         format: TagFormat.plainText
       });
       if (color) {
@@ -34756,9 +35493,9 @@ var BitmarkGenerator = class extends AstWalkerGenerator {
   }
   // bodyBit -> mark
   enter_mark(node, _route) {
-    const mark = node.value;
+    const mark2 = node.value;
     this.writeOPE();
-    this.writeTextOrValue(mark.solution, TextFormat2.plainText, TextLocation2.tag);
+    this.writeTextOrValue(mark2.solution, TextFormat2.plainText, TextLocation2.tag);
     this.writeCL();
     return true;
   }
@@ -34818,9 +35555,9 @@ var BitmarkGenerator = class extends AstWalkerGenerator {
   leaf_mark(node, route) {
     const root = route[0];
     if (root?.key !== NodeType.mark) return;
-    const mark = node.value;
-    if (mark) {
-      this.writeProperty("mark", mark, route, {
+    const mark2 = node.value;
+    if (mark2) {
+      this.writeProperty("mark", mark2, route, {
         format: TagFormat.plainText
       });
     }
@@ -35534,7 +36271,7 @@ var BitmarkGenerator = class extends AstWalkerGenerator {
   leaf_level(node, route) {
     const parent = this.getParentNode(route);
     if (parent?.key !== NodeType.bitsValue) return true;
-    if (!instance2.isOfBitType(this.bitType, [BitType2.chapter])) return true;
+    if (!instance2.isOfBitType(this.bitType, [BitType2.chapter, BitType2.h])) return true;
     const level = node.value;
     const bit = parent?.value;
     if (level > 0 && bit.title == null) {
@@ -36577,8 +37314,6 @@ var MARK_TO_TAG = {
   highlight: "mark",
   code: "code"
 };
-var INLINE_IMAGE_RE = /==([^=]*(?:=(?!=)[^=]*)*)==\|imageInline:([^|\s]+)((?:\|(?:@?[A-Za-z][A-Za-z0-9_-]*:[^|\s]+|#[^|\s]*))*)\|?/g;
-var MAX_IMAGE_DIMENSION = 9999;
 var HtmlTableGenerator = class {
   constructor() {
     __publicField(this, "indentUnit", "  ");
@@ -36720,13 +37455,13 @@ var HtmlTableGenerator = class {
     if (!marks || marks.length === 0) return text;
     let open = "";
     let close = "";
-    for (const mark of marks) {
-      if (mark.type === "link") {
-        const href = mark.attrs?.href ?? "";
+    for (const mark2 of marks) {
+      if (mark2.type === "link") {
+        const href = mark2.attrs?.href ?? "";
         open += `<a href="${this.escapeAttr(href)}">`;
         close = `</a>${close}`;
       } else {
-        const tag = MARK_TO_TAG[mark.type];
+        const tag = MARK_TO_TAG[mark2.type];
         if (tag) {
           open += `<${tag}>`;
           close = `</${tag}>${close}`;
@@ -36790,37 +37525,7 @@ var HtmlTableGenerator = class {
     return `<img ${parts.join(" ")}>`;
   }
   textToHtml(text) {
-    let html = "";
-    let lastIndex = 0;
-    for (const match of text.matchAll(INLINE_IMAGE_RE)) {
-      const index = match.index ?? 0;
-      html += this.escapeText(text.slice(lastIndex, index));
-      html += this.inlineImageTokenToHtml(match);
-      lastIndex = index + match[0].length;
-    }
-    html += this.escapeText(text.slice(lastIndex));
-    return html;
-  }
-  inlineImageTokenToHtml(match) {
-    const attrs = {
-      alt: match[1],
-      src: match[2]
-    };
-    const rawAttrs = match[3] ?? "";
-    for (const attr of rawAttrs.split("|")) {
-      if (!attr || attr.startsWith("#")) continue;
-      const colon = attr.indexOf(":");
-      if (colon < 1) continue;
-      const key = attr.slice(0, colon).replace(/^@/, "");
-      const value = attr.slice(colon + 1);
-      if (key === "width" || key === "height") {
-        const n = Number.parseInt(value, 10);
-        if (!Number.isNaN(n) && n > 0 && n <= MAX_IMAGE_DIMENSION) attrs[key] = n;
-      } else if (key === "class" || key === "title") {
-        attrs[key] = value;
-      }
-    }
-    return this.imageToHtml({ type: "imageInline", attrs });
+    return this.escapeText(text);
   }
   // --- formulas -------------------------------------------------------------
   latexToHtml(node) {
@@ -41304,13 +42009,13 @@ function markChainContentProcessor(context, contentDepth, tagsConfig, content, t
   if (contentDepth === ContentDepth.Chain) {
     markTagContentProcessor(context, ContentDepth.Chain, content, target);
   } else {
-    const mark = buildMark(
+    const mark2 = buildMark(
       context,
       contentDepth,
       tagsConfig,
       content
     );
-    if (mark) bodyParts.push(mark);
+    if (mark2) bodyParts.push(mark2);
   }
 }
 function buildMark(context, _contentDepth, tagsConfig, content) {
@@ -41325,13 +42030,13 @@ function buildMark(context, _contentDepth, tagsConfig, content) {
   if (context.DEBUG_CHAIN_TAGS) context.debugPrint("mark TAGS", chainTags);
   const { solution } = tags2;
   const { mark: markType, ...rest } = chainTags;
-  const mark = {
+  const mark2 = {
     type: BodyBitType.mark,
     solution: solution ?? "",
     mark: instance4.asSingle(markType) ?? "",
     ...rest
   };
-  return mark;
+  return mark2;
 }
 
 // src/parser/bitmark/peg/contentProcessors/PropertyContentProcessor.ts
@@ -41583,7 +42288,7 @@ function markConfigChainContentProcessor(context, _contentDepth, tagsConfig, con
     content.chain
   );
   if (context.DEBUG_CHAIN_TAGS) context.debugPrint("mark TAGS", tags2);
-  const mark = instance3.unbreakscape(
+  const mark2 = instance3.unbreakscape(
     stringUtils.trimmedString(content.value) ?? "unknown",
     {
       format: TextFormat2.bitmarkText,
@@ -41591,7 +42296,7 @@ function markConfigChainContentProcessor(context, _contentDepth, tagsConfig, con
     }
   );
   const config = {
-    mark,
+    mark: mark2,
     emphasis: "underline",
     ...tags2
   };
@@ -42059,15 +42764,23 @@ function titleTagContentProcessor(context, _contentDepth, _tagsConfig, content,
     titleString: titleText ?? ""
   };
 }
-function buildTitles(_context, bitType, title) {
+var H_TITLE_LEVEL_MAX = 7;
+function buildTitles(context, bitType, title) {
   title = title ?? [];
-  if (instance2.isOfBitType(bitType, BitType2.chapter)) {
+  if (instance2.isOfBitType(bitType, [BitType2.chapter, BitType2.h])) {
     let t;
     if (title.length > 0) t = title[title.length - 1];
+    let level = title.length > 0 ? title.length - 1 : void 0;
+    if (level != null && level > H_TITLE_LEVEL_MAX && instance2.isOfBitType(bitType, BitType2.h)) {
+      context.addWarning(
+        `Title level of ${level} too high, setting to max value of ${H_TITLE_LEVEL_MAX}`
+      );
+      level = H_TITLE_LEVEL_MAX;
+    }
     return {
       title: t?.titleAst ?? [],
       titleString: t?.titleString ?? "",
-      level: title.length > 0 ? title.length - 1 : void 0
+      level
     };
   } else {
     if (Array.isArray(title)) {