@jxsuite/parser 4.1.2 → 4.3.0

package/dist/content-loader.js

@@ -80,6 +80,9 @@ function isRef(value) {
 function isNodeObject(value) {
   return isJsonObject(value);
 }
+function isTemplateString(value) {
+  return typeof value === "string" && value.includes("${");
+}
 function isPlainTagName(tagName) {
   return typeof tagName === "string";
 }
@@ -272,6 +275,195 @@ var init_alerts = __esm(() => {
   LINE_END = /\r?\n/;
 });
 
+// ../../packages/schema/src/content-query.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function comparable(value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      return;
+    }
+    const iso = value.toISOString();
+    return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso.replace(/\.\d{3}Z$/, "Z");
+  }
+  return value;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => deepEqual(comparable(item), comparable(b[i])));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => (key in b) && deepEqual(comparable(a[key]), comparable(b[key])));
+  }
+  return false;
+}
+function sameValue(actual, expected) {
+  const a = comparable(actual);
+  if (Array.isArray(expected) || isPlainObject(expected)) {
+    return deepEqual(a, expected);
+  }
+  if (Array.isArray(a)) {
+    return a.some((item) => comparable(item) === expected);
+  }
+  return a === expected;
+}
+function readField(data, key) {
+  if (Object.hasOwn(data, key)) {
+    return data[key];
+  }
+  if (!key.includes(".")) {
+    return;
+  }
+  return readPath(data, key.split("."));
+}
+function readPath(holder, [part, ...rest]) {
+  if (part === undefined || !isPlainObject(holder) || !Object.hasOwn(holder, part)) {
+    return;
+  }
+  const value = holder[part];
+  return rest.length === 0 ? value : readPath(value, rest);
+}
+function order(actual, operand) {
+  const a = comparable(actual);
+  if (isNumber(a) && isNumber(operand)) {
+    return a - operand;
+  }
+  if (isString(a) && isString(operand)) {
+    return a < operand ? -1 : a > operand ? 1 : 0;
+  }
+  return;
+}
+function isNowOperand(operand) {
+  return isPlainObject(operand) && operand.$now === true && Object.keys(operand).length === 1;
+}
+function timeOf(value) {
+  const time = value instanceof Date ? value.getTime() : isString(value) ? Date.parse(value) : Number.NaN;
+  return Number.isNaN(time) ? undefined : time;
+}
+function operatorTest(where, op, operand, ctx) {
+  switch (op) {
+    case "$eq": {
+      return (actual) => sameValue(actual, operand);
+    }
+    case "$ne": {
+      return (actual) => !sameValue(actual, operand);
+    }
+    case "$in":
+    case "$nin": {
+      if (!Array.isArray(operand)) {
+        throw new TypeError(`${where}.${op}: expected an array, got ${JSON.stringify(operand)}`);
+      }
+      const hit = (actual) => operand.some((candidate) => sameValue(actual, candidate));
+      return op === "$in" ? hit : (actual) => !hit(actual);
+    }
+    case "$exists": {
+      if (!isBoolean(operand)) {
+        throw new TypeError(`${where}.$exists: expected true or false, got ${JSON.stringify(operand)}`);
+      }
+      return (actual) => (actual !== undefined && actual !== null) === operand;
+    }
+    default: {
+      const test = (diff) => op === "$gt" ? diff > 0 : op === "$gte" ? diff >= 0 : op === "$lt" ? diff < 0 : diff <= 0;
+      if (isNowOperand(operand)) {
+        return (actual) => {
+          if (actual === undefined || actual === null) {
+            return false;
+          }
+          const time = timeOf(actual);
+          return time === undefined ? ctx.onBadDate : test(time - ctx.now().getTime());
+        };
+      }
+      if (!isString(operand) && !isNumber(operand)) {
+        throw new TypeError(`${where}.${op}: expected a string or number, got ${JSON.stringify(operand)}`);
+      }
+      return (actual) => {
+        const diff = order(actual, operand);
+        return diff !== undefined && test(diff);
+      };
+    }
+  }
+}
+function operatorKeys(condition) {
+  const keys = Object.keys(condition);
+  const dollars = keys.filter((key) => key.startsWith("$"));
+  if (dollars.length === 0) {
+    return null;
+  }
+  return dollars.length === keys.length ? keys : [];
+}
+function compileCondition(key, condition, ctx) {
+  const where = `${ctx.name}.${key}`;
+  if (!isPlainObject(condition)) {
+    return (actual) => sameValue(actual, condition);
+  }
+  const ops = operatorKeys(condition);
+  if (ops === null) {
+    return (actual) => deepEqual(comparable(actual), condition);
+  }
+  if (ops.length === 0) {
+    throw new TypeError(`${where}: cannot mix $operators with plain keys in one condition`);
+  }
+  const tests = ops.map((op) => {
+    if (!OPERATORS.has(op)) {
+      throw new TypeError(`${where}: unknown operator "${op}" (use ${[...OPERATORS].join(", ")})`);
+    }
+    return operatorTest(where, op, condition[op], ctx);
+  });
+  return (actual) => tests.every((test) => test(actual));
+}
+function compileFields(query, ctx) {
+  return Object.entries(query).map(([key, condition]) => {
+    if (key.startsWith("$")) {
+      throw new TypeError(`${ctx.name}.${key}: top-level operators are not supported, conditions on different fields already combine with AND`);
+    }
+    return { key, test: compileCondition(key, condition, ctx) };
+  });
+}
+function compileWhere(where, options = {}) {
+  if (where === undefined) {
+    return Object.assign(() => true, { why: nothing });
+  }
+  if (!isPlainObject(where)) {
+    throw new TypeError(`"where" must be an object mapping frontmatter fields to conditions`);
+  }
+  const ctx = { name: "where", now: options.now ?? realClock, onBadDate: false };
+  const tests = compileFields(where, ctx);
+  return Object.assign((data) => tests.every(({ key, test }) => test(readField(data, key))), {
+    why: (data) => tests.find(({ key, test }) => !test(readField(data, key)))?.key
+  });
+}
+function compileHold(hold, options = {}) {
+  if (hold === undefined) {
+    return nothing;
+  }
+  if (!Array.isArray(hold)) {
+    throw new TypeError(`"hold" must be an array of { "label", "when" } rules`);
+  }
+  const now = options.now ?? realClock;
+  const rules = hold.map((rule, index) => {
+    const at = `hold[${index}]`;
+    if (!isPlainObject(rule) || !isString(rule.label) || rule.label.trim() === "") {
+      throw new TypeError(`${at}: expected a non-empty "label"`);
+    }
+    if (!isPlainObject(rule.when) || Object.keys(rule.when).length === 0) {
+      throw new TypeError(`${at}: expected "when" to name at least one frontmatter field`);
+    }
+    const ctx = { name: `${at}.when`, now, onBadDate: true };
+    return { label: rule.label, tests: compileFields(rule.when, ctx) };
+  });
+  return (data) => rules.find(({ tests }) => tests.every(({ key, test }) => test(readField(data, key))))?.label;
+}
+var OPERATORS, nothing = () => {}, realClock = () => new Date;
+var init_content_query = __esm(() => {
+  init_guards();
+  OPERATORS = new Set(["$eq", "$ne", "$in", "$nin", "$exists", "$gt", "$gte", "$lt", "$lte"]);
+});
+
 // src/content-rules.ts
 function escapeRegExp(text) {
   return text.replaceAll(REGEXP_SPECIAL, String.raw`\$&`);
@@ -397,7 +589,7 @@ function mayNameDirectory(pattern) {
 }
 function compileExclude(patterns) {
   if (patterns === undefined) {
-    return { empty: true, excludedBy: nothing, excludesDir: () => false };
+    return { empty: true, excludedBy: nothing2, excludesDir: () => false };
   }
   if (!Array.isArray(patterns)) {
     throw new TypeError(`"exclude" must be an array of glob patterns`);
@@ -437,152 +629,11 @@ function compileExclude(patterns) {
     excludedBy: (path) => files.find((f) => f.re.test(path))?.pattern
   };
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
-}
-function comparable(value) {
-  if (value instanceof Date) {
-    if (Number.isNaN(value.getTime())) {
-      return;
-    }
-    const iso = value.toISOString();
-    return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso.replace(/\.\d{3}Z$/, "Z");
-  }
-  return value;
-}
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((item, i) => deepEqual(comparable(item), comparable(b[i])));
-  }
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const keys = Object.keys(a);
-    return keys.length === Object.keys(b).length && keys.every((key) => (key in b) && deepEqual(comparable(a[key]), comparable(b[key])));
-  }
-  return false;
-}
-function sameValue(actual, expected) {
-  const a = comparable(actual);
-  if (Array.isArray(expected) || isPlainObject(expected)) {
-    return deepEqual(a, expected);
-  }
-  if (Array.isArray(a)) {
-    return a.some((item) => comparable(item) === expected);
-  }
-  return a === expected;
-}
-function readField(data, key) {
-  if (Object.hasOwn(data, key)) {
-    return data[key];
-  }
-  if (!key.includes(".")) {
-    return;
-  }
-  return readPath(data, key.split("."));
-}
-function readPath(holder, [part, ...rest]) {
-  if (part === undefined || !isPlainObject(holder) || !Object.hasOwn(holder, part)) {
-    return;
-  }
-  const value = holder[part];
-  return rest.length === 0 ? value : readPath(value, rest);
-}
-function order(actual, operand) {
-  const a = comparable(actual);
-  if (isNumber(a) && isNumber(operand)) {
-    return a - operand;
-  }
-  if (isString(a) && isString(operand)) {
-    return a < operand ? -1 : a > operand ? 1 : 0;
-  }
-  return;
-}
-function operatorTest(where, op, operand) {
-  switch (op) {
-    case "$eq": {
-      return (actual) => sameValue(actual, operand);
-    }
-    case "$ne": {
-      return (actual) => !sameValue(actual, operand);
-    }
-    case "$in":
-    case "$nin": {
-      if (!Array.isArray(operand)) {
-        throw new TypeError(`${where}.${op}: expected an array, got ${JSON.stringify(operand)}`);
-      }
-      const hit = (actual) => operand.some((candidate) => sameValue(actual, candidate));
-      return op === "$in" ? hit : (actual) => !hit(actual);
-    }
-    case "$exists": {
-      if (!isBoolean(operand)) {
-        throw new TypeError(`${where}.$exists: expected true or false, got ${JSON.stringify(operand)}`);
-      }
-      return (actual) => (actual !== undefined && actual !== null) === operand;
-    }
-    default: {
-      if (!isString(operand) && !isNumber(operand)) {
-        throw new TypeError(`${where}.${op}: expected a string or number, got ${JSON.stringify(operand)}`);
-      }
-      const test = (diff) => op === "$gt" ? diff > 0 : op === "$gte" ? diff >= 0 : op === "$lt" ? diff < 0 : diff <= 0;
-      return (actual) => {
-        const diff = order(actual, operand);
-        return diff !== undefined && test(diff);
-      };
-    }
-  }
-}
-function operatorKeys(condition) {
-  const keys = Object.keys(condition);
-  const dollars = keys.filter((key) => key.startsWith("$"));
-  if (dollars.length === 0) {
-    return null;
-  }
-  return dollars.length === keys.length ? keys : [];
-}
-function compileCondition(key, condition) {
-  const where = `where.${key}`;
-  if (!isPlainObject(condition)) {
-    return (actual) => sameValue(actual, condition);
-  }
-  const ops = operatorKeys(condition);
-  if (ops === null) {
-    return (actual) => deepEqual(comparable(actual), condition);
-  }
-  if (ops.length === 0) {
-    throw new TypeError(`${where}: cannot mix $operators with plain keys in one condition`);
-  }
-  const tests = ops.map((op) => {
-    if (!OPERATORS.has(op)) {
-      throw new TypeError(`${where}: unknown operator "${op}" (use ${[...OPERATORS].join(", ")})`);
-    }
-    return operatorTest(where, op, condition[op]);
-  });
-  return (actual) => tests.every((test) => test(actual));
-}
-function compileWhere(where) {
-  if (where === undefined) {
-    return Object.assign(() => true, { why: nothing });
-  }
-  if (!isPlainObject(where)) {
-    throw new TypeError(`"where" must be an object mapping frontmatter fields to conditions`);
-  }
-  const tests = Object.entries(where).map(([key, condition]) => {
-    if (key.startsWith("$")) {
-      throw new TypeError(`where.${key}: top-level operators are not supported, conditions on different fields already combine with AND`);
-    }
-    return { key, test: compileCondition(key, condition) };
-  });
-  return Object.assign((data) => tests.every(({ key, test }) => test(readField(data, key))), {
-    why: (data) => tests.find(({ key, test }) => !test(readField(data, key)))?.key
-  });
-}
-var nothing = () => {}, REGEXP_SPECIAL, MAX_STAR_RUNS = 4, OPERATORS;
+var nothing2 = () => {}, REGEXP_SPECIAL, MAX_STAR_RUNS = 4;
 var init_content_rules = __esm(() => {
   init_guards();
+  init_content_query();
   REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/g;
-  OPERATORS = new Set(["$eq", "$ne", "$in", "$nin", "$exists", "$gt", "$gte", "$lt", "$lte"]);
 });
 
 // ../../node_modules/bail/index.js
