react-codemirror-runmode 2.2.1 → 2.4.0

package/.oxfmtrc.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "arrowParens": "avoid",
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "sortImports": true,
+  "sortPackageJson": true
+}

package/.oxlintrc.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "plugins": ["typescript", "unicorn", "oxc", "react"],
+  "categories": {
+    "correctness": "error"
+  },
+  "settings": {
+    "react": {
+      "version": "19"
+    }
+  },
+  "rules": {
+    "typescript/no-explicit-any": "off",
+    "typescript/ban-ts-comment": "off",
+    "typescript/no-this-alias": "off",
+    "typescript/no-unused-vars": [
+      "warn",
+      {
+        "argsIgnorePattern": "^_",
+        "varsIgnorePattern": "^_",
+        "caughtErrorsIgnorePattern": "^_"
+      }
+    ],
+    "no-useless-escape": "off",
+    "no-unused-expressions": "off",
+    "prefer-const": "error",
+    "no-unused-vars": "off",
+    "react-hooks/exhaustive-deps": "off"
+  },
+  "ignorePatterns": ["dist/**", "node_modules/**"]
+}

package/README.md

@@ -37,28 +37,62 @@ You can apply custom themes using CodeMirror's theme system. This component uses
 Props:
 
 - `lang`: `string` - The name of the language
