@camerontaylor/paseo-highlight 0.8.0-fork.1

package/dist/astro/parser.d.ts

@@ -0,0 +1,11 @@
+import { type Input, type PartialParse, Parser, type TreeFragment } from "@lezer/common";
+interface Range {
+    from: number;
+    to: number;
+}
+declare class AstroParser extends Parser {
+    createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly Range[]): PartialParse;
+}
+export declare const astroParser: AstroParser;
+export {};
+//# sourceMappingURL=parser.d.ts.map

package/dist/astro/parser.js

@@ -0,0 +1,228 @@
+// Adapted from @fazelstudio/codemirror-lang-astro@0.2.0 (MIT).
+// The parser is kept pure so server-side diff highlighting does not load editor-only modules.
+import { Parser, parseMixed, } from "@lezer/common";
+import { parser as cssParser } from "@lezer/css";
+import { parser as htmlParser } from "@lezer/html";
+import { parser as jsParser } from "@lezer/javascript";
+const jsxParser = jsParser.configure({ dialect: "ts jsx" });
+const typescriptParser = jsParser.configure({ dialect: "ts" });
+function isSpace(code) {
+    return code === 32 || code === 9 || code === 10 || code === 13;
+}
+function isRegexStart(text, position) {
+    let previous = position - 1;
+    while (previous >= 0 && isSpace(text.charCodeAt(previous)))
+        previous--;
+    if (previous < 0)
+        return true;
+    const character = text[previous];
+    if (/[)\]}<"'`\d]/.test(character))
+        return false;
+    const code = text.charCodeAt(previous);
+    if (code === 62)
+        return previous > 0 && text.charCodeAt(previous - 1) === 61;
+    if (!/[A-Za-z_$]/.test(character))
+        return true;
+    let start = previous;
+    while (start >= 0 && /[A-Za-z0-9_$]/.test(text[start]))
+        start--;
+    const keyword = text.slice(start + 1, previous + 1);
+    return /^(return|typeof|instanceof|in|of|new|void|delete|yield|await|case|do|else|throw|extends|assert|with)$/.test(keyword);
+}
+function skipQuotedText(text, opening) {
+    const quote = text.charCodeAt(opening);
+    for (let position = opening + 1; position < text.length; position++) {
+        const code = text.charCodeAt(position);
+        if (code === 92)
+            position++;
+        else if (code === quote)
+            return position;
+    }
+    return text.length - 1;
+}
+function skipLineComment(text, opening) {
+    const newline = text.indexOf("\n", opening + 2);
+    return newline >= 0 ? newline : text.length - 1;
+}
+function skipBlockComment(text, opening) {
+    const closing = text.indexOf("*/", opening + 2);
+    return closing >= 0 ? closing + 1 : text.length - 1;
+}
+function skipRegex(text, opening) {
+    let isInCharacterClass = false;
+    for (let position = opening + 1; position < text.length; position++) {
+        const code = text.charCodeAt(position);
+        if (code === 10 || code === 13)
+            return position;
+        if (code === 92)
+            position++;
+        else if (isInCharacterClass && code === 93)
+            isInCharacterClass = false;
+        else if (!isInCharacterClass && code === 91)
+            isInCharacterClass = true;
+        else if (!isInCharacterClass && code === 47)
+            return position;
+    }
+    return text.length - 1;
+}
+function findClosingBrace(text, opening) {
+    let depth = 0;
+    for (let position = opening; position < text.length; position++) {
+        const code = text.charCodeAt(position);
+        if (code === 47 && text.charCodeAt(position + 1) === 47) {
+            position = skipLineComment(text, position);
+        }
+        else if (code === 47 && text.charCodeAt(position + 1) === 42) {
+            position = skipBlockComment(text, position);
+        }
+        else if (code === 47 && isRegexStart(text, position)) {
+            position = skipRegex(text, position);
+        }
+        else if (code === 34 || code === 39 || code === 96) {
+            position = skipQuotedText(text, position);
+        }
+        else if (code === 123) {
+            depth++;
+        }
+        else if (code === 125 && --depth === 0) {
+            return position;
+        }
+    }
+    return -1;
+}
+function findExpressions(text) {
+    const ranges = [];
+    for (let position = 0; position < text.length; position++) {
+        if (text.charCodeAt(position) !== 123)
+            continue;
+        const closing = findClosingBrace(text, position);
+        if (closing < 0)
+            break;
+        ranges.push({ from: position, to: closing });
+        position = closing;
+    }
+    return ranges;
+}
+function maskExpressions(text) {
+    const characters = text.split("");
+    for (const { from, to } of findExpressions(text)) {
+        for (let position = from + 1; position < to; position++)
+            characters[position] = "a";
+    }
+    return characters.join("");
+}
+function expressionOverlays(node, input) {
+    const overlays = findExpressions(input.read(node.from, node.to)).map(({ from, to }) => ({
+        from: node.from + from + 1,
+        to: node.from + to,
+    }));
+    return overlays.length > 0 ? overlays : null;
+}
+function isFenceEnd(text, position) {
+    if (position >= text.length)
+        return true;
+    const code = text.charCodeAt(position);
+    return code === 10 || code === 13 || code === 32 || code === 9;
+}
+function findFrontmatter(text) {
+    const from = text.charCodeAt(0) === 0xfeff ? 1 : 0;
+    if (!text.startsWith("---", from) || !isFenceEnd(text, from + 3))
+        return null;
+    let newline = text.indexOf("\n", from + 3);
+    while (newline >= 0) {
+        const closing = newline + 1;
+        if (text.startsWith("---", closing) && isFenceEnd(text, closing + 3)) {
+            return { from, to: closing + 3 };
+        }
+        newline = text.indexOf("\n", closing);
+    }
+    return null;
+}
+function maskDocument(text, frontmatter) {
+    if (!frontmatter)
+        return maskExpressions(text);
+    return (text.slice(0, frontmatter.from) +
+        "<!--" +
+        text.slice(frontmatter.from + 4, frontmatter.to - 3) +
+        "-->" +
+        maskExpressions(text.slice(frontmatter.to)));
+}
+function getOpenTagAttributes(node, input) {
+    const attributes = Object.create(null);
+    const openTag = node.getChild("OpenTag");
+    if (!openTag)
+        return attributes;
+    for (const attribute of openTag.getChildren("Attribute")) {
+        const name = attribute.getChild("AttributeName");
+        if (!name)
+            continue;
+        const value = attribute.getChild("AttributeValue") || attribute.getChild("UnquotedAttributeValue");
+        const key = input.read(name.from, name.to).toLowerCase();
+        attributes[key] = value ? input.read(value.from, value.to).replace(/^["']|["']$/g, "") : "";
+    }
+    return attributes;
+}
+function nestedLanguage(node, input) {
+    if (node.name === "Comment") {
+        const isFrontmatter = input.read(node.from, node.from + 3) === "---" && input.read(node.to - 3, node.to) === "---";
+        const from = node.from + 4;
+        const to = node.to - 3;
+        return isFrontmatter && to > from
+            ? { parser: typescriptParser, overlay: [{ from, to }] }
+            : null;
+    }
+    const canContainExpression = node.name === "Text" ||
+        node.name === "UnquotedAttributeValue" ||
+        node.name === "AttributeValue";
+    if (canContainExpression) {
+        const overlay = expressionOverlays(node, input);
+        return overlay ? { parser: jsxParser, overlay } : null;
+    }
+    if (node.name === "StyleText")
+        return { parser: cssParser };
+    if (node.name !== "ScriptText" || !node.node.parent)
+        return null;
+    const attributes = getOpenTagAttributes(node.node.parent, input);
+    if (attributes.src)
+        return null;
+    const language = (attributes.lang || attributes.type || "").toLowerCase();
+    let dialect = "";
+    if (language.includes("tsx"))
+        dialect = "ts jsx";
+    else if (language.includes("typescript") || language === "ts")
+        dialect = "ts";
+    else if (language.includes("jsx"))
+        dialect = "jsx";
+    return { parser: dialect ? jsParser.configure({ dialect }) : jsParser };
+}
+class CompletedParse {
+    constructor(tree) {
+        this.tree = tree;
+        this.isDone = false;
+    }
+    advance() {
+        if (this.isDone)
+            return null;
+        this.isDone = true;
+        return this.tree;
+    }
+    get parsedPos() {
+        return this.tree.length;
+    }
+    stopAt() { }
+    get stoppedAt() {
+        return null;
+    }
+}
+const mountNestedLanguages = parseMixed(nestedLanguage);
+class AstroParser extends Parser {
+    createParse(input, fragments, ranges) {
+        const from = ranges[0]?.from ?? 0;
+        const to = ranges[0]?.to ?? input.length;
+        const text = input.read(from, to);
+        const tree = htmlParser.parse(maskDocument(text, findFrontmatter(text)));
+        return mountNestedLanguages(new CompletedParse(tree), input, fragments, ranges);
+    }
+}
+export const astroParser = new AstroParser();
+//# sourceMappingURL=parser.js.map

package/dist/colors.d.ts

@@ -0,0 +1,4 @@
+import type { HighlightStyle } from "./types.js";
+export declare const darkHighlightColors: Record<HighlightStyle, string>;
+export declare const lightHighlightColors: Record<HighlightStyle, string>;
+//# sourceMappingURL=colors.d.ts.map

package/dist/colors.js

@@ -0,0 +1,45 @@
+export const darkHighlightColors = {
+    keyword: "#ff7b72",
+    comment: "#8b949e",
+    string: "#a5d6ff",
+    number: "#79c0ff",
+    literal: "#79c0ff",
+    function: "#d2a8ff",
+    definition: "#d2a8ff",
+    class: "#ffa657",
+    type: "#ff7b72",
+    tag: "#7ee787",
+    attribute: "#79c0ff",
+    property: "#79c0ff",
+    variable: "#c9d1d9",
+    operator: "#79c0ff",
+    punctuation: "#c9d1d9",
+    regexp: "#a5d6ff",
+    escape: "#79c0ff",
+    meta: "#8b949e",
+    heading: "#79c0ff",
+    link: "#a5d6ff",
+};
+export const lightHighlightColors = {
+    keyword: "#cf222e",
+    comment: "#6e7781",
+    string: "#0a3069",
+    number: "#0550ae",
+    literal: "#0550ae",
+    function: "#8250df",
+    definition: "#8250df",
+    class: "#953800",
+    type: "#cf222e",
+    tag: "#116329",
+    attribute: "#0550ae",
+    property: "#0550ae",
+    variable: "#24292f",
+    operator: "#0550ae",
+    punctuation: "#24292f",
+    regexp: "#0a3069",
+    escape: "#0550ae",
+    meta: "#6e7781",
+    heading: "#0550ae",
+    link: "#0a3069",
+};
+//# sourceMappingURL=colors.js.map

package/dist/csharp/highlight.d.ts

@@ -0,0 +1,2 @@
+export declare const csharpHighlighting: import("@lezer/common").NodePropSource;
+//# sourceMappingURL=highlight.d.ts.map

package/dist/csharp/highlight.js

@@ -0,0 +1,22 @@
+import { styleTags, tags as t } from "@lezer/highlight";
+export const csharpHighlighting = styleTags({
+    "Keyword ContextualKeyword SimpleType": t.keyword,
+    "NullLiteral BooleanLiteral": t.bool,
+    IntegerLiteral: t.integer,
+    RealLiteral: t.float,
+    'StringLiteral CharacterLiteral InterpolatedRegularString InterpolatedVerbatimString $" @$" $@"': t.string,
+    "LineComment BlockComment": t.comment,
+    ". .. : Astrisk Slash % + - ++ -- Not ~ << & | ^ && || < > <= >= == NotEq = += -= *= SlashEq %= &= |= ^= ? ?? ??= =>": t.operator,
+    PP_Directive: t.keyword,
+    TypeIdentifier: t.typeName,
+    "ArgumentName AttrsNamedArg": t.variableName,
+    ConstName: t.constant(t.variableName),
+    MethodName: t.function(t.variableName),
+    ParamName: [t.emphasis, t.variableName],
+    VarName: t.variableName,
+    "FieldName PropertyName": t.propertyName,
+    "( )": t.paren,
+    "{ }": t.brace,
+    "[ ]": t.squareBracket,
+});
+//# sourceMappingURL=highlight.js.map

package/dist/csharp/language.d.ts

@@ -0,0 +1,3 @@
+import { LRLanguage } from "@codemirror/language";
+export declare const csharpLanguage: LRLanguage;
+//# sourceMappingURL=language.d.ts.map

package/dist/csharp/language.js

@@ -0,0 +1,21 @@
+import { continuedIndent, foldInside, foldNodeProp, indentNodeProp, LRLanguage, } from "@codemirror/language";
+import { parser } from "./parser.js";
+export const csharpLanguage = LRLanguage.define({
+    name: "C#",
+    parser: parser.configure({
+        props: [
+            indentNodeProp.add({
+                Delim: continuedIndent({ except: /^\s*(?:case\b|default:)/ }),
+            }),
+            foldNodeProp.add({
+                Delim: foldInside,
+            }),
+        ],
+    }),
+    languageData: {
+        commentTokens: { line: "//", block: { open: "/*", close: "*/" } },
+        closeBrackets: { brackets: ["(", "[", "{", '"', "'"] },
+        indentOnInput: /^\s*((\)|\]|\})$|(else|else\s+if|catch|finally|case)\b|default:)/,
+    },
+});
+//# sourceMappingURL=language.js.map

package/dist/csharp/parser.d.ts

@@ -0,0 +1,3 @@
+import { LRParser } from "@lezer/lr";
+export declare const parser: LRParser;
+//# sourceMappingURL=parser.d.ts.map