jexl-lezer 0.4.0 → 0.5.0

package/package.json

@@ -1,24 +1,34 @@
 {
   "name": "jexl-lezer",
-  "description": "lezer-based Apache JEXL",
-  "version": "0.4.0",
+  "version": "0.5.0",
+  "description": "lezer-based JavaScript grammar",
+  "main": "dist/index.cjs",
   "type": "module",
   "exports": {
     "import": "./dist/index.js",
     "require": "./dist/index.cjs"
   },
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "devDependencies": {
     "@lezer/generator": "^1.7.0",
-    "@rollup/plugin-node-resolve": "^9.0.0",
     "mocha": "^10.2.0",
-    "rollup": "^2.52.2"
+    "rollup": "^2.52.2",
+    "@rollup/plugin-node-resolve": "^9.0.0"
   },
   "dependencies": {
+    "@lezer/lr": "^1.3.0",
     "@lezer/common": "^1.2.0",
-    "@lezer/highlight": "^1.1.3",
-    "@lezer/lr": "^1.3.0"
+    "@lezer/highlight": "^1.1.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lezer-parser/javascript.git"
   },
   "scripts": {
-    "prepare": "rollup -c"
+    "build": "lezer-generator src/javascript.grammar -o src/parser && rollup -c",
+    "build-debug": "lezer-generator src/javascript.grammar --names -o src/parser && rollup -c",
+    "prepare": "npm run build",
+    "test": "mocha test/test-*.js"
   }
 }

package/rollup.config.js

