@markup-carve/carve-grammars 0.1.2

package/highlightjs/carve.js

@@ -0,0 +1,537 @@
+/**
+ * Carve language definition for highlight.js
+ *
+ * Carve is a Djot-derived markup language with distinct inline delimiters:
+ * emphasis is /text/ (not _text_), underline is _text_, strikethrough is
+ * ~text~ (Djot uses ~ for subscript), subscript is ,text, and highlight is
+ * =text= (Djot uses {=text=}). Strong (*text*), superscript (^text^),
+ * insert ({+text+}) and delete ({-text-}) match Djot.
+ *
+ * This file is a UMD module so it works in every documented integration:
+ *
+ * - ESM: `import carve from 'carve-grammars/highlightjs/carve.js'` (resolved to
+ *   the carve.mjs shim via the package `exports` map), then
+ *   `hljs.registerLanguage('carve', carve)`.
+ * - Classic `<script src=".../highlightjs/carve.js">` after highlight.js: it
+ *   self-registers against the global `hljs` (and exposes `globalThis.carveHljs`).
+ * - CommonJS contexts that load this file as CommonJS get the factory on
+ *   `module.exports`.
+ *
+ * A top-level `export default` is intentionally NOT used: that would be a
+ * syntax error when the file is loaded as a classic browser script.
+ *
+ * @see https://github.com/markup-carve/carve for the Carve specification
+ */
+(function (root, factory) {
+    var carve = factory();
+    if (typeof module === 'object' && module.exports) {
+        module.exports = carve;
+    }
+    if (root) {
+        // Exposed for the ESM shim (carve.mjs) and for classic <script> use.
+        root.carveHljs = carve;
+        if (root.hljs && typeof root.hljs.registerLanguage === 'function') {
+            root.hljs.registerLanguage('carve', carve);
+        }
+    }
+}(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+    'use strict';
+    /**
+     * @param {object} [hljs] - the highlight.js instance (unused, kept for the
+     *   standard language-definition signature).
+     * @returns {object} a highlight.js language definition.
+     */
+    return function carve(hljs) {
+    // Block attributes: {.class #id key=value} or boolean {reversed}
+    // Excludes special inline syntax like {= {+ {- {%
+    // 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.
+    const ATTR_ITEM = /(?:[.#][A-Za-z_][\w-]*|[A-Za-z_][\w:-]*(?:=(?:"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|[^\s"'{}]+))?)/.source;
+    // Forced intraword family (PART 9 S22). Content may contain the delimiter
+    // (`{/a/b/}` is <em>a/b</em>), so the run ends at the closing `X}`. These
+    // must precede ATTRIBUTE, or `{_path_}` reads as a boolean attribute.
+    const FORCED_STRONG = { className: 'strong', begin: /\{\*(?=\S)/, end: /\*\}/, relevance: 5 };
+    const FORCED_EMPHASIS = { className: 'emphasis', begin: /\{\/(?=\S)/, end: /\/\}/, relevance: 5 };
+    const FORCED_UNDERLINE = { className: 'emphasis', begin: /\{_(?=\S)/, end: /_\}/, relevance: 5 };
+    const FORCED_STRIKE = { className: 'deletion', begin: /\{~(?=\S)(?!.*~>)/, end: /~\}/, relevance: 5 };
+
+    const ATTRIBUTE_EMPTY = {
+        className: 'attr',
+        // Valid only glued to a preceding `]` (`[x]{}`); a bare `{}` is literal.
+        begin: /(?<=\])\{\s*\}/,
+        relevance: 5,
+    };
+    const ATTRIBUTE = {
+        className: 'attr',
+        begin: new RegExp('\\{\\s*' + ATTR_ITEM + '(?:\\s+' + ATTR_ITEM + ')*\\s*\\}'),
+        relevance: 5,
+    };
+
+    // Headings: # to ######
+    const HEADING = {
+        className: 'section',
+        begin: /^#{1,6}\s/,
+        end: /$/,
+        relevance: 10,
+    };
+
+    // Emphasis (Carve): /text/ - the begin guard avoids URLs and paths
+    // (a/b, ://); the end is a closing slash not followed by word char/slash.
+    const EMPHASIS = {
+        className: 'emphasis',
+        begin: /(?<![\w:/])\/(?=\S)/,
+        end: /\/(?![\w/])/,
+        relevance: 0,
+    };
+
+    // Underline (Carve): _text_ - not in the middle of words
+    const UNDERLINE = {
+        className: 'emphasis',
+        begin: /(?<!\w)_(?!\s)/,
+        end: /_(?!\w)/,
+        relevance: 0,
+    };
+
+    // Strong: *text* - not in the middle of words, can contain emphasis.
+    // Excludes *[ which is abbreviation-definition syntax.
+    const STRONG = {
+        className: 'strong',
+        begin: /(?<!\w)\*(?![\s\[])/,
+        end: /\*(?!\w)/,
+        relevance: 0,
+        contains: [EMPHASIS, UNDERLINE],
+    };
+
+    // Highlight (Carve): =text= (single-char; intraword as {=text=})
+    const HIGHLIGHT = {
+        className: 'addition',
+        begin: /(?<![=\w])=(?=\S)/,
+        end: /=(?![=\w])/,
+        relevance: 3,
+    };
+
+    // Insert: {+text+}
+    const INSERT = {
+        className: 'addition',
+        begin: /\{\+/,
+        end: /\+\}/,
+        relevance: 5,
+    };
+
+    // Delete: {-text-}
+    const DELETE = {
+        className: 'deletion',
+        begin: /\{-/,
+        end: /-\}/,
+        relevance: 5,
+    };
+
+    // Strikethrough (Carve): ~text~ (Djot uses ~ for subscript instead)
+    const STRIKETHROUGH = {
+        className: 'deletion',
+        begin: /(?<!\w)~(?=\S)/,
+        end: /~(?!\w)/,
+        relevance: 2,
+    };
+
+    // Subscript (Carve): braced-only `{,text,}` - a bare `,` is literal text.
+    const SUBSCRIPT = {
+        className: 'built_in',
+        begin: /\{,(?=\S)/,
+        end: /,\}/,
+        relevance: 3,
+    };
+
+    // Superscript (Carve): braced-only `{^text^}` - a bare `^` is literal text.
+    const SUPERSCRIPT = {
+        className: 'built_in',
+        begin: /\{\^(?=\S)/,
+        end: /\^\}/,
+        relevance: 3,
+    };
+
+    // Math: $$`...`$$ (display) and $`...`$ (inline). Must precede the inline
+    // code modes - the leading $ keeps them from matching, but order is clearer.
+    const MATH_DISPLAY = {
+        className: 'string',
+        begin: /\$\$`+/,
+        end: /`+\$\$/,
+        relevance: 5,
+    };
+    const MATH_INLINE = {
+        className: 'string',
+        begin: /\$`+/,
+        end: /`+\$/,
+        relevance: 5,
+    };
+
+    // Inline code: `code` or ``code``. highlight.js has no begin->end
+    // backreference to match fence widths, so handle the two common widths
+    // explicitly - double backticks first, so an embedded single backtick
+    // (``a ` b``) does not close the span early.
+    const INLINE_CODE_DOUBLE = {
+        className: 'code',
+        begin: /``/,
+        end: /``/,
+        relevance: 0,
+    };
+    const INLINE_CODE_SINGLE = {
+        className: 'code',
+        begin: /`/,
+        end: /`/,
+        relevance: 0,
+    };
+
+    // Inline links: [text](url) with optional trailing attributes
+    const LINK = {
+        className: 'link',
+        begin: /\[[^\]]*\]\([^)]*\)(\{[^}]+\})?/,
+        relevance: 5,
+    };
+
+    // Autolinks: <https://...> or <mailto:...>
+    const AUTOLINK = {
+        className: 'link',
+        begin: /<(?:https?:\/\/|mailto:)[^>]+>/,
+        relevance: 5,
+    };
+
+    // Email autolinks: <user@example.com>
+    const EMAIL_AUTOLINK = {
+        className: 'link',
+        begin: /<[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}>/,
+        relevance: 5,
+    };
+
+    // Images: ![alt](url) with optional trailing attributes
+    const IMAGE = {
+        className: 'link',
+        begin: /!\[[^\]]*\]\([^)]*\)(\{[^}]+\})?/,
+        relevance: 5,
+    };
+
+    // Reference links: [text][ref] with optional trailing attributes
+    const REFERENCE_LINK = {
+        className: 'link',
+        begin: /\[[^\]]+\]\[[^\]]*\](\{[^}]+\})?/,
+        relevance: 5,
+    };
+
+    // Spans with attributes: [text]{.class} or [text]{#id}
+    const SPAN = {
+        className: 'string',
+        // Only the bracket run; the trailing `{...}` is left to ATTRIBUTE so it
+        // scopes as an attribute block rather than vanishing into the span.
+        begin: /\[[^\]]+\](?=\{)/,
+        relevance: 5,
+    };
+
+    // Reference definitions: [ref]: url
+    const REFERENCE_DEF = {
+        className: 'symbol',
+        begin: /^\[[^\]^\]]+\]:/,
+        end: /$/,
+        relevance: 10,
+    };
+
+    // Footnote references: [^note]
+    const FOOTNOTE_REF = {
+        className: 'symbol',
+        begin: /\[\^[^\]]+\]/,
+        relevance: 5,
+    };
+
+    // Citations (Tier-2 §22): [@key], [+@key], [@key, p.10], [@a; @b]
+    // A bracket whose content holds at least one `@key` with no trailing
+    // `(url)`, `[ref]`, or `{attrs}` suffix. The negative lookahead is handled
+    // by position in the contains array (SPAN and REFERENCE_LINK are checked
+    // first to claim those suffixed forms).
+    const CITATION = {
+        className: 'symbol',
+        begin: /\[\+?(?:[^\]@]*@[A-Za-z0-9_][A-Za-z0-9_.:#$%&+?<>~\/-]*[^\]]*)\](?!\(|\[|\{)/,
+        relevance: 8,
+    };
+
+    // Code callouts (Tier-2 §10): <n> markers trailing a code-fence line or
+    // leading a callout-list item.
+    const CODE_CALLOUT = {
+        className: 'symbol',
+        begin: /<\d+>/,
+        relevance: 5,
+    };
+
+    // Footnote definitions: [^note]: content
+    const FOOTNOTE_DEF = {
+        className: 'symbol',
+        begin: /^\[\^[^\]]+\]:/,
+        end: /$/,
+        relevance: 10,
+    };
+
+    // Abbreviation definitions: *[ABBR]: text
+    const ABBREVIATION_DEF = {
+        className: 'symbol',
+        begin: /^\*\[[^\]]+\]:/,
+        end: /$/,
+        relevance: 10,
+    };
+
+    // Blockquotes: > text
+    const BLOCKQUOTE = {
+        className: 'quote',
+        begin: /^>/,
+        end: /$/,
+        relevance: 0,
+    };
+
+    // Horizontal rules: --- or *** or ___
+    const HORIZONTAL_RULE = {
+        className: 'meta',
+        begin: /^(-{3,}|\*{3,}|_{3,})$/,
+        relevance: 10,
+    };
+
+    // Bullet list items: - or *
+    const LIST_BULLET = {
+        className: 'bullet',
+        // A marker line may carry several markers (`- - A`, corpus 103).
+        begin: /^[ \t]*(?:[-*][ \t]+)*[-*](?=\s)/,
+        relevance: 0,
+    };
+
+    // Numbered list items: decimal (1.), alpha (a. A.), roman (i. I.)
+    const LIST_NUMBER = {
+        className: 'bullet',
+        begin: /^[ \t]*(\d+[.)]|[a-zA-Z][.)]|[ivxlcdmIVXLCDM]+[.)])(?=\s)/,
+        relevance: 0,
+    };
+
+    // Task list items: - [ ] or - [x]
+    const TASK_LIST = {
+        className: 'bullet',
+        begin: /^[ \t]*[-*]\s\[[ xX_]\]/,
+        relevance: 5,
+    };
+
+    // Definition list terms: : term
+    const DEFINITION_TERM = {
+        className: 'title',
+        begin: /^: /,
+        end: /$/,
+        relevance: 5,
+    };
+
+    // Code fence opening: ``` or ~~~ with optional language
+    const CODE_FENCE_START = {
+        className: 'keyword',
+        begin: /^[`~]{3,}\s*[a-zA-Z]*$/,
+        relevance: 10,
+    };
+
+    // Code fence closing: ``` or ~~~
+    const CODE_FENCE_END = {
+        className: 'keyword',
+        begin: /^[`~]{3,}$/,
+        relevance: 10,
+    };
+
+    // Div block opening: ::: with optional type, "title", [label], or the
+    // | / \ layout tokens. Strict shapes only - unquoted or curly-quoted
+    // trailing text is a paragraph, not a fence, and must not highlight.
+    const DIV_BLOCK_START = {
+        className: 'keyword',
+        begin: /^:{3,}(?:[ \t]*(?:\||\\)|[ \t]*[a-zA-Z_][\w-]*(?:[ \t]+"[^"\n]*")?(?:[ \t]+\[[^\]\n]*\])?|[ \t]*\[[^\]\n]*\])?[ \t]*$/,
+        relevance: 10,
+    };
+
+    // Div block closing: :::
+    const DIV_BLOCK_END = {
+        className: 'keyword',
+        begin: /^:{3,}$/,
+        relevance: 10,
+    };
+
+    // Inline comments: {% comment %}
+    // Carve comments: `%%` to end of line, a `%%%` fenced block, and the
+    // CriticMarkup comment `{# ... #}`. (The previous rule here matched
+    // `{% ... %}`, which is Jinja/Liquid syntax and does not exist in Carve.)
+    const LINE_COMMENT = {
+        className: 'comment',
+        begin: /(?:^|(?<=\s))%%(?!%)/,
+        end: /$/,
+        relevance: 5,
+    };
+    const BLOCK_COMMENT = {
+        className: 'comment',
+        begin: /^%%%\s*$/,
+        end: /^%%%\s*$/,
+        relevance: 10,
+    };
+    const CRITIC_SUB = {
+        className: 'meta',
+        // The `~>` arrow is what distinguishes a substitution from a forced
+        // strikethrough (`{~gone~}`), so it is required here.
+        begin: /\{~(?=[^}\n]*~>)/,
+        end: /~\}/,
+        relevance: 10,
+    };
+    const CRITIC_COMMENT = {
+        className: 'comment',
+        // The closing `#}` is required, or this would swallow an attribute
+        // block whose id comes first (`{#id .class}`).
+        begin: /\{#(?=[^}\n]*#\})/,
+        end: /#\}/,
+        relevance: 5,
+    };
+
+    // Mentions and tags: @name / #name (a heading `#` is line-anchored and is
+    // matched earlier, so an inline `#tag` is unambiguous).
+    const MENTION = {
+        className: 'symbol',
+        begin: /(?<![\w@])@[A-Za-z0-9][\w-]*(?:\.[\w-]+)*/,
+        relevance: 5,
+    };
+    const TAG = {
+        className: 'symbol',
+        begin: /(?<![\w#])#[A-Za-z0-9][\w-]*(?:\.[\w-]+)*/,
+        relevance: 5,
+    };
+
+    // Table separator: |---|---|
+    const TABLE_SEPARATOR = {
+        className: 'meta',
+        begin: /^\|[-:| ]+\|$/,
+        relevance: 5,
+    };
+
+    // Line blocks: | text (for poetry) - must precede TABLE_ROW
+    const LINE_BLOCK = {
+        className: 'string',
+        begin: /^\| /,
+        end: /$/,
+        relevance: 3,
+    };
+
+    // Table rows: | cell | cell |
+    const TABLE_ROW = {
+        className: 'string',
+        begin: /^\|/,
+        end: /\|(\{[^}]*\})?$/,
+        relevance: 2,
+    };
+
+    // Captions: ^ caption text
+    const CAPTION = {
+        className: 'title',
+        begin: /^\^ /,
+        end: /$/,
+        relevance: 5,
+    };
+
+    // Raw format marker: {=html} or {=latex}
+    const RAW_FORMAT = {
+        className: 'meta',
+        begin: /\{=[a-zA-Z]+\}/,
+        relevance: 5,
+    };
+
+    // Escaped characters: \* \[ etc
+    const ESCAPE = {
+        className: 'symbol',
+        begin: /\\[!"#$%&'()*+,.\/:;<=>?@\[\\\]^_`{|}~-]/,
+        relevance: 0,
+    };
+
+    // Hard line break: \ at end of line
+    const HARD_BREAK = {
+        className: 'meta',
+        begin: /\\$/,
+        relevance: 2,
+    };
+
+    // Symbol shortcodes (e.g. emoji): :name: (parser shape - name starts
+    // alphanumeric, then word chars, `+` or `-`; no whitespace, so
+    // `a : b : c` stays text)
+    const SYMBOL = {
+        className: 'symbol',
+        begin: /(?<!\w):[A-Za-z0-9+-][\w+-]*:/,
+        relevance: 0,
+    };
+
+    return {
+        name: 'Carve',
+        aliases: ['carve'],
+        case_insensitive: false,
+        contains: [
+            // NOTE: front matter is intentionally NOT highlighted. It is valid
+            // only at the very top of the document, but highlight.js has no
+            // document-start anchor, so a `^---$` begin would also match a bare
+            // `---` horizontal rule mid-document and swallow everything up to
+            // the next `---`. The horizontal-rule rule below handles `---`
+            // lines instead. (Prism anchors front matter via `^` with no `m`
+            // flag; see prism/carve.js.)
+
+            // Block-level elements (order matters - more specific first)
+            HEADING,
+            CODE_FENCE_START,
+            CODE_FENCE_END,
+            DIV_BLOCK_START,
+            DIV_BLOCK_END,
+            HORIZONTAL_RULE,
+            TABLE_SEPARATOR,
+            LINE_BLOCK,        // Must be before TABLE_ROW (both start with |)
+            TABLE_ROW,
+            BLOCKQUOTE,
+            CAPTION,
+            TASK_LIST,         // Must be before LIST_BULLET
+            LIST_BULLET,
+            LIST_NUMBER,
+            DEFINITION_TERM,
+            FOOTNOTE_DEF,      // Must be before REFERENCE_DEF
+            ABBREVIATION_DEF,  // Must be before REFERENCE_DEF (*[ABBR]: vs [ref]:)
+            REFERENCE_DEF,
+
+            // Inline elements (order matters - more specific first)
+            FOOTNOTE_REF,
+            IMAGE,             // Must be before LINK (starts with !)
+            SPAN,              // Must be before LINK ([text]{attr} vs [text](url))
+            REFERENCE_LINK,    // Must be before LINK ([text][ref] vs [text](url))
+            CITATION,          // Must be after SPAN/REF_LINK (no (url)/[ref]/{attr} tail)
+            CODE_CALLOUT,      // <n> callout markers
+            SYMBOL,            // :name: shortcodes
+            LINK,
+            AUTOLINK,
+            EMAIL_AUTOLINK,
+            RAW_FORMAT,        // {=html} - must be before INSERT/DELETE braces
+            INSERT,            // {+text+}
+            DELETE,            // {-text-}
+            BLOCK_COMMENT,     // %%% fence - before LINE_COMMENT
+            LINE_COMMENT,      // %% to end of line
+            CRITIC_SUB,        // {~old~>new~} - before FORCED_STRIKE
+            CRITIC_COMMENT,    // {# ... #} - must be before ATTRIBUTE
+            MENTION,
+            TAG,
+            HIGHLIGHT,         // =text=
+            SUBSCRIPT,         // ,text,
+            SUPERSCRIPT,       // ^text^
+            STRONG,
+            EMPHASIS,          // /text/
+            UNDERLINE,         // _text_
+            STRIKETHROUGH,     // ~text~
+            MATH_DISPLAY,      // $$`...`$$ - before inline code (leading $)
+            MATH_INLINE,       // $`...`$
+            INLINE_CODE_DOUBLE, // ``code`` - before single
+            INLINE_CODE_SINGLE, // `code`
+            FORCED_STRONG,
+            FORCED_EMPHASIS,
+            FORCED_UNDERLINE,
+            FORCED_STRIKE,
+            ATTRIBUTE_EMPTY,
+            ATTRIBUTE,
+            ESCAPE,
+            HARD_BREAK,
+        ],
+    };
+    };
+}));

package/highlightjs/carve.mjs

@@ -0,0 +1,25 @@
+/**
+ * ESM entry for the Carve highlight.js grammar.
+ *
+ * The grammar itself lives in the UMD file `carve.js` (so it can also load as a
+ * classic `<script>` or via CommonJS). This shim runs that module for its side
+ * effect - which assigns `globalThis.carveHljs` - and re-exports the language
+ * factory as the default export, so ESM consumers get the documented:
+ *
+ * ```js
+ * import hljs from 'highlight.js';
+ * import carve from 'carve-grammars/highlightjs/carve.js';
+ * hljs.registerLanguage('carve', carve);
+ * ```
+ *
+ * (The package `exports` map routes the ESM `import` of `./highlightjs/carve.js`
+ * to this file.)
+ *
+ * @module carve-grammars/highlightjs/carve
+ */
+import './carve.js';
+
+/** @type {(hljs?: object) => object} */
+const carve = globalThis.carveHljs;
+
+export default carve;

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@markup-carve/carve-grammars",
+  "version": "0.1.2",
+  "description": "Grammars for the Carve markup language: Tiptap editor kit + serializer, plus Prism, highlight.js and TextMate syntax-highlighting grammars",
+  "type": "module",
+  "main": "tiptap/index.js",
+  "scripts": {
+    "test": "node tests/coverage-test.js && node tests/snapshot-test.js && node tests/roundtrip-test.js && node tests/serializer-test.js && node tests/tabs-roundtrip-test.js && node tests/parse-test.js && node tests/grammar-test.js && node tests/shiki-test.js && node tests/engine-sweep-test.js && node tests/textmate-sweep-test.js",
+    "test:coverage": "node tests/coverage-test.js",
+    "test:snapshot": "node tests/snapshot-test.js",
+    "test:roundtrip": "node tests/roundtrip-test.js",
+    "snapshots:update": "UPDATE_SNAPSHOTS=1 node tests/snapshot-test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markup-carve/carve-grammars.git"
+  },
+  "keywords": [
+    "carve",
+    "tiptap",
+    "prosemirror",
+    "wysiwyg",
+    "serializer",
+    "markup",
+    "syntax-highlighting",
+    "prism",
+    "prismjs",
+    "highlight.js",
+    "hljs"
+  ],
+  "author": "markup-carve",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/markup-carve/carve-grammars/issues"
+  },
+  "homepage": "https://github.com/markup-carve/carve-grammars#readme",
+  "files": [
+    "tiptap/",
+    "prism/",
+    "highlightjs/",
+    "shiki/",
+    "textmate/",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./tiptap/index.js",
+    "./tiptap": "./tiptap/index.js",
+    "./tiptap/*": "./tiptap/*",
+    "./prism/carve.js": "./prism/carve.js",
+    "./prism/*": "./prism/*",
+    "./highlightjs/carve.js": {
+      "import": "./highlightjs/carve.mjs",
+      "default": "./highlightjs/carve.js"
+    },
+    "./highlightjs/*": "./highlightjs/*",
+    "./shiki": "./shiki/index.js",
+    "./shiki/carve.css": "./shiki/carve.css",
+    "./textmate/carve.tmLanguage.json": "./textmate/carve.tmLanguage.json"
+  },
+  "peerDependencies": {
+    "@shikijs/themes": "^2 || ^3",
+    "@tiptap/core": "^2",
+    "@tiptap/extension-underline": "^2",
+    "@tiptap/starter-kit": "^2",
+    "highlight.js": "^11",
+    "prismjs": "^1"
+  },
+  "peerDependenciesMeta": {
+    "@tiptap/core": {
+      "optional": true
+    },
+    "@tiptap/starter-kit": {
+      "optional": true
+    },
+    "@tiptap/extension-underline": {
+      "optional": true
+    },
+    "prismjs": {
+      "optional": true
+    },
+    "highlight.js": {
+      "optional": true
+    },
+    "@shikijs/themes": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@markup-carve/carve": "github:markup-carve/carve-js",
+    "@shikijs/themes": "^3.13.0",
+    "@tiptap/core": "^2.27.2",
+    "@tiptap/extension-bullet-list": "^2.27.2",
+    "@tiptap/extension-code-block": "^2.27.2",
+    "@tiptap/extension-hard-break": "^2.27.2",
+    "@tiptap/extension-highlight": "^2.27.2",
+    "@tiptap/extension-image": "^2.27.2",
+    "@tiptap/extension-link": "^2.27.2",
+    "@tiptap/extension-list-item": "^2.27.2",
+    "@tiptap/extension-subscript": "^2.27.2",
+    "@tiptap/extension-superscript": "^2.27.2",
+    "@tiptap/extension-table": "^2.27.2",
+    "@tiptap/extension-table-cell": "^2.27.2",
+    "@tiptap/extension-table-header": "^2.27.2",
+    "@tiptap/extension-table-row": "^2.27.2",
+    "@tiptap/extension-task-item": "^2.27.2",
+    "@tiptap/extension-task-list": "^2.27.2",
+    "@tiptap/extension-underline": "^2.27.2",
+    "@tiptap/pm": "^2.27.2",
+    "@tiptap/starter-kit": "^2.27.2",
+    "happy-dom": "^20.10.6",
+    "highlight.js": "^11.11.1",
+    "prismjs": "^1.30.0",
+    "shiki": "^4.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}