@pacem/pacem-foundation 1.1.0-sierpinski → 2.0.0-abel

package/dist/browser/pacem-foundation.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.1.0-sierpinski (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */
@@ -1778,6 +1778,600 @@
     };
     //}
 
+    /** Token types shared by the built-in vocabularies (vocabularies may add their own). */
+    var SyntaxTokenType;
+    (function (SyntaxTokenType) {
+        SyntaxTokenType["Text"] = "text";
+        SyntaxTokenType["Space"] = "space";
+        SyntaxTokenType["Newline"] = "newline";
+        SyntaxTokenType["Comment"] = "comment";
+        SyntaxTokenType["DocComment"] = "doc-comment";
+        SyntaxTokenType["Keyword"] = "keyword";
+        SyntaxTokenType["Identifier"] = "identifier";
+        SyntaxTokenType["String"] = "string";
+        SyntaxTokenType["Regex"] = "regex";
+        SyntaxTokenType["Number"] = "number";
+        SyntaxTokenType["Bracket"] = "bracket";
+        SyntaxTokenType["Punctuation"] = "punctuation";
+        SyntaxTokenType["Operator"] = "operator";
+        SyntaxTokenType["Preprocessor"] = "preprocessor";
+        SyntaxTokenType["Tag"] = "tag";
+        SyntaxTokenType["TagName"] = "tagname";
+        SyntaxTokenType["Attribute"] = "attribute";
+        SyntaxTokenType["Entity"] = "entity";
+    })(SyntaxTokenType || (SyntaxTokenType = {}));
+
+    //namespace Pacem.Compile {
+    const registry = new Map();
+    function normalize(name) {
+        return (name ?? '').trim().toLowerCase();
+    }
+    /**
+     * Registry of the {@link Syntax} vocabularies known to the {@link Scanner}, by (case-insensitive) name and aliases.
+     * The built-in vocabularies (see {@link SyntaxName}) are registered upfront; more can be
+     * registered at runtime, e.g. after fetching them as JSON.
+     */
+    class Syntaxes {
+        /**
+         * 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);
+        }
+    }
+
+    //namespace Pacem.Compile {
+    const DEFAULT_START = 'root';
+    const DEFAULT_KEYWORD_SOURCES = [SyntaxTokenType.Identifier];
+    const DEFAULT_INSIGNIFICANT = [SyntaxTokenType.Space, SyntaxTokenType.Newline, SyntaxTokenType.Comment, SyntaxTokenType.DocComment];
+    /** Consecutive zero-length transitions tolerated before a rule gets skipped (guards against push/pop loops). */
+    const MAX_EMPTY_TRANSITIONS = 64;
+    /** Base-syntax chain length tolerated before giving up (guards against `extends` cycles). */
+    const MAX_EXTENDS_DEPTH = 16;
+    function isCombined(item) {
+        return item.combined != null;
+    }
+    const compiledCache = 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;
+    }
+    /** Resolves the `extends` chain of `syntax` (own rules first, then the base ones). */
+    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
+        };
+    }
+    /** Flattens `include` rules of a state (recursively, ignoring cycles). */
+    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;
+        // sticky and indices flags are the engine's business
+        const userFlags = (rule.flags ?? '').replace(/[yd]/g, '');
+        const ownFlags = uniqueFlags(userFlags);
+        // the `d` flag yields the capture group offsets, needed to split a match into per-group tokens
+        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 = new Map();
+        for (let type in keywords) {
+            for (let word of keywords[type]) {
+                map.set(word, type);
+            }
+        }
+        return map;
+    }
+    /** Backreferences and named groups would break once renumbered/duplicated inside an alternation. */
+    const UNMERGEABLE_SOURCE = /\\[1-9]|\\k<|\(\?<(?![=!])/;
+    function countGroups(source, flags) {
+        const probe = new RegExp(source + '|', flags);
+        const match = probe.exec('');
+        return match.length - 1;
+    }
+    function canMatchEmpty(source, flags) {
+        const probe = new RegExp('^(?:' + source + ')$', flags);
+        return probe.test('');
+    }
+    /** Whether a rule can be merged into a {@link CombinedSegment}. */
+    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 };
+    }
+    /** Groups consecutive mergeable rules (sharing the same flags) into combined segments, keeping their order. */
+    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 = new Map();
+        for (let name in merged.states) {
+            const visiting = 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);
+    }
+    /** A single tokenization pass: holds the cursor, the state stack and the produced tokens. */
+    class ScanRun {
+        constructor(_source, root) {
+            this._source = _source;
+            this._tokens = [];
+            /** Current scanning position. */
+            this._position = 0;
+            /** End of the already emitted tokens (characters between it and `_position` are pending unrecognized text). */
+            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) {
+                // unrecognized character: accumulates into a `text` token
+                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 match = this._tryRule(rule);
+            if (match == null) {
+                return null;
+            }
+            return { rule, match };
+        }
+        /** 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 match = combined.exec(this._source);
+            if (match == null) {
+                return null;
+            }
+            const indices = item.groupIndices;
+            for (let k = 0; k < indices.length; k++) {
+                if (match[indices[k]] === undefined) {
+                    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 match = regex.exec(this._source);
+            if (match == null) {
+                return null;
+            }
+            if (match[0].length > 0) {
+                return match;
+            }
+            // zero-length matches are only meaningful as (bounded) state transitions
+            if (!rule.hasTransition || this._emptyTransitions >= MAX_EMPTY_TRANSITIONS) {
+                return null;
+            }
+            this._emptyTransitions++;
+            return match;
+        }
+        _emitMatch({ rule, match }, syntax) {
+            const raw = match[0];
+            if (rule.groupTypes == null) {
+                this._append(rule.type, raw, syntax);
+                return;
+            }
+            this._emitGroups(rule, match, syntax);
+        }
+        /** Splits a match into one token per (top-level) capture group; uncovered characters become `text` tokens. */
+        _emitGroups(rule, match, syntax) {
+            const indices = match.indices;
+            const start = match.index, end = start + match[0].length, types = rule.groupTypes;
+            let cursor = start;
+            for (let i = 1; i < match.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;
+        }
+    }
+    // #endregion
+    /** Used for unknown syntaxes: no rules, the whole source becomes a single `text` token. */
+    const PLAIN_TEXT_SYNTAX = { name: SyntaxTokenType.Text, lexical: { states: {} } };
+    /**
+     * Language-agnostic lexical engine: tokenizes a source text according to a {@link Syntax} vocabulary.
+     * - lossless: concatenating the tokens' `raw` reproduces the source exactly;
+     * - linear: a single cursor and sticky regular expressions (compiled once per syntax);
+     * - error tolerant: unrecognized characters become `text` tokens, it never throws.
+     */
+    class Scanner {
+        /**
+         * 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();
+        }
+    }
+
+    //namespace Pacem.Compile {
+    /** Default token type → CSS class mapping, matching the `code-*` classes styled by the theme (see `ui/markdown.css`). */
+    const 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',
+    });
+    const HTML_ESCAPES = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
+    function htmlEncode$1(text) {
+        return text.replace(/[&<>"]/g, c => HTML_ESCAPES[c]);
+    }
+    /**
+     * Renders a token stream (typically produced by the {@link Scanner}) as HTML: every token's `raw` text is HTML-encoded and,
+     * when its type has a mapped class, wrapped in a `<span class="…">`.
+     */
+    class HighlightRenderer {
+        /**
+         * @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$1(token.raw ?? '');
+            const cssClass = this._classes[token.type];
+            if (cssClass == null) {
+                return encoded;
+            }
+            return `<span class="${cssClass}">${encoded}</span>`;
+        }
+    }
+
     //namespace Pacem.Compile.Markdown {
     // #region HELPERS
     function htmlEncode(input) {
@@ -1795,6 +2389,84 @@
         }
         return input;
     }
+    /** Splits a link/image destination into its url and optional title: `url "title"`, `url 'title'` or `url (title)`. */
+    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;');
+    }
+    /** Splits a table row into its (trimmed) cells: outer pipes are optional, `\|` is a literal pipe. */
+    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;
+    }
+    /**
+     * Splits a list block into its items, by indentation: a marker indented less than the current item's content
+     * starts a sibling item; anything else (nested lists included) is item content, dedented by the content offset.
+     */
+    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+$/, ''));
+    }
+    /**
+     * Code meant for a syntax highlighter: `MarkdownService` escapes every `<` of its input (no html allowed), hence
+     * `&lt;` is turned back into `<` (the highlighter encodes everything it renders anyway).
+     */
+    function decodeCode(code) {
+        return (code ?? '').replace(/&lt;/g, '<');
+    }
+    /** Highlights fenced code blocks of the registered languages (see {@link Syntaxes}). */
+    const scanner = new Scanner();
+    /** Fenced code in this vocabulary also gets the `code-markup` class. */
+    const MARKUP_SYNTAX = 'markup';
     function regexMatchIndex(arr) {
         return arr?.index || void 0;
     }
