@getpaseo/highlight 0.2.0-beta.1 → 0.2.0-beta.2

package/dist/highlighter.js

@@ -1,48 +1,6 @@
-import { highlightTree, tagHighlighter, tags } from "@lezer/highlight";
+import { highlightTree } from "@lezer/highlight";
 import { getParserForFile } from "./parsers.js";
-const highlighter = tagHighlighter([
-    { tag: tags.keyword, class: "keyword" },
-    { tag: tags.controlKeyword, class: "keyword" },
-    { tag: tags.operatorKeyword, class: "keyword" },
-    { tag: tags.definitionKeyword, class: "keyword" },
-    { tag: tags.moduleKeyword, class: "keyword" },
-    { tag: tags.comment, class: "comment" },
-    { tag: tags.lineComment, class: "comment" },
-    { tag: tags.blockComment, class: "comment" },
-    { tag: tags.docComment, class: "comment" },
-    { tag: tags.string, class: "string" },
-    { tag: tags.special(tags.string), class: "string" },
-    { tag: tags.number, class: "number" },
-    { tag: tags.integer, class: "number" },
-    { tag: tags.float, class: "number" },
-    { tag: tags.bool, class: "literal" },
-    { tag: tags.null, class: "literal" },
-    { tag: tags.function(tags.variableName), class: "function" },
-    { tag: tags.function(tags.propertyName), class: "function" },
-    { tag: tags.definition(tags.variableName), class: "definition" },
-    { tag: tags.definition(tags.propertyName), class: "definition" },
-    { tag: tags.definition(tags.function(tags.variableName)), class: "definition" },
-    { tag: tags.className, class: "class" },
-    { tag: tags.definition(tags.className), class: "class" },
-    { tag: tags.typeName, class: "type" },
-    { tag: tags.tagName, class: "tag" },
-    { tag: tags.attributeName, class: "attribute" },
-    { tag: tags.attributeValue, class: "string" },
-    { tag: tags.propertyName, class: "property" },
-    { tag: tags.variableName, class: "variable" },
-    { tag: tags.local(tags.variableName), class: "variable" },
-    { tag: tags.special(tags.variableName), class: "variable" },
-    { tag: tags.operator, class: "operator" },
-    { tag: tags.punctuation, class: "punctuation" },
-    { tag: tags.bracket, class: "punctuation" },
-    { tag: tags.separator, class: "punctuation" },
-    { tag: tags.regexp, class: "regexp" },
-    { tag: tags.escape, class: "escape" },
-    { tag: tags.meta, class: "meta" },
-    { tag: tags.heading, class: "heading" },
-    { tag: tags.link, class: "link" },
-    { tag: tags.url, class: "link" },
-]);
+import { staticSyntaxHighlighter } from "./syntax-roles.js";
 export function highlightCode(code, filename) {
     const parser = getParserForFile(filename);
     if (!parser) {
@@ -56,7 +14,7 @@ export function highlightCode(code, filename) {
     }
     // Build a map of character positions to styles
     const styleMap = Array.from({ length: code.length }, () => null);
-    highlightTree(tree, highlighter, (from, to, classes) => {
+    highlightTree(tree, staticSyntaxHighlighter, (from, to, classes) => {
         for (let i = from; i < to && i < styleMap.length; i++) {
             styleMap[i] = classes;
         }

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export type { HighlightStyle, HighlightToken } from "./types.js";
-export { getParserForFile, isLanguageSupported, getSupportedExtensions } from "./parsers.js";
+export { getLanguageForFile, getParserForFile, isLanguageSupported, getSupportedExtensions, } from "./parsers.js";
+export { createCodeMirrorHighlightStyle } from "./syntax-roles.js";
 export { highlightCode, highlightLine } from "./highlighter.js";
 export { darkHighlightColors, lightHighlightColors } from "./colors.js";
 export type { SyntaxThemeId, SyntaxThemeOption, SyntaxColors } from "./themes.js";

package/dist/index.js

@@ -1,4 +1,5 @@
-export { getParserForFile, isLanguageSupported, getSupportedExtensions } from "./parsers.js";
+export { getLanguageForFile, getParserForFile, isLanguageSupported, getSupportedExtensions, } from "./parsers.js";
+export { createCodeMirrorHighlightStyle } from "./syntax-roles.js";
 export { highlightCode, highlightLine } from "./highlighter.js";
 export { darkHighlightColors, lightHighlightColors } from "./colors.js";
 export { SYNTAX_THEME_IDS, SYNTAX_THEME_OPTIONS, isSyntaxThemeId, resolveSyntaxColors, } from "./themes.js";

package/dist/parsers.d.ts

@@ -1,4 +1,6 @@
+import { Language } from "@codemirror/language";
 import type { Parser } from "@lezer/common";
+export declare function getLanguageForFile(filename: string): Language | null;
 export declare function getParserForFile(filename: string): Parser | null;
 export declare function isLanguageSupported(filename: string): boolean;
 export declare function getSupportedExtensions(): string[];

package/dist/parsers.js

@@ -1,4 +1,4 @@
-import { StreamLanguage } from "@codemirror/language";
+import { defineLanguageFacet, Language, StreamLanguage } from "@codemirror/language";
 import { dart } from "@codemirror/legacy-modes/mode/clike";
 import { swift } from "@codemirror/legacy-modes/mode/swift";
 import { parser as jsParser } from "@lezer/javascript";
@@ -16,70 +16,76 @@ import { parser as xmlParser } from "@lezer/xml";
 import { parser as yamlParser } from "@lezer/yaml";
 import { csharpLanguage } from "@replit/codemirror-lang-csharp";
 import { parser as elixirParser } from "lezer-elixir";
-const parsersByExtension = {
+function language(parser) {
+    return new Language(defineLanguageFacet(), parser);
+}
+const languagesByExtension = {
     // JavaScript/TypeScript
-    js: jsParser,
-    jsx: jsParser.configure({ dialect: "jsx" }),
-    ts: jsParser.configure({ dialect: "ts" }),
-    tsx: jsParser.configure({ dialect: "ts jsx" }),
-    mjs: jsParser,
-    cjs: jsParser,
+    js: language(jsParser),
+    jsx: language(jsParser.configure({ dialect: "jsx" })),
+    ts: language(jsParser.configure({ dialect: "ts" })),
+    tsx: language(jsParser.configure({ dialect: "ts jsx" })),
+    mjs: language(jsParser),
+    cjs: language(jsParser),
     // C / C++ / Objective-C
-    c: cppParser,
-    h: cppParser,
-    cc: cppParser,
-    cpp: cppParser,
-    cxx: cppParser,
-    hpp: cppParser,
-    hxx: cppParser,
-    m: cppParser,
-    mm: cppParser,
+    c: language(cppParser),
+    h: language(cppParser),
+    cc: language(cppParser),
+    cpp: language(cppParser),
+    cxx: language(cppParser),
+    hpp: language(cppParser),
+    hxx: language(cppParser),
+    m: language(cppParser),
+    mm: language(cppParser),
     // JSON
-    json: jsonParser,
+    json: language(jsonParser),
     // CSS
-    css: cssParser,
-    scss: cssParser,
+    css: language(cssParser),
+    scss: language(cssParser),
     // HTML
-    html: htmlParser,
-    htm: htmlParser,
+    html: language(htmlParser),
+    htm: language(htmlParser),
     // XML
-    xml: xmlParser,
+    xml: language(xmlParser),
     // Java
-    java: javaParser,
+    java: language(javaParser),
     // Python
-    py: pythonParser,
+    py: language(pythonParser),
     // Go
-    go: goParser,
+    go: language(goParser),
     // PHP
-    php: phpParser,
+    php: language(phpParser),
     // YAML
-    yaml: yamlParser,
-    yml: yamlParser,
+    yaml: language(yamlParser),
+    yml: language(yamlParser),
     // Rust
-    rs: rustParser,
+    rs: language(rustParser),
     // Swift
-    swift: StreamLanguage.define(swift).parser,
+    swift: StreamLanguage.define(swift),
     // Dart
-    dart: StreamLanguage.define(dart).parser,
+    dart: StreamLanguage.define(dart),
     // C#
-    cs: csharpLanguage.parser,
+    cs: csharpLanguage,
     // Elixir
-    ex: elixirParser,
-    exs: elixirParser,
+    ex: language(elixirParser),
+    exs: language(elixirParser),
     // Markdown
-    md: markdownParser,
-    mdx: markdownParser,
+    md: language(markdownParser),
+    mdx: language(markdownParser),
 };
-export function getParserForFile(filename) {
+export function getLanguageForFile(filename) {
     const ext = filename.split(".").pop()?.toLowerCase();
     if (!ext)
         return null;
-    return parsersByExtension[ext] ?? null;
+    return languagesByExtension[ext] ?? null;
+}
+export function getParserForFile(filename) {
+    return getLanguageForFile(filename)?.parser ?? null;
 }
 export function isLanguageSupported(filename) {
     return getParserForFile(filename) !== null;
 }
 export function getSupportedExtensions() {
-    return Object.keys(parsersByExtension);
+    return Object.keys(languagesByExtension);
 }
 //# sourceMappingURL=parsers.js.map

package/dist/syntax-roles.d.ts

@@ -0,0 +1,10 @@
+import { HighlightStyle as CodeMirrorHighlightStyle } from "@codemirror/language";
+import { type Tag } from "@lezer/highlight";
+import type { HighlightStyle } from "./types.js";
+export declare const syntaxRoleTags: ReadonlyArray<{
+    tag: Tag;
+    role: HighlightStyle;
+}>;
+export declare const staticSyntaxHighlighter: import("@lezer/highlight").Highlighter;
+export declare function createCodeMirrorHighlightStyle(colors: Record<HighlightStyle, string>): CodeMirrorHighlightStyle;
+//# sourceMappingURL=syntax-roles.d.ts.map

package/dist/syntax-roles.js

@@ -0,0 +1,50 @@
+import { HighlightStyle as CodeMirrorHighlightStyle } from "@codemirror/language";
+import { tagHighlighter, tags } from "@lezer/highlight";
+export const syntaxRoleTags = [
+    { tag: tags.keyword, role: "keyword" },
+    { tag: tags.controlKeyword, role: "keyword" },
+    { tag: tags.operatorKeyword, role: "keyword" },
+    { tag: tags.definitionKeyword, role: "keyword" },
+    { tag: tags.moduleKeyword, role: "keyword" },
+    { tag: tags.comment, role: "comment" },
+    { tag: tags.lineComment, role: "comment" },
+    { tag: tags.blockComment, role: "comment" },
+    { tag: tags.docComment, role: "comment" },
+    { tag: tags.string, role: "string" },
+    { tag: tags.special(tags.string), role: "string" },
+    { tag: tags.number, role: "number" },
+    { tag: tags.integer, role: "number" },
+    { tag: tags.float, role: "number" },
+    { tag: tags.bool, role: "literal" },
+    { tag: tags.null, role: "literal" },
+    { tag: tags.function(tags.variableName), role: "function" },
+    { tag: tags.function(tags.propertyName), role: "function" },
+    { tag: tags.definition(tags.variableName), role: "definition" },
+    { tag: tags.definition(tags.propertyName), role: "definition" },
+    { tag: tags.definition(tags.function(tags.variableName)), role: "definition" },
+    { tag: tags.className, role: "class" },
+    { tag: tags.definition(tags.className), role: "class" },
+    { tag: tags.typeName, role: "type" },
+    { tag: tags.tagName, role: "tag" },
+    { tag: tags.attributeName, role: "attribute" },
+    { tag: tags.attributeValue, role: "string" },
+    { tag: tags.propertyName, role: "property" },
+    { tag: tags.variableName, role: "variable" },
+    { tag: tags.local(tags.variableName), role: "variable" },
+    { tag: tags.special(tags.variableName), role: "variable" },
+    { tag: tags.operator, role: "operator" },
+    { tag: tags.punctuation, role: "punctuation" },
+    { tag: tags.bracket, role: "punctuation" },
+    { tag: tags.separator, role: "punctuation" },
+    { tag: tags.regexp, role: "regexp" },
+    { tag: tags.escape, role: "escape" },
+    { tag: tags.meta, role: "meta" },
+    { tag: tags.heading, role: "heading" },
+    { tag: tags.link, role: "link" },
+    { tag: tags.url, role: "link" },
+];
+export const staticSyntaxHighlighter = tagHighlighter(syntaxRoleTags.map(({ tag, role }) => ({ tag, class: role })));
+export function createCodeMirrorHighlightStyle(colors) {
+    return CodeMirrorHighlightStyle.define(syntaxRoleTags.map(({ tag, role }) => ({ tag, color: colors[role] })));
+}
+//# sourceMappingURL=syntax-roles.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/highlight",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.2",
   "files": [
     "dist",
     "!dist/**/*.map"
@@ -27,7 +27,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@codemirror/language": "^6.12.3",
+    "@codemirror/language": "6.12.4",
     "@codemirror/legacy-modes": "^6.5.3",
     "@lezer/common": "^1.5.0",
     "@lezer/cpp": "^1.1.5",