@markup-carve/carve-grammars 0.1.2

package/prism/carve.js

@@ -0,0 +1,471 @@
+/**
+ * Prism.js grammar for the Carve markup language.
+ *
+ * Mirrors the canonical token set in markup-carve/carve
+ * (`resources/grammar.ebnf`) and the TextMate grammar in vscode-carve
+ * (`syntaxes/carve.tmLanguage.json`). Carve's inline delimiters differ from
+ * Markdown/Djot: emphasis is `/italic/`, `*bold*`, `_underline_`,
+ * `~strike~`, `=highlight=`, `^sup^`, `,sub,` (the doubled forms `==x==` /
+ * `,,x,,` are literal in Carve; the forced brace forms `{=x=}` / `{,x,}` /
+ * `{^x^}` render intraword).
+ *
+ * Usage (ESM):
+ *
+ * ```js
+ * import Prism from 'prismjs';
+ * import 'carve-grammars/prism/carve.js'; // registers Prism.languages.carve
+ *
+ * const html = Prism.highlight(src, Prism.languages.carve, 'carve');
+ * ```
+ *
+ * Usage (browser / bundler): load `prismjs` first (which sets the global
+ * `Prism`), then import this file for its side effect - it reads the global
+ * `Prism` (`globalThis` / `window` / `global`) and registers the grammar.
+ *
+ * @module carve-grammars/prism/carve
+ */
+(function (Prism) {
+    if (!Prism) {
+        return;
+    }
+
+    // Inline attribute block: {#id .class key="val"} - reused by spans, divs,
+    // headings and extension calls.
+    // The payload is STRICT (spec PART 9 S14): a class/id/key identifier may not
+    // start with a digit, so `{2=v}` stays literal text rather than scoping as
+    // an attribute block. An unquoted value may contain dots and colons.
+    var attrItem = /(?:[.#][A-Za-z_][\w-]*|[A-Za-z_][\w:-]*(?:=(?:"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|[^\s"'{}]+))?)/.source;
+    // An EMPTY block is valid only glued to a preceding `]` (`[x]{}` ->
+    // <span>x</span>); a bare `{}` in prose is literal text (corpus 123).
+    // An EMPTY attribute block is valid only where it is glued to a preceding
+    // `]` (`[x]{}` -> <span>x</span>); a bare `{}` in prose is literal text
+    // (corpus 123). Prism tokenizes left to right, so the span and its empty
+    // block have to be ONE rule -- a lookbehind would lose its `]` to the span.
+    var spanEmptyAttrs = {
+        pattern: /\[[^\^\]][^\]]*\]\{\s*\}/,
+        inside: {
+            'attr-value': { pattern: /\{\s*\}/, inside: { 'punctuation': /[{}]/ } },
+            'string': /\[[^\]]*\]/,
+        },
+    };
+    var attributes = {
+        pattern: RegExp('\\{\\s*' + attrItem + '(?:\\s+' + attrItem + ')*\\s*\\}'),
+        alias: 'attr-value',
+        inside: {
+            'id': /#[A-Za-z_][\w-]*/,
+            'class-name': /\.[A-Za-z_][\w-]*/,
+            'attr-name': /[A-Za-z_:][\w:-]*(?==)/,
+            'string': /"[^"]*"|'[^']*'/,
+            'punctuation': /[{}=]/,
+        },
+    };
+
+    // Shared inline emphasis/markup, referenced from block tokens that contain
+    // running text (headings, list items, table cells, quotes).
+    var inline = {
+        'bold-italic': {
+            pattern: /\/\*(?=\S)[^*]+\*\//,
+            alias: 'important',
+        },
+        // The "no leading/trailing space" rule is expressed without JS
+        // lookbehind (unsupported on Safari < 16.4 and some engines): the first
+        // and last content chars are required to be non-space directly.
+        // Forced intraword family (PART 9 S22): `{*x*}` `{/x/}` `{_x_}` `{~x~}`.
+        // Content may contain the delimiter -- `{/a/b/}` is <em>a/b</em> -- so the
+        // run ends at the closing `X}`. These MUST precede 'attributes', or
+        // `{_path_}` reads as a boolean attribute instead of <u>path</u>.
+        'forced-bold': {
+            pattern: /\{\*(?=\S)[^\n]*?\*\}/,
+            alias: 'bold',
+        },
+        'forced-italic': {
+            pattern: /\{\/(?=\S)[^\n]*?\/\}/,
+            alias: 'italic',
+        },
+        'forced-underline': {
+            pattern: /\{_(?=\S)[^\n]*?_\}/,
+            alias: 'underline',
+        },
+        'forced-strike': {
+            pattern: /\{~(?=\S)(?:(?!~>)[^\n])*?~\}/,
+            alias: 'deleted',
+        },
+        'bold': {
+            pattern: /\*[^*\s\n](?:[^*\n]*?[^*\s\n])?\*/,
+            alias: 'bold',
+        },
+        'italic': {
+            // leading guard via Prism lookbehind (avoids URLs, paths); the
+            // trailing `(?![\w/])` lookahead is fine (lookahead is universal).
+            pattern: /(^|[^\w/])\/[^/\s\n](?:[^/\n]*?[^/\s\n])?\/(?![\w/])/,
+            lookbehind: true,
+            alias: 'italic',
+        },
+        'underline': {
+            pattern: /(^|[^\w_])_[^_\s\n](?:[^_\n]*?[^_\s\n])?_(?![\w_])/,
+            lookbehind: true,
+            alias: 'underline',
+        },
+        'strike': {
+            pattern: /~[^~\s\n](?:[^~\n]*?[^~\s\n])?~/,
+            alias: 'deleted',
+        },
+        'highlight': {
+            pattern: /\{=(?=\S)[^\n]*?=\}|(?<![\w=])=(?=\S)[^=\n]+?(?<=\S)=(?![\w=])/,
+            alias: 'important',
+        },
+        // Braced-only: a bare `^` / `,` is literal text (no bare sup/sub).
+        'superscript': {
+            pattern: /\{\^(?=\S)[^\n]*?\^\}/,
+            alias: 'important',
+        },
+        'subscript': {
+            pattern: /\{,(?=\S)[^\n]*?,\}/,
+            alias: 'important',
+        },
+    };
+
+    Prism.languages.carve = {
+        // Block comments %%% ... %%% and line comments %% ...
+        // The comment fence is a *bare* %%% line; a `%%% format` opener is a
+        // raw passthrough block instead (handled by #raw-block below).
+        'comment': [
+            {
+                pattern: /^[ \t]*%%%[ \t]*\n[\s\S]*?^[ \t]*%%%[ \t]*$/m,
+                greedy: true,
+            },
+            {
+                pattern: /^[ \t]*%%(?!%).*$/m,
+                greedy: true,
+            },
+            {
+                // trailing comment after whitespace (Prism lookbehind, no JS
+                // lookbehind: the leading space is captured and excluded).
+                pattern: /([ \t])%%.*$/m,
+                lookbehind: true,
+                greedy: true,
+            },
+        ],
+
+        // YAML/typed front matter delimited by --- at the very top of the file.
+        // `^` (no `m` flag) anchors to the start of the document; the close is
+        // matched at end-of-line so a document body may follow.
+        'front-matter': {
+            pattern: /^---[ \t]*[A-Za-z0-9_-]*[ \t]*\n[\s\S]*?\n---[ \t]*(?:\n|$)/,
+            alias: 'comment',
+            greedy: true,
+            inside: {
+                'punctuation': /---/,
+            },
+        },
+
+        // Fenced code blocks: ``` lang ... ``` or ~~~ lang ... ~~~
+        'code-block': {
+            pattern: /^(`{3,}|~{3,})[ \t]*[^\n]*\n[\s\S]*?^\1[ \t]*$/m,
+            greedy: true,
+            inside: {
+                'punctuation': /^(?:`{3,}|~{3,})|(?:`{3,}|~{3,})$/,
+                'language': {
+                    pattern: /(^(?:`{3,}|~{3,})[ \t]*)[^\s`~]+/,
+                    lookbehind: true,
+                    alias: 'class-name',
+                },
+            },
+        },
+
+        // Raw passthrough blocks: %%% format ... %%%  (rendered verbatim)
+        'raw-block': {
+            pattern: /^%{3,}[ \t]*\S*[ \t]*\n[\s\S]*?^%{3,}[ \t]*$/m,
+            greedy: true,
+            alias: 'string',
+            inside: {
+                'punctuation': /^%{3,}|%{3,}$/,
+                'language': {
+                    pattern: /(^%{3,}[ \t]*)\S+/,
+                    lookbehind: true,
+                    alias: 'class-name',
+                },
+            },
+        },
+
+        // ATX headings # .. ######
+        'title': {
+            pattern: /^#{1,6}[ \t]+.+$/m,
+            alias: 'important',
+            inside: Object.assign({
+                'punctuation': /^#{1,6}/,
+            }, inline),
+        },
+
+        // Container divs ::: class  /  :::
+        // Strict opener shapes only: type word, optional "title" (straight
+        // quotes), optional [label], the | / \ layout tokens, or a typeless
+        // [label]. Trailing junk makes the line a paragraph, so it must not
+        // highlight as a fence.
+        'div': {
+            pattern: /^[ \t]*:{3,}(?:[ \t]*(?:\||\\)|[ \t]*[a-zA-Z_][\w-]*(?:[ \t]+"[^"\n]*")?(?:[ \t]+\[[^\]\n]*\])?|[ \t]*\[[^\]\n]*\])?[ \t]*$/m,
+            alias: 'tag',
+            inside: {
+                'punctuation': /:{3,}/,
+                'string': /"[^"\n]*"/,
+                'symbol': /\[[^\]\n]*\]/,
+                'class-name': {
+                    pattern: /(^[ \t]*:{3,}[ \t]*)(?:[a-zA-Z_][\w-]*|\||\\)/,
+                    lookbehind: true,
+                },
+            },
+        },
+
+        // Table rows: | a | b |   (plus header `|=`, caption `^`, span markers)
+        'table': {
+            pattern: /^[ \t]*\|.*$/m,
+            inside: Object.assign({
+                // rowspan `^` / colspan `<` markers - must precede `punctuation`
+                // so the surrounding `|` is not consumed first.
+                'operator': {
+                    pattern: /(\|)[ \t]*[\^<](?=[ \t]*\|)/,
+                    lookbehind: true,
+                },
+                'punctuation': /\|=|\|/,
+                'attributes': attributes,
+                'url': /\[[^\]]+\]\([^\s)]+\)/,
+            }, inline),
+        },
+
+        // Table continuation / list continuation: a lone `+`
+        'table-continuation': {
+            pattern: /^[ \t]*\+[ \t]*$/m,
+            alias: 'punctuation',
+        },
+
+        // Blockquotes: leading > (possibly nested >>)
+        'blockquote': {
+            pattern: /^[ \t]*>+[ \t]?.*$/m,
+            inside: Object.assign({
+                'punctuation': /^[ \t]*>+/,
+            }, inline),
+        },
+
+        // List markers: -, *, ordered (1. a) i.), task [ ]/[x], definition `: `
+        'list': {
+            pattern: /^[ \t]*(?:(?:[-*][ \t]+)*[-*][ \t]+(?:\[[ xX]\][ \t]+)?|(?:[0-9]+|[A-Za-z]|[ivxlcdmIVXLCDM]+)[.)][ \t]+|:[ \t]+)/m,
+            alias: 'punctuation',
+            inside: {
+                'constant': /\[[ xX]\]/,
+            },
+        },
+
+        // Reference link / abbreviation definitions
+        'reference-definition': {
+            pattern: /^[ \t]*\[[^\]]+\]:[ \t]+\S+.*$/m,
+            alias: 'url',
+            inside: {
+                'constant': /^[ \t]*\[[^\]]+\]:/,
+            },
+        },
+        'abbreviation-definition': {
+            pattern: /^[ \t]*\*\[[A-Z][A-Z0-9]*\]:[ \t]+.*$/m,
+            inside: {
+                'punctuation': /^[ \t]*\*|\[|\]|:/,
+                'symbol': /[A-Z][A-Z0-9]*/,
+            },
+        },
+
+        // Display + inline math: $$`...`$$ and $`...`$
+        'math': [
+            {
+                pattern: /\$\$(`+)[\s\S]*?\1\$\$/,
+                greedy: true,
+                alias: 'string',
+            },
+            {
+                pattern: /\$(`+)[\s\S]*?\1\$/,
+                greedy: true,
+                alias: 'string',
+            },
+        ],
+
+        // Raw inline passthrough: `code`{=format}
+        'raw-inline': {
+            pattern: /(`+)(?:[^`]|[^`][\s\S]*?[^`])\1\{=[A-Za-z_][\w-]*\}/,
+            greedy: true,
+            alias: 'string',
+        },
+
+        // Inline code spans
+        'code': {
+            pattern: /(`+)(?:[^`]|[^`][\s\S]*?[^`])\1/,
+            greedy: true,
+        },
+
+        // Images: ![alt](src "title"); the title may contain
+        // backslash-escaped quotes like the link title.
+        'image': {
+            pattern: /!\[[^\]]*\]\([^\s)]+(?:[ \t]+"(?:[^"\\]|\\[\s\S])*")?\)/,
+            greedy: true,
+            alias: 'url',
+            inside: {
+                'string': /"(?:[^"\\]|\\[\s\S])*"/,
+                'punctuation': /!\[|\]\(|\)/,
+            },
+        },
+
+        // Footnote references: [^label]
+        'footnote': {
+            pattern: /\[\^[^\]]+\]/,
+            alias: 'symbol',
+        },
+
+        // Citations (Tier-2 §22): [@key], [+@key], [@key, p.10], [@a; @b; @c]
+        // Distinguished from links/spans/refs by the absence of a trailing
+        // `(url)`, `[ref]`, or `{attrs}` suffix. The bracket MUST contain at
+        // least one `@key` item.
+        'citation': {
+            pattern: /\[\+?(?:[^\]@]*@[A-Za-z0-9_][A-Za-z0-9_.:#$%&+?<>~\/-]*(?:[^\]]*)?)\](?!\(|\[|\{)/,
+            greedy: true,
+            alias: 'string',
+            inside: {
+                // Integral marker `+` and suppress-author `-`
+                'operator': /(?<=^\[)\+|(?<=[@;]\s*)-(?=@)/,
+                // The `@key` itself
+                'function': /@[A-Za-z0-9_][A-Za-z0-9_.:#$%&+?<>~\/-]*/,
+                // Separators and locator punctuation
+                'punctuation': /\[|\]|;|,/,
+            },
+        },
+
+        // Code callouts (Tier-2 §10): <n> markers trailing a code-fence line
+        // or leading a callout-list item. Only pure-digit content.
+        'code-callout': {
+            pattern: /<\d+>/,
+            alias: 'symbol',
+        },
+
+        // Inline links: [text](url "title") and reference [text][id]
+        'url': [
+            {
+                // The link text may be empty ([](url), spec corpus 03-links-8)
+                // and the title may contain backslash-escaped quotes:
+                // [t](/url "ti\"tle") (spec corpus 03-links-4).
+                pattern: /\[[^\]]*\]\([^\s)]+(?:[ \t]+"(?:[^"\\]|\\[\s\S])*")?\)/,
+                greedy: true,
+                inside: {
+                    'string': /"(?:[^"\\]|\\[\s\S])*"/,
+                    'punctuation': /\[|\]\(|\)/,
+                },
+            },
+            {
+                pattern: /\[[^\]]+\]\[[^\]]*\]/,
+                greedy: true,
+                inside: {
+                    'punctuation': /\[|\]\[|\]/,
+                },
+            },
+            {
+                // autolink <https://...> and <mailto-ish>
+                pattern: /<[a-zA-Z][a-zA-Z0-9+.-]*:[^>\s]+>|<[^>\s@]+@[^>\s]+>/,
+                greedy: true,
+            },
+        ],
+
+        // An EMPTY attribute block, only where it is glued to a preceding `]`
+        // (`[x]{}` -> <span>x</span>). A bare `{}` in prose is literal text
+        // (corpus 123). Must precede 'span', which would otherwise consume the
+        // `]` this rule anchors on.
+        'span-empty-attrs': spanEmptyAttrs,
+
+        // Bracketed span with attributes: [text]{.class}
+        'span': {
+            pattern: /\[[^\^\]][^\]]*\](?=\{)/,
+            alias: 'string',
+        },
+
+        // Extension inline call: :name[content]{attrs}
+        'extension': {
+            pattern: /:[a-zA-Z][\w-]*\[[^\]]*\](?:\{[^}]*\})?/,
+            alias: 'function',
+            inside: {
+                'function': /:[a-zA-Z][\w-]*/,
+                'attributes': attributes,
+                'punctuation': /\[|\]/,
+            },
+        },
+
+        // CriticMarkup: {+ins+} {-del-} {~old~>new~} {#comment#}
+        'inserted': {
+            pattern: /\{\+[^}]*\+\}/,
+            alias: 'inserted',
+        },
+        'deleted': {
+            pattern: /\{-[^}]*-\}/,
+            alias: 'deleted',
+        },
+        'changed': {
+            pattern: /\{~[^~]*~>[^~]*~\}/,
+            alias: 'important',
+        },
+        'critic-comment': {
+            pattern: /\{#[^}]*#\}/,
+            alias: 'comment',
+        },
+
+        // Forced brace emphasis must beat the attribute rule (`{_path_}`).
+        'forced-bold': inline['forced-bold'],
+        'forced-italic': inline['forced-italic'],
+        'forced-underline': inline['forced-underline'],
+        'forced-strike': inline['forced-strike'],
+
+        // Attribute blocks attached to the preceding element
+        'attributes': attributes,
+
+        // Inline emphasis family (must come after code/links/attributes)
+        'bold-italic': inline['bold-italic'],
+        'bold': inline['bold'],
+        'italic': inline['italic'],
+        'underline': inline['underline'],
+        'strike': inline['strike'],
+        'highlight': inline['highlight'],
+        'superscript': inline['superscript'],
+        'subscript': inline['subscript'],
+
+        // Mentions @name, tags #tag, symbols :name:
+        'mention': {
+            pattern: /(^|[^\w.])@[A-Za-z0-9_][\w-]*/,
+            lookbehind: true,
+            alias: 'variable',
+        },
+        'tag': {
+            pattern: /(^|[^\w])#[A-Za-z0-9_][\w-]*/,
+            lookbehind: true,
+            alias: 'variable',
+        },
+        'symbol': {
+            // Symbol shortcode (e.g. emoji). Parser shape: name starts
+            // alphanumeric, then word chars, `+` or `-` (`:+1:` stays literal).
+            pattern: /(^|[^\w]):[A-Za-z0-9+-][\w+-]*:/,
+            lookbehind: true,
+            alias: 'constant',
+        },
+
+        // Escapes and smart typography
+        'escape': {
+            pattern: /\\[\\`*_{}[\]()#+\-.!~^/<>@%|=,]/,
+            alias: 'constant',
+        },
+        'typography': {
+            pattern: /\.\.\.|---|--|<->|<-|->|=>|!=|<=|>=|\+-|\(c\)|\(r\)|\(tm\)/,
+            alias: 'constant',
+        },
+    };
+
+    // Allow Carve to be embedded and to embed itself (e.g. inside ```carve).
+    Prism.languages.carvemd = Prism.languages.carve;
+})(
+    (typeof globalThis !== 'undefined' && globalThis.Prism)
+        ? globalThis.Prism
+        : (typeof window !== 'undefined' && window.Prism)
+            ? window.Prism
+            : (typeof global !== 'undefined' && global.Prism)
+                ? global.Prism
+                : undefined
+);