-- `theme`: [`Highlighter`](https://lezer.codemirror.net/docs/ref/#highlight.Highlighter) - The highlight style
+- `theme`: [`Highlighter`](https://lezer.codemirror.net/docs/ref/#highlight.Highlighter)` | readonly Highlighter[]` - The highlight style. Pass an array to combine several highlighters; their emitted classes are merged per token (e.g. a generic token theme plus a markdown-specific one).
 - `children`: `string` - The code to highlight
 - `fallbackLanguage`: `Language` - Optional fallback language to use if the specified language isn't found
 - `languages`: `LanguageDescription[]` - Optional custom list of language descriptions
+- `markdownConfig`: `MarkdownConfig` - Optional markdown parser options, applied only when `lang` is `markdown`/`md`. See [Markdown highlighting](#markdown-highlighting).
 
-### `highlightCode<o>(languageName, input, highlightStyle, fallbackLanguage?, languages?, callback): Promise<Output[]>`
+### `highlightCode<o>(languageName, input, highlighter, fallbackLanguage?, languages?, callback, markdownConfig?): Promise<Output[]>`
 
 Parameters:
 
 - `languageName`: `string` - The name of the language
 - `input`: `string` - The code to highlight
-- `highlighter`: [`Highlighter`](https://lezer.codemirror.net/docs/ref/#highlight.Highlighter) - The highlight style
+- `highlighter`: [`Highlighter`](https://lezer.codemirror.net/docs/ref/#highlight.Highlighter)` | readonly Highlighter[]` - The highlight style, or an array of styles whose classes are merged
 - `fallbackLanguage`: `Language` - Optional fallback language to use if the specified language isn't found
 - `languages`: `LanguageDescription[]` - Optional custom list of language descriptions
 - `callback`: `(text: string, style: string | null, from: number, to: number) => Output)` - A callback function that converts the parsed tokens
+- `markdownConfig`: `MarkdownConfig` - Optional markdown parser options, applied only when `languageName` is `markdown`/`md`
 
-### `getCodeParser(languageName, defaultLanguage?): Promise<Parser | null>`
+### `getCodeParser(input, languageName, fallbackLanguage?, languages?, markdownConfig?): Promise<Parser | null>`
 
 Parameters:
 
-- `languageName: string` - The name of the language
-- `defaultLanguage?: Language` - A fallback language (Optional)
+- `input`: `string` - The code to highlight (used to preload nested code-fence languages for markdown)
+- `languageName`: `string` - The name of the language
+- `fallbackLanguage?`: `Language` - A fallback language (Optional)
+- `languages?`: `LanguageDescription[]` - Optional custom list of language descriptions
+- `markdownConfig?`: `MarkdownConfig` - Optional markdown parser options, applied only when `languageName` is `markdown`/`md`
+
+## Markdown highlighting
+
+When `lang` is `markdown` (or `md`), the markdown source is parsed with
+[`@codemirror/lang-markdown`](https://github.com/codemirror/lang-markdown). By default this
+uses a **CommonMark** base with no extensions. Pass `markdownConfig` to opt into GFM and/or
+custom [Lezer markdown extensions](https://github.com/lezer-parser/markdown#user-content-markdownextension):
+
+```javascript
+import { Highlighter } from 'react-codemirror-runmode'
+import { markdownLanguage } from '@codemirror/lang-markdown'
+
+// GFM (tables, strikethrough, task lists, autolinks) + custom extensions,
+// with two highlighters whose classes are merged per token.
+;<Highlighter
+  lang="markdown"
+  theme={[tokenHighlighter, mdTokenHighlighter]}
+  markdownConfig={{
+    base: markdownLanguage,
+    extensions: [/* your @lezer/markdown extensions */]
+  }}
+>
+  {markdownSource}
+</Highlighter>
+```
+
+`MarkdownConfig` mirrors the `base` and `extensions` options of `markdown()`. Prefer a stable
+reference for `markdownConfig` (e.g. a module-level constant) to avoid re-highlighting on every
+render.
 
 ## License
 

package/dist/highlight.d.ts

@@ -1,6 +1,16 @@
-import { Parser } from '@lezer/common';
+import { markdown } from '@codemirror/lang-markdown';
 import { Language, LanguageDescription } from '@codemirror/language';
+import { Parser } from '@lezer/common';
 import { Highlighter } from '@lezer/highlight';
-export declare function getMarkdownParser(input: string, languages?: LanguageDescription[]): Promise<Parser>;
-export declare function getCodeParser(input: string, languageName: string, fallbackLanguage?: Language, languages?: LanguageDescription[]): Promise<Parser | null>;
-export declare function highlightCode<Output>(languageName: string, input: string, highlighter: Highlighter, fallbackLanguage: Language | undefined, languages: LanguageDescription[] | undefined, callback: (text: string, style: string | null, from: number, to: number) => Output): Promise<Output[]>;
+/**
+ * Configuration for the markdown parser used when highlighting `markdown`/`md`
+ * input. Mirrors the relevant subset of `@codemirror/lang-markdown`'s `markdown()`
+ * options so callers can opt into GFM (`base: markdownLanguage`) and custom Lezer
+ * markdown extensions (e.g. app-specific node props, GFM alerts).
+ *
+ * Defaults match `@codemirror/lang-markdown`: a CommonMark base with no extensions.
+ */
+export type MarkdownConfig = Pick<NonNullable<Parameters<typeof markdown>[0]>, 'base' | 'extensions'>;
+export declare function getMarkdownParser(input: string, languages?: LanguageDescription[], markdownConfig?: MarkdownConfig): Promise<Parser>;
+export declare function getCodeParser(input: string, languageName: string, fallbackLanguage?: Language, languages?: LanguageDescription[], markdownConfig?: MarkdownConfig): Promise<Parser | null>;
+export declare function highlightCode<Output>(languageName: string, input: string, highlighter: Highlighter | readonly Highlighter[], fallbackLanguage: Language | undefined, languages: LanguageDescription[] | undefined, callback: (text: string, style: string | null, from: number, to: number) => Output, markdownConfig?: MarkdownConfig): Promise<Output[]>;

package/dist/highlight.js

@@ -1,7 +1,7 @@
+import { markdown } from '@codemirror/lang-markdown';
 import { LanguageDescription } from '@codemirror/language';
-import { highlightTree } from '@lezer/highlight';
 import { languages as builtinLanguages } from '@codemirror/language-data';
-import { markdown } from '@codemirror/lang-markdown';
+import { highlightTree } from '@lezer/highlight';
 /**
  * Extract language names from code blocks in markdown text
  */
@@ -29,17 +29,18 @@ async function preloadLanguageParsers(languageNames, languages) {
         }
     }))).filter((desc) => !!desc);
 }
-export async function getMarkdownParser(input, languages = builtinLanguages) {
+export async function getMarkdownParser(input, languages = builtinLanguages, markdownConfig = {}) {
     const codeBlockLanguages = extractCodeBlockLanguages(input);
     const preloadedLanguages = await preloadLanguageParsers(codeBlockLanguages || [], languages);
     const langSupport = markdown({
+        ...markdownConfig,
         codeLanguages: preloadedLanguages
     });
     return langSupport.language.parser;
 }
-export async function getCodeParser(input, languageName, fallbackLanguage, languages = builtinLanguages) {
+export async function getCodeParser(input, languageName, fallbackLanguage, languages = builtinLanguages, markdownConfig) {
     if (languageName === 'markdown' || languageName === 'md') {
-        return await getMarkdownParser(input, languages);
+        return await getMarkdownParser(input, languages, markdownConfig);
     }
     else {
         const found = LanguageDescription.matchLanguageName(languages, languageName, true);
@@ -53,8 +54,8 @@ export async function getCodeParser(input, languageName, fallbackLanguage, langu
     }
     return fallbackLanguage ? fallbackLanguage.parser : null;
 }
-export async function highlightCode(languageName, input, highlighter, fallbackLanguage, languages, callback) {
-    const parser = await getCodeParser(input, languageName, fallbackLanguage, languages);
+export async function highlightCode(languageName, input, highlighter, fallbackLanguage, languages, callback, markdownConfig) {
+    const parser = await getCodeParser(input, languageName, fallbackLanguage, languages, markdownConfig);
     if (parser) {
         const tree = parser.parse(input);
         const output = [];

package/dist/react-highlighter.d.ts

@@ -1,11 +1,24 @@
-import React from 'react';
-import type { Highlighter as LezerHighlighter } from '@lezer/highlight';
 import type { Language, LanguageDescription } from '@codemirror/language';
+import type { Highlighter as LezerHighlighter } from '@lezer/highlight';
+import React from 'react';
+import { type MarkdownConfig } from './highlight.js';
 export type HighlighterProps = {
     lang: string;
     children: string;
-    theme: LezerHighlighter;
+    /**
+     * One highlighter, or several whose emitted classes are merged per token.
+     * Pass an array to combine, e.g. a generic token theme with a
+     * markdown-specific one.
+     */
+    theme: LezerHighlighter | readonly LezerHighlighter[];
     fallbackLanguage?: Language;
     languages?: LanguageDescription[];
+    /**
+     * Markdown parser options, used only when `lang` is `markdown`/`md`. Enables
+     * GFM (`base: markdownLanguage`) and custom Lezer markdown extensions. Pass a
+     * stable reference (e.g. a module-level constant) to avoid re-highlighting on
+     * every render.
+     */
+    markdownConfig?: MarkdownConfig;
 };
 export declare const Highlighter: React.NamedExoticComponent<HighlighterProps>;

package/dist/react-highlighter.js

@@ -1,14 +1,15 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { memo, useEffect, useState } from 'react';
 import { highlightCode } from './highlight.js';
+const WRAPPER_STYLE = { display: 'contents' };
 export const Highlighter = memo((props) => {
-    const { lang, children: code, theme, fallbackLanguage, languages } = props;
+    const { lang, children: code, theme, fallbackLanguage, languages, markdownConfig } = props;
     const [highlightedCode, setHighlightedCode] = useState(null);
     useEffect(() => {
         highlightCode(lang, code, theme, fallbackLanguage, languages, (text, style, from) => {
             return (_jsx("span", { className: style || '', children: text }, from));
-        }).then(setHighlightedCode);
-    }, [lang, code, theme]);
-    return _jsx(_Fragment, { children: highlightedCode || code });
+        }, markdownConfig).then(setHighlightedCode);
+    }, [lang, code, theme, markdownConfig]);
+    return highlightedCode ? (_jsx("span", { style: WRAPPER_STYLE, children: highlightedCode }, "highlighted")) : (_jsx("span", { style: WRAPPER_STYLE, children: code }, "pending"));
 });
 Highlighter.displayName = 'Highlighter';

package/dist/src/highlight.d.ts

@@ -0,0 +1,16 @@
+import { markdown } from '@codemirror/lang-markdown';
+import { Language, LanguageDescription } from '@codemirror/language';
+import { Parser } from '@lezer/common';
+import { Highlighter } from '@lezer/highlight';
+/**
+ * Configuration for the markdown parser used when highlighting `markdown`/`md`
+ * input. Mirrors the relevant subset of `@codemirror/lang-markdown`'s `markdown()`
+ * options so callers can opt into GFM (`base: markdownLanguage`) and custom Lezer
+ * markdown extensions (e.g. app-specific node props, GFM alerts).
+ *
+ * Defaults match `@codemirror/lang-markdown`: a CommonMark base with no extensions.
+ */
+export type MarkdownConfig = Pick<NonNullable<Parameters<typeof markdown>[0]>, 'base' | 'extensions'>;
+export declare function getMarkdownParser(input: string, languages?: LanguageDescription[], markdownConfig?: MarkdownConfig): Promise<Parser>;
+export declare function getCodeParser(input: string, languageName: string, fallbackLanguage?: Language, languages?: LanguageDescription[], markdownConfig?: MarkdownConfig): Promise<Parser | null>;
+export declare function highlightCode<Output>(languageName: string, input: string, highlighter: Highlighter | readonly Highlighter[], fallbackLanguage: Language | undefined, languages: LanguageDescription[] | undefined, callback: (text: string, style: string | null, from: number, to: number) => Output, markdownConfig?: MarkdownConfig): Promise<Output[]>;

package/dist/src/highlight.js

@@ -0,0 +1,76 @@
+import { markdown } from '@codemirror/lang-markdown';
+import { LanguageDescription } from '@codemirror/language';
+import { languages as builtinLanguages } from '@codemirror/language-data';
+import { highlightTree } from '@lezer/highlight';
+/**
+ * Extract language names from code blocks in markdown text
+ */
+function extractCodeBlockLanguages(text) {
+    const codeBlockRegex = /```(\w+)/g;
+    const languages = [];
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        languages.push(match[1]);
+    }
+    return languages;
+}
+/**
+ * Pre-load parsers for a list of language names
+ */
+async function preloadLanguageParsers(languageNames, languages) {
+    return (await Promise.all(languageNames.map(async (langName) => {
+        const found = LanguageDescription.matchLanguageName(languages, langName, true);
+        if (found instanceof LanguageDescription) {
+            if (!found.support)
+                await found.load();
+            if (found.support) {
+                return found;
+            }
+        }
+    }))).filter((desc) => !!desc);
+}
+export async function getMarkdownParser(input, languages = builtinLanguages, markdownConfig = {}) {
+    const codeBlockLanguages = extractCodeBlockLanguages(input);
+    const preloadedLanguages = await preloadLanguageParsers(codeBlockLanguages || [], languages);
+    const langSupport = markdown({
+        ...markdownConfig,
+        codeLanguages: preloadedLanguages
+    });
+    return langSupport.language.parser;
+}
+export async function getCodeParser(input, languageName, fallbackLanguage, languages = builtinLanguages, markdownConfig) {
+    if (languageName === 'markdown' || languageName === 'md') {
+        return await getMarkdownParser(input, languages, markdownConfig);
+    }
+    else {
+        const found = LanguageDescription.matchLanguageName(languages, languageName, true);
+        if (found instanceof LanguageDescription) {
+            if (!found.support)
+                await found.load();
+            return found.support ? found.support.language.parser : null;
+        }
+        else if (found)
+            return found.parser;
+    }
+    return fallbackLanguage ? fallbackLanguage.parser : null;
+}
+export async function highlightCode(languageName, input, highlighter, fallbackLanguage, languages, callback, markdownConfig) {
+    const parser = await getCodeParser(input, languageName, fallbackLanguage, languages, markdownConfig);
+    if (parser) {
+        const tree = parser.parse(input);
+        const output = [];
+        let pos = 0;
+        highlightTree(tree, highlighter, (from, to, classes) => {
+            if (from > pos)
+                output.push(callback(input.slice(pos, from), null, pos, from));
+            output.push(callback(input.slice(from, to), classes, from, to));
+            pos = to;
+        });
+        pos != tree.length &&
+            output.push(callback(input.slice(pos, tree.length), null, pos, tree.length));
+        return output;
+    }
+    else {
+        return [callback(input, null, 0, input.length)];
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './highlight.js';
+export * from './react-highlighter.js';

package/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from './highlight.js';
+export * from './react-highlighter.js';

package/dist/src/react-highlighter.d.ts

@@ -0,0 +1,24 @@
+import type { Language, LanguageDescription } from '@codemirror/language';
+import type { Highlighter as LezerHighlighter } from '@lezer/highlight';
+import React from 'react';
+import { type MarkdownConfig } from './highlight.js';
+export type HighlighterProps = {
+    lang: string;
+    children: string;
+    /**
+     * One highlighter, or several whose emitted classes are merged per token.
+     * Pass an array to combine, e.g. a generic token theme with a
+     * markdown-specific one.
+     */
+    theme: LezerHighlighter | readonly LezerHighlighter[];
+    fallbackLanguage?: Language;
+    languages?: LanguageDescription[];
+    /**
+     * Markdown parser options, used only when `lang` is `markdown`/`md`. Enables
+     * GFM (`base: markdownLanguage`) and custom Lezer markdown extensions. Pass a
+     * stable reference (e.g. a module-level constant) to avoid re-highlighting on
+     * every render.
+     */
+    markdownConfig?: MarkdownConfig;
+};
+export declare const Highlighter: React.NamedExoticComponent<HighlighterProps>;

package/dist/src/react-highlighter.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo, useEffect, useState } from 'react';
+import { highlightCode } from './highlight.js';
+export const Highlighter = memo((props) => {
+    const { lang, children: code, theme, fallbackLanguage, languages, markdownConfig } = props;
+    const [highlightedCode, setHighlightedCode] = useState(null);
+    useEffect(() => {
+        highlightCode(lang, code, theme, fallbackLanguage, languages, (text, style, from) => {
+            return (_jsx("span", { className: style || '', children: text }, from));
+        }, markdownConfig).then(setHighlightedCode);
+    }, [lang, code, theme, markdownConfig]);
+    return _jsx(_Fragment, { children: highlightedCode || code });
+});
+Highlighter.displayName = 'Highlighter';

package/package.json

@@ -1,62 +1,60 @@
 {
   "name": "react-codemirror-runmode",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "Syntax highlighting for react, utilizing CodeMirror's parser",
-  "type": "module",
-  "main": "dist/index.js",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "scripts": {
-    "build": "tsc --project tsconfig.build.json",
-    "test": "vitest",
-    "lint": "eslint .",
-    "typecheck": "tsc --noEmit",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "prepublishOnly": "npm-run-all lint format:check build && npm run test run"
-  },
   "keywords": [
-    "react",
     "codemirror",
-    "syntax",
-    "highlight"
+    "highlight",
+    "react",
+    "syntax"
   ],
-  "author": "Takuya Matsuyama <hi@craftz.dog>",
   "license": "MIT",
+  "author": "Takuya Matsuyama <hi@craftz.dog>",
   "repository": {
     "type": "git",
     "url": "https://github.com/craftzdog/react-codemirror-runmode.git"
   },
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "dependencies": {
-    "@codemirror/language": "^6.11.3",
+    "@codemirror/lang-markdown": "^6.5.1",
+    "@codemirror/language": "^6.12.4",
     "@codemirror/language-data": "^6.5.2",
-    "@lezer/common": "^1.4.0",
+    "@lezer/common": "^1.5.2",
     "@lezer/highlight": "^1.2.3"
   },
-  "peerDependencies": {
-    "react": ">= 18"
-  },
   "devDependencies": {
     "@codemirror/theme-one-dark": "^6.1.3",
-    "@testing-library/react": "^16.3.0",
-    "@types/node": "^25.0.1",
-    "@types/react": "^19.2.7",
-    "@vitejs/plugin-react": "^5.1.2",
-    "eslint": "^9.39.1",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-react": "^7.37.5",
-    "jsdom": "^27.3.0",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^26.1.1",
+    "@types/react": "^19.2.17",
+    "@vitejs/plugin-react": "^6.0.4",
+    "jsdom": "^29.1.1",
     "npm-run-all": "^4.1.5",
-    "prettier": "^3.7.4",
-    "react": "^19.2.3",
-    "react-dom": "^19.2.3",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.49.0",
-    "vite": "^7.2.7",
-    "vitest": "^4.0.15"
+    "oxfmt": "0.60.0",
+    "oxlint": "1.75.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "typescript": "^7.0.2",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "react": ">= 18"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "test": "vitest --run",
+    "bench": "vitest bench --run",
+    "lint": "oxlint",
+    "typecheck": "tsc --noEmit",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check"
   }
-}
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,43 @@
+allowBuilds:
+  esbuild: true
+minimumReleaseAgeExclude:
+  - '@oxfmt/binding-android-arm-eabi@0.56.0'
+  - '@oxfmt/binding-android-arm64@0.56.0'
+  - '@oxfmt/binding-darwin-arm64@0.56.0'
+  - '@oxfmt/binding-darwin-x64@0.56.0'
+  - '@oxfmt/binding-freebsd-x64@0.56.0'
+  - '@oxfmt/binding-linux-arm-gnueabihf@0.56.0'
+  - '@oxfmt/binding-linux-arm-musleabihf@0.56.0'
+  - '@oxfmt/binding-linux-arm64-gnu@0.56.0'
+  - '@oxfmt/binding-linux-arm64-musl@0.56.0'
+  - '@oxfmt/binding-linux-ppc64-gnu@0.56.0'
+  - '@oxfmt/binding-linux-riscv64-gnu@0.56.0'
+  - '@oxfmt/binding-linux-riscv64-musl@0.56.0'
+  - '@oxfmt/binding-linux-s390x-gnu@0.56.0'
+  - '@oxfmt/binding-linux-x64-gnu@0.56.0'
+  - '@oxfmt/binding-linux-x64-musl@0.56.0'
+  - '@oxfmt/binding-openharmony-arm64@0.56.0'
+  - '@oxfmt/binding-win32-arm64-msvc@0.56.0'
+  - '@oxfmt/binding-win32-ia32-msvc@0.56.0'
+  - '@oxfmt/binding-win32-x64-msvc@0.56.0'
+  - '@oxlint/binding-android-arm-eabi@1.71.0'
+  - '@oxlint/binding-android-arm64@1.71.0'
+  - '@oxlint/binding-darwin-arm64@1.71.0'
+  - '@oxlint/binding-darwin-x64@1.71.0'
+  - '@oxlint/binding-freebsd-x64@1.71.0'
+  - '@oxlint/binding-linux-arm-gnueabihf@1.71.0'
+  - '@oxlint/binding-linux-arm-musleabihf@1.71.0'
+  - '@oxlint/binding-linux-arm64-gnu@1.71.0'
+  - '@oxlint/binding-linux-arm64-musl@1.71.0'
+  - '@oxlint/binding-linux-ppc64-gnu@1.71.0'
+  - '@oxlint/binding-linux-riscv64-gnu@1.71.0'
+  - '@oxlint/binding-linux-riscv64-musl@1.71.0'
+  - '@oxlint/binding-linux-s390x-gnu@1.71.0'
+  - '@oxlint/binding-linux-x64-gnu@1.71.0'
+  - '@oxlint/binding-linux-x64-musl@1.71.0'
+  - '@oxlint/binding-openharmony-arm64@1.71.0'
+  - '@oxlint/binding-win32-arm64-msvc@1.71.0'
+  - '@oxlint/binding-win32-ia32-msvc@1.71.0'
+  - '@oxlint/binding-win32-x64-msvc@1.71.0'
+  - oxfmt@0.56.0
+  - oxlint@1.71.0

package/src/highlight.ts

@@ -1,8 +1,21 @@
-import { Parser } from '@lezer/common'
+import { markdown } from '@codemirror/lang-markdown'
 import { Language, LanguageDescription } from '@codemirror/language'
-import { Highlighter, highlightTree } from '@lezer/highlight'
 import { languages as builtinLanguages } from '@codemirror/language-data'
-import { markdown } from '@codemirror/lang-markdown'
+import { Parser } from '@lezer/common'
+import { Highlighter, highlightTree } from '@lezer/highlight'
+
+/**
+ * Configuration for the markdown parser used when highlighting `markdown`/`md`
+ * input. Mirrors the relevant subset of `@codemirror/lang-markdown`'s `markdown()`
+ * options so callers can opt into GFM (`base: markdownLanguage`) and custom Lezer
+ * markdown extensions (e.g. app-specific node props, GFM alerts).
+ *
+ * Defaults match `@codemirror/lang-markdown`: a CommonMark base with no extensions.
+ */
+export type MarkdownConfig = Pick<
+  NonNullable<Parameters<typeof markdown>[0]>,
+  'base' | 'extensions'
+>
 
 /**
  * Extract language names from code blocks in markdown text
@@ -27,11 +40,7 @@ async function preloadLanguageParsers(
   return (
     await Promise.all(
       languageNames.map(async langName => {
-        const found = LanguageDescription.matchLanguageName(
-          languages,
-          langName,
-          true
-        )
+        const found = LanguageDescription.matchLanguageName(languages, langName, true)
         if (found instanceof LanguageDescription) {
           if (!found.support) await found.load()
           if (found.support) {
@@ -45,14 +54,13 @@ async function preloadLanguageParsers(
 
 export async function getMarkdownParser(
   input: string,
-  languages: LanguageDescription[] = builtinLanguages
+  languages: LanguageDescription[] = builtinLanguages,
+  markdownConfig: MarkdownConfig = {}
 ): Promise<Parser> {
   const codeBlockLanguages = extractCodeBlockLanguages(input)
-  const preloadedLanguages = await preloadLanguageParsers(
-    codeBlockLanguages || [],
-    languages
-  )
+  const preloadedLanguages = await preloadLanguageParsers(codeBlockLanguages || [], languages)
   const langSupport = markdown({
+    ...markdownConfig,
     codeLanguages: preloadedLanguages
   })
   return langSupport.language.parser
@@ -62,16 +70,13 @@ export async function getCodeParser(
   input: string,
   languageName: string,
   fallbackLanguage?: Language,
-  languages: LanguageDescription[] = builtinLanguages
+  languages: LanguageDescription[] = builtinLanguages,
+  markdownConfig?: MarkdownConfig
 ): Promise<Parser | null> {
   if (languageName === 'markdown' || languageName === 'md') {
-    return await getMarkdownParser(input, languages)
+    return await getMarkdownParser(input, languages, markdownConfig)
   } else {
-    const found = LanguageDescription.matchLanguageName(
-      languages,
-      languageName,
-      true
-    )
+    const found = LanguageDescription.matchLanguageName(languages, languageName, true)
     if (found instanceof LanguageDescription) {
       if (!found.support) await found.load()
       return found.support ? found.support.language.parser : null
@@ -83,36 +88,30 @@ export async function getCodeParser(
 export async function highlightCode<Output>(
   languageName: string,
   input: string,
-  highlighter: Highlighter,
+  highlighter: Highlighter | readonly Highlighter[],
   fallbackLanguage: Language | undefined,
   languages: LanguageDescription[] | undefined,
-  callback: (
-    text: string,
-    style: string | null,
-    from: number,
-    to: number
-  ) => Output
+  callback: (text: string, style: string | null, from: number, to: number) => Output,
+  markdownConfig?: MarkdownConfig
 ): Promise<Output[]> {
   const parser = await getCodeParser(
     input,
     languageName,
     fallbackLanguage,
-    languages
+    languages,
+    markdownConfig
   )
   if (parser) {
     const tree = parser.parse(input)
     const output: Array<Output> = []
     let pos = 0
     highlightTree(tree, highlighter, (from, to, classes) => {
-      if (from > pos)
-        output.push(callback(input.slice(pos, from), null, pos, from))
+      if (from > pos) output.push(callback(input.slice(pos, from), null, pos, from))
       output.push(callback(input.slice(from, to), classes, from, to))
       pos = to
     })
     pos != tree.length &&
-      output.push(
-        callback(input.slice(pos, tree.length), null, pos, tree.length)
-      )
+      output.push(callback(input.slice(pos, tree.length), null, pos, tree.length))
     return output
   } else {
     return [callback(input, null, 0, input.length)]