@@ -1,7 +1,7 @@
-import {lezer} from "@lezer/generator/rollup"
+import {nodeResolve} from "@rollup/plugin-node-resolve"
 
 export default {
-  input: "./src/jexl.grammar",
+  input: "./src/parser.js",
   output: [{
     format: "cjs",
     file: "./dist/index.cjs"
@@ -9,8 +9,8 @@ export default {
     format: "es",
     file: "./dist/index.js"
   }],
-  external: ["@lezer/lr", "@lezer/highlight"],
+  external(id) { return !/^[\.\/]/.test(id) },
   plugins: [
-    lezer()
+    nodeResolve()
   ]
 }

package/src/highlight.js

@@ -1,192 +1,62 @@
-////////////////////////////////////////////
-// highlight.js
-////////////////////////////////////////////
-import { styleTags, tags as t } from "@lezer/highlight";
-
-export const jsHighlight = styleTags({
-  "get set async static": t.modifier,
-  "for while do if else switch try catch finally return throw break continue default case": t.controlKeyword,
-  "in of await yield void typeof delete instanceof": t.operatorKeyword,
-  "let var const using function class extends": t.definitionKeyword,
-  "pragma import export from": t.moduleKeyword,
-  "with debugger as new": t.keyword,
-  TemplateString: t.special(t.string),
-  super: t.atom,
-  BooleanLiteral: t.bool,
-  this: t.self,
-  null: t.null,
-  Star: t.modifier,
-  VariableName: t.variableName,
-  "CallExpression/VariableName TaggedTemplateExpression/VariableName": t.function(t.variableName),
-  VariableDefinition: t.definition(t.variableName),
-  Label: t.labelName,
-  PropertyName: t.propertyName,
-  PrivatePropertyName: t.special(t.propertyName),
-  "CallExpression/MemberExpression/PropertyName": t.function(t.propertyName),
-  "FunctionDeclaration/VariableDefinition": t.function(t.definition(t.variableName)),
-  "ClassDeclaration/VariableDefinition": t.definition(t.className),
-  "NewExpression/VariableName": t.className,
-  PropertyDefinition: t.definition(t.propertyName),
-  PrivatePropertyDefinition: t.definition(t.special(t.propertyName)),
-  UpdateOp: t.updateOperator,
-  "LineComment Hashbang": t.lineComment,
-  BlockComment: t.blockComment,
-  Number: t.number,
-  String: t.string,
-  Escape: t.escape,
-  ArithOp: t.arithmeticOperator,
-  LogicOp: t.logicOperator,
-  BitOp: t.bitwiseOperator,
-  CompareOp: t.compareOperator,
-  RegExp: t.regexp,
-  Equals: t.definitionOperator,
-  Arrow: t.function(t.punctuation),
-  ": Spread": t.punctuation,
-  "( )": t.paren,
-  "[ ]": t.squareBracket,
-  "{ }": t.brace,
-  "InterpolationStart InterpolationEnd": t.special(t.brace),
-  ".": t.derefOperator,
-  ", ;": t.separator,
-  "@": t.meta,
-	ClassPath: t.labelName,
-
-  TypeName: t.typeName,
-  TypeDefinition: t.definition(t.typeName),
-  "type enum interface implements namespace module declare": t.definitionKeyword,
-  "abstract global Privacy readonly override": t.modifier,
-  "is keyof unique infer asserts": t.operatorKeyword,
-
-  JSXAttributeValue: t.attributeValue,
-  JSXText: t.content,
-  "JSXStartTag JSXStartCloseTag JSXSelfCloseEndTag JSXEndTag": t.angleBracket,
-  "JSXIdentifier JSXNameSpacedName": t.tagName,
-  "JSXAttribute/JSXIdentifier JSXAttribute/JSXNameSpacedName": t.attributeName,
-  "JSXBuiltin/JSXIdentifier": t.standard(t.tagName)
-})
-
-////////////////////////////////////////////
-// tokens.js
-////////////////////////////////////////////
-
-/* Hand-written tokenizers for JavaScript tokens that can't be
-   expressed by lezer's built-in tokenizer. */
-
-import {ExternalTokenizer, ContextTracker} from "@lezer/lr"
-import {insertSemi, noSemi, noSemiType, incdec, incdecPrefix, questionDot,
-        spaces, newline, BlockComment, LineComment,
-        JSXStartTag, Dialect_jsx} from "./parser.terms.js"
-
-const space = [9, 10, 11, 12, 13, 32, 133, 160, 5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200,
-              8201, 8202, 8232, 8233, 8239, 8287, 12288]
-
-const braceR = 125, semicolon = 59, slash = 47, star = 42, plus = 43, minus = 45, lt = 60, comma = 44,
-      question = 63, dot = 46, bracketL = 91
-
-export const trackNewline = new ContextTracker({
-  start: false,
-  shift(context, term) {
-    return term == LineComment || term == BlockComment || term == spaces ? context : term == newline
-  },
-  strict: false
-})
-
-export const insertSemicolon = new ExternalTokenizer((input, stack) => {
-  let {next} = input
-  if (next == braceR || next == -1 || stack.context)
-    input.acceptToken(insertSemi)
-}, {contextual: true, fallback: true})
-
-export const noSemicolon = new ExternalTokenizer((input, stack) => {
-  let {next} = input, after
-  if (space.indexOf(next) > -1) return
-  if (next == slash && ((after = input.peek(1)) == slash || after == star)) return
-  if (next != braceR && next != semicolon && next != -1 && !stack.context)
-    input.acceptToken(noSemi)
-}, {contextual: true})
-
-export const noSemicolonType = new ExternalTokenizer((input, stack) => {
-  if (input.next == bracketL && !stack.context) input.acceptToken(noSemiType)
-}, {contextual: true})
-
-export const operatorToken = new ExternalTokenizer((input, stack) => {
-  let {next} = input
-  if (next == plus || next == minus) {
-    input.advance()
-    if (next == input.next) {
-      input.advance()
-      let mayPostfix = !stack.context && stack.canShift(incdec)
-      input.acceptToken(mayPostfix ? incdec : incdecPrefix)
-    }
-  } else if (next == question && input.peek(1) == dot) {
-    input.advance(); input.advance()
-    if (input.next < 48 || input.next > 57) // No digit after
-      input.acceptToken(questionDot)
-  }
-}, {contextual: true})
-
-function identifierChar(ch, start) {
-  return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch == 95 || ch >= 192 ||
-    !start && ch >= 48 && ch <= 57
-}
-
-export const jsx = new ExternalTokenizer((input, stack) => {
-  if (input.next != lt || !stack.dialectEnabled(Dialect_jsx)) return
-  input.advance()
-  if (input.next == slash) return
-  // Scan for an identifier followed by a comma or 'extends', don't
-  // treat this as a start tag if present.
-  let back = 0
-  while (space.indexOf(input.next) > -1) { input.advance(); back++ }
-  if (identifierChar(input.next, true)) {
-    input.advance()
-    back++
-    while (identifierChar(input.next, false)) { input.advance(); back++ }
-    while (space.indexOf(input.next) > -1) { input.advance(); back++ }
-    if (input.next == comma) return
-    for (let i = 0;; i++) {
-      if (i == 7) {
-        if (!identifierChar(input.next, true)) return
-        break
-      }
-      if (input.next != "extends".charCodeAt(i)) break
-      input.advance()
-      back++
-    }
-  }
-  input.acceptToken(JSXStartTag, -back)
-})
-
-// A very dim/dull syntax highlighting so you have something to look at, but also to trigger you to write your own ;)
-// Also shows that you can use `export let extension = [...]`, to add extensions to the "demo text" editor.
-import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
-const syntax_colors = syntaxHighlighting(
-  HighlightStyle.define(
-    [
-      { tag: t.name, color: "#a8a8a8" },
-      { tag: t.propertyName, color: "#966a6a" },
-      { tag: t.comment, color: "#4b4949" },
-      { tag: t.atom, color: "#a25496" },
-
-      { tag: t.literal, color: "#7b87b8" },
-      { tag: t.unit, color: "#7b87b8" },
-      { tag: t.null, color: "#7b87b8" },
-
-      { tag: t.keyword, color: "#585858" },
-      { tag: t.punctuation, color: "#585858" },
-      { tag: t.derefOperator, color: "#585858" },
-      { tag: t.special(t.brace), fontWeight: 700 },
-
-      { tag: t.operator, color: "white" },
-      { tag: t.self, color: "white" },
-      { tag: t.function(t.punctuation), color: "white" },
-      { tag: t.special(t.logicOperator), color: "white", fontWeight: "bold" },
-      { tag: t.moduleKeyword, color: "white", fontWeight: "bold" },
-      { tag: t.controlKeyword, color: "white", fontWeight: "bold" },
-      { tag: t.controlOperator, color: "white", fontWeight: "bold" },
-    ],
-    { all: { color: "#585858" } }
-  )
-);
-
-export let extensions = [syntax_colors];
+import {styleTags, tags as t} from "@lezer/highlight"
+
+export const jsHighlight = styleTags({
+  "get set async static": t.modifier,
+  "for while do if else switch try catch finally return throw break continue default case defer": t.controlKeyword,
+  "in of await yield void typeof delete instanceof as satisfies": t.operatorKeyword,
+  "let var const using function class extends": t.definitionKeyword,
+  "import export from": t.moduleKeyword,
+  "with debugger new": t.keyword,
+  TemplateString: t.special(t.string),
+  super: t.atom,
+  BooleanLiteral: t.bool,
+  this: t.self,
+  null: t.null,
+  Star: t.modifier,
+  VariableName: t.variableName,
+  "CallExpression/VariableName TaggedTemplateExpression/VariableName": t.function(t.variableName),
+  VariableDefinition: t.definition(t.variableName),
+  Label: t.labelName,
+  PropertyName: t.propertyName,
+  PrivatePropertyName: t.special(t.propertyName),
+  "CallExpression/MemberExpression/PropertyName": t.function(t.propertyName),
+  "FunctionDeclaration/VariableDefinition": t.function(t.definition(t.variableName)),
+  "ClassDeclaration/VariableDefinition": t.definition(t.className),
+  "NewExpression/VariableName": t.className,
+  PropertyDefinition: t.definition(t.propertyName),
+  PrivatePropertyDefinition: t.definition(t.special(t.propertyName)),
+  UpdateOp: t.updateOperator,
+  "LineComment Hashbang": t.lineComment,
+  BlockComment: t.blockComment,
+  Number: t.number,
+  String: t.string,
+  Escape: t.escape,
+  ArithOp: t.arithmeticOperator,
+  LogicOp: t.logicOperator,
+  BitOp: t.bitwiseOperator,
+  CompareOp: t.compareOperator,
+  RegExp: t.regexp,
+  Equals: t.definitionOperator,
+  Arrow: t.function(t.punctuation),
+  ": Spread": t.punctuation,
+  "( )": t.paren,
+  "[ ]": t.squareBracket,
+  "{ }": t.brace,
+  "InterpolationStart InterpolationEnd": t.special(t.brace),
+  ".": t.derefOperator,
+  ", ;": t.separator,
+  "@": t.meta,
+
+  TypeName: t.typeName,
+  TypeDefinition: t.definition(t.typeName),
+  "type enum interface implements namespace module declare": t.definitionKeyword,
+  "abstract global Privacy readonly override": t.modifier,
+  "is keyof unique infer asserts": t.operatorKeyword,
+
+  JSXAttributeValue: t.attributeValue,
+  JSXText: t.content,
+  "JSXStartTag JSXStartCloseTag JSXSelfCloseEndTag JSXEndTag": t.angleBracket,
+  "JSXIdentifier JSXNameSpacedName": t.tagName,
+  "JSXAttribute/JSXIdentifier JSXAttribute/JSXNameSpacedName": t.attributeName,
+  "JSXBuiltin/JSXIdentifier": t.standard(t.tagName)
+})