@@ -1822,27 +2494,51 @@
     }
     // #endregion
     const COMMENT = /(<!--)([\s\S]*?)(-->|$)/;
-    const HR = /^ {0,3}(={3,}|_{3,}|-{3,})(\r?\n|$)/;
+    const HR = /^ {0,3}(={3,}|(?:_[ \t]*){3,}|(?:-[ \t]*){3,}|(?:\*[ \t]*){3,})(\r?\n|$)/;
     const HEADING = /^ {0,3}(#{1,6})\s+([^\n]+)(\r?\n|$)+/;
     const HEADING1 = /^ {0,3}([^\n]+)(\r?\n=+(\r?\n|$))+/;
     const HEADING2 = /^ {0,3}([^\n]+)(\r?\n-+(\r?\n|$))+/;
     const CODEBLOCK = /^ {4,}.+(\r?\n {4,}.+)*(\r?\n|$)+/;
     const FENCES = /^ {0,3}``` *([^\n]*)\r?\n(([\s\S](?!\r?\n {0,3}```))*.(\r?\n)+) {0,3}```(\r?\n|$)+/;
     const BLOCKQUOTE = /^ {0,3}> *([^\n]+)(\r?\n {0,3}> *([^\n]*))*(\r?\n|$)+/;
-    const ULIST = /^( {0,3}([-+]).*\r?\n|$)((?!(?: {0,3}(?:\d+[.\)]|\r?\n\S))).*(\r?\n|$))*/;
-    const OLIST = /^( {0,3}(\d+[.\)]).*\r?\n|$)((?!(?: {0,3}(?:[+-]|\r?\n\S))).*(\r?\n|$))*/;
-    const LISTITEM = /^(?:[-+*]|\d+[.\)])/m;
-    const PARAGRAPH = /^(?! {4,})(.+(\n(?! {0,3}```)(?! {0,3}([-+]|\d+[.\)]))(?! {4,})(?! {0,3}>).+)*)/;
+    // (`*` bullets need a following space, not to be mistaken for emphasis; nested lists of the other kind are indented)
+    const ULIST = /^( {0,3}([-+]|\*(?=[ \t])).*(\r?\n|$))((?!(?: ?\d+[.\)]|\r?\n\S)).*(\r?\n|$))*/;
+    const OLIST = /^( {0,3}(\d+[.\)]).*(\r?\n|$))((?!(?: {0,2}(?:[-+]|\*[ \t])|\r?\n\S)).*(\r?\n|$))*/;
+    /** A list item marker, with its indentation and the spaces following it. */
+    const LISTMARKER = /^( *)([-+*]|\d+[.\)])([ \t]+|$)/;
+    /** GFM task list item: `[ ]` or `[x]` at the beginning of the item. */
+    const TASK = /^\[([ xX])\][ \t]+/;
+    // (whitespace-only lines are blank lines: they never start nor continue a paragraph)
+    const PARAGRAPH = /^(?! {4,})(?=[ \t]*\S)(.+(\n(?![ \t]*(?:\n|$))(?! {0,3}```)(?! {0,3}([-+]|\*[ \t]|\d+[.\)]))(?! {0,3}#{1,6}[ \t])(?! {4,})(?! {0,3}>).+)*)/;
     const REF = /^ {0,3}(!?)\[([^\]]+)\]: +(\S+)(?: +['"\(](.+)['"\)])?(\r?\n|$)+/;
-    const IMAGE_OR_LINK = /!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?(\[[^\[\]]*\]|\([^\(\)]*\))?/;
+    // (an escaped `\[` never opens a link)
+    const IMAGE_OR_LINK = /(?<!\\)!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?(\[[^\[\]]*\]|\([^\(\)]*\))?/;
     const EMPHASIZED_LINK = /(\*\*?|__?)(\[[^\]]*]\([^\)]+\))\1/;
     const CODE = /(?:(?<!\\)`)(.+?)(?:(?<!\\)`)/;
-    const EMPHASIZE = /(\*\*?|__?)((?!\1\s?)(?:(?!\1)[\S\s])*[^\s])\1/;
-    const STRIKE = /(~~?|__?)(?!\1\s?)([^\s][\s\S]*?(?!\1)[^\s])\1/;
+    // (underscores never emphasize inside words: `snake_case_word`)
+    const EMPHASIZE = /(\*\*?)((?!\1\s?)(?:(?!\1)[\S\s])*[^\s])\1|(?<![A-Za-z0-9])(__?)((?!\3\s?)(?:(?!\3)[\S\s])*[^\s])\3(?![A-Za-z0-9])/;
+    // (underscores are emphasis markers only: `snake_case_word` must not strike anything through)
+    const STRIKE = /(~~?)(?!\1\s?)([^\s][\s\S]*?(?!\1)[^\s])\1/;
     const QUOTE = /(:")(?!":\s?)([^\s][\s\S]*?(?!":)[^\s])":/;
     const SPACE = /^\s+/;
-    const LINEBREAK = / {2,}\r?\n/;
+    /** Blank lines between blocks (it keeps the indentation of the next line, which matters to indented code blocks). */
+    const BLOCK_SPACE = /^(?:[ \t]*\r?\n)+|^\s+/;
+    const LINEBREAK = /(?: {2,}|\\)\r?\n/;
     const TEXT = /^[^\r\n]+/;
+    /** Backslash escapes of ASCII punctuation (CommonMark); `\&lt;` is an escaped `<` already escaped by `MarkdownService`. */
+    const ESCAPE = /\\(&lt;|[!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~])/;
+    /** Escaped characters that must stay text once rendered as html. */
+    const ESCAPED_HTML = { '<': '&lt;', '&lt;': '&lt;', '&': '&amp;' };
+    /** `<https://…>`, `<mailto:…>` and `<user@domain>` (the `<` may come escaped, e.g. by `MarkdownService`). */
+    const AUTOLINK = /(?:<|&lt;)((?:https?|ftp|mailto):[^\s<>]+|[\w.+-]+@[\w-]+(?:\.[\w-]+)+)>/;
+    /** GFM bare URLs (`https://…`, `www.…`), trailing punctuation excluded. */
+    const BARE_URL = /(?<![\w\/\\(\[<"'=;&@])(?:https?:\/\/|www\.)[^\s<>]*[^\s<>.,:;"'!?)\]*_~]/;
+    /** GFM footnote reference `[^id]`. */
+    const FOOTNOTE_REF = /\[\^([^\]\s]+)\]/;
+    /** GFM footnote definition `[^id]: text` (continuation lines indented). */
+    const FOOTNOTE_DEF = /^ {0,3}\[\^([^\]\s]+)\]: *([^\r\n]*(?:\r?\n {2,}[^\r\n]+)*)(\r?\n|$)+/;
+    /** GFM table: header row, delimiter row, then body rows (up to a blank line). */
+    const 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_TYPES) {
         MARKDOWN_TYPES["Html"] = "html";
@@ -1867,6 +2563,11 @@
         MARKDOWN_TYPES["UnorderedList"] = "ul";
         MARKDOWN_TYPES["ListItem"] = "listitem";
         MARKDOWN_TYPES["Reference"] = "ref";
+        MARKDOWN_TYPES["Table"] = "table";
+        MARKDOWN_TYPES["TableRow"] = "tr";
+        MARKDOWN_TYPES["TableCell"] = "td";
+        MARKDOWN_TYPES["FootnoteReference"] = "fnref";
+        MARKDOWN_TYPES["FootnoteDefinition"] = "fndef";
     })(MARKDOWN_TYPES || (MARKDOWN_TYPES = {}));
     var MARKDOWN_RULES;
     (function (MARKDOWN_RULES) {
@@ -1889,6 +2590,12 @@
         MARKDOWN_RULES[MARKDOWN_RULES["Quote"] = 16] = "Quote";
         MARKDOWN_RULES[MARKDOWN_RULES["Code"] = 17] = "Code";
         MARKDOWN_RULES[MARKDOWN_RULES["LineBreak"] = 18] = "LineBreak";
+        MARKDOWN_RULES[MARKDOWN_RULES["FootnoteDefinition"] = 19] = "FootnoteDefinition";
+        MARKDOWN_RULES[MARKDOWN_RULES["Table"] = 20] = "Table";
+        MARKDOWN_RULES[MARKDOWN_RULES["Escape"] = 21] = "Escape";
+        MARKDOWN_RULES[MARKDOWN_RULES["AutoLink"] = 22] = "AutoLink";
+        MARKDOWN_RULES[MARKDOWN_RULES["FootnoteReference"] = 23] = "FootnoteReference";
+        MARKDOWN_RULES[MARKDOWN_RULES["BareUrl"] = 24] = "BareUrl";
         // lowest priority
         MARKDOWN_RULES[MARKDOWN_RULES["Text"] = 254] = "Text";
         MARKDOWN_RULES[MARKDOWN_RULES["Space"] = 255] = "Space";
@@ -1909,7 +2616,8 @@
                             type: MARKDOWN_TYPES.Html, index, raw: arr[0], text: arr[2]
                         }];
                     if (index > 0) {
-                        const left = input.substr(0, index), tokens = lexer.tokenize(left, blockRules);
+                        // (the top-level rules: reference and footnote definitions may precede a comment)
+                        const left = input.substr(0, index), tokens = lexer.tokenize(left, topRules);
                         Array.prototype.unshift.apply(output, tokens);
                     }
                     return output;
@@ -1924,6 +2632,16 @@
                         }];
                 })
             },