package/shiki/carve.css

@@ -0,0 +1,46 @@
+/**
+ * Companion CSS for carve-grammars/shiki.
+ *
+ * Applies the Shiki dual-theme CSS variables (VitePress emits them but
+ * only applies color by default) and styles the data-carve-* attributes
+ * emitted by the carveStylingTransformer.
+ */
+
+/* Apply Shiki font-style, font-weight and text-decoration CSS variables */
+.vp-code span {
+  font-style: var(--shiki-light-font-style, inherit);
+  font-weight: var(--shiki-light-font-weight, inherit);
+  text-decoration: var(--shiki-light-text-decoration, inherit);
+}
+
+.dark .vp-code span {
+  font-style: var(--shiki-dark-font-style, inherit);
+  font-weight: var(--shiki-dark-font-weight, inherit);
+  text-decoration: var(--shiki-dark-text-decoration, inherit);
+}
+
+/* Carve token styling the Shiki HTML emitter can't express directly.
+   Use html prefix to outrank `html.dark .vp-code span` (specificity 0,2,2). */
+html .vp-code span[data-carve-strike] {
+  text-decoration: line-through;
+}
+
+html .vp-code span[data-carve-super] {
+  vertical-align: super;
+  font-size: 0.75em;
+}
+
+html .vp-code span[data-carve-sub] {
+  vertical-align: sub;
+  font-size: 0.75em;
+}
+
+html .vp-code span[data-carve-highlight] {
+  background: rgba(255, 213, 0, 0.35);
+  padding: 0 2px;
+  border-radius: 2px;
+}
+
+html.dark .vp-code span[data-carve-highlight] {
+  background: rgba(255, 213, 0, 0.18);
+}