@pacem/pacem-foundation 1.0.6-ricci → 2.0.0-abel

package/dist/bundle/pacem-foundation.mjs

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */
@@ -1532,8 +1532,19 @@ var Strings = class {
 // packages/foundation/dist/esm/index-compile.js
 var index_compile_exports = {};
 __export(index_compile_exports, {
+  CSharpSyntax: () => CSharpSyntax,
+  CSyntax: () => CSyntax,
+  DefaultHighlightClasses: () => DefaultHighlightClasses,
+  HighlightRenderer: () => HighlightRenderer,
+  JavaScriptSyntax: () => JavaScriptSyntax,
+  JsonSyntax: () => JsonSyntax,
   Markdown: () => index_compile_markdown_exports,
-  Parser: () => Parser
+  MarkupSyntax: () => MarkupSyntax,
+  PacemBindingSyntax: () => PacemBindingSyntax,
+  Parser: () => Parser,
+  Scanner: () => Scanner,
+  SyntaxTokenType: () => SyntaxTokenType,
+  Syntaxes: () => Syntaxes
 });
 
 // packages/foundation/dist/esm/index-compile-markdown.js
@@ -1590,8 +1601,577 @@ var Parser = class {
   }
 };
 
+// packages/foundation/dist/esm/compile/syntax/types.js
+var SyntaxTokenType;
+(function(SyntaxTokenType2) {
+  SyntaxTokenType2["Text"] = "text";
+  SyntaxTokenType2["Space"] = "space";
+  SyntaxTokenType2["Newline"] = "newline";
+  SyntaxTokenType2["Comment"] = "comment";
+  SyntaxTokenType2["DocComment"] = "doc-comment";
+  SyntaxTokenType2["Keyword"] = "keyword";
+  SyntaxTokenType2["Identifier"] = "identifier";
+  SyntaxTokenType2["String"] = "string";
+  SyntaxTokenType2["Regex"] = "regex";
+  SyntaxTokenType2["Number"] = "number";
+  SyntaxTokenType2["Bracket"] = "bracket";
+  SyntaxTokenType2["Punctuation"] = "punctuation";
+  SyntaxTokenType2["Operator"] = "operator";
+  SyntaxTokenType2["Preprocessor"] = "preprocessor";
+  SyntaxTokenType2["Tag"] = "tag";
+  SyntaxTokenType2["TagName"] = "tagname";
+  SyntaxTokenType2["Attribute"] = "attribute";
+  SyntaxTokenType2["Entity"] = "entity";
+})(SyntaxTokenType || (SyntaxTokenType = {}));
+
+// packages/foundation/dist/esm/compile/syntax/registry.js
+var registry = /* @__PURE__ */ new Map();
+function normalize(name) {
+  return (name ?? "").trim().toLowerCase();
+}
+var Syntaxes = class {
+  /**
+   * Registers (or replaces) a syntax under its name and aliases.
+   * @param syntax The vocabulary to register.
+   */
+  static register(syntax) {
+    if (syntax == null) {
+      return;
+    }
+    const names = [syntax.name].concat(syntax.aliases ?? []);
+    for (let name of names) {
+      const key = normalize(name);
+      registry.set(key, syntax);
+    }
+  }
+  /**
+   * Gets a registered syntax by name or alias.
+   * @param nameOrAlias Case-insensitive name or alias (e.g. `'ts'`).
+   * @returns The syntax, or `null` when unknown.
+   */
+  static get(nameOrAlias) {
+    const key = normalize(nameOrAlias);
+    return registry.get(key) ?? null;
+  }
+  /** Names (and aliases) of every registered syntax. */
+  static names() {
+    const keys = registry.keys();
+    return Array.from(keys);
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/scanner.js
+var DEFAULT_START = "root";
+var DEFAULT_KEYWORD_SOURCES = [SyntaxTokenType.Identifier];
+var DEFAULT_INSIGNIFICANT = [SyntaxTokenType.Space, SyntaxTokenType.Newline, SyntaxTokenType.Comment, SyntaxTokenType.DocComment];
+var MAX_EMPTY_TRANSITIONS = 64;
+var MAX_EXTENDS_DEPTH = 16;
+function isCombined(item) {
+  return item.combined != null;
+}
+var compiledCache = /* @__PURE__ */ new WeakMap();
+function isIncludeRule(rule) {
+  return "include" in rule;
+}
+function toSet(values) {
+  if (values == null || values.length === 0) {
+    return null;
+  }
+  return new Set(values);
+}
+function uniqueFlags(flags) {
+  const chars = flags.split("");
+  const unique = new Set(chars);
+  const array = Array.from(unique);
+  return array.join("");
+}
+function mergeStates(own, base) {
+  const merged = {};
+  for (let name in base) {
+    merged[name] = base[name].slice();
+  }
+  for (let name in own) {
+    const baseRules = merged[name] ?? [];
+    merged[name] = own[name].concat(baseRules);
+  }
+  return merged;
+}
+function mergeKeywords(own, base) {
+  const merged = {};
+  for (let type in base) {
+    merged[type] = base[type].slice();
+  }
+  for (let type in own) {
+    const baseWords = merged[type] ?? [];
+    merged[type] = baseWords.concat(own[type]);
+  }
+  return merged;
+}
+function mergeSyntax(syntax, depth = 0) {
+  const lexical = syntax.lexical ?? { states: {} };
+  const own = {
+    start: lexical.start,
+    states: lexical.states ?? {},
+    keywords: lexical.keywords ?? {},
+    keywordSources: lexical.keywordSources,
+    keywordExceptAfter: lexical.keywordExceptAfter,
+    insignificant: lexical.insignificant
+  };
+  const baseSyntax = syntax.extends ? Syntaxes.get(syntax.extends) : null;
+  if (baseSyntax == null || baseSyntax === syntax || depth >= MAX_EXTENDS_DEPTH) {
+    return own;
+  }
+  const base = mergeSyntax(baseSyntax, depth + 1);
+  return {
+    start: own.start ?? base.start,
+    states: mergeStates(own.states, base.states),
+    keywords: mergeKeywords(own.keywords, base.keywords),
+    keywordSources: own.keywordSources ?? base.keywordSources,
+    keywordExceptAfter: own.keywordExceptAfter ?? base.keywordExceptAfter,
+    insignificant: own.insignificant ?? base.insignificant
+  };
+}
+function expandRules(states, stateName, visiting) {
+  const rules = states[stateName] ?? [];
+  if (visiting.has(stateName)) {
+    return [];
+  }
+  visiting.add(stateName);
+  const expanded = [];
+  for (let rule of rules) {
+    if (!isIncludeRule(rule)) {
+      expanded.push(rule);
+      continue;
+    }
+    const included = expandRules(states, rule.include, visiting);
+    Array.prototype.push.apply(expanded, included);
+  }
+  visiting.delete(stateName);
+  return expanded;
+}
+function compileCondition(condition) {
+  if (condition == null) {
+    return null;
+  }
+  return {
+    previousTypes: toSet(condition.previousTypes),
+    previousNotTypes: toSet(condition.previousNotTypes),
+    previousTexts: toSet(condition.previousTexts),
+    previousNotTexts: toSet(condition.previousNotTexts)
+  };
+}
+function compileRule(rule) {
+  const groupTypes = Array.isArray(rule.type) ? rule.type : null;
+  const type = Array.isArray(rule.type) ? rule.type[0] : rule.type;
+  const userFlags = (rule.flags ?? "").replace(/[yd]/g, "");
+  const ownFlags = uniqueFlags(userFlags);
+  const flags = ownFlags + "y" + (groupTypes ? "d" : "");
+  const regex = new RegExp(rule.match, flags);
+  const until = rule.until ? new RegExp(rule.until, "y") : null;
+  const pop = rule.pop === true ? 1 : typeof rule.pop === "number" ? rule.pop : 0;
+  const when = compileCondition(rule.when);
+  return {
+    regex,
+    type,
+    groupTypes,
+    when,
+    pop,
+    until,
+    source: rule.match,
+    flags: ownFlags,
+    next: rule.next ?? null,
+    push: rule.push ?? null,
+    embed: rule.embed ?? null,
+    hasTransition: pop > 0 || !!rule.next || !!rule.push || !!rule.embed
+  };
+}
+function compileKeywords(keywords) {
+  const map = /* @__PURE__ */ new Map();
+  for (let type in keywords) {
+    for (let word of keywords[type]) {
+      map.set(word, type);
+    }
+  }
+  return map;
+}
+var UNMERGEABLE_SOURCE = /\\[1-9]|\\k<|\(\?<(?![=!])/;
+function countGroups(source, flags) {
+  const probe = new RegExp(source + "|", flags);
+  const match2 = probe.exec("");
+  return match2.length - 1;
+}
+function canMatchEmpty(source, flags) {
+  const probe = new RegExp("^(?:" + source + ")$", flags);
+  return probe.test("");
+}
+function isMergeable(rule) {
+  if (rule.when != null || UNMERGEABLE_SOURCE.test(rule.source)) {
+    return false;
+  }
+  return !canMatchEmpty(rule.source, rule.flags);
+}
+function combine(rules) {
+  if (rules.length === 1) {
+    return { rule: rules[0], combined: null };
+  }
+  const groupIndices = [];
+  let groupIndex = 1;
+  for (let rule of rules) {
+    groupIndices.push(groupIndex);
+    const ownGroups = countGroups(rule.source, rule.flags);
+    groupIndex += 1 + ownGroups;
+  }
+  const alternatives = rules.map((r) => "(" + r.source + ")");
+  const source = alternatives.join("|");
+  const combined = new RegExp(source, rules[0].flags + "y");
+  return { rule: null, combined, rules, groupIndices };
+}
+function segment(rules) {
+  const segments = [];
+  let pending = [];
+  const flush = () => {
+    if (pending.length > 0) {
+      const combinedSegment = combine(pending);
+      segments.push(combinedSegment);
+    }
+    pending = [];
+  };
+  for (let rule of rules) {
+    if (!isMergeable(rule)) {
+      flush();
+      segments.push({ rule, combined: null });
+      continue;
+    }
+    if (pending.length > 0 && pending[0].flags !== rule.flags) {
+      flush();
+    }
+    pending.push(rule);
+  }
+  flush();
+  return segments;
+}
+function compileSyntax(syntax) {
+  const cached = compiledCache.get(syntax);
+  if (cached != null) {
+    return cached;
+  }
+  const merged = mergeSyntax(syntax);
+  const states = /* @__PURE__ */ new Map();
+  for (let name in merged.states) {
+    const visiting = /* @__PURE__ */ new Set();
+    const rules = expandRules(merged.states, name, visiting);
+    const compiledRules = rules.map(compileRule);
+    const segments = segment(compiledRules);
+    states.set(name, segments);
+  }
+  const compiled = {
+    name: syntax.name,
+    start: merged.start ?? DEFAULT_START,
+    states,
+    keywords: compileKeywords(merged.keywords),
+    keywordSources: new Set(merged.keywordSources ?? DEFAULT_KEYWORD_SOURCES),
+    keywordExceptAfter: new Set(merged.keywordExceptAfter ?? []),
+    insignificant: new Set(merged.insignificant ?? DEFAULT_INSIGNIFICANT)
+  };
+  compiledCache.set(syntax, compiled);
+  return compiled;
+}
+function compileByName(name) {
+  const syntax = Syntaxes.get(name);
+  if (syntax == null) {
+    return null;
+  }
+  return compileSyntax(syntax);
+}
+function meets(condition, previous) {
+  const type = previous?.type ?? null, text = previous?.raw ?? null;
+  if (condition.previousTypes != null && !condition.previousTypes.has(type)) {
+    return false;
+  }
+  if (condition.previousNotTypes != null && condition.previousNotTypes.has(type)) {
+    return false;
+  }
+  if (condition.previousTexts != null && !condition.previousTexts.has(text)) {
+    return false;
+  }
+  return condition.previousNotTexts == null || !condition.previousNotTexts.has(text);
+}
+var ScanRun = class {
+  constructor(_source, root) {
+    this._source = _source;
+    this._tokens = [];
+    this._position = 0;
+    this._emitted = 0;
+    this._line = 1;
+    this._column = 1;
+    this._previous = null;
+    this._emptyTransitions = 0;
+    this._stack = [{ syntax: root, state: root.start, until: null }];
+  }
+  run() {
+    const length = this._source.length;
+    while (this._position < length) {
+      this._step();
+    }
+    this._flushText();
+    return this._tokens;
+  }
+  get _top() {
+    const stack = this._stack;
+    return stack[stack.length - 1];
+  }
+  _step() {
+    const frame = this._top;
+    if (this._popOnUntil(frame)) {
+      return;
+    }
+    const found = this._findRule(frame);
+    if (found == null) {
+      this._position++;
+      return;
+    }
+    this._flushText();
+    this._emitMatch(found, frame.syntax);
+    this._transition(found.rule, frame.syntax);
+    const length = found.match[0].length;
+    this._position += length;
+    if (length > 0) {
+      this._emptyTransitions = 0;
+    }
+  }
+  /** Pops an embedded syntax as soon as its `until` pattern matches (without consuming input). */
+  _popOnUntil(frame) {
+    const until = frame.until;
+    if (until == null || this._stack.length <= 1) {
+      return false;
+    }
+    until.lastIndex = this._position;
+    if (!until.test(this._source)) {
+      return false;
+    }
+    this._flushText();
+    this._stack.pop();
+    return true;
+  }
+  _findRule(frame) {
+    const segments = frame.syntax.states.get(frame.state) ?? [];
+    for (let item of segments) {
+      const found = isCombined(item) ? this._tryCombined(item) : this._trySingle(item.rule);
+      if (found != null) {
+        return found;
+      }
+    }
+    return null;
+  }
+  _trySingle(rule) {
+    const match2 = this._tryRule(rule);
+    if (match2 == null) {
+      return null;
+    }
+    return { rule, match: match2 };
+  }
+  /** Finds which merged rule matched (the first defined wrapping group), then re-runs it alone for its own groups. */
+  _tryCombined(item) {
+    const combined = item.combined;
+    combined.lastIndex = this._position;
+    const match2 = combined.exec(this._source);
+    if (match2 == null) {
+      return null;
+    }
+    const indices = item.groupIndices;
+    for (let k = 0; k < indices.length; k++) {
+      if (match2[indices[k]] === void 0) {
+        continue;
+      }
+      const rule = item.rules[k];
+      return this._trySingle(rule);
+    }
+    return null;
+  }
+  _tryRule(rule) {
+    if (rule.when != null && !meets(rule.when, this._previous)) {
+      return null;
+    }
+    const regex = rule.regex;
+    regex.lastIndex = this._position;
+    const match2 = regex.exec(this._source);
+    if (match2 == null) {
+      return null;
+    }
+    if (match2[0].length > 0) {
+      return match2;
+    }
+    if (!rule.hasTransition || this._emptyTransitions >= MAX_EMPTY_TRANSITIONS) {
+      return null;
+    }
+    this._emptyTransitions++;
+    return match2;
+  }
+  _emitMatch({ rule, match: match2 }, syntax) {
+    const raw = match2[0];
+    if (rule.groupTypes == null) {
+      this._append(rule.type, raw, syntax);
+      return;
+    }
+    this._emitGroups(rule, match2, syntax);
+  }
+  /** Splits a match into one token per (top-level) capture group; uncovered characters become `text` tokens. */
+  _emitGroups(rule, match2, syntax) {
+    const indices = match2.indices;
+    const start = match2.index, end = start + match2[0].length, types = rule.groupTypes;
+    let cursor = start;
+    for (let i = 1; i < match2.length; i++) {
+      const range = indices[i];
+      if (range == null || range[0] < cursor || range[1] === range[0]) {
+        continue;
+      }
+      if (range[0] > cursor) {
+        const gap = this._source.slice(cursor, range[0]);
+        this._append(SyntaxTokenType.Text, gap, syntax);
+      }
+      const groupText = this._source.slice(range[0], range[1]);
+      const groupType = types[i - 1] ?? types[types.length - 1];
+      this._append(groupType, groupText, syntax);
+      cursor = range[1];
+    }
+    if (cursor < end) {
+      const rest = this._source.slice(cursor, end);
+      this._append(SyntaxTokenType.Text, rest, syntax);
+    }
+  }
+  _transition(rule, syntax) {
+    const stack = this._stack;
+    for (let i = 0; i < rule.pop && stack.length > 1; i++) {
+      stack.pop();
+    }
+    if (rule.next != null) {
+      this._top.state = rule.next;
+    }
+    if (rule.push != null) {
+      stack.push({ syntax, state: rule.push, until: null });
+    }
+    if (rule.embed == null) {
+      return;
+    }
+    const embedded = compileByName(rule.embed);
+    if (embedded == null) {
+      return;
+    }
+    stack.push({ syntax: embedded, state: embedded.start, until: rule.until });
+  }
+  /** Emits the pending unrecognized characters (if any) as a single `text` token. */
+  _flushText() {
+    if (this._emitted >= this._position) {
+      return;
+    }
+    const text = this._source.slice(this._emitted, this._position);
+    const syntax = this._top.syntax;
+    this._append(SyntaxTokenType.Text, text, syntax);
+  }
+  _resolveType(type, raw, syntax) {
+    if (!syntax.keywordSources.has(type)) {
+      return type;
+    }
+    const previousText = this._previous?.raw;
+    if (syntax.keywordExceptAfter.has(previousText)) {
+      return type;
+    }
+    return syntax.keywords.get(raw) ?? type;
+  }
+  _append(type, raw, syntax) {
+    const resolvedType = this._resolveType(type, raw, syntax);
+    const token = {
+      type: resolvedType,
+      raw,
+      text: raw,
+      index: this._emitted,
+      line: this._line,
+      column: this._column,
+      depth: this._stack.length - 1,
+      syntax: syntax.name
+    };
+    this._tokens.push(token);
+    this._advance(raw);
+    if (!syntax.insignificant.has(resolvedType)) {
+      this._previous = token;
+    }
+  }
+  /** Moves the emitted offset and the line/column counters past `raw`. */
+  _advance(raw) {
+    this._emitted += raw.length;
+    const lastNewline = raw.lastIndexOf("\n");
+    if (lastNewline < 0) {
+      this._column += raw.length;
+      return;
+    }
+    for (let i = 0; i <= lastNewline; i++) {
+      if (raw.charCodeAt(i) === 10) {
+        this._line++;
+      }
+    }
+    this._column = raw.length - lastNewline;
+  }
+};
+var PLAIN_TEXT_SYNTAX = { name: SyntaxTokenType.Text, lexical: { states: {} } };
+var Scanner = class {
+  /**
+   * Tokenizes `source`.
+   * @param source Source text.
+   * @param syntax A {@link Syntax} or the name/alias of a registered one (see {@link Syntaxes}); an unknown one yields a single `text` token.
+   * @returns The lossless, positioned token stream.
+   */
+  tokenize(source, syntax) {
+    const text = source ?? "";
+    const resolved = typeof syntax === "string" ? Syntaxes.get(syntax) : syntax;
+    const compiled = compileSyntax(resolved ?? PLAIN_TEXT_SYNTAX);
+    const run = new ScanRun(text, compiled);
+    return run.run();
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/highlight.js
+var DefaultHighlightClasses = Object.freeze({
+  "keyword": "code-keyword",
+  "preprocessor": "code-keyword",
+  "string": "code-string",
+  "regex": "code-string",
+  "number": "code-number",
+  "comment": "code-comment",
+  "doc-comment": "code-comment",
+  "tag": "code-tag",
+  "tagname": "code-tagname",
+  "attribute": "code-attribute"
+});
+var HTML_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+function htmlEncode(text) {
+  return text.replace(/[&<>"]/g, (c) => HTML_ESCAPES[c]);
+}
+var HighlightRenderer = class {
+  /**
+   * @param _classes Token type → CSS class mapping (defaults to {@link DefaultHighlightClasses}).
+   */
+  constructor(_classes = DefaultHighlightClasses) {
+    this._classes = _classes;
+  }
+  render(tree) {
+    let html = "";
+    for (let token of tree ?? []) {
+      html += this._renderToken(token);
+    }
+    return html;
+  }
+  _renderToken(token) {
+    const encoded = htmlEncode(token.raw ?? "");
+    const cssClass = this._classes[token.type];
+    if (cssClass == null) {
+      return encoded;
+    }
+    return `<span class="${cssClass}">${encoded}</span>`;
+  }
+};
+
 // packages/foundation/dist/esm/compile/markdown/parser.js
-function htmlEncode(input) {
+function htmlEncode2(input) {
   return (input ?? "").replace(/</g, "&lt;");
 }
 function extractReference(input) {
@@ -1606,6 +2186,72 @@ function extractReference(input) {
   }
   return input;
 }
+function splitUrlAndTitle(destination) {
+  if (NullChecker.isNullOrEmpty(destination)) {
+    return { url: destination };
+  }
+  const trimmed = destination.trim();
+  const arr = /^(\S*)\s+(?:"([^"]*)"|'([^']*)'|\(([^)]*)\))\s*$/.exec(trimmed);
+  if (arr == null) {
+    return { url: trimmed };
+  }
+  const title = arr[2] ?? arr[3] ?? arr[4];
+  return { url: arr[1], title };
+}
+function attributeEncode(input) {
+  return (input ?? "").replace(/&(?!(?:#\d+|#x[\da-fA-F]+|\w+);)/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function splitTableCells(row) {
+  let line = row.trim();
+  if (line.startsWith("|")) {
+    line = line.slice(1);
+  }
+  if (line.endsWith("|") && !line.endsWith("\\|")) {
+    line = line.slice(0, -1);
+  }
+  const cells = line.split(/(?<!\\)\|/);
+  return cells.map((c) => c.trim().replace(/\\\|/g, "|"));
+}
+function tableAlignment(delimiter) {
+  const left = delimiter.startsWith(":"), right = delimiter.endsWith(":");
+  if (left && right) {
+    return "center";
+  }
+  if (right) {
+    return "right";
+  }
+  return left ? "left" : null;
+}
+function indentationOf(line) {
+  const arr = /^ */.exec(line);
+  return arr[0].length;
+}
+function splitListItems(raw) {
+  const lines = raw.replace(/\t/g, "    ").split(/\r?\n/);
+  const items = [];
+  for (let line of lines) {
+    const current = items[items.length - 1];
+    const marker = LISTMARKER.exec(line);
+    if (marker != null && (current == null || marker[1].length < current.indent)) {
+      const contentIndent = marker[0].length;
+      const firstLine = line.slice(contentIndent);
+      items.push({ indent: contentIndent, lines: [firstLine] });
+      continue;
+    }
+    if (current == null) {
+      continue;
+    }
+    const dedent = Math.min(current.indent, indentationOf(line));
+    const content = line.slice(dedent);
+    current.lines.push(content);
+  }
+  return items.map((i) => i.lines.join("\n").replace(/\s+$/, ""));
+}
+function decodeCode(code) {
+  return (code ?? "").replace(/&lt;/g, "<");
+}
+var scanner = new Scanner();
+var MARKUP_SYNTAX = "markup";
 function regexMatchIndex(arr) {
   return arr?.index || void 0;
 }
@@ -1632,27 +2278,36 @@ function match(input, pattern, fn) {
   return null;
 }
 var COMMENT = /(<!--)([\s\S]*?)(-->|$)/;
-var HR = /^ {0,3}(={3,}|_{3,}|-{3,})(\r?\n|$)/;
+var HR = /^ {0,3}(={3,}|(?:_[ \t]*){3,}|(?:-[ \t]*){3,}|(?:\*[ \t]*){3,})(\r?\n|$)/;
 var HEADING = /^ {0,3}(#{1,6})\s+([^\n]+)(\r?\n|$)+/;
 var HEADING1 = /^ {0,3}([^\n]+)(\r?\n=+(\r?\n|$))+/;
 var HEADING2 = /^ {0,3}([^\n]+)(\r?\n-+(\r?\n|$))+/;
 var CODEBLOCK = /^ {4,}.+(\r?\n {4,}.+)*(\r?\n|$)+/;
 var FENCES = /^ {0,3}``` *([^\n]*)\r?\n(([\s\S](?!\r?\n {0,3}```))*.(\r?\n)+) {0,3}```(\r?\n|$)+/;
 var BLOCKQUOTE = /^ {0,3}> *([^\n]+)(\r?\n {0,3}> *([^\n]*))*(\r?\n|$)+/;
-var ULIST = /^( {0,3}([-+]).*\r?\n|$)((?!(?: {0,3}(?:\d+[.\)]|\r?\n\S))).*(\r?\n|$))*/;
-var OLIST = /^( {0,3}(\d+[.\)]).*\r?\n|$)((?!(?: {0,3}(?:[+-]|\r?\n\S))).*(\r?\n|$))*/;
-var LISTITEM = /^(?:[-+*]|\d+[.\)])/m;
-var PARAGRAPH = /^(?! {4,})(.+(\n(?! {0,3}```)(?! {0,3}([-+]|\d+[.\)]))(?! {4,})(?! {0,3}>).+)*)/;
+var ULIST = /^( {0,3}([-+]|\*(?=[ \t])).*(\r?\n|$))((?!(?: ?\d+[.\)]|\r?\n\S)).*(\r?\n|$))*/;
+var OLIST = /^( {0,3}(\d+[.\)]).*(\r?\n|$))((?!(?: {0,2}(?:[-+]|\*[ \t])|\r?\n\S)).*(\r?\n|$))*/;
+var LISTMARKER = /^( *)([-+*]|\d+[.\)])([ \t]+|$)/;
+var TASK = /^\[([ xX])\][ \t]+/;
+var PARAGRAPH = /^(?! {4,})(?=[ \t]*\S)(.+(\n(?![ \t]*(?:\n|$))(?! {0,3}```)(?! {0,3}([-+]|\*[ \t]|\d+[.\)]))(?! {0,3}#{1,6}[ \t])(?! {4,})(?! {0,3}>).+)*)/;
 var REF = /^ {0,3}(!?)\[([^\]]+)\]: +(\S+)(?: +['"\(](.+)['"\)])?(\r?\n|$)+/;
-var IMAGE_OR_LINK = /!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?(\[[^\[\]]*\]|\([^\(\)]*\))?/;
+var IMAGE_OR_LINK = /(?<!\\)!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?(\[[^\[\]]*\]|\([^\(\)]*\))?/;
 var EMPHASIZED_LINK = /(\*\*?|__?)(\[[^\]]*]\([^\)]+\))\1/;
 var CODE = /(?:(?<!\\)`)(.+?)(?:(?<!\\)`)/;
-var EMPHASIZE = /(\*\*?|__?)((?!\1\s?)(?:(?!\1)[\S\s])*[^\s])\1/;
-var STRIKE = /(~~?|__?)(?!\1\s?)([^\s][\s\S]*?(?!\1)[^\s])\1/;
+var EMPHASIZE = /(\*\*?)((?!\1\s?)(?:(?!\1)[\S\s])*[^\s])\1|(?<![A-Za-z0-9])(__?)((?!\3\s?)(?:(?!\3)[\S\s])*[^\s])\3(?![A-Za-z0-9])/;
+var STRIKE = /(~~?)(?!\1\s?)([^\s][\s\S]*?(?!\1)[^\s])\1/;
 var QUOTE = /(:")(?!":\s?)([^\s][\s\S]*?(?!":)[^\s])":/;
 var SPACE = /^\s+/;
-var LINEBREAK = / {2,}\r?\n/;
+var BLOCK_SPACE = /^(?:[ \t]*\r?\n)+|^\s+/;
+var LINEBREAK = /(?: {2,}|\\)\r?\n/;
 var TEXT = /^[^\r\n]+/;
+var ESCAPE = /\\(&lt;|[!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~])/;
+var ESCAPED_HTML = { "<": "&lt;", "&lt;": "&lt;", "&": "&amp;" };
+var AUTOLINK = /(?:<|&lt;)((?:https?|ftp|mailto):[^\s<>]+|[\w.+-]+@[\w-]+(?:\.[\w-]+)+)>/;
+var BARE_URL = /(?<![\w\/\\(\[<"'=;&@])(?:https?:\/\/|www\.)[^\s<>]*[^\s<>.,:;"'!?)\]*_~]/;
+var FOOTNOTE_REF = /\[\^([^\]\s]+)\]/;
+var FOOTNOTE_DEF = /^ {0,3}\[\^([^\]\s]+)\]: *([^\r\n]*(?:\r?\n {2,}[^\r\n]+)*)(\r?\n|$)+/;
+var TABLE = /^ {0,3}(\|?[^\r\n]*\|[^\r\n]*)\r?\n {0,3}(\|? *:?-+:? *(?:\| *:?-+:? *)*\|?) *(?:\r?\n|$)((?:(?! {0,3}(?:\r?\n|$))[^\r\n]*\|[^\r\n]*(?:\r?\n|$))*)/;
 var MARKDOWN_TYPES;
 (function(MARKDOWN_TYPES2) {
   MARKDOWN_TYPES2["Html"] = "html";
@@ -1677,6 +2332,11 @@ var MARKDOWN_TYPES;
   MARKDOWN_TYPES2["UnorderedList"] = "ul";
   MARKDOWN_TYPES2["ListItem"] = "listitem";
   MARKDOWN_TYPES2["Reference"] = "ref";
+  MARKDOWN_TYPES2["Table"] = "table";
+  MARKDOWN_TYPES2["TableRow"] = "tr";
+  MARKDOWN_TYPES2["TableCell"] = "td";
+  MARKDOWN_TYPES2["FootnoteReference"] = "fnref";
+  MARKDOWN_TYPES2["FootnoteDefinition"] = "fndef";
 })(MARKDOWN_TYPES || (MARKDOWN_TYPES = {}));
 var MARKDOWN_RULES;
 (function(MARKDOWN_RULES2) {
@@ -1699,6 +2359,12 @@ var MARKDOWN_RULES;
   MARKDOWN_RULES2[MARKDOWN_RULES2["Quote"] = 16] = "Quote";
   MARKDOWN_RULES2[MARKDOWN_RULES2["Code"] = 17] = "Code";
   MARKDOWN_RULES2[MARKDOWN_RULES2["LineBreak"] = 18] = "LineBreak";
+  MARKDOWN_RULES2[MARKDOWN_RULES2["FootnoteDefinition"] = 19] = "FootnoteDefinition";
+  MARKDOWN_RULES2[MARKDOWN_RULES2["Table"] = 20] = "Table";
+  MARKDOWN_RULES2[MARKDOWN_RULES2["Escape"] = 21] = "Escape";
+  MARKDOWN_RULES2[MARKDOWN_RULES2["AutoLink"] = 22] = "AutoLink";
+  MARKDOWN_RULES2[MARKDOWN_RULES2["FootnoteReference"] = 23] = "FootnoteReference";
+  MARKDOWN_RULES2[MARKDOWN_RULES2["BareUrl"] = 24] = "BareUrl";
   MARKDOWN_RULES2[MARKDOWN_RULES2["Text"] = 254] = "Text";
   MARKDOWN_RULES2[MARKDOWN_RULES2["Space"] = 255] = "Space";
 })(MARKDOWN_RULES || (MARKDOWN_RULES = {}));
@@ -1715,7 +2381,7 @@ function getGrammar(extra = []) {
           text: arr[2]
         }];
         if (index > 0) {
-          const left = input.substr(0, index), tokens = lexer.tokenize(left, blockRules);
+          const left = input.substr(0, index), tokens = lexer.tokenize(left, topRules);
           Array.prototype.unshift.apply(output, tokens);
         }
         return output;
@@ -1736,6 +2402,20 @@ function getGrammar(extra = []) {
           title
         }];
       })
+    },
+    // footnote definition (rendered at the end of the document, see HtmlRenderer)
+    [MARKDOWN_RULES.FootnoteDefinition]: {
+      exec: (input, lexer) => match(input, FOOTNOTE_DEF, (arr) => {
+        const raw = arr[0], id = normalizeReference(arr[1]), text = arr[2].replace(/\r?\n {2,}/g, " ");
+        return [{
+          type: MARKDOWN_TYPES.FootnoteDefinition,
+          index: regexMatchIndex(arr),
+          raw,
+          text,
+          id,
+          tokens: lexer.tokenize(text, inlineRules)
+        }];
+      })
     }
   };
   const blockExtra = [], inlineExtra = [], codeExtra = {};
@@ -1798,7 +2478,9 @@ function getGrammar(extra = []) {
     // link/image
     [MARKDOWN_RULES.ImageOrLink]: {
       exec: (input, lexer) => inlineMatch(input, IMAGE_OR_LINK, lexer, (arr) => {
-        const index = regexMatchIndex(arr), raw = arr[0], image = raw.charAt(0) === "!", text = arr[1], url = extractUrl(arr[2]), ref = normalizeReference(extractReference(arr[2]) ?? text);
+        const index = regexMatchIndex(arr), raw = arr[0], image = raw.charAt(0) === "!", text = arr[1], destination = extractUrl(arr[2]), reference = extractReference(arr[2]) ?? text, ref = normalizeReference(reference);
+        const { url, title } = splitUrlAndTitle(destination);
+        const tokens = lexer.tokenize(text, inlineRules);
         if (image) {
           return [{
             index,
@@ -1806,26 +2488,83 @@ function getGrammar(extra = []) {
             raw,
             text,
             src: url,
+            title,
             ref,
-            tokens: lexer.tokenize(text, inlineRules)
-          }];
-        } else {
-          return [{
-            index,
-            type: url ? MARKDOWN_TYPES.Link : MARKDOWN_TYPES.LinkLike,
-            raw,
-            text,
-            href: url,
-            ref,
-            tokens: lexer.tokenize(text, inlineRules)
+            tokens
           }];
         }
+        return [{
+          index,
+          type: url ? MARKDOWN_TYPES.Link : MARKDOWN_TYPES.LinkLike,
+          raw,
+          text,
+          href: url,
+          title,
+          ref,
+          tokens
+        }];
+      })
+    },
+    // backslash escapes: the escaped character is plain text
+    [MARKDOWN_RULES.Escape]: {
+      exec: (input, lexer) => inlineMatch(input, ESCAPE, lexer, (arr) => {
+        const text = ESCAPED_HTML[arr[1]] ?? arr[1];
+        return [{
+          index: regexMatchIndex(arr),
+          raw: arr[0],
+          text,
+          type: MARKDOWN_TYPES.Text
+        }];
+      })
+    },
+    // <https://…>, <user@domain>
+    [MARKDOWN_RULES.AutoLink]: {
+      exec: (input, lexer) => inlineMatch(input, AUTOLINK, lexer, (arr) => {
+        const text = arr[1];
+        const isEmail = !/^[a-z]+:/i.test(text);
+        const href = isEmail ? "mailto:" + text : text;
+        return [{
+          index: regexMatchIndex(arr),
+          raw: arr[0],
+          text,
+          href,
+          type: MARKDOWN_TYPES.Link,
+          tokens: [{ type: MARKDOWN_TYPES.Text, raw: text, text }]
+        }];
+      })
+    },
+    // bare https://… or www.… urls
+    [MARKDOWN_RULES.BareUrl]: {
+      exec: (input, lexer) => inlineMatch(input, BARE_URL, lexer, (arr) => {
+        const text = arr[0];
+        const href = /^www\./i.test(text) ? "http://" + text : text;
+        return [{
+          index: regexMatchIndex(arr),
+          raw: text,
+          text,
+          href,
+          type: MARKDOWN_TYPES.Link,
+          tokens: [{ type: MARKDOWN_TYPES.Text, raw: text, text }]
+        }];
+      })
+    },
+    // [^footnote]
+    [MARKDOWN_RULES.FootnoteReference]: {
+      exec: (input, lexer) => inlineMatch(input, FOOTNOTE_REF, lexer, (arr) => {
+        const id = normalizeReference(arr[1]);
+        return [{
+          index: regexMatchIndex(arr),
+          raw: arr[0],
+          text: arr[1],
+          id,
+          type: MARKDOWN_TYPES.FootnoteReference
+        }];
       })
     },
     // code
     [MARKDOWN_RULES.Code]: {
       exec: (input, lexer) => inlineMatch(input, CODE, lexer, (arr) => {
-        const text = htmlEncode(arr[1]);
+        const text = htmlEncode2(arr[1]);
         return [{
           type: MARKDOWN_TYPES.Code,
           raw: arr[0],
@@ -1853,10 +2592,11 @@ function getGrammar(extra = []) {
     // italic/bold
     [MARKDOWN_RULES.Emphasize]: {
       exec: (input, lexer) => inlineMatch(input, EMPHASIZE, lexer, (arr) => {
-        if (arr.length < 3 || NullChecker.isNullOrEmpty(arr[2])) {
+        const marker = arr[1] ?? arr[3], text = arr[2] ?? arr[4];
+        if (NullChecker.isNullOrEmpty(text)) {
           return null;
         }
-        const type = arr[1].length > 1 ? MARKDOWN_TYPES.Bold : MARKDOWN_TYPES.Italic, text = arr[2];
+        const type = marker.length > 1 ? MARKDOWN_TYPES.Bold : MARKDOWN_TYPES.Italic;
         return [{
           index: regexMatchIndex(arr),
           type,
@@ -1932,7 +2672,19 @@ function getGrammar(extra = []) {
     inPlaceInlineExec(input, output, lexer);
     return output;
   };
-  const inlineRules = Object.values(inline);
+  const inlineRules = [
+    inline[MARKDOWN_RULES.FootnoteReference],
+    inline[MARKDOWN_RULES.EmphasizedLink],
+    inline[MARKDOWN_RULES.ImageOrLink],
+    inline[MARKDOWN_RULES.Escape],
+    inline[MARKDOWN_RULES.AutoLink],
+    inline[MARKDOWN_RULES.Emphasize],
+    inline[MARKDOWN_RULES.StrikeThrough],
+    inline[MARKDOWN_RULES.Quote],
+    inline[MARKDOWN_RULES.Code],
+    inline[MARKDOWN_RULES.LineBreak],
+    inline[MARKDOWN_RULES.BareUrl]
+  ];
   Array.prototype.push.apply(inlineRules, inlineExtra);
   inlineRules.push(inlinelowpriority[MARKDOWN_RULES.Text], inlinelowpriority[MARKDOWN_RULES.Space]);
   const getLangGrammar = (lang) => {
@@ -1947,7 +2699,10 @@ function getGrammar(extra = []) {
     // paragraph
     [MARKDOWN_RULES.Paragraph]: {
       exec: (input, lexer) => match(input, PARAGRAPH, (arr) => {
-        const raw = arr[0], text = raw;
+        const raw = arr[0], text = raw.replace(/^[ \t]+/gm, "");
+        if (text.trim().length === 0) {
+          return null;
+        }
         return [{
           type: MARKDOWN_TYPES.Paragraph,
           raw,
@@ -1957,12 +2712,56 @@ function getGrammar(extra = []) {
         }];
       })
     },
-    // sparse lines
-    [MARKDOWN_RULES.Space]: inlinelowpriority[MARKDOWN_RULES.Space]
+    // blank lines (the indentation of the following line is kept: it matters to indented code blocks)
+    [MARKDOWN_RULES.Space]: {
+      exec: (input) => match(input, BLOCK_SPACE, (arr) => {
+        const raw = arr[0];
+        return [{
+          type: MARKDOWN_TYPES.Space,
+          raw,
+          text: raw
+        }];
+      })
+    }
   };
   const tokenizeListItem = (text, lexer) => {
-    const grammar = !/^ {0,3}(`{3,}|$|>|[+-]\s|\d+[.\)])/m.test(text) ? inlineRules : blockRules;
-    return lexer.tokenize(text, grammar);
+    const needsBlocks = /^ {0,3}(`{3,}|$|>|[-+*]\s|\d+[.\)]|#{1,6}\s|\|)/m.test(text);
+    if (!needsBlocks) {
+      return lexer.tokenize(text, inlineRules);
+    }
+    const tokens = lexer.tokenize(text, blockRules);
+    const first = tokens[0];
+    const tight = !/\n[ \t]*\n/.test(text);
+    if (!tight || first?.type !== MARKDOWN_TYPES.Paragraph) {
+      return tokens;
+    }
+    const inner = first.tokens ?? [];
+    const rest = tokens.slice(1);
+    return inner.concat(rest);
+  };
+  const tokenizeListItems = (raw, lexer) => {
+    const items = splitListItems(raw);
+    const nonEmpty = items.filter((i) => !NullChecker.isNullOrEmpty(i));
+    return nonEmpty.map((item) => {
+      const task = TASK.exec(item);
+      const text = task ? item.slice(task[0].length) : item;
+      const tokens = tokenizeListItem(text, lexer);
+      if (task == null) {
+        return { type: MARKDOWN_TYPES.ListItem, raw: item, text, tokens };
+      }
+      const checked = task[1] !== " ";
+      return { type: MARKDOWN_TYPES.ListItem, raw: item, text, tokens, task: true, checked };
+    });
+  };
+  const tokenizeTableRow = (cells, align, header, lexer) => {
+    const tokens = align.map((cellAlign, i) => {
+      const text = cells[i] ?? "";
+      const cellTokens = lexer.tokenize(text, inlineRules);
+      return { type: MARKDOWN_TYPES.TableCell, raw: text, text, header, align: cellAlign, tokens: cellTokens };
+    });
+    const raw = cells.join(" | ");
+    const row = { type: MARKDOWN_TYPES.TableRow, raw, text: raw, header, tokens };
+    return row;
   };
   const block = {
     // hr
@@ -1979,7 +2778,7 @@ function getGrammar(extra = []) {
     // headings
     [MARKDOWN_RULES.Heading]: {
       exec: (input, lexer) => match(input, HEADING, (arr) => {
-        const text = arr[2];
+        const text = arr[2].replace(/[ \t]+#+[ \t]*$/, "");
         return [{
           type: MARKDOWN_TYPES.Heading,
           raw: arr[0],
@@ -2019,79 +2818,104 @@ function getGrammar(extra = []) {
     // codeblock
     [MARKDOWN_RULES.CodeBlock]: {
       exec: (input, lexer) => match(input, CODEBLOCK, (arr) => {
-        const raw = arr[0], text = htmlEncode(raw);
+        const raw = arr[0], code = raw.replace(/^ {4}/gm, "").replace(/\s+$/, ""), text = htmlEncode2(code);
+        if (code.length === 0) {
+          return null;
+        }
         return [{
           type: MARKDOWN_TYPES.CodeBlock,
           raw,
           text,
-          tokens: lexer.tokenize(text, [])
+          tokens: lexer.tokenize(text, getLangGrammar(""))
         }];
       })
     },
     // codeblock
     [MARKDOWN_RULES.Fences]: {
       exec: (input, lexer) => match(input, FENCES, (arr) => {
-        const text = htmlEncode(arr[2]), lang = arr[1]?.toLowerCase();
+        const info = (arr[1] ?? "").trim(), words = info.split(/\s+/), lang = words[0].toLowerCase();
+        const syntax = lang in codeExtra ? null : Syntaxes.get(lang);
+        if (syntax == null) {
+          const text = htmlEncode2(arr[2]);
+          return [{
+            type: MARKDOWN_TYPES.CodeBlock,
+            raw: arr[0],
+            text,
+            lang,
+            tokens: lexer.tokenize(text, getLangGrammar(lang))
+          }];
+        }
+        const code = decodeCode(arr[2]);
+        const tokens = scanner.tokenize(code, syntax);
         return [{
           type: MARKDOWN_TYPES.CodeBlock,
           raw: arr[0],
-          text,
+          text: code,
           lang,
-          tokens: lexer.tokenize(text, getLangGrammar(lang))
+          syntax: syntax.name,
+          highlighted: true,
+          tokens
         }];
       })
     },
     // blockquote
     [MARKDOWN_RULES.BlockQuote]: {
       exec: (input, lexer) => match(input, BLOCKQUOTE, (arr) => {
-        const raw = arr[0], text = raw.replace(/^ {0,3}> */gm, "");
+        const raw = arr[0], text = raw.replace(/^ {0,3}> ?/gm, "");
         return [{
           type: MARKDOWN_TYPES.BlockQuote,
           raw,
           text,
-          // recursion
-          tokens: lexer.tokenize(text, [
-            lowpriority[MARKDOWN_RULES.Paragraph],
-            lowpriority[MARKDOWN_RULES.Space]
-          ])
+          // recursion: any block (nested quotes, lists, code…)
+          tokens: lexer.tokenize(text, blockRules)
         }];
       })
     },
     // lists
     [MARKDOWN_RULES.OrderedList]: {
       exec: (input, lexer) => match(input, OLIST, (arr) => {
-        const raw = arr[0], items = raw.replace(/^ {0,3}/gm, "").split(LISTITEM).filter((i) => !NullChecker.isNullOrEmpty(i)).map((i) => i.trim());
+        const raw = arr[0], startMatch = /\d+/.exec(raw), start = parseInt(startMatch[0]), tokens = tokenizeListItems(raw, lexer);
         return [{
           type: MARKDOWN_TYPES.OrderedList,
-          start: parseInt(/\d/.exec(arr[0])[0]),
+          start,
           raw,
           text: raw,
-          tokens: items.map((i) => {
-            return {
-              type: MARKDOWN_TYPES.ListItem,
-              raw: i,
-              text: i,
-              tokens: tokenizeListItem(i, lexer)
-            };
-          })
+          tokens
         }];
       })
     },
     [MARKDOWN_RULES.UnorderedList]: {
       exec: (input, lexer) => match(input, ULIST, (arr) => {
-        const raw = arr[0], items = raw.replace(/^ {0,3}/gm, "").split(LISTITEM).filter((i) => !NullChecker.isNullOrEmpty(i)).map((i) => i.trim());
+        const raw = arr[0], tokens = tokenizeListItems(raw, lexer);
         return [{
           type: MARKDOWN_TYPES.UnorderedList,
           raw,
           text: raw,
-          tokens: items.map((i) => {
-            return {
-              type: MARKDOWN_TYPES.ListItem,
-              raw: i,
-              text: i,
-              tokens: tokenizeListItem(i, lexer)
-            };
-          })
+          tokens
+        }];
+      })
+    },
+    // GFM tables
+    [MARKDOWN_RULES.Table]: {
+      exec: (input, lexer) => match(input, TABLE, (arr) => {
+        const headers = splitTableCells(arr[1]), delimiters = splitTableCells(arr[2]);
+        if (headers.length !== delimiters.length) {
+          return null;
+        }
+        const align = delimiters.map(tableAlignment);
+        const bodyLines = arr[3].split(/\r?\n/).filter((l) => l.trim().length > 0);
+        const headerRow = tokenizeTableRow(headers, align, true, lexer);
+        const bodyRows = bodyLines.map((line) => {
+          const cells = splitTableCells(line);
+          return tokenizeTableRow(cells, align, false, lexer);
+        });
+        const rows = [headerRow].concat(bodyRows);
+        return [{
+          type: MARKDOWN_TYPES.Table,
+          raw: arr[0],
+          text: arr[0],
+          align,
+          tokens: rows
         }];
       })
     }
@@ -2099,23 +2923,43 @@ function getGrammar(extra = []) {
   const blockRules = Object.values(block);
   Array.prototype.push.apply(blockRules, blockExtra);
   blockRules.push(lowpriority[MARKDOWN_RULES.Paragraph], lowpriority[MARKDOWN_RULES.Space]);
-  return [
+  const topRules = [
     // comment first
     inert[MARKDOWN_RULES.Comment],
+    // (before references: `[^id]: …` would match them too)
+    inert[MARKDOWN_RULES.FootnoteDefinition],
     inert[MARKDOWN_RULES.Reference]
   ].concat(
     // block rules contain recursive inline rules (at least)
     blockRules
   );
+  return topRules;
 }
 var CARRIAGE_RETURN_PLACEHOLDER = "\0";
 var TRIM_INSIDE = /[ \r\n]*\0+[ \r\n]*/g;
 function trim(input) {
   return input?.replace(TRIM_INSIDE, "\n").trim();
 }
+function titleAttribute(title) {
+  if (NullChecker.isNullOrEmpty(title)) {
+    return "";
+  }
+  const encoded = attributeEncode(title);
+  return ` title="${encoded}"`;
+}
+function alignAttribute(align) {
+  if (align == null) {
+    return "";
+  }
+  return ` style="text-align: ${align}"`;
+}
 var HtmlRenderer = class {
   constructor(_extraItemRender = (token, __) => token?.text || "") {
     this._extraItemRender = _extraItemRender;
+    this.#references = [];
+    this.#footnotes = /* @__PURE__ */ new Map();
+    this.#footnoteOrder = [];
+    this.#highlighter = new HighlightRenderer();
     this._renderContent = (token) => {
       const children = token.tokens;
       if (NullChecker.isNullOrEmpty(children)) {
@@ -2124,10 +2968,143 @@ var HtmlRenderer = class {
       return this._render(children);
     };
   }
+  /** Link/image reference definitions of the whole document (they may be referenced from any depth). */
+  #references;
+  /** Footnote definitions by id, and the order of their first reference (their numbering). */
+  #footnotes;
+  #footnoteOrder;
+  #highlighter;
+  /** Collects the reference and footnote definitions of the whole tree. */
+  _collectDefinitions(tree) {
+    for (let token of tree ?? []) {
+      if (token?.type === MARKDOWN_TYPES.Reference) {
+        this.#references.push(token);
+      }
+      if (token?.type === MARKDOWN_TYPES.FootnoteDefinition && !this.#footnotes.has(token["id"])) {
+        this.#footnotes.set(token["id"], token);
+      }
+      this._collectDefinitions(token?.tokens);
+    }
+  }
+  _findReference(ref, image) {
+    if (NullChecker.isNullOrEmpty(ref)) {
+      return void 0;
+    }
+    const key = ref.toLowerCase();
+    return this.#references.find((t) => t.image === true === image && t.id?.toLowerCase() === key);
+  }
+  _renderCodeBlock(token) {
+    const R = CARRIAGE_RETURN_PLACEHOLDER;
+    const lang = token["lang"];
+    if (token["highlighted"] !== true) {
+      const classAttribute = lang ? ' class="' + lang + '"' : "";
+      const content = this._renderContent(token);
+      return `<pre>${R}<code${classAttribute}>${content}</code>${R}</pre>${R}`;
+    }
+    const classes = [lang, "code-highlighted"];
+    if (token["syntax"] === MARKUP_SYNTAX) {
+      classes.push("code-markup");
+    }
+    const classList = attributeEncode(classes.join(" "));
+    const highlighted = this.#highlighter.render(token.tokens);
+    return `<pre>${R}<code class="${classList}">${highlighted}</code>${R}</pre>${R}`;
+  }
+  _renderImage(token) {
+    let src = token.src, title = token.title;
+    if (!src) {
+      const reference = this._findReference(token.ref, true);
+      src = reference?.url;
+      title = reference?.title;
+    }
+    if (!src) {
+      const content = this._renderContent(token);
+      return `![${content}]`;
+    }
+    const titleAttr = titleAttribute(title);
+    return `<img src="${src}" alt="${token.text}"${titleAttr} />`;
+  }
+  _renderLink(token) {
+    let href = token.href, title = token.title;
+    if (!href) {
+      const reference = this._findReference(token.ref, false);
+      href = reference?.url;
+      title = reference?.title;
+    }
+    const content = this._renderContent(token);
+    if (!href) {
+      return `[${content}]`;
+    }
+    const titleAttr = titleAttribute(title);
+    return `<a href="${href}"${titleAttr}>${content}</a>`;
+  }
+  _renderListItem(token) {
+    const R = CARRIAGE_RETURN_PLACEHOLDER;
+    const content = this._renderContent(token);
+    if (token["task"] !== true) {
+      return `	<li>${content}</li>${R}`;
+    }
+    const checked = token["checked"] === true ? " checked" : "";
+    return `	<li class="task-list-item"><input type="checkbox" disabled${checked} /> ${content}</li>${R}`;
+  }
+  _renderTableRow(row) {
+    const R = CARRIAGE_RETURN_PLACEHOLDER;
+    let cells = "";
+    for (let cell of row.tokens ?? []) {
+      const tag = cell["header"] === true ? "th" : "td";
+      const align = alignAttribute(cell["align"]);
+      const content = this._renderContent(cell);
+      cells += `<${tag}${align}>${content}</${tag}>`;
+    }
+    return `<tr>${cells}</tr>${R}`;
+  }
+  _renderTable(token) {
+    const R = CARRIAGE_RETURN_PLACEHOLDER;
+    const rows = token.tokens ?? [];
+    const headerRows = rows.filter((r) => r["header"] === true);
+    const bodyRows = rows.filter((r) => r["header"] !== true);
+    const head = headerRows.map((r) => this._renderTableRow(r)).join("");
+    let html = `<table>${R}<thead>${R}${head}</thead>${R}`;
+    if (bodyRows.length > 0) {
+      const body = bodyRows.map((r) => this._renderTableRow(r)).join("");
+      html += `<tbody>${R}${body}</tbody>${R}`;
+    }
+    return html + `</table>${R}`;
+  }
+  _renderFootnoteReference(token) {
+    const id = token["id"];
+    if (!this.#footnotes.has(id)) {
+      return `[^${token.text}]`;
+    }
+    const order = this.#footnoteOrder;
+    const isFirst = !order.includes(id);
+    if (isFirst) {
+      order.push(id);
+    }
+    const number = order.indexOf(id) + 1;
+    const anchorId = isFirst ? ` id="fnref-${id}"` : "";
+    return `<sup class="footnote-ref"><a href="#fn-${id}"${anchorId}>${number}</a></sup>`;
+  }
+  /** Renders the referenced footnotes, in order of first reference (definitions may reference further footnotes). */
+  _renderFootnotes() {
+    const order = this.#footnoteOrder;
+    if (order.length === 0) {
+      return "";
+    }
+    const R = CARRIAGE_RETURN_PLACEHOLDER;
+    let items = "";
+    for (let i = 0; i < order.length; i++) {
+      const id = order[i];
+      const definition = this.#footnotes.get(id);
+      const content = this._renderContent(definition);
+      items += `<li id="fn-${id}">${content} <a href="#fnref-${id}" class="footnote-backref">&#8617;</a></li>${R}`;
+    }
+    return `<section class="footnotes">${R}<ol>${R}${items}</ol>${R}</section>${R}`;
+  }
   _rendeItem(token, allTokens) {
     const r = this._renderContent, R = CARRIAGE_RETURN_PLACEHOLDER;
     switch (token?.type) {
       case MARKDOWN_TYPES.Reference:
+      case MARKDOWN_TYPES.FootnoteDefinition:
         return "";
       case MARKDOWN_TYPES.Html:
         return token.raw;
@@ -2137,8 +3114,7 @@ ${r(token)}</blockquote>${R}`;
       case MARKDOWN_TYPES.Bold:
         return `<b>${r(token)}</b>`;
       case MARKDOWN_TYPES.CodeBlock:
-        const lang = token["lang"];
-        return `<pre>${R}<code${lang ? ' class="' + lang + '"' : ""}>${r(token)}</code>${R}</pre>${R}`;
+        return this._renderCodeBlock(token);
       case MARKDOWN_TYPES.Code:
         return `<code>${r(token)}</code>`;
       case MARKDOWN_TYPES.HorizontalRule:
@@ -2148,17 +3124,7 @@ ${r(token)}</blockquote>${R}`;
         return `<h${hlevel} id="${hid}">${r(token)}</h${hlevel}>${R}`;
       case MARKDOWN_TYPES.Image:
       case MARKDOWN_TYPES.ImageLike:
-        const itk = token;
-        let isrc = itk.src, ititle = "";
-        const alt = itk.text, iref = itk.ref;
-        if (!isrc && iref) {
-          const ireftk = allTokens.find((t) => t.type === MARKDOWN_TYPES.Reference && t["image"] === true && t["id"]?.toLowerCase() === iref.toLowerCase());
-          if (ireftk) {
-            isrc = ireftk.url;
-            ititle = ireftk.title ?? "";
-          }
-        }
-        return isrc ? `<img src="${isrc}" alt="${alt}"${ititle ? ' title="' + ititle + '"' : ""} />` : `![${r(token)}]`;
+        return this._renderImage(token);
       case MARKDOWN_TYPES.Italic:
         return `<i>${r(token)}</i>`;
       case MARKDOWN_TYPES.StrikeThrough:
@@ -2174,20 +3140,14 @@ ${r(token)}</ol>${R}`;
         return `<ul>
 ${r(token)}</ul>${R}`;
       case MARKDOWN_TYPES.ListItem:
-        return `	<li>${r(token)}</li>${R}`;
+        return this._renderListItem(token);
       case MARKDOWN_TYPES.Link:
       case MARKDOWN_TYPES.LinkLike:
-        const atk = token;
-        let ahref = atk.href, atitle = "";
-        const aref = atk.ref;
-        if (!ahref && aref) {
-          const areftk = allTokens.find((t) => t.type === MARKDOWN_TYPES.Reference && t["image"] !== true && t["id"]?.toLowerCase() === aref.toLowerCase());
-          if (areftk) {
-            ahref = areftk.url;
-            atitle = areftk.title ?? "";
-          }
-        }
-        return ahref ? `<a href="${ahref}"${atitle ? ' title="' + atitle + '"' : ""}>${r(token)}</a>` : `[${r(token)}]`;
+        return this._renderLink(token);
+      case MARKDOWN_TYPES.Table:
+        return this._renderTable(token);
+      case MARKDOWN_TYPES.FootnoteReference:
+        return this._renderFootnoteReference(token);
       case MARKDOWN_TYPES.Paragraph:
         return `<p>${r(token)}</p>${R}`;
       case MARKDOWN_TYPES.Text:
@@ -2204,7 +3164,13 @@ ${r(token)}</ul>${R}`;
     return acc;
   }
   render(tree) {
-    return trim(this._render(tree));
+    this.#references = [];
+    this.#footnotes.clear();
+    this.#footnoteOrder = [];
+    this._collectDefinitions(tree);
+    const body = this._render(tree);
+    const footnotes = this._renderFootnotes();
+    return trim(body + footnotes);
   }
 };
 var TokenRenderer = class {
@@ -2244,13 +3210,582 @@ var Parser2 = class extends Parser {
     return JSON.parse(json);
   }
   parse(input, grammarOrRenderer = getGrammar(), renderer = new HtmlRenderer()) {
+    const normalized = (input ?? "").replace(/\r\n?/g, "\n");
     if (isRenderer(grammarOrRenderer)) {
-      return super.parse(input, getGrammar(), grammarOrRenderer);
-    } else {
-      return super.parse(input, grammarOrRenderer, renderer);
+      const grammar = getGrammar();
+      return super.parse(normalized, grammar, grammarOrRenderer);
     }
+    return super.parse(normalized, grammarOrRenderer, renderer);
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/vocabularies/javascript.js
+var DIVISION_AFTER_TYPES = ["identifier", "number", "string", "regex"];
+var DIVISION_AFTER_TEXTS = [")", "]", "}", "this", "super", "null", "undefined", "true", "false", "++", "--"];
+var JAVASCRIPT_KEYWORDS = [
+  // JavaScript
+  "async",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "from",
+  "function",
+  "get",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "null",
+  "of",
+  "return",
+  "set",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "undefined",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  // TypeScript
+  "abstract",
+  "accessor",
+  "any",
+  "as",
+  "asserts",
+  "bigint",
+  "boolean",
+  "declare",
+  "implements",
+  "infer",
+  "interface",
+  "is",
+  "keyof",
+  "module",
+  "namespace",
+  "never",
+  "number",
+  "object",
+  "override",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "satisfies",
+  "string",
+  "symbol",
+  "type",
+  "unique",
+  "unknown"
+];
+var CODE_RULES = [
+  { match: String.raw`/\*\*(?!/)[\s\S]*?(?:\*/|$)`, type: "doc-comment" },
+  { match: String.raw`/\*[\s\S]*?(?:\*/|$)`, type: "comment" },
+  { match: String.raw`//[^\r\n]*`, type: "comment" },
+  { match: String.raw`\r\n|[\r\n

]`, type: "newline" },
+  { match: String.raw`[ \t\f\v ]+`, type: "space" },
+  { match: "`", type: "string", push: "template" },
+  { match: String.raw`"(?:\\[\s\S]|[^"\\\r\n])*"?`, type: "string" },
+  { match: String.raw`'(?:\\[\s\S]|[^'\\\r\n])*'?`, type: "string" },
+  {
+    // regular expression literal (only where a division can't be)
+    match: String.raw`/(?![*/])(?:\\.|\[(?:\\.|[^\]\\\r\n])*\]|[^/\\\[\r\n])+/[a-z]*`,
+    type: "regex",
+    when: { previousNotTypes: DIVISION_AFTER_TYPES, previousNotTexts: DIVISION_AFTER_TEXTS }
+  },
+  { match: String.raw`0[xX][\da-fA-F_]+n?|0[bB][01_]+n?|0[oO][0-7_]+n?|(?:\d[\d_]*\.?[\d_]*|\.\d[\d_]*)(?:[eE][+-]?\d[\d_]*)?n?`, type: "number" },
+  { match: String.raw`#?[A-Za-z_$ -￿][\w$ -￿]*`, type: "identifier" },
+  { match: String.raw`[()\[\]{}]`, type: "bracket" },
+  { match: String.raw`\?\.(?!\d)|\.\.\.|[;,.]`, type: "punctuation" },
+  { match: String.raw`>>>=|<<=|>>=|>>>|\*\*=|&&=|\|\|=|\?\?=|===|!==|=>|\*\*|\+\+|--|<<|>>|&&|\|\||\?\?|[-+*/%&|^<>!=]=?|[~?:@]`, type: "operator" }
+];
+var JavaScriptSyntax = {
+  name: "javascript",
+  aliases: ["js", "mjs", "cjs", "jsx", "typescript", "ts", "tsx", "script", "ecmascript"],
+  lexical: {
+    start: "root",
+    states: {
+      root: CODE_RULES,
+      template: [
+        { match: "`", type: "string", pop: true },
+        { match: String.raw`\$\{`, type: "punctuation", push: "templateExpression" },
+        { match: String.raw`(?:\\[\s\S]|\$(?!\{)|[^\\` + "`" + String.raw`$])+`, type: "string" }
+      ],
+      templateExpression: [
+        { match: String.raw`\}`, type: "punctuation", pop: true },
+        { match: String.raw`\{`, type: "bracket", push: "braces" },
+        { include: "root" }
+      ],
+      braces: [
+        { match: String.raw`\}`, type: "bracket", pop: true },
+        { match: String.raw`\{`, type: "bracket", push: "braces" },
+        { include: "root" }
+      ]
+    },
+    keywords: { keyword: JAVASCRIPT_KEYWORDS },
+    keywordExceptAfter: [".", "?."]
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/vocabularies/pacem-binding.js
+var NOT_AFTER_MEMBER_ACCESS = { previousNotTexts: [".", "?."] };
+var PacemBindingSyntax = {
+  name: "pacem-binding",
+  aliases: ["pacem", "binding"],
+  extends: "javascript",
+  lexical: {
+    states: {
+      root: [
+        { match: String.raw`:host(?=\.)`, type: "binding-host", when: NOT_AFTER_MEMBER_ACCESS },
+        { match: String.raw`::[A-Za-z_$][\w$]*`, type: "binding-host-property" },
+        { match: String.raw`\^+item(?![\w$])`, type: "binding-item" },
+        { match: String.raw`\^+index(?![\w$])`, type: "binding-index" },
+        { match: String.raw`#[A-Za-z_][\w]*`, type: "binding-element", when: NOT_AFTER_MEMBER_ACCESS },
+        { match: String.raw`\$?this(?![\w$])`, type: "binding-this", when: NOT_AFTER_MEMBER_ACCESS }
+      ]
+    }
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/vocabularies/markup.js
+var NEWLINE_RULE = { match: String.raw`\r\n|[\r\n]`, type: "newline" };
+var ATTRIBUTE_RULES = [
+  NEWLINE_RULE,
+  { match: String.raw`[ \t\f]+`, type: "space" },
+  { match: '"', type: "string", push: "doubleQuoted" },
+  { match: "'", type: "string", push: "singleQuoted" },
+  { match: String.raw`[^\s=/>"']+`, type: "attribute" },
+  { match: "=", type: "operator" },
+  { match: "/", type: "punctuation" }
+];
+var BINDING_RULES = [
+  { match: String.raw`\{\{`, type: "punctuation", embed: "pacem-binding", until: String.raw`\}\}` },
+  { match: String.raw`\}\}`, type: "punctuation" }
+];
+var MarkupSyntax = {
+  name: "markup",
+  aliases: ["html", "htm", "xml", "xhtml", "svg"],
+  lexical: {
+    start: "root",
+    states: {
+      root: [
+        { match: String.raw`<!--[\s\S]*?(?:-->|$)`, type: "comment" },
+        { match: String.raw`<![^>]*>?`, type: "tag" },
+        { match: String.raw`(<\/)([\w:.-]+)(\s*>?)`, type: ["tag", "tagname", "tag"] },
+        { match: String.raw`(<)(script)(?![\w:.-])`, flags: "i", type: ["tag", "tagname"], push: "scriptTag" },
+        { match: String.raw`(<)([\w:.-]+)`, type: ["tag", "tagname"], push: "tag" },
+        { match: String.raw`&(?:#\d+|#[xX][\da-fA-F]+|\w+);`, type: "entity" },
+        NEWLINE_RULE,
+        { match: String.raw`[^<&\r\n]+`, type: "text" }
+      ],
+      tag: [
+        { match: String.raw`/?>`, type: "tag", pop: true },
+        { include: "attributes" }
+      ],
+      scriptTag: [
+        { match: "/>", type: "tag", pop: true },
+        // the script body is tokenized as JavaScript, up to the closing tag
+        { match: ">", type: "tag", pop: true, embed: "javascript", until: String.raw`<\/script` },
+        { include: "attributes" }
+      ],
+      attributes: ATTRIBUTE_RULES,
+      doubleQuoted: [
+        { match: '"', type: "string", pop: true },
+        ...BINDING_RULES,
+        { match: String.raw`(?:[^"{}]|\{(?!\{)|\}(?!\}))+`, type: "string" }
+      ],
+      singleQuoted: [
+        { match: "'", type: "string", pop: true },
+        ...BINDING_RULES,
+        { match: String.raw`(?:[^'{}]|\{(?!\{)|\}(?!\}))+`, type: "string" }
+      ]
+    },
+    insignificant: ["space", "newline", "comment", "text"]
   }
 };
+
+// packages/foundation/dist/esm/compile/syntax/vocabularies/csharp.js
+var CSHARP_KEYWORDS = [
+  "abstract",
+  "add",
+  "alias",
+  "and",
+  "args",
+  "as",
+  "ascending",
+  "async",
+  "await",
+  "base",
+  "bool",
+  "break",
+  "by",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "descending",
+  "do",
+  "double",
+  "dynamic",
+  "else",
+  "enum",
+  "equals",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "file",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "from",
+  "get",
+  "global",
+  "goto",
+  "group",
+  "if",
+  "implicit",
+  "in",
+  "init",
+  "int",
+  "interface",
+  "internal",
+  "into",
+  "is",
+  "join",
+  "let",
+  "lock",
+  "long",
+  "managed",
+  "nameof",
+  "namespace",
+  "new",
+  "nint",
+  "not",
+  "notnull",
+  "nuint",
+  "null",
+  "object",
+  "on",
+  "operator",
+  "or",
+  "orderby",
+  "out",
+  "override",
+  "params",
+  "partial",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "record",
+  "ref",
+  "remove",
+  "required",
+  "return",
+  "sbyte",
+  "scoped",
+  "sealed",
+  "select",
+  "set",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unmanaged",
+  "unsafe",
+  "ushort",
+  "using",
+  "value",
+  "var",
+  "virtual",
+  "void",
+  "volatile",
+  "when",
+  "where",
+  "while",
+  "with",
+  "yield"
+];
+var CODE_RULES2 = [
+  { match: String.raw`///[^\r\n]*`, type: "doc-comment" },
+  { match: String.raw`//[^\r\n]*`, type: "comment" },
+  { match: String.raw`/\*[\s\S]*?(?:\*/|$)`, type: "comment" },
+  // preprocessor directives, at the beginning of a line
+  { match: String.raw`(?<=^[ \t]*|[\r\n][ \t]*)#[ \t]*[a-z]+[^\r\n]*`, type: "preprocessor" },
+  { match: String.raw`\r\n|[\r\n]`, type: "newline" },
+  { match: String.raw`[ \t\f\v\u00A0\uFEFF]+`, type: "space" },
+  // raw string literals ("""…""", optionally interpolated)
+  { match: String.raw`\$*("{3,})[\s\S]*?\1`, type: "string" },
+  { match: String.raw`\$@"|@\$"`, type: "string", push: "interpolatedVerbatim" },
+  { match: String.raw`\$"`, type: "string", push: "interpolated" },
+  { match: String.raw`@"(?:[^"]|"")*"?`, type: "string" },
+  { match: String.raw`"(?:\\.|[^"\\\r\n])*"?`, type: "string" },
+  { match: String.raw`'(?:\\.|[^'\\\r\n])*'?`, type: "string" },
+  { match: String.raw`0[xX][\da-fA-F_]+[uUlL]*|0[bB][01_]+[uUlL]*|(?:\d[\d_]*\.?[\d_]*|\.\d[\d_]*)(?:[eE][+-]?\d+)?[fFdDmMuUlL]*`, type: "number" },
+  { match: String.raw`@?[A-Za-z_\u00A0-\uFFFF][\w\u00A0-\uFFFF]*`, type: "identifier" },
+  { match: String.raw`[()\[\]{}]`, type: "bracket" },
+  { match: String.raw`\?\.|::|[;,.]`, type: "punctuation" },
+  { match: String.raw`\?\?=|<<=|>>>=|>>=|>>>|=>|==|!=|<=|>=|&&|\|\||\?\?|\+\+|--|->|<<|[-+*/%&|^<>!=]=?|[~?:]`, type: "operator" }
+];
+var CSharpSyntax = {
+  name: "csharp",
+  aliases: ["cs", "c#", "c-sharp", "dotnet"],
+  lexical: {
+    start: "root",
+    states: {
+      root: CODE_RULES2,
+      interpolated: [
+        { match: '"', type: "string", pop: true },
+        { match: String.raw`\{\{|\}\}`, type: "string" },
+        { match: String.raw`\{`, type: "punctuation", push: "interpolation" },
+        { match: String.raw`(?:\\.|[^"\\{}\r\n])+`, type: "string" }
+      ],
+      interpolatedVerbatim: [
+        { match: '""', type: "string" },
+        { match: '"', type: "string", pop: true },
+        { match: String.raw`\{\{|\}\}`, type: "string" },
+        { match: String.raw`\{`, type: "punctuation", push: "interpolation" },
+        { match: String.raw`[^"{}]+`, type: "string" }
+      ],
+      interpolation: [
+        { match: String.raw`\}`, type: "punctuation", pop: true },
+        { match: String.raw`\{`, type: "bracket", push: "braces" },
+        { include: "root" }
+      ],
+      braces: [
+        { match: String.raw`\}`, type: "bracket", pop: true },
+        { match: String.raw`\{`, type: "bracket", push: "braces" },
+        { include: "root" }
+      ]
+    },
+    keywords: { keyword: CSHARP_KEYWORDS },
+    keywordExceptAfter: [".", "?."]
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/vocabularies/c.js
+var C_KEYWORDS = [
+  // C
+  "auto",
+  "break",
+  "case",
+  "char",
+  "const",
+  "continue",
+  "default",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "extern",
+  "float",
+  "for",
+  "goto",
+  "if",
+  "inline",
+  "int",
+  "long",
+  "register",
+  "restrict",
+  "return",
+  "short",
+  "signed",
+  "sizeof",
+  "static",
+  "struct",
+  "switch",
+  "typedef",
+  "union",
+  "unsigned",
+  "void",
+  "volatile",
+  "while",
+  "bool",
+  "true",
+  "false",
+  "NULL",
+  "_Bool",
+  "_Complex",
+  "_Imaginary",
+  "_Alignas",
+  "_Alignof",
+  "_Atomic",
+  "_Generic",
+  "_Noreturn",
+  "_Static_assert",
+  "_Thread_local",
+  // C++
+  "alignas",
+  "alignof",
+  "and",
+  "and_eq",
+  "asm",
+  "bitand",
+  "bitor",
+  "catch",
+  "char8_t",
+  "char16_t",
+  "char32_t",
+  "class",
+  "co_await",
+  "co_return",
+  "co_yield",
+  "compl",
+  "concept",
+  "consteval",
+  "constexpr",
+  "constinit",
+  "const_cast",
+  "decltype",
+  "delete",
+  "dynamic_cast",
+  "explicit",
+  "export",
+  "final",
+  "friend",
+  "mutable",
+  "namespace",
+  "new",
+  "noexcept",
+  "not",
+  "not_eq",
+  "nullptr",
+  "operator",
+  "or",
+  "or_eq",
+  "override",
+  "private",
+  "protected",
+  "public",
+  "reinterpret_cast",
+  "requires",
+  "static_assert",
+  "static_cast",
+  "template",
+  "this",
+  "thread_local",
+  "throw",
+  "try",
+  "typeid",
+  "typename",
+  "using",
+  "virtual",
+  "wchar_t",
+  "xor",
+  "xor_eq"
+];
+var CSyntax = {
+  name: "c",
+  aliases: ["cpp", "c++", "cc", "cxx", "h", "hpp", "hxx", "objc"],
+  lexical: {
+    start: "root",
+    states: {
+      root: [
+        { match: String.raw`/\*\*(?!/)[\s\S]*?(?:\*/|$)|///[^\r\n]*`, type: "doc-comment" },
+        { match: String.raw`/\*[\s\S]*?(?:\*/|$)`, type: "comment" },
+        { match: String.raw`//[^\r\n]*`, type: "comment" },
+        // preprocessor directives, at the beginning of a line (line continuations included)
+        { match: String.raw`(?<=^[ \t]*|[\r\n][ \t]*)#[ \t]*\w+(?:\\\r?\n|[^\r\n])*`, type: "preprocessor" },
+        { match: String.raw`\r\n|[\r\n]`, type: "newline" },
+        { match: String.raw`[ \t\f\v]+`, type: "space" },
+        { match: String.raw`(?:u8|u|U|L)?R"([^()\\\s]{0,16})\([\s\S]*?\)\1"`, type: "string" },
+        { match: String.raw`(?:u8|u|U|L)?"(?:\\[\s\S]|[^"\\\r\n])*"?`, type: "string" },
+        { match: String.raw`(?:u8|u|U|L)?'(?:\\.|[^'\\\r\n])*'?`, type: "string" },
+        { match: String.raw`0[xX][\da-fA-F']+[uUlL]*|0[bB][01']+[uUlL]*|(?:\d[\d']*\.?[\d']*|\.\d[\d']*)(?:[eEpP][+-]?\d+)?[fFlLuU]*`, type: "number" },
+        { match: String.raw`[A-Za-z_][\w]*`, type: "identifier" },
+        { match: String.raw`[()\[\]{}]`, type: "bracket" },
+        { match: String.raw`::|\.\.\.|->\*?|\.\*?|[;,]`, type: "punctuation" },
+        { match: String.raw`<=>|<<=|>>=|<<|>>|\+\+|--|&&|\|\||[-+*/%&|^<>!=]=?|[~?:#]`, type: "operator" }
+      ]
+    },
+    keywords: { keyword: C_KEYWORDS },
+    keywordExceptAfter: [".", "->", "::"]
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/vocabularies/json.js
+var JsonSyntax = {
+  name: "json",
+  aliases: ["jsonc", "json5", "webmanifest"],
+  lexical: {
+    start: "root",
+    states: {
+      root: [
+        { match: String.raw`/\*[\s\S]*?(?:\*/|$)`, type: "comment" },
+        { match: String.raw`//[^\r\n]*`, type: "comment" },
+        { match: String.raw`\r\n|[\r\n]`, type: "newline" },
+        { match: String.raw`[ \t\f\v ]+`, type: "space" },
+        // keys: strings followed by a colon
+        { match: String.raw`(?:"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*')(?=\s*:)`, type: "attribute" },
+        { match: String.raw`"(?:\\.|[^"\\\r\n])*"?|'(?:\\.|[^'\\\r\n])*'?`, type: "string" },
+        { match: String.raw`-?(?:0[xX][\da-fA-F]+|(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)|-?Infinity|NaN`, type: "number" },
+        { match: String.raw`[A-Za-z_$][\w$]*`, type: "identifier" },
+        { match: String.raw`[\[\]{}]`, type: "bracket" },
+        { match: String.raw`[:,]`, type: "punctuation" }
+      ]
+    },
+    keywords: { keyword: ["true", "false", "null"] }
+  }
+};
+
+// packages/foundation/dist/esm/compile/syntax/builtins.js
+var BUILTIN_SYNTAXES = {
+  "javascript": JavaScriptSyntax,
+  "pacem-binding": PacemBindingSyntax,
+  "markup": MarkupSyntax,
+  "csharp": CSharpSyntax,
+  "c": CSyntax,
+  "json": JsonSyntax
+};
+for (let name in BUILTIN_SYNTAXES) {
+  const syntax = BUILTIN_SYNTAXES[name];
+  Syntaxes.register(syntax);
+}
 export {
   Angle,
   Arrays,