@@ -17660,16 +17711,43 @@ function color(d) {
 }
 
 // ../../node_modules/mdast-util-find-and-replace/node_modules/unist-util-visit-parents/lib/index.js
-function visitParents(tree, test, visitor, reverse) {
+function visitParents(tree, testOrEnterOrVisitors, enterOrVisitorsOrReverse, reverse) {
+  if (!tree || typeof tree !== "object") {
+    throw new Error("Unexpected value `" + tree + "` for `tree`, expected node");
+  }
+  let preorder = true;
   let check;
-  if (typeof test === "function" && typeof visitor !== "function") {
-    reverse = visitor;
-    visitor = test;
+  let visitors;
+  let enter;
+  let exit;
+  if (typeof enterOrVisitorsOrReverse === "function" || enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === "object") {
+    check = testOrEnterOrVisitors;
+    visitors = enterOrVisitorsOrReverse;
+    if (reverse)
+      preorder = false;
   } else {
-    check = test;
+    visitors = testOrEnterOrVisitors;
+    if (enterOrVisitorsOrReverse)
+      preorder = false;
+  }
+  if (typeof visitors === "function") {
+    enter = visitors;
+  } else if (visitors && typeof visitors === "object") {
+    if (visitors.enter === null || visitors.enter === undefined) {} else if (typeof visitors.enter === "function") {
+      enter = visitors.enter;
+    } else {
+      throw new Error("Unexpected value `" + visitors.enter + "` for `visitors.enter`, expected optional visitor");
+    }
+    if (typeof visitors.exit === "function") {
+      exit = visitors.exit;
+    } else {
+      throw new Error("Unexpected value `" + visitors.exit + "` for `visitors.exit`, expected visitor (pass a visitor directly if you only want an enter visitor)");
+    }
+  } else {
+    throw new Error("Unexpected value `" + visitors + "` for `enter` or `visitors`, expected visitor or object with visitors");
   }
   const is = convert(check);
-  const step = reverse ? -1 : 1;
+  const step = preorder ? 1 : -1;
   factory(tree, undefined, [])();
   function factory(node, index, parents) {
     const value = node && typeof node === "object" ? node : {};
@@ -17681,12 +17759,10 @@ function visitParents(tree, test, visitor, reverse) {
     }
     return visit;
     function visit() {
+      const matches = !check || is(node, index, parents[parents.length - 1] || undefined);
       let result = empty;
-      let subresult;
-      let offset;
-      let grandparents;
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        result = toResult(visitor(node, parents));
+      if (enter && matches) {
+        result = toResult(enter(node, parents, index));
         if (result[0] === EXIT) {
           return result;
         }
@@ -17694,11 +17770,11 @@ function visitParents(tree, test, visitor, reverse) {
       if ("children" in node && node.children) {
         const nodeAsParent = node;
         if (nodeAsParent.children && result[0] !== SKIP) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step;
-          grandparents = parents.concat(nodeAsParent);
+          let offset = (preorder ? -1 : nodeAsParent.children.length) + step;
+          const grandparents = [...parents, nodeAsParent];
           while (offset > -1 && offset < nodeAsParent.children.length) {
             const child = nodeAsParent.children[offset];
-            subresult = factory(child, offset, grandparents)();
+            const subresult = factory(child, offset, grandparents)();
             if (subresult[0] === EXIT) {
               return subresult;
             }
@@ -17706,6 +17782,15 @@ function visitParents(tree, test, visitor, reverse) {
           }
         }
       }
+      if (exit && matches) {
+        const exitResult = toResult(exit(node, parents, index));
+        if (exitResult[0] === SKIP) {
+          throw new Error("Unexpected value `" + exitResult[0] + "` from `exit`, expected `CONTINUE`, `EXIT`, index, or nothing");
+        }
+        if (exitResult[0] === EXIT || typeof exitResult[1] === "number") {
+          return exitResult;
+        }
+      }
       return result;
     }
   }
@@ -17737,30 +17822,20 @@ function findAndReplace(tree, list, options) {
   const pairs = toPairs(list);
   let pairIndex = -1;
   while (++pairIndex < pairs.length) {
-    visitParents(tree, "text", visitor);
+    visitParents(tree, visitor);
   }
-  function visitor(node, parents) {
-    let index = -1;
-    let grandparent;
-    while (++index < parents.length) {
-      const parent = parents[index];
-      const siblings = grandparent ? grandparent.children : undefined;
-      if (ignored(parent, siblings ? siblings.indexOf(parent) : undefined, grandparent)) {
-        return;
-      }
-      grandparent = parent;
-    }
-    if (grandparent) {
-      return handler(node, parents);
+  function visitor(node, parents, index) {
+    if (node.type === "text" && typeof index === "number") {
+      return handler(node, parents, index);
     }
+    if (ignored(node, index, parents[parents.length - 1]))
+      return SKIP;
   }
-  function handler(node, parents) {
+  function handler(node, parents, index) {
     const parent = parents[parents.length - 1];
     const find = pairs[pairIndex][0];
     const replace = pairs[pairIndex][1];
     let start = 0;
-    const siblings = parent.children;
-    const index = siblings.indexOf(node);
     let change = false;
     let nodes = [];
     find.lastIndex = 0;
@@ -18609,10 +18684,402 @@ function checkEmphasis(state) {
   return marker;
 }
 
+// ../../node_modules/mdast-util-to-markdown/lib/util/character.js
+function firstCharacter(value) {
+  const code = value.codePointAt(0);
+  return code === undefined ? "" : String.fromCodePoint(code);
+}
+function lastCharacter(value) {
+  const code = value.codePointAt(value.length - 2);
+  return code !== undefined && code > 65535 ? value.slice(-2) : value.slice(-1);
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js
+function encodeCharacterReference(code) {
+  return "&#x" + code.toString(16).toUpperCase() + ";";
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/encode-info.js
+function encodeInfo(outside, inside, marker) {
+  const outsideKind = classifyCharacter(outside);
+  const insideKind = classifyCharacter(inside);
+  if (outsideKind === undefined) {
+    return insideKind === undefined ? marker === "_" ? { inside: true, outside: true } : { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: true };
+  }
+  if (outsideKind === 1) {
+    return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: false };
+  }
+  return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: false } : { inside: false, outside: false };
+}
+var init_encode_info = __esm(() => {
+  init_dev6();
+});
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/html-kind.js
+function htmlKind(value) {
+  if (value.charCodeAt(0) !== 60)
+    return;
+  const next = value.charCodeAt(1);
+  if (next === 33) {
+    const code = value.charCodeAt(2);
+    if (code === 45)
+      return 2;
+    if (code === 91)
+      return 5;
+    if (asciiAlpha(code))
+      return 4;
+    return;
+  }
+  if (next === 63)
+    return 3;
+  const closing = next === 47;
+  const start = closing ? 2 : 1;
+  let end = start;
+  let code = value.charCodeAt(end);
+  if (!asciiAlpha(code))
+    return;
+  while (code === 45 || asciiAlphanumeric(code)) {
+    code = value.charCodeAt(++end);
+  }
+  const name = value.slice(start, end).toLowerCase();
+  if (!closing && code !== 47 && htmlRawNames.includes(name)) {
+    return 1;
+  }
+  return htmlBlockNames.includes(name) ? 6 : 7;
+}
+var init_html_kind = __esm(() => {
+  init_dev4();
+  init_micromark_util_html_tag_name();
+});
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
+function candidates(tokens, involved, runOf) {
+  const related = new Set;
+  for (const token of tokens) {
+    const siblings = runOf.get(token);
+    if (siblings && token.attention && involved.some((d) => d.attention === token.attention)) {
+      for (const sibling of siblings.tokens) {
+        related.add(sibling.attention);
+      }
+    }
+  }
+  const ordered = [];
+  for (const token of tokens) {
+    if (token.attention && related.delete(token.attention)) {
+      ordered.push(token.attention);
+    }
+  }
+  ordered.reverse();
+  return ordered;
+}
+function check(tokens, before, after) {
+  const runs = [];
+  const wrong = new Map;
+  const runOf = new Map;
+  let index = 0;
+  while (index < tokens.length) {
+    if (!tokens[index].attention) {
+      index++;
+      continue;
+    }
+    const marker = tokens[index].value.charAt(0);
+    const strict = builtins.get(marker);
+    let end = index + 1;
+    while (end < tokens.length && tokens[end].attention && tokens[end].value.charAt(0) === marker) {
+      end++;
+    }
+    const head = index ? tokens[index - 1].value : before;
+    const previous = classifyCharacter(head.charCodeAt(head.length - 1));
+    const next = classifyCharacter((end < tokens.length ? tokens[end].value : after).charCodeAt(0));
+    const open = !next || next === 2 && Boolean(previous);
+    const close = !previous || previous === 2 && Boolean(next);
+    const run = {
+      tokens: tokens.slice(index, end),
+      markers: [],
+      start: 0,
+      end: 0,
+      open: strict ? open && (Boolean(previous) || !close) : open,
+      close: strict ? close && (Boolean(next) || !open) : close,
+      split: strict !== undefined
+    };
+    for (const token of run.tokens) {
+      wrong.set(token, [...run.tokens]);
+      runOf.set(token, run);
+      let size = token.value.length;
+      while (size--)
+        run.markers.push(token);
+    }
+    run.end = run.markers.length;
+    runs.push(run);
+    index = end;
+  }
+  pair(runs, wrong);
+  index = -1;
+  while (++index < tokens.length) {
+    const involved = wrong.get(tokens[index]);
+    if (involved)
+      return { attention: candidates(tokens, involved, runOf), index };
+  }
+}
+function containerPhrasing(parent, state, info) {
+  return serialize2(phrasing2(parent, state, info), info.before, info.after);
+}
+function encode(tokens, start) {
+  const token = tokens[start ? 0 : tokens.length - 1];
+  if (!token || token.attention)
+    return;
+  const character = start ? firstCharacter(token.value) : lastCharacter(token.value);
+  const reference = encodeCharacterReference(character.codePointAt(0));
+  if (start) {
+    token.value = reference + token.value.slice(character.length);
+  } else {
+    let value = token.value.slice(0, token.value.length - character.length);
+    let escapes = 0;
+    while (value.charCodeAt(value.length - 1 - escapes) === 92) {
+      escapes++;
+    }
+    if (escapes % 2)
+      value += "\\";
+    token.value = value + reference;
+  }
+}
+function improve(items, chosen, mistake, before, after) {
+  for (const attention of mistake.attention) {
+    const current = chosen.get(attention) || attention.sequences[0];
+    for (const sequence of attention.sequences) {
+      if (sequence === current)
+        continue;
+      const trial = new Map(chosen);
+      trial.set(attention, sequence);
+      const tokens = render(items, trial, before, after);
+      const next = check(tokens, before, after);
+      if (!next || next.index > mistake.index) {
+        return { chosen: trial, mistake: next, tokens };
+      }
+    }
+  }
+}
+function pair(runs, wrong) {
+  const openersByMarker = new Map;
+  for (const closer of runs) {
+    const marker = closer.tokens[0].value.charAt(0);
+    let openers = openersByMarker.get(marker);
+    if (!openers) {
+      openers = [];
+      openersByMarker.set(marker, openers);
+    }
+    let open = closer.close ? openers.length : 0;
+    while (open-- && closer.start < closer.end) {
+      const opener = openers[open];
+      const openerSize = opener.end - opener.start;
+      const closerSize = closer.end - closer.start;
+      if (closer.split ? (opener.close || closer.open) && closerSize % 3 && !((openerSize + closerSize) % 3) : openerSize !== opener.markers.length || openerSize !== closerSize) {
+        continue;
+      }
+      const size = closer.split ? openerSize > 1 && closerSize > 1 ? 2 : 1 : closerSize;
+      const opening = opener.markers.slice(opener.end - size, opener.end);
+      const closing = closer.markers.slice(closer.start, closer.start + size);
+      const openToken = opening[0];
+      const closeToken = closing[0];
+      if (openToken === opening[size - 1] && openToken.value.length === size && closeToken === closing[size - 1] && closeToken.value.length === size && openToken.attention === closeToken.attention) {
+        wrong.delete(openToken);
+        wrong.delete(closeToken);
+      } else {
+        const involved = [...new Set([...opening, ...closing])];
+        for (const token of involved) {
+          const list = wrong.get(token);
+          if (list)
+            list.push(...involved);
+        }
+      }
+      opener.end -= size;
+      closer.start += size;
+      if (opener.start === opener.end)
+        openers.splice(open, 1);
+      open = openers.length;
+    }
+    if (closer.open && closer.start < closer.end)
+      openers.push(closer);
+  }
+}
+function attentionSequences(type, markers, sizes) {
+  if (markers.length === 0) {
+    throw new Error("Cannot serialize `" + type + "` as attention without markers, expected one or more markers");
+  }
+  if (sizes.length === 0) {
+    throw new Error("Cannot serialize `" + type + "` as attention without sizes, expected one or more sizes");
+  }
+  for (const size of sizes) {
+    if (!Number.isSafeInteger(size) || size < 1) {
+      throw new Error("Cannot serialize `" + type + "` as attention with `" + size + "` as size, expected positive integer");
+    }
+  }
+  const sequences = [];
+  for (const marker of markers) {
+    if (marker.length !== 1) {
+      throw new Error("Cannot serialize `" + type + "` as attention with `" + marker + "` as marker, expected a single ascii character");
+    }
+    if (!asciiPunctuation(marker.charCodeAt(0))) {
+      throw new Error("Cannot serialize `" + type + "` as attention with `" + marker + "` as marker, expected ascii punctuation");
+    }
+    for (const size of sizes) {
+      sequences.push(marker.repeat(size));
+    }
+  }
+  return sequences;
+}
+function phrasing2(parent, state, info) {
+  const indexStack = state.indexStack;
+  const children = parent.children || [];
+  const results = [];
+  let index = -1;
+  let before = info.before;
+  indexStack.push(-1);
+  let tracker = state.createTracker(info);
+  while (++index < children.length) {
+    const child = children[index];
+    let after;
+    indexStack[indexStack.length - 1] = index;
+    if (index + 1 < children.length) {
+      let handle = state.handle.handlers[children[index + 1].type];
+      if (handle && handle.peek)
+        handle = handle.peek;
+      after = handle ? firstCharacter(handle(children[index + 1], parent, state, {
+        before: "",
+        after: "",
+        ...tracker.current()
+      })) : "";
+    } else {
+      after = info.after;
+    }
+    const previous = results[results.length - 1];
+    if (typeof previous === "string" && (before === "\r" || before === `
+`) && child.type === "html" && htmlKind(child.value) !== 7) {
+      results[results.length - 1] = previous.replace(/(\r?\n|\r)$/, " ");
+      before = " ";
+      tracker = state.createTracker(info);
+      tracker.move(serialize2(results, info.before, info.after));
+    }
+    const handle = state.handle.handlers[child.type];
+    if (handle && handle.attention) {
+      const item = attentionItem(child, handle.attention, state, tracker);
+      results.push(item);
+      before = lastCharacter(item.sequences[0]);
+    } else {
+      const value = state.handle(child, parent, state, {
+        ...tracker.current(),
+        after,
+        before
+      });
+      if (!value)
+        continue;
+      tracker.move(value);
+      results.push(value);
+      before = lastCharacter(value);
+    }
+  }
+  indexStack.pop();
+  return results;
+}
+function attentionItem(node, attention, state, tracker) {
+  const { construct, markers, sizes } = attention(node, state);
+  const sequences = attentionSequences(node.type, markers, sizes);
+  const sequence = sequences[0];
+  const exit = state.enter(construct);
+  tracker.move(sequence);
+  const children = phrasing2(node, state, {
+    ...tracker.current(),
+    before: sequence,
+    after: sequence
+  });
+  tracker.move(serialize2(children, sequence, sequence));
+  tracker.move(sequence);
+  exit();
+  return { children, sequences };
+}
+function render(items, chosen, before, after) {
+  const tokens = [];
+  let encodeAfter;
+  let previous = lastCharacter(before);
+  let index = -1;
+  while (++index < items.length) {
+    const item = items[index];
+    if (typeof item === "string") {
+      const token = { value: item, attention: undefined };
+      if (encodeAfter && encodeAfter === firstCharacter(item)) {
+        encode([token], true);
+      }
+      encodeAfter = undefined;
+      tokens.push(token);
+      if (token.value)
+        previous = lastCharacter(token.value);
+      continue;
+    }
+    const sequence = chosen.get(item) || item.sequences[0];
+    const marker = sequence.charAt(0);
+    const next = items[index + 1];
+    const outsideBefore = previous;
+    const outsideAfter = firstCharacter(next === undefined ? after : typeof next === "string" ? next : chosen.get(next) || next.sequences[0]);
+    const inside = render(item.children, chosen, sequence, sequence);
+    const head = inside.length > 0 ? inside[0].value : "";
+    const open = encodeInfo(outsideBefore.charCodeAt(outsideBefore.length - 1), head.charCodeAt(0), marker);
+    if (open.inside)
+      encode(inside, true);
+    const tail = inside.length > 0 ? lastCharacter(inside[inside.length - 1].value) : "";
+    const close = encodeInfo(outsideAfter.charCodeAt(0), tail.charCodeAt(tail.length - 1), marker);
+    if (close.inside)
+      encode(inside, false);
+    if (open.outside && outsideBefore !== `
+` && outsideBefore !== "\r") {
+      encode(tokens, false);
+    }
+    if (close.outside)
+      encodeAfter = outsideAfter;
+    tokens.push({ value: sequence, attention: item }, ...inside, {
+      value: sequence,
+      attention: item
+    });
+    previous = sequence.charAt(sequence.length - 1);
+  }
+  return tokens;
+}
+function serialize2(items, before, after) {
+  let chosen = new Map;
+  const initial = render(items, chosen, before, after);
+  let tokens = initial;
+  let mistake = check(tokens, before, after);
+  while (mistake) {
+    const next = improve(items, chosen, mistake, before, after);
+    if (!next) {
+      tokens = initial;
+      break;
+    }
+    chosen = next.chosen;
+    tokens = next.tokens;
+    mistake = next.mistake;
+  }
+  let result = "";
+  for (const token of tokens)
+    result += token.value;
+  return result;
+}
+var builtins;
+var init_container_phrasing = __esm(() => {
+  init_dev4();
+  init_dev6();
+  init_encode_info();
+  init_html_kind();
+  builtins = new Map([
+    ["*", false],
+    ["_", true]
+  ]);
+});
+
 // ../../node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
 function emphasis(node, _, state, info) {
   const exit = state.enter("phrasing");
-  const value = state.containerPhrasing({ type: "root", children: [node] }, info);
+  const item = attentionItem(node, attention2, state, state.createTracker(info));
+  const value = serialize2([item], info.before, info.after);
   exit();
   return value;
 }
@@ -18628,15 +19095,11 @@ function peek(_, _1, state) {
   return state.options.emphasis || "*";
 }
 var init_emphasis = __esm(() => {
+  init_container_phrasing();
   emphasis.attention = attention2;
   emphasis.peek = peek;
 });
 
-// ../../node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js
-function encodeCharacterReference(code) {
-  return "&#x" + code.toString(16).toUpperCase() + ";";
-}
-
 // ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.js
 function color2(d) {
   return "\x1B[33m" + d + "\x1B[39m";
@@ -19021,14 +19484,27 @@ function link(node, _, state, info) {
   const exit = state.enter("link");
   let subexit = state.enter("label");
   let value = tracker.move("[");
-  value += tracker.move(state.containerPhrasing(node, {
+  const text = state.containerPhrasing(node, {
     before: value,
     after: "](",
     ...tracker.current()
-  }));
-  value += tracker.move("](");
+  });
+  value += tracker.move(text);
   subexit();
-  if (!node.url && node.title || /[\0- \u007F]/.test(node.url)) {
+  value += tracker.move("](");
+  const enclose = /[\0- \u007F]/.test(node.url);
+  const last = info.before.charAt(info.before.length - 1);
+  let title = node.title || undefined;
+  if (!title && !enclose && (last === `
+` || last === "\r")) {
+    let index = 0;
+    while (index < text.length && text.charCodeAt(index) !== 93) {
+      index += text.charCodeAt(index) === 92 ? 2 : 1;
+    }
+    if (text.charCodeAt(index + 1) === 58)
+      title = "";
+  }
+  if (!node.url && typeof title === "string" || enclose) {
     subexit = state.enter("destinationLiteral");
     value += tracker.move("<");
     value += tracker.move(state.safe(node.url, { before: value, after: ">", ...tracker.current() }));
@@ -19037,15 +19513,15 @@ function link(node, _, state, info) {
     subexit = state.enter("destinationRaw");
     value += tracker.move(state.safe(node.url, {
       before: value,
-      after: node.title ? " " : ")",
+      after: typeof title === "string" ? " " : ")",
       ...tracker.current()
     }));
   }
   subexit();
-  if (node.title) {
+  if (typeof title === "string") {
     subexit = state.enter(`title${suffix}`);
     value += tracker.move(" " + quote);
-    value += tracker.move(state.safe(node.title, {
+    value += tracker.move(state.safe(title, {
       before: value,
       after: quote,
       ...tracker.current()
@@ -19263,7 +19739,8 @@ function checkStrong(state) {
 // ../../node_modules/mdast-util-to-markdown/lib/handle/strong.js
 function strong(node, _, state, info) {
   const exit = state.enter("phrasing");
-  const value = state.containerPhrasing({ type: "root", children: [node] }, info);
+  const item = attentionItem(node, attention3, state, state.createTracker(info));
+  const value = serialize2([item], info.before, info.after);
   exit();
   return value;
 }
@@ -19279,6 +19756,7 @@ function peek2(_, _1, state) {
   return state.options.strong || "*";
 }
 var init_strong = __esm(() => {
+  init_container_phrasing();
   strong.attention = attention3;
   strong.peek = peek2;
 });
@@ -19286,7 +19764,7 @@ var init_strong = __esm(() => {
 // ../../node_modules/mdast-util-to-markdown/lib/handle/text.js
 function text3(node, parent, state, info) {
   const siblings = parent ? parent.children : [];
-  const index = siblings.indexOf(node);
+  const index = state.indexStack[state.indexStack.length - 1];
   return state.safe(node.value, {
     ...info,
     afterNode: siblings[index + 1],
@@ -19353,63 +19831,44 @@ var init_handle = __esm(() => {
   };
 });
 
-// ../../node_modules/mdast-util-to-markdown/lib/util/html-kind.js
-function htmlKind(value) {
-  if (value.charCodeAt(0) !== 60)
-    return;
-  const next = value.charCodeAt(1);
-  if (next === 33) {
-    const code = value.charCodeAt(2);
-    if (code === 45)
-      return 2;
-    if (code === 91)
-      return 5;
-    if (asciiAlpha(code))
-      return 4;
-    return;
-  }
-  if (next === 63)
-    return 3;
-  const closing = next === 47;
-  const start = closing ? 2 : 1;
-  let end = start;
-  let code = value.charCodeAt(end);
-  if (!asciiAlpha(code))
-    return;
-  while (code === 45 || asciiAlphanumeric(code)) {
-    code = value.charCodeAt(++end);
-  }
-  const name = value.slice(start, end).toLowerCase();
-  if (!closing && code !== 47 && htmlRawNames.includes(name)) {
-    return 1;
-  }
-  return htmlBlockNames.includes(name) ? 6 : 7;
-}
-var init_html_kind = __esm(() => {
-  init_dev4();
-  init_micromark_util_html_tag_name();
-});
-
 // ../../node_modules/mdast-util-to-markdown/lib/join.js
 function joinDefaults(left, right, parent, state) {
   if (right.type === "code" && formatCodeAsIndented(right, state) && (left.type === "list" || left.type === right.type && formatCodeAsIndented(left, state))) {
     return false;
   }
   if ("spread" in parent && typeof parent.spread === "boolean") {
-    if (left.type === "paragraph" && (left.type === right.type || right.type === "definition" || right.type === "heading" && formatHeadingAsSetext(right, state))) {
-      return;
-    }
+    if (parent.spread)
+      return 1;
     if (left.type === "html") {
       const kind = htmlKind(left.value);
       if (kind === undefined || kind === 6 || kind === 7)
         return 1;
     }
-    if (left.type === "paragraph" && right.type === "html") {
+    if (left.type === "blockquote" && right.type === "blockquote")
+      return 1;
+    if ((left.type === "definition" || left.type === "paragraph") && right.type === "list" && (right.ordered && typeof right.start === "number" && right.start !== 1 || right.children.length > 0 && right.children[0].children.length === 0)) {
+      return 1;
+    }
+    if (left.type === "paragraph" && right.type === "thematicBreak" && checkRule(state) === "-" && !state.options.ruleSpaces) {
+      return 1;
+    }
+    let tail = left;
+    while ((tail.type === "blockquote" || tail.type === "list" || tail.type === "listItem") && tail.children.length > 0) {
+      tail = tail.children[tail.children.length - 1];
+    }
+    if (tail.type !== "definition" && tail.type !== "paragraph")
+      return 0;
+    if (right.type === "code" && formatCodeAsIndented(right, state))
+      return 1;
+    if (right.type === "html") {
       const kind = htmlKind(right.value);
       if (kind === undefined || kind === 7)
         return 1;
     }
-    return parent.spread ? 1 : 0;
+    if ((left.type === "paragraph" || left !== tail) && (right.type === "definition" || right.type === "heading" && formatHeadingAsSetext(right, state) || right.type === "paragraph")) {
+      return 1;
+    }
+    return 0;
   }
 }
 var join;
@@ -19482,7 +19941,21 @@ var init_unsafe = __esm(() => {
     { atBreak: true, character: "#" },
     { character: "#", inConstruct: "headingAtx", after: `(?:[\r
 ]|$)` },
-    { character: "&", after: "[#A-Za-z]", inConstruct: "phrasing" },
+    {
+      character: "&",
+      after: "[#A-Za-z]",
+      inConstruct: [
+        "codeFencedLangGraveAccent",
+        "codeFencedLangTilde",
+        "codeFencedMetaGraveAccent",
+        "codeFencedMetaTilde",
+        "destinationLiteral",
+        "destinationRaw",
+        "phrasing",
+        "titleApostrophe",
+        "titleQuote"
+      ]
+    },
     { character: "'", inConstruct: "titleApostrophe" },
     { character: "(", inConstruct: "destinationRaw" },
     {
@@ -19556,333 +20029,6 @@ function compilePattern(pattern) {
   return pattern._compiled;
 }
 
-// ../../node_modules/mdast-util-to-markdown/lib/util/character.js
-function firstCharacter(value) {
-  const code = value.codePointAt(0);
-  return code === undefined ? "" : String.fromCodePoint(code);
-}
-function lastCharacter(value) {
-  const code = value.codePointAt(value.length - 2);
-  return code !== undefined && code > 65535 ? value.slice(-2) : value.slice(-1);
-}
-
-// ../../node_modules/mdast-util-to-markdown/lib/util/encode-info.js
-function encodeInfo(outside, inside, marker) {
-  const outsideKind = classifyCharacter(outside);
-  const insideKind = classifyCharacter(inside);
-  if (outsideKind === undefined) {
-    return insideKind === undefined ? marker === "_" ? { inside: true, outside: true } : { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: true };
-  }
-  if (outsideKind === 1) {
-    return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: false };
-  }
-  return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: false } : { inside: false, outside: false };
-}
-var init_encode_info = __esm(() => {
-  init_dev6();
-});
-
-// ../../node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
-function candidates(tokens, involved, runOf) {
-  const related = new Set;
-  for (const token of tokens) {
-    const siblings = runOf.get(token);
-    if (siblings && token.attention && involved.some((d) => d.attention === token.attention)) {
-      for (const sibling of siblings.tokens) {
-        related.add(sibling.attention);
-      }
-    }
-  }
-  const ordered = [];
-  for (const token of tokens) {
-    if (token.attention && related.delete(token.attention)) {
-      ordered.push(token.attention);
-    }
-  }
-  ordered.reverse();
-  return ordered;
-}
-function check(tokens, before, after) {
-  const runs = [];
-  const wrong = new Map;
-  const runOf = new Map;
-  let index = 0;
-  while (index < tokens.length) {
-    if (!tokens[index].attention) {
-      index++;
-      continue;
-    }
-    const marker = tokens[index].value.charAt(0);
-    const strict = builtins.get(marker);
-    let end = index + 1;
-    while (end < tokens.length && tokens[end].attention && tokens[end].value.charAt(0) === marker) {
-      end++;
-    }
-    const head = index ? tokens[index - 1].value : before;
-    const previous = classifyCharacter(head.charCodeAt(head.length - 1));
-    const next = classifyCharacter((end < tokens.length ? tokens[end].value : after).charCodeAt(0));
-    const open = !next || next === 2 && Boolean(previous);
-    const close = !previous || previous === 2 && Boolean(next);
-    const run = {
-      tokens: tokens.slice(index, end),
-      markers: [],
-      start: 0,
-      end: 0,
-      open: strict ? open && (Boolean(previous) || !close) : open,
-      close: strict ? close && (Boolean(next) || !open) : close,
-      split: strict !== undefined
-    };
-    for (const token of run.tokens) {
-      wrong.set(token, [...run.tokens]);
-      runOf.set(token, run);
-      let size = token.value.length;
-      while (size--)
-        run.markers.push(token);
-    }
-    run.end = run.markers.length;
-    runs.push(run);
-    index = end;
-  }
-  pair(runs, wrong);
-  index = -1;
-  while (++index < tokens.length) {
-    const involved = wrong.get(tokens[index]);
-    if (involved)
-      return { attention: candidates(tokens, involved, runOf), index };
-  }
-}
-function containerPhrasing(parent, state, info) {
-  return serialize2(phrasing2(parent, state, info), info.before, info.after);
-}
-function encode(tokens, start) {
-  const token = tokens[start ? 0 : tokens.length - 1];
-  if (!token || token.attention)
-    return;
-  const character = start ? firstCharacter(token.value) : lastCharacter(token.value);
-  const reference = encodeCharacterReference(character.codePointAt(0));
-  token.value = start ? reference + token.value.slice(character.length) : token.value.slice(0, token.value.length - character.length) + reference;
-}
-function improve(items, chosen, mistake, before, after) {
-  for (const attention of mistake.attention) {
-    const current = chosen.get(attention) || attention.sequences[0];
-    for (const sequence of attention.sequences) {
-      if (sequence === current)
-        continue;
-      const trial = new Map(chosen);
-      trial.set(attention, sequence);
-      const tokens = render(items, trial, before, after);
-      const next = check(tokens, before, after);
-      if (!next || next.index > mistake.index) {
-        return { chosen: trial, mistake: next, tokens };
-      }
-    }
-  }
-}
-function pair(runs, wrong) {
-  let index = 0;
-  while (index < runs.length) {
-    const closer = runs[index];
-    const marker = closer.tokens[0].value.charAt(0);
-    const closerSize = closer.end - closer.start;
-    let open = closer.close && closerSize ? index : 0;
-    while (open--) {
-      const opener = runs[open];
-      const openerSize = opener.end - opener.start;
-      if (opener.tokens[0].value.charAt(0) === marker && opener.open && openerSize && (closer.split ? !((opener.close || closer.open) && closerSize % 3) || (openerSize + closerSize) % 3 : openerSize === opener.markers.length && openerSize === closerSize)) {
-        const size = closer.split ? openerSize > 1 && closerSize > 1 ? 2 : 1 : closerSize;
-        const opening = opener.markers.slice(opener.end - size, opener.end);
-        const closing = closer.markers.slice(closer.start, closer.start + size);
-        const openToken = opening[0];
-        const closeToken = closing[0];
-        if (openToken === opening[size - 1] && openToken.value.length === size && closeToken === closing[size - 1] && closeToken.value.length === size && openToken.attention === closeToken.attention) {
-          wrong.delete(openToken);
-          wrong.delete(closeToken);
-        } else {
-          const involved = [...new Set([...opening, ...closing])];
-          for (const token of involved) {
-            const list = wrong.get(token);
-            if (list)
-              list.push(...involved);
-          }
-        }
-        opener.end -= size;
-        closer.start += size;
-        break;
-      }
-    }
-    if (open === -1 || closer.start === closer.end)
-      index++;
-  }
-}
-function attentionSequences(type, markers, sizes) {
-  if (markers.length === 0) {
-    throw new Error("Cannot serialize `" + type + "` as attention without markers, expected one or more markers");
-  }
-  if (sizes.length === 0) {
-    throw new Error("Cannot serialize `" + type + "` as attention without sizes, expected one or more sizes");
-  }
-  for (const size of sizes) {
-    if (!Number.isSafeInteger(size) || size < 1) {
-      throw new Error("Cannot serialize `" + type + "` as attention with `" + size + "` as size, expected positive integer");
-    }
-  }
-  const sequences = [];
-  for (const marker of markers) {
-    if (marker.length !== 1) {
-      throw new Error("Cannot serialize `" + type + "` as attention with `" + marker + "` as marker, expected a single ascii character");
-    }
-    if (!asciiPunctuation(marker.charCodeAt(0))) {
-      throw new Error("Cannot serialize `" + type + "` as attention with `" + marker + "` as marker, expected ascii punctuation");
-    }
-    for (const size of sizes) {
-      sequences.push(marker.repeat(size));
-    }
-  }
-  return sequences;
-}
-function phrasing2(parent, state, info) {
-  const indexStack = state.indexStack;
-  const children = parent.children || [];
-  const results = [];
-  let index = -1;
-  let before = info.before;
-  indexStack.push(-1);
-  let tracker = state.createTracker(info);
-  while (++index < children.length) {
-    const child = children[index];
-    let after;
-    indexStack[indexStack.length - 1] = index;
-    if (index + 1 < children.length) {
-      let handle = state.handle.handlers[children[index + 1].type];
-      if (handle && handle.peek)
-        handle = handle.peek;
-      after = handle ? firstCharacter(handle(children[index + 1], parent, state, {
-        before: "",
-        after: "",
-        ...tracker.current()
-      })) : "";
-    } else {
-      after = info.after;
-    }
-    const previous = results[results.length - 1];
-    if (typeof previous === "string" && (before === "\r" || before === `
-`) && child.type === "html" && htmlKind(child.value) !== 7) {
-      results[results.length - 1] = previous.replace(/(\r?\n|\r)$/, " ");
-      before = " ";
-      tracker = state.createTracker(info);
-      tracker.move(serialize2(results, info.before, info.after));
-    }
-    const handle = state.handle.handlers[child.type];
-    if (handle && handle.attention) {
-      const { construct, markers, sizes } = handle.attention(child, state);
-      const sequences = attentionSequences(child.type, markers, sizes);
-      const sequence = sequences[0];
-      const exit = state.enter(construct);
-      tracker.move(sequence);
-      const inside = phrasing2(child, state, {
-        ...tracker.current(),
-        before: sequence,
-        after: sequence
-      });
-      tracker.move(serialize2(inside, sequence, sequence));
-      tracker.move(sequence);
-      exit();
-      results.push({ children: inside, sequences });
-      before = sequence.charAt(sequence.length - 1);
-    } else {
-      const value = state.handle(child, parent, state, {
-        ...tracker.current(),
-        after,
-        before
-      });
-      if (!value)
-        continue;
-      tracker.move(value);
-      results.push(value);
-      before = lastCharacter(value);
-    }
-  }
-  indexStack.pop();
-  return results;
-}
-function render(items, chosen, before, after) {
-  const tokens = [];
-  let encodeAfter;
-  let previous = lastCharacter(before);
-  let index = -1;
-  while (++index < items.length) {
-    const item = items[index];
-    if (typeof item === "string") {
-      const token = { value: item, attention: undefined };
-      if (encodeAfter && encodeAfter === firstCharacter(item)) {
-        encode([token], true);
-      }
-      encodeAfter = undefined;
-      tokens.push(token);
-      if (token.value)
-        previous = lastCharacter(token.value);
-      continue;
-    }
-    const sequence = chosen.get(item) || item.sequences[0];
-    const marker = sequence.charAt(0);
-    const next = items[index + 1];
-    const outsideBefore = previous;
-    const outsideAfter = firstCharacter(next === undefined ? after : typeof next === "string" ? next : chosen.get(next) || next.sequences[0]);
-    const inside = render(item.children, chosen, sequence, sequence);
-    const head = inside.length > 0 ? inside[0].value : "";
-    const open = encodeInfo(outsideBefore.charCodeAt(outsideBefore.length - 1), head.charCodeAt(0), marker);
-    if (open.inside)
-      encode(inside, true);
-    const tail = inside.length > 0 ? lastCharacter(inside[inside.length - 1].value) : "";
-    const close = encodeInfo(outsideAfter.charCodeAt(0), tail.charCodeAt(tail.length - 1), marker);
-    if (close.inside)
-      encode(inside, false);
-    if (open.outside && outsideBefore !== `
-` && outsideBefore !== "\r") {
-      encode(tokens, false);
-    }
-    if (close.outside)
-      encodeAfter = outsideAfter;
-    tokens.push({ value: sequence, attention: item }, ...inside, {
-      value: sequence,
-      attention: item
-    });
-    previous = sequence.charAt(sequence.length - 1);
-  }
-  return tokens;
-}
-function serialize2(items, before, after) {
-  let chosen = new Map;
-  const initial = render(items, chosen, before, after);
-  let tokens = initial;
-  let mistake = check(tokens, before, after);
-  while (mistake) {
-    const next = improve(items, chosen, mistake, before, after);
-    if (!next) {
-      tokens = initial;
-      break;
-    }
-    chosen = next.chosen;
-    tokens = next.tokens;
-    mistake = next.mistake;
-  }
-  let result = "";
-  for (const token of tokens)
-    result += token.value;
-  return result;
-}
-var builtins;
-var init_container_phrasing = __esm(() => {
-  init_dev4();
-  init_dev6();
-  init_encode_info();
-  init_html_kind();
-  builtins = new Map([
-    ["*", false],
-    ["_", true]
-  ]);
-});
-
 // ../../node_modules/mdast-util-to-markdown/lib/util/container-flow.js
 function containerFlow(parent, state, info) {
   const indexStack = state.indexStack;
@@ -20013,22 +20159,20 @@ function safe(state, input, config) {
         continue;
       }
     }
-    if (position + 1 < end && positions[index + 1] === position + 1 && infos[position].after && !infos[position + 1].before && !infos[position + 1].after || positions[index - 1] === position - 1 && infos[position].before && !infos[position - 1].before && !infos[position - 1].after) {
+    if (position + 1 < end && positions[index + 1] === position + 1 && infos[position].after && !infos[position + 1].before && !infos[position + 1].after || position - 1 >= offset && positions[index - 1] === position - 1 && infos[position].before && !infos[position - 1].before && !infos[position - 1].after) {
       continue;
     }
     if (start !== position) {
       const slice = value.slice(start, position);
       result.push(percentEncode ? slice : escapeBackslashes(slice, "\\"));
     }
-    start = position;
+    start = position + 1;
     if (percentEncode) {
       result.push("%" + value.charCodeAt(position).toString(16).toUpperCase().padStart(2, "0"));
-      start++;
     } else if (/[!-/:-@[-`{-~]/.test(value.charAt(position)) && (!config.encode || !config.encode.includes(value.charAt(position)))) {
-      result.push("\\");
+      result.push("\\" + value.charAt(position));
     } else {
       result.push(encodeCharacterReference(value.charCodeAt(position)));
-      start++;
     }
   }
   const rest = value.slice(start, end);
@@ -22561,84 +22705,9 @@ var init_stringify_entities = __esm(() => {
   init_lib23();
 });
 
-// ../../node_modules/mdast-util-directive/node_modules/unist-util-visit-parents/lib/color.node.js
-function color3(d) {
-  return "\x1B[33m" + d + "\x1B[39m";
-}
-
-// ../../node_modules/mdast-util-directive/node_modules/unist-util-visit-parents/lib/index.js
-function visitParents3(tree, test, visitor, reverse) {
-  let check;
-  if (typeof test === "function" && typeof visitor !== "function") {
-    reverse = visitor;
-    visitor = test;
-  } else {
-    check = test;
-  }
-  const is = convert(check);
-  const step = reverse ? -1 : 1;
-  factory(tree, undefined, [])();
-  function factory(node, index, parents) {
-    const value = node && typeof node === "object" ? node : {};
-    if (typeof value.type === "string") {
-      const name = typeof value.tagName === "string" ? value.tagName : typeof value.name === "string" ? value.name : undefined;
-      Object.defineProperty(visit, "name", {
-        value: "node (" + color3(node.type + (name ? "<" + name + ">" : "")) + ")"
-      });
-    }
-    return visit;
-    function visit() {
-      let result = empty3;
-      let subresult;
-      let offset;
-      let grandparents;
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        result = toResult3(visitor(node, parents));
-        if (result[0] === EXIT3) {
-          return result;
-        }
-      }
-      if ("children" in node && node.children) {
-        const nodeAsParent = node;
-        if (nodeAsParent.children && result[0] !== SKIP3) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step;
-          grandparents = parents.concat(nodeAsParent);
-          while (offset > -1 && offset < nodeAsParent.children.length) {
-            const child = nodeAsParent.children[offset];
-            subresult = factory(child, offset, grandparents)();
-            if (subresult[0] === EXIT3) {
-              return subresult;
-            }
-            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
-          }
-        }
-      }
-      return result;
-    }
-  }
-}
-function toResult3(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "number") {
-    return [CONTINUE3, value];
-  }
-  return value === null || value === undefined ? empty3 : [value];
-}
-var empty3, CONTINUE3 = true, EXIT3 = false, SKIP3 = "skip";
-var init_lib24 = __esm(() => {
-  init_unist_util_is();
-  empty3 = [];
-});
-
-// ../../node_modules/mdast-util-directive/node_modules/unist-util-visit-parents/index.js
-var init_unist_util_visit_parents3 = __esm(() => {
-  init_lib24();
-});
-
 // ../../node_modules/mdast-util-directive/lib/index.js
-function directiveFromMarkdown() {
+function directiveFromMarkdown(options) {
+  const settings = options || emptyFromMarkdownOptions;
   return {
     canContainEols: ["textDirective"],
     enter: {
@@ -22652,29 +22721,57 @@ function directiveFromMarkdown() {
     },
     exit: {
       directiveContainer: exit3,
+      directiveContainerAttributeClass: exitAttributeShortcut,
       directiveContainerAttributeClassValue: exitAttributeClassValue,
+      directiveContainerAttributeId: exitAttributeShortcut,
       directiveContainerAttributeIdValue: exitAttributeIdValue,
       directiveContainerAttributeName: exitAttributeName,
       directiveContainerAttributeValue: exitAttributeValue,
+      directiveContainerAttributeValueLiteral: exitAttributeValueLiteral,
       directiveContainerAttributes: exitAttributes,
       directiveContainerLabel: exitContainerLabel,
       directiveContainerName: exitName,
+      directiveContainerSequence: exitSequence,
       directiveLeaf: exit3,
+      directiveLeafAttributeClass: exitAttributeShortcut,
       directiveLeafAttributeClassValue: exitAttributeClassValue,
+      directiveLeafAttributeId: exitAttributeShortcut,
       directiveLeafAttributeIdValue: exitAttributeIdValue,
       directiveLeafAttributeName: exitAttributeName,
       directiveLeafAttributeValue: exitAttributeValue,
+      directiveLeafAttributeValueLiteral: exitAttributeValueLiteral,
       directiveLeafAttributes: exitAttributes,
+      directiveLeafLabel: exitLabel,
       directiveLeafName: exitName,
+      directiveLeafSequence: exitSequence,
       directiveText: exit3,
+      directiveTextAttributeClass: exitAttributeShortcut,
       directiveTextAttributeClassValue: exitAttributeClassValue,
+      directiveTextAttributeId: exitAttributeShortcut,
       directiveTextAttributeIdValue: exitAttributeIdValue,
       directiveTextAttributeName: exitAttributeName,
       directiveTextAttributeValue: exitAttributeValue,
+      directiveTextAttributeValueLiteral: exitAttributeValueLiteral,
       directiveTextAttributes: exitAttributes,
+      directiveTextLabel: exitLabel,
+      directiveTextMarker: exitSequence,
       directiveTextName: exitName
     }
   };
+  function exitSequence(token) {
+    if (!settings.verbose)
+      return;
+    const node = this.stack[this.stack.length - 1];
+    ok(node, "expected `node`");
+    ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
+    const place = { start: point3(token.start), end: point3(token.end) };
+    if (node.data && node.data.position) {
+      ok(node.type === "containerDirective");
+      node.data.position.closing = place;
+    } else {
+      node.data = { position: { opening: place } };
+    }
+  }
 }
 function directiveToMarkdown(options) {
   const settings = options || emptyOptions4;
@@ -22711,8 +22808,20 @@ function directiveToMarkdown(options) {
   };
   function handleDirective(node, _, state, info) {
     const tracker = state.createTracker(info);
-    const sequence = fence3(node);
     const exit = state.enter(node.type);
+    let content;
+    if (node.type === "containerDirective") {
+      const head = (node.children || [])[0];
+      const children = inlineDirectiveLabel(head) ? node.children.slice(1) : node.children;
+      if (children && children.length > 0) {
+        const current = tracker.current();
+        content = state.containerFlow({ ...node, children }, {
+          now: { line: current.now.line + 1, column: 1 + current.lineShift },
+          lineShift: current.lineShift
+        });
+      }
+    }
+    const sequence = fence3(node, content ? longestColonLine(content) : 0);
     let value = tracker.move(sequence + (node.name || ""));
     const attributesValue = attributes(node, state);
     const after = info.after.charCodeAt(0);
@@ -22741,15 +22850,9 @@ function directiveToMarkdown(options) {
     }
     value += tracker.move(attributesValue || (after === 123 ? "{}" : ""));
     if (node.type === "containerDirective") {
-      const head = (node.children || [])[0];
-      let shallow = node;
-      if (inlineDirectiveLabel(head)) {
-        shallow = Object.assign({}, node, { children: node.children.slice(1) });
-      }
-      if (shallow && shallow.children && shallow.children.length > 0) {
+      if (content) {
         value += tracker.move(`
-`);
-        value += tracker.move(state.containerFlow(shallow, tracker.current()));
+` + content);
       }
       value += tracker.move(`
 ` + sequence);
@@ -22766,16 +22869,15 @@ function directiveToMarkdown(options) {
     let key;
     for (key in attributes) {
       if (own9.call(attributes, key) && attributes[key] !== undefined && attributes[key] !== null) {
-        const value = String(attributes[key]);
+        const value = encode2(String(attributes[key]));
         if (key === "id") {
           id = settings.preferShortcut !== false && shortcut.test(value) ? "#" + value : quoted("id", value, node, state);
         } else if (key === "class") {
           const list = value.split(/[\t\n\r ]+/);
           const classesFullList = [];
           const classesList = [];
-          let index = -1;
-          while (++index < list.length) {
-            (settings.preferShortcut !== false && shortcut.test(list[index]) ? classesList : classesFullList).push(list[index]);
+          for (const item of list) {
+            (settings.preferShortcut !== false && shortcut.test(item) ? classesList : classesFullList).push(item);
           }
           classesFull = classesFullList.length > 0 ? quoted("class", classesFullList.join(" "), node, state) : "";
           classes = classesList.length > 0 ? "." + classesList.join(".") : "";
@@ -22823,19 +22925,50 @@ function enter(type, token) {
 }
 function exitName(token) {
   const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
   ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
   node.name = this.sliceSerialize(token);
+  openingEnd(node, token);
 }
 function enterContainerLabel(token) {
   this.enter({ type: "paragraph", data: { directiveLabel: true }, children: [] }, token);
 }
 function exitContainerLabel(token) {
   this.exit(token);
+  const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
+  ok(node.type === "containerDirective");
+  openingEnd(node, token);
+}
+function exitLabel(token) {
+  const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
+  ok(node.type === "leafDirective" || node.type === "textDirective");
+  openingEnd(node, token);
 }
 function enterAttributes() {
+  const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
+  ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
+  if (node.data && node.data.position) {
+    this.data.directiveAttributePositions = {};
+  }
   this.data.directiveAttributes = [];
   this.buffer();
 }
+function exitAttributeShortcut(token) {
+  const positions = this.data.directiveAttributePositions;
+  if (positions) {
+    const list = this.data.directiveAttributes;
+    ok(list, "expected `directiveAttributes`");
+    const tail = list[list.length - 1];
+    ok(tail, "expected attribute");
+    positions[tail[0]] = { start: point3(token.start), end: point3(token.end) };
+  }
+}
+function exitAttributeValueLiteral(token) {
+  attributeEnd(this, token);
+}
 function exitAttributeIdValue(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
@@ -22855,33 +22988,67 @@ function exitAttributeClassValue(token) {
 function exitAttributeValue(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
-  list[list.length - 1][1] = parseEntities(this.sliceSerialize(token), {
-    attribute: true
-  });
+  const tail = list[list.length - 1];
+  ok(tail, "expected attribute");
+  tail[1] = parseEntities(this.sliceSerialize(token), { attribute: true });
+  attributeEnd(this, token);
 }
 function exitAttributeName(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
-  list.push([this.sliceSerialize(token), ""]);
+  const name = this.sliceSerialize(token);
+  list.push([name, ""]);
+  const positions = this.data.directiveAttributePositions;
+  if (positions) {
+    positions[name] = { start: point3(token.start), end: point3(token.end) };
+  }
 }
-function exitAttributes() {
+function exitAttributes(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
   const cleaned = {};
-  let index = -1;
-  while (++index < list.length) {
-    const attribute = list[index];
+  for (const attribute of list) {
     if (attribute[0] === "class" && cleaned.class) {
       cleaned.class += " " + attribute[1];
     } else {
       cleaned[attribute[0]] = attribute[1];
     }
   }
+  const positions = this.data.directiveAttributePositions;
+  this.data.directiveAttributePositions = undefined;
   this.data.directiveAttributes = undefined;
   this.resume();
   const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
   ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
   node.attributes = cleaned;
+  if (positions) {
+    ok(node.data && node.data.position, "expected `position`");
+    node.data.position.attributes = positions;
+  }
+  openingEnd(node, token);
+}
+function openingEnd(node, token) {
+  if (node.data && node.data.position) {
+    const { opening } = node.data.position;
+    ok(opening, "expected `opening`");
+    opening.end = point3(token.end);
+  }
+}
+function attributeEnd(context, token) {
+  const positions = context.data.directiveAttributePositions;
+  if (positions) {
+    const list = context.data.directiveAttributes;
+    ok(list, "expected `directiveAttributes`");
+    const tail = list[list.length - 1];
+    ok(tail, "expected attribute");
+    const position = positions[tail[0]];
+    ok(position, "expected position");
+    position.end = point3(token.end);
+  }
+}
+function point3(d) {
+  return { line: d.line, column: d.column, offset: d.offset };
 }
 function exit3(token) {
   this.exit(token);
@@ -22889,26 +23056,28 @@ function exit3(token) {
 function peekDirective() {
   return ":";
 }
+function encode2(value) {
+  const result = [];
+  let start = 0;
+  let index = value.indexOf("&");
+  while (index !== -1) {
+    const code = value.charCodeAt(index + 1);
+    if (code === 35 || asciiAlpha(code)) {
+      result.push(value.slice(start, index), "&#x26;");
+      start = index + 1;
+    }
+    index = value.indexOf("&", index + 1);
+  }
+  result.push(value.slice(start));
+  return result.join("");
+}
 function inlineDirectiveLabel(node) {
   return Boolean(node && node.type === "paragraph" && node.data && node.data.directiveLabel);
 }
-function fence3(node) {
+function fence3(node, longest) {
   let size = 0;
   if (node.type === "containerDirective") {
-    visitParents3(node, function(node, parents) {
-      if (node.type === "containerDirective") {
-        let index = parents.length;
-        let nesting = 0;
-        while (index--) {
-          if (parents[index].type === "containerDirective") {
-            nesting++;
-          }
-        }
-        if (nesting > size)
-          size = nesting;
-      }
-    });
-    size += 3;
+    size = Math.max(3, longest + 1);
   } else if (node.type === "leafDirective") {
     size = 2;
   } else {
@@ -22916,14 +23085,40 @@ function fence3(node) {
   }
   return ":".repeat(size);
 }
-var own9, emptyOptions4, shortcut, unquoted;
-var init_lib25 = __esm(() => {
+function longestColonLine(value) {
+  let longest = 0;
+  let index = 0;
+  while (index < value.length) {
+    let size = 0;
+    let code = value.charCodeAt(index);
+    while (code === 9 || code === 32) {
+      code = value.charCodeAt(++index);
+    }
+    while (code === 58) {
+      size++;
+      code = value.charCodeAt(++index);
+    }
+    while (code === 9 || code === 32) {
+      code = value.charCodeAt(++index);
+    }
+    while (!(code === 10 || code === 13 || Number.isNaN(code))) {
+      size = 0;
+      code = value.charCodeAt(++index);
+    }
+    if (size > longest)
+      longest = size;
+    index++;
+  }
+  return longest;
+}
+var own9, emptyFromMarkdownOptions, emptyOptions4, shortcut, unquoted;
+var init_lib24 = __esm(() => {
   init_development();
   init_dev4();
   init_parse_entities();
   init_stringify_entities();
-  init_unist_util_visit_parents3();
   own9 = {}.hasOwnProperty;
+  emptyFromMarkdownOptions = {};
   emptyOptions4 = {};
   shortcut = /^[^\t\n\r "#'.<=>`}]+$/;
   unquoted = /^[^\t\n\r "'<=>`}]+$/;
@@ -22931,7 +23126,7 @@ var init_lib25 = __esm(() => {
 
 // ../../node_modules/mdast-util-directive/index.js
 var init_mdast_util_directive = __esm(() => {
-  init_lib25();
+  init_lib24();
 });
 
 // ../../node_modules/micromark-extension-directive/dev/lib/factory-attributes.js
@@ -23547,14 +23742,14 @@ function remarkDirective() {
   fromMarkdownExtensions.push(directiveFromMarkdown());
   toMarkdownExtensions.push(directiveToMarkdown());
 }
-var init_lib26 = __esm(() => {
+var init_lib25 = __esm(() => {
   init_mdast_util_directive();
   init_dev22();
 });
 
 // ../../node_modules/remark-directive/index.js
 var init_remark_directive = __esm(() => {
-  init_lib26();
+  init_lib25();
 });
 
 // ../../node_modules/property-information/lib/util/schema.js
@@ -24814,13 +25009,13 @@ function parseSelector(selector, defaultTagName) {
   };
 }
 var search2;
-var init_lib27 = __esm(() => {
+var init_lib26 = __esm(() => {
   search2 = /[#.]/g;
 });
 
 // ../../node_modules/hast-util-parse-selector/index.js
 var init_hast_util_parse_selector = __esm(() => {
-  init_lib27();
+  init_lib26();
 });
 
 // ../../node_modules/space-separated-tokens/index.js
@@ -24857,7 +25052,7 @@ function createH(schema, defaultTagName, caseSensitive) {
     for (const child of children) {
       addChild(node.children, child);
     }
-    if (node.type === "element" && node.tagName === "template") {
+    if (node.type === "element" && node.tagName === "template" && schema.space === "html") {
       node.content = { type: "root", children: node.children };
       node.children = [];
     }
@@ -24892,10 +25087,10 @@ function isChild(value) {
   return false;
 }
 function addProperty(schema, properties, key, value) {
-  const info = find(schema, key);
-  let result;
   if (value === null || value === undefined)
     return;
+  const info = find(schema, key);
+  let result;
   if (typeof value === "number") {
     if (Number.isNaN(value))
       return;
@@ -24925,7 +25120,8 @@ function addProperty(schema, properties, key, value) {
     result = finalResult;
   }
   if (info.property === "className" && Array.isArray(properties.className)) {
-    result = properties.className.concat(result);
+    const add = result;
+    result = [...properties.className, ...Array.isArray(add) ? add : [add]];
   }
   properties[info.property] = result;
 }
@@ -25024,7 +25220,7 @@ var init_svg_case_sensitive_tag_names = __esm(() => {
 
 // ../../node_modules/hastscript/lib/index.js
 var h, s;
-var init_lib28 = __esm(() => {
+var init_lib27 = __esm(() => {
   init_property_information();
   init_create_h();
   init_svg_case_sensitive_tag_names();
@@ -25034,7 +25230,7 @@ var init_lib28 = __esm(() => {
 
 // ../../node_modules/hastscript/index.js
 var init_hastscript = __esm(() => {
-  init_lib28();
+  init_lib27();
 });
 
 // ../../node_modules/vfile-location/lib/index.js
@@ -25174,7 +25370,7 @@ function all2(state, nodes) {
   return results;
 }
 function element(state, node) {
-  const schema = state.schema;
+  const { schema } = state;
   state.schema = node.namespaceURI === webNamespaces.svg ? svg2 : html3;
   let index = -1;
   const properties = {};
@@ -25189,15 +25385,20 @@ function element(state, node) {
   const result = x(node.tagName, properties, all2(state, node.childNodes));
   patch(state, node, result);
   if (result.tagName === "template") {
-    const reference = node;
-    const pos = reference.sourceCodeLocation;
-    const startTag = pos && pos.startTag && position2(pos.startTag);
-    const endTag = pos && pos.endTag && position2(pos.endTag);
-    const content = one2(state, reference.content);
-    if (startTag && endTag && state.file) {
-      content.position = { start: startTag.end, end: endTag.start };
+    if (node.namespaceURI === webNamespaces.html) {
+      const reference = node;
+      const pos = reference.sourceCodeLocation;
+      const startTag = pos && pos.startTag && position2(pos.startTag);
+      const endTag = pos && pos.endTag && position2(pos.endTag);
+      const content = one2(state, reference.content);
+      if (startTag && endTag && state.file) {
+        content.position = { start: startTag.end, end: endTag.start };
+      }
+      result.content = content;
+    } else if (result.content) {
+      result.children = result.content.children;
+      delete result.content;
     }
-    result.content = content;
   }
   state.schema = schema;
   return result;
@@ -25241,23 +25442,23 @@ function createLocation(state, node, location) {
   return result;
 }
 function position2(loc) {
-  const start = point3({
+  const start = point4({
     line: loc.startLine,
     column: loc.startCol,
     offset: loc.startOffset
   });
-  const end = point3({
+  const end = point4({
     line: loc.endLine,
     column: loc.endCol,
     offset: loc.endOffset
   });
   return start || end ? { start, end } : undefined;
 }
-function point3(point) {
+function point4(point) {
   return point.line && point.column ? point : undefined;
 }
 var own10, proto;
-var init_lib29 = __esm(() => {
+var init_lib28 = __esm(() => {
   init_development();
   init_hastscript();
   init_property_information();
@@ -25269,7 +25470,7 @@ var init_lib29 = __esm(() => {
 
 // ../../node_modules/hast-util-from-parse5/index.js
 var init_hast_util_from_parse5 = __esm(() => {
-  init_lib29();
+  init_lib28();
 });
 
 // ../../node_modules/parse5/dist/common/unicode.js
@@ -33162,7 +33363,7 @@ function visualizeCharacterCode(charCode) {
   return "0x" + charCode.toString(16).toUpperCase();
 }
 var base = "https://html.spec.whatwg.org/multipage/parsing.html#parse-error-", dashToCamelRe, formatCRe, formatXRe, fatalities, emptyOptions5;
-var init_lib30 = __esm(() => {
+var init_lib29 = __esm(() => {
   init_development();
   init_hast_util_from_parse5();
   init_dist2();
@@ -33178,24 +33379,24 @@ var init_lib30 = __esm(() => {
 
 // ../../node_modules/hast-util-from-html/index.js
 var init_hast_util_from_html = __esm(() => {
-  init_lib30();
+  init_lib29();
 });
 
 // ../../node_modules/hast-util-whitespace/lib/index.js
 function whitespace(thing) {
-  return typeof thing === "object" ? thing.type === "text" ? empty4(thing.value) : false : empty4(thing);
+  return typeof thing === "object" ? thing.type === "text" ? empty3(thing.value) : false : empty3(thing);
 }
-function empty4(value) {
+function empty3(value) {
   return value.replace(re, "") === "";
 }
 var re;
-var init_lib31 = __esm(() => {
+var init_lib30 = __esm(() => {
   re = /[ \t\n\f\r]/g;
 });
 
 // ../../node_modules/hast-util-whitespace/index.js
 var init_hast_util_whitespace = __esm(() => {
-  init_lib31();
+  init_lib30();
 });
 
 // ../../packages/markup/src/html-to-jx.ts
@@ -34497,7 +34698,7 @@ function isNonRelativeRef(value) {
 }
 var DOCUMENT_EXTENSIONS = new Set([".md", ".markdown", ".mdx"]);
 function mountFilterFor(def) {
-  if (!def || def.exclude === undefined && def.where === undefined && def.route === undefined) {
+  if (!def || def.exclude === undefined && def.where === undefined && def.hold === undefined && def.route === undefined) {
     return;
   }
   let exclude;
@@ -34649,11 +34850,11 @@ function loadContentConfig(projectRoot, projectConfig) {
   const config = { content: projectConfig?.content ?? {} };
   return { config, contentDir };
 }
-async function loadContentSection(section, root, formats, projectConfig) {
+async function loadContentSection(section, root, formats, projectConfig, includeHeld) {
   const contentTypes = new Map;
   const mounts = sectionMounts(section, root, projectConfig);
   for (const name of Object.keys(section)) {
-    contentTypes.set(name, await loadSectionType(name, { formats, mounts, projectConfig, root, section }));
+    contentTypes.set(name, await loadSectionType(name, { formats, includeHeld, mounts, projectConfig, root, section }));
   }
   return contentTypes;
 }
@@ -34664,7 +34865,7 @@ function sectionMounts(section, root, projectConfig) {
   ]));
 }
 async function loadSectionType(name, source) {
-  const { section, root, formats, projectConfig, mounts, onDeferred } = source;
+  const { section, root, formats, projectConfig, mounts, onDeferred, includeHeld } = source;
   const contentTypeDef = section[name];
   if (!contentTypeDef) {
     return [];
@@ -34673,6 +34874,7 @@ async function loadSectionType(name, source) {
   const typeSource = contentTypeDef.source;
   if (!isString(typeSource) || !typeSource.includes(LOCALE_PLACEHOLDER)) {
     return await loadContentType(name, contentTypeDef, root, formats, {
+      includeHeld,
       mount: mounts.get(name),
       projectConfig,
       ...deferral
@@ -34687,6 +34889,7 @@ async function loadSectionType(name, source) {
   for (const locale of locales) {
     const localized = { ...contentTypeDef, source: localeSource(root, typeSource, locale) };
     const entries = await loadContentType(name, localized, root, formats, {
+      includeHeld,
       locale,
       mount: mounts.get(`${name}/${locale}`),
       projectConfig,
@@ -34713,6 +34916,7 @@ var KNOWN_TYPE_KEYS = [
   "alerts",
   "exclude",
   "format",
+  "hold",
   "idField",
   "indexRoute",
   "links",
@@ -34772,7 +34976,8 @@ function compileTypeRules(name, def) {
       idField: def.idField,
       links,
       route: parseRouteConfig(def.route, def.indexRoute, name),
-      where: def.where === undefined ? null : compileWhere(def.where)
+      where: def.where === undefined ? null : compileWhere(def.where),
+      hold: def.hold === undefined ? null : compileHold(def.hold)
     };
   } catch (error) {
     const message = errorMessage(error);
@@ -34787,6 +34992,7 @@ function finishEntries(files, ctx) {
   const { name, rules } = ctx;
   const kept = [];
   const unpublished = new Map;
+  const held = [];
   let loadedCount = 0;
   for (const file of files) {
     const keep = [];
@@ -34796,8 +35002,19 @@ function finishEntries(files, ctx) {
         if (file.rel !== null && file.entries.length === 1) {
           unpublished.set(file.rel, `left out by where.${rules.where.why(entry.data) ?? "filter"}`);
         }
-      } else {
+        continue;
+      }
+      const hold = rules.hold?.(entry.data);
+      if (hold === undefined) {
         keep.push(entry);
+      } else if (ctx.includeHeld === true) {
+        entry._meta = { ...entry._meta, hold };
+        keep.push(entry);
+      } else {
+        held.push(`${file.rel ?? entry.id} (${hold})`);
+        if (file.rel !== null && file.entries.length === 1) {
+          unpublished.set(file.rel, `held: ${hold}`);
+        }
       }
     }
     if (keep.length > 0) {
@@ -34808,6 +35025,9 @@ function finishEntries(files, ctx) {
     const [first] = files.flatMap((file) => file.entries);
     console.warn(`Content type "${name}": "where" left out all ${loadedCount} entries, so the collection is ` + `empty (it failed on "${first ? rules.where.why(first.data) ?? "?" : "?"}" for the first one). ` + `Check the field names and the value types: YAML \`true\` is a boolean, "true" is text.`);
   }
+  if (held.length > 0) {
+    console.info(`Content type "${name}": holding ${held.length} from this build: ${held.join(", ")}`);
+  }
   for (const file of kept) {
     for (const entry of file.entries) {
       if (file.rel !== null) {
@@ -35075,12 +35295,13 @@ async function loadContentType(name, contentTypeDef, projectRoot, registry, opti
   if (!source) {
     return [];
   }
-  const { mount, projectConfig, locale, deferBody, onDeferred } = options;
+  const { mount, projectConfig, locale, deferBody, onDeferred, includeHeld } = options;
   const { schema } = contentTypeDef;
   const rules = compileTypeRules(name, contentTypeDef);
   const finishContext = (extra) => ({
     coerceDates: false,
     entryExtensions: new Set,
+    includeHeld,
     locale,
     mount,
     name,
@@ -35369,7 +35590,7 @@ class ContentStore extends Map {
   }
   static async whole(source) {
     const store = new ContentStore(source);
-    const loaded = await loadContentSection(source.section, source.root, source.formats, source.projectConfig);
+    const loaded = await loadContentSection(source.section, source.root, source.formats, source.projectConfig, source.includeHeld);
     for (const [name, entries] of loaded) {
       store.#adopt(name, entries);
       store.#loads.set(name, Promise.resolve());
@@ -35444,8 +35665,9 @@ class ContentStore extends Map {
   #loadType(name) {
     let load = this.#loads.get(name);
     if (!load) {
-      const { section, root, formats, projectConfig } = this.#source;
+      const { section, root, formats, projectConfig, includeHeld } = this.#source;
       load = loadSectionType(name, {
+        includeHeld,
         formats,
         mounts: this.#mounts,
         onDeferred: (entry, completeBody) => {
@@ -35496,6 +35718,7 @@ class Content {
   static async projectData(sectionValue, ctx) {
     const source = {
       formats: ctx.registry.formats,
+      includeHeld: ctx.includeHeld,
       projectConfig: ctx.projectConfig,
       root: ctx.root,
       section: sectionValue ?? {}