+            // 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 = {};
         for (let r of extra) {
@@ -1982,21 +2700,61 @@
             // 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);
+                    // `(url "title")`
+                    const { url, title } = splitUrlAndTitle(destination);
+                    const tokens = lexer.tokenize(text, inlineRules);
                     if (image) {
                         return [{
                                 index, type: url ? MARKDOWN_TYPES.Image : MARKDOWN_TYPES.ImageLike,
-                                raw, text, src: url, 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)
+                                raw, text, src: url, title, ref, 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
@@ -2024,10 +2782,12 @@
             // italic/bold
             [MARKDOWN_RULES.Emphasize]: {
                 exec: (input, lexer) => inlineMatch(input, EMPHASIZE, lexer, arr => {
-                    if (arr.length < 3 || NullChecker.isNullOrEmpty(arr[2])) {
+                    // `*` (groups 1-2) or word-bounded `_` (groups 3-4) markers
+                    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, raw: arr[0], text, tokens: lexer.tokenize(text, inlineRules)
@@ -2096,7 +2856,20 @@
             inPlaceInlineExec(input, output, lexer);
             return output;
         };
-        const inlineRules = Object.values(inline);
+        // explicit priorities: footnote references before `[links]`, escapes before emphasis, bare urls last
+        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]);
         // #endregion
@@ -2115,7 +2888,12 @@
             // paragraph
             [MARKDOWN_RULES.Paragraph]: {
                 exec: (input, lexer) => match(input, PARAGRAPH, arr => {
-                    const raw = arr[0], text = raw;
+                    // leading whitespace of paragraph lines is not content (CommonMark)
+                    const raw = arr[0], text = raw.replace(/^[ \t]+/gm, '');
+                    // whitespace-only lines are blank lines, not (empty) paragraphs
+                    if (text.trim().length === 0) {
+                        return null;
+                    }
                     return [{
                             type: MARKDOWN_TYPES.Paragraph, raw, text,
                             // recursion (inline rules only)
@@ -2123,12 +2901,57 @@
                         }];
                 })
             },
-            // 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);
+            // tight items (no blank lines) keep their first paragraph unwrapped, e.g. `<li>a<ul>…</ul></li>`
+            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 => {
+                // GFM task list item: `[ ]`/`[x]`
+                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) => {
+                // missing cells are empty, exceeding ones are ignored (GFM)
+                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
@@ -2143,7 +2966,8 @@
             // headings
             [MARKDOWN_RULES.Heading]: {
                 exec: (input, lexer) => match(input, HEADING, arr => {
-                    const text = arr[2];
+                    // optional closing sequence: `## Title ##`
+                    const text = arr[2].replace(/[ \t]+#+[ \t]*$/, '');
                     return [{
                             type: MARKDOWN_TYPES.Heading, raw: arr[0], text, level: arr[1].length, ref: normalizeReference(text),
                             tokens: lexer.tokenize(text, inlineRules)
@@ -2171,60 +2995,86 @@
             // codeblock
             [MARKDOWN_RULES.CodeBlock]: {
                 exec: (input, lexer) => match(input, CODEBLOCK, arr => {
-                    const raw = arr[0], text = htmlEncode(raw);
+                    // indented code: 4 spaces of indentation are not part of the code
+                    const raw = arr[0], code = raw.replace(/^ {4}/gm, '').replace(/\s+$/, ''), text = htmlEncode(code);
+                    // whitespace-only indented lines are blank lines, not 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();
+                    // the info string may carry more than the language (e.g. ```js title)
+                    const info = (arr[1] ?? '').trim(), words = info.split(/\s+/), lang = words[0].toLowerCase();
+                    // custom `code` rules (see ExtraRule) win over the registered vocabularies
+                    const syntax = lang in codeExtra ? null : Syntaxes.get(lang);
+                    if (syntax == null) {
+                        const text = htmlEncode(arr[2]);
+                        return [{
+                                type: MARKDOWN_TYPES.CodeBlock, raw: arr[0], text, lang,
+                                tokens: lexer.tokenize(text, getLangGrammar(lang))
+                            }];
+                    }
+                    // highlighted by the language-agnostic Scanner (see HtmlRenderer)
+                    const code = decodeCode(arr[2]);
+                    const tokens = scanner.tokenize(code, syntax);
                     return [{
-                            type: MARKDOWN_TYPES.CodeBlock, raw: arr[0], text, lang,
-                            tokens: lexer.tokenize(text, getLangGrammar(lang))
+                            type: MARKDOWN_TYPES.CodeBlock, raw: arr[0], text: code, 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]), raw, text: raw, tokens: items.map(i => {
-                                // avoid paragraphs if not strictly needed
-                                return {
-                                    type: MARKDOWN_TYPES.ListItem, raw: i, text: i, tokens: tokenizeListItem(i, lexer)
-                                };
-                            })
+                            type: MARKDOWN_TYPES.OrderedList, start, raw, text: raw, 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
+                        }];
+                })
+            },
+            // GFM tables
+            [MARKDOWN_RULES.Table]: {
+                exec: (input, lexer) => match(input, TABLE, arr => {
+                    const headers = splitTableCells(arr[1]), delimiters = splitTableCells(arr[2]);
+                    // the delimiter row must match the header row
+                    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.UnorderedList, raw, text: raw, tokens: items.map(i => {
-                                return {
-                                    type: MARKDOWN_TYPES.ListItem, raw: i, text: i, tokens: tokenizeListItem(i, lexer)
-                                };
-                            })
+                            type: MARKDOWN_TYPES.Table, raw: arr[0], text: arr[0], align, tokens: rows
                         }];
                 })
             }
@@ -2233,13 +3083,16 @@
         Array.prototype.push.apply(blockRules, blockExtra);
         blockRules.push(lowpriority[MARKDOWN_RULES.Paragraph], lowpriority[MARKDOWN_RULES.Space]);
         // #endregion
-        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;
     }
     // #region HTML RENDERER HELPER
     // meant to help in unnecessary spaces replacement.
@@ -2248,11 +3101,29 @@
     function trim(input) {
         return input?.replace(TRIM_INSIDE, '\n').trim();
     }
-    // #endregion
+    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}"`;
+    }
     /** Renders a Markdown token tree, as produced by the grammar returned by {@link getGrammar}, into HTML markup. */
     class HtmlRenderer {
         constructor(_extraItemRender = (token, __) => token?.text || '') {
             this._extraItemRender = _extraItemRender;
+            /** Link/image reference definitions of the whole document (they may be referenced from any depth). */
+            this.#references = [];
+            /** Footnote definitions by id, and the order of their first reference (their numbering). */
+            this.#footnotes = new Map();
+            this.#footnoteOrder = [];
+            this.#highlighter = new HighlightRenderer();
             this._renderContent = (token) => {
                 const children = token.tokens;
                 if (NullChecker.isNullOrEmpty(children)) {
@@ -2261,10 +3132,144 @@
                 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 undefined;
+            }
+            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}`;
+            }
+            // `code-highlighted` (and `code-markup`) let the theme style any registered language
+            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 `\t<li>${content}</li>${R}`;
+            }
+            const checked = token['checked'] === true ? ' checked' : '';
+            return `\t<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;
@@ -2273,8 +3278,7 @@
                 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:
@@ -2284,17 +3288,7 @@
                     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:
@@ -2308,20 +3302,14 @@
                 case MARKDOWN_TYPES.UnorderedList:
                     return `<ul>\n${r(token)}</ul>${R}`;
                 case MARKDOWN_TYPES.ListItem:
-                    return `\t<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:
@@ -2338,7 +3326,13 @@
             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);
         }
     }
     /** Renders a Markdown token tree as a JSON array of tokens, mainly useful for debugging/inspection. */
@@ -2380,12 +3374,13 @@
             return JSON.parse(json);
         }
         parse(input, grammarOrRenderer = getGrammar(), renderer = new HtmlRenderer()) {
+            // line endings are normalized: the grammar expects `\n` (`.` doesn't match `\r`: CRLF paragraphs would split by line)
+            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);
         }
     }
     //}
@@ -2395,10 +3390,357 @@
         Parser: Parser
     });
 
+    //namespace Pacem.Compile {
+    /** After these, a `/` starts a division (not a regular expression literal). */
+    const DIVISION_AFTER_TYPES = ['identifier', 'number', 'string', 'regex'];
+    const DIVISION_AFTER_TEXTS = [')', ']', '}', 'this', 'super', 'null', 'undefined', 'true', 'false', '++', '--'];
+    const 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'
+    ];
+    /** Rules shared by every "code" state (top level, template expressions, nested braces). */
+    const CODE_RULES$1 = [
+        { 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' },
+    ];
+    /**
+     * JavaScript vocabulary, TypeScript superset: comments (JSDoc as `doc-comment`), strings, template literals with nested
+     * `${…}` expressions, regular expression literals (told from divisions by the previous significant token), numbers
+     * (hex/binary/octal/BigInt/separators), identifiers (`#private` included), keywords (JS + TS, not after `.`/`?.`),
+     * brackets, punctuation and operators.
+     */
+    const JavaScriptSyntax = {
+        name: 'javascript',
+        aliases: ['js', 'mjs', 'cjs', 'jsx', 'typescript', 'ts', 'tsx', 'script', 'ecmascript'],
+        lexical: {
+            start: 'root',
+            states: {
+                root: CODE_RULES$1,
+                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: ['.', '?.'],
+        }
+    };
+
+    //namespace Pacem.Compile {
+    /** Member accesses (`obj.#x`, `obj?.x`) are never Pacem binding tokens. */
+    const NOT_AFTER_MEMBER_ACCESS = { previousNotTexts: ['.', '?.'] };
+    /**
+     * Pacem binding-expression vocabulary (the content of `{{ … }}` attributes): JavaScript plus the special tokens
+     * resolved by core's `Expression`:
+     * - `binding-host`: `:host` (followed by `.`);
+     * - `binding-host-property`: `::name`;
+     * - `binding-item`: `^item`, `^^item`, … (repeater item, n levels up);
+     * - `binding-index`: `^index`, `^^index`, …;
+     * - `binding-element`: `#id` (element reference);
+     * - `binding-this`: `$this` / `this` (the bound element).
+     */
+    const 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 },
+                ]
+            }
+        }
+    };
+
+    //namespace Pacem.Compile {
+    const NEWLINE_RULE = { match: String.raw `\r\n|[\r\n]`, type: 'newline' };
+    /** Attribute list of an opening tag. */
+    const 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' },
+    ];
+    /** A Pacem binding (`{{ … }}`) inside an attribute value: embeds the `pacem-binding` vocabulary up to `}}`. */
+    const BINDING_RULES = [
+        { match: String.raw `\{\{`, type: 'punctuation', embed: 'pacem-binding', until: String.raw `\}\}` },
+        { match: String.raw `\}\}`, type: 'punctuation' },
+    ];
+    /**
+     * Markup (HTML/XML) vocabulary: comments, doctypes/CDATA, tags (`tag`/`tagname`), attributes, quoted values (Pacem
+     * `{{ … }}` bindings tokenized with `pacem-binding`), entities, text, and `<script>` bodies tokenized with `javascript`.
+     */
+    const 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']
+        }
+    };
+
+    //namespace Pacem.Compile {
+    const 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'
+    ];
+    /** Rules shared by every "code" state (top level, interpolations, nested braces). */
+    const CODE_RULES = [
+        { 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' },
+    ];
+    /**
+     * C# vocabulary: XML doc comments (`doc-comment`), comments, preprocessor directives, strings (regular, verbatim, raw,
+     * interpolated with nested `{…}` expressions), chars, numbers (with suffixes), identifiers (`@verbatim` included),
+     * keywords (contextual ones included, not after `.`/`?.`), brackets, punctuation and operators.
+     */
+    const CSharpSyntax = {
+        name: 'csharp',
+        aliases: ['cs', 'c#', 'c-sharp', 'dotnet'],
+        lexical: {
+            start: 'root',
+            states: {
+                root: CODE_RULES,
+                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: ['.', '?.'],
+        }
+    };
+
+    //namespace Pacem.Compile {
+    const 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'
+    ];
+    /**
+     * C/C++ vocabulary: comments (`/** … *\/` and `///` as `doc-comment`), preprocessor directives (with their `<header>`),
+     * strings (raw `R"x(…)x"` and prefixed ones included), chars, numbers (with suffixes/separators), identifiers, keywords
+     * (C and C++), brackets, punctuation and operators.
+     */
+    const 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: ['.', '->', '::'],
+        }
+    };
+
+    //namespace Pacem.Compile {
+    /**
+     * JSON vocabulary (JSONC and JSON5-ish tolerant: comments, single quotes and trailing commas are recognized):
+     * object keys are `attribute`s, values `string`/`number`/`keyword` (`true`, `false`, `null`).
+     */
+    const 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'] },
+        }
+    };
+
+    //namespace Pacem.Compile {
+    /** The built-in vocabularies, one per {@link SyntaxName} (enforced by the type). */
+    const BUILTIN_SYNTAXES = {
+        'javascript': JavaScriptSyntax,
+        'pacem-binding': PacemBindingSyntax,
+        'markup': MarkupSyntax,
+        'csharp': CSharpSyntax,
+        'c': CSyntax,
+        'json': JsonSyntax
+    };
+    // available as soon as the compile module loads
+    for (let name in BUILTIN_SYNTAXES) {
+        const syntax = BUILTIN_SYNTAXES[name];
+        Syntaxes.register(syntax);
+    }
+
     var indexCompile = /*#__PURE__*/Object.freeze({
         __proto__: null,
+        CSharpSyntax: CSharpSyntax,
+        CSyntax: CSyntax,
+        DefaultHighlightClasses: DefaultHighlightClasses,
+        HighlightRenderer: HighlightRenderer,
+        JavaScriptSyntax: JavaScriptSyntax,
+        JsonSyntax: JsonSyntax,
         Markdown: indexCompileMarkdown,
-        Parser: Parser$1
+        MarkupSyntax: MarkupSyntax,
+        PacemBindingSyntax: PacemBindingSyntax,
+        Parser: Parser$1,
+        Scanner: Scanner,
+        get SyntaxTokenType () { return SyntaxTokenType; },
+        Syntaxes: Syntaxes
     });
 
     var Output = /*#__PURE__*/Object.freeze({