groove-dev 0.15.1 → 0.16.1

package/node_modules/@lezer/javascript/test/typescript.txt

@@ -0,0 +1,401 @@
+# Undefined and Null Type {"dialect": "ts"}
+
+let x: undefined
+let y: null
+
+==>
+
+Script(
+  VariableDeclaration(let,VariableDefinition,TypeAnnotation(
+    TypeName)),
+  VariableDeclaration(let,VariableDefinition,TypeAnnotation(
+    NullType(null))))
+
+# Type declaration {"dialect": "ts"}
+
+function foo(a: number, b: "literal" | Map<number, boolean>): RegExp[] {}
+
+==>
+
+Script(FunctionDeclaration(function, VariableDefinition, ParamList(
+  VariableDefinition, TypeAnnotation(TypeName),
+  VariableDefinition, TypeAnnotation(UnionType(LiteralType(String), LogicOp, ParameterizedType(TypeName, TypeArgList(TypeName, TypeName))))
+), TypeAnnotation(ArrayType(TypeName)), Block))
+
+# Type predicate {"dialect": "ts"}
+
+function isFoo(foo: any): foo is Foo { return true }
+
+function assertFoo(foo: any): asserts foo is "string" { return true }
+
+==>
+
+Script(
+  FunctionDeclaration(function, VariableDefinition, ParamList(
+    VariableDefinition, TypeAnnotation(TypeName)
+  ), TypePredicate(VariableName, is, TypeName), Block(ReturnStatement(return, BooleanLiteral))),
+  FunctionDeclaration(function,VariableDefinition,ParamList(
+    VariableDefinition,TypeAnnotation(TypeName)
+  ),TypePredicate(asserts,VariableName,is,LiteralType(String)),Block(ReturnStatement(return,BooleanLiteral))))
+
+# Type alias {"dialect": "ts"}
+
+type Foo<T extends string> = T[]
+
+==>
+
+Script(TypeAliasDeclaration(type, TypeDefinition, TypeParamList(TypeDefinition, extends, TypeName), Equals, ArrayType(TypeName)))
+
+# Enum declaration {"dialect": "ts"}
+
+const enum Type { Red = 1, Blue, Green }
+
+==>
+
+Script(EnumDeclaration(const, enum, TypeDefinition, EnumBody(PropertyName, Equals, Number, PropertyName, PropertyName)))
+
+# Interface declaration {"dialect": "ts"}
+
+interface Foo {
+  readonly a: number
+  b(arg: string): void
+  (call: number): boolean
+  new (): Foo
+  readonly [x: string]: number
+}
+
+==>
+
+Script(InterfaceDeclaration(interface, TypeDefinition, ObjectType(
+  PropertyType(readonly, PropertyDefinition, TypeAnnotation(TypeName)),
+  MethodType(PropertyDefinition, ParamList(VariableDefinition, TypeAnnotation(TypeName)), TypeAnnotation(VoidType(void))),
+  CallSignature(ParamList(VariableDefinition, TypeAnnotation(TypeName)), TypeAnnotation(TypeName)),
+  NewSignature(new,ParamList, TypeAnnotation(TypeName)),
+  IndexSignature(readonly, PropertyDefinition, TypeAnnotation(TypeName), TypeAnnotation(TypeName)))))
+
+# Call type args {"dialect": "ts"}
+
+foo<number, string>() + new Bar<11>()
+x < 10 > 5
+
+==>
+
+Script(
+  ExpressionStatement(BinaryExpression(
+    CallExpression(InstantiationExpression(VariableName, TypeArgList(TypeName, TypeName)), ArgList),
+    ArithOp,
+    NewExpression(new, InstantiationExpression(VariableName, TypeArgList(LiteralType(Number))), ArgList))),
+  ExpressionStatement(BinaryExpression(BinaryExpression(VariableName, CompareOp, Number), CompareOp, Number)))
+
+# Advanced types {"dialect": "ts"}
+
+let x: typeof X.x | keyof Y & Z["Foo"] | A<string>
+let tuple: [a, b]
+let f: (x: number) => boolean
+
+==>
+
+Script(
+  VariableDeclaration(let, VariableDefinition, TypeAnnotation(
+    UnionType(TypeofType(typeof, MemberExpression(VariableName, PropertyName)), LogicOp,
+              IntersectionType(KeyofType(keyof, TypeName), LogicOp, IndexedType(TypeName, LiteralType(String))),
+              LogicOp, ParameterizedType(TypeName, TypeArgList(TypeName))))),
+  VariableDeclaration(let, VariableDefinition, TypeAnnotation(TupleType(TypeName, TypeName))),
+  VariableDeclaration(let, VariableDefinition, TypeAnnotation(FunctionSignature(
+    ParamList(VariableDefinition, TypeAnnotation(TypeName)), Arrow, TypeName))))
+
+# Prefix union/intersection
+
+let x:
+  | A
+  | B
+  | C
+let y: & RegExp & (& Date)
+
+==>
+
+Script(
+  VariableDeclaration(let,VariableDefinition,TypeAnnotation(
+    UnionType(LogicOp,TypeName,LogicOp,TypeName,LogicOp,TypeName))),
+  VariableDeclaration(let,VariableDefinition,TypeAnnotation(
+    IntersectionType(LogicOp,TypeName,LogicOp,ParenthesizedType(IntersectionType(LogicOp,TypeName))))))
+
+# Prefix cast {"dialect": "ts"}
+
+<string>foo
+
+==>
+
+Script(ExpressionStatement(PrefixCast(TypeName, VariableName)))
+
+# No prefix cast in JSX {"dialect": "ts jsx"}
+
+<string>foo</string>
+
+==>
+
+Script(ExpressionStatement(JSXElement(
+  JSXOpenTag(JSXStartTag, JSXBuiltin(JSXIdentifier), JSXEndTag),
+  JSXText,
+  JSXCloseTag(JSXStartCloseTag, JSXBuiltin(JSXIdentifier), JSXEndTag))))
+
+# Class definition {"dialect": "ts"}
+
+class Foo<T> extends Bar<T> implements Stuff {
+  a: number
+  public readonly b: string = "two"
+  constructor(readonly x: boolean, public y: number, z: string) {}
+  private static blah(): void {}
+}
+
+==>
+
+Script(ClassDeclaration(
+  class, VariableDefinition, TypeParamList(TypeDefinition),
+  extends, VariableName, TypeArgList(TypeName),
+  implements TypeName,
+  ClassBody(
+    PropertyDeclaration(PropertyDefinition, TypeAnnotation(TypeName)),
+    PropertyDeclaration(Privacy, readonly, PropertyDefinition, TypeAnnotation(TypeName), Equals, String),
+    MethodDeclaration(PropertyDefinition, ParamList(
+      readonly, VariableDefinition, TypeAnnotation(TypeName),
+      Privacy, VariableDefinition, TypeAnnotation(TypeName),
+      VariableDefinition, TypeAnnotation(TypeName)), Block),
+    MethodDeclaration(Privacy, static, PropertyDefinition, ParamList, TypeAnnotation(VoidType(void)), Block))))
+
+# Arrow with type params {"dialect": "ts"}
+
+let x = <T>(arg: T): T => arg
+
+==>
+
+Script(VariableDeclaration(let, VariableDefinition, Equals, ArrowFunction(
+  TypeParamList(TypeDefinition),
+  ParamList(VariableDefinition, TypeAnnotation(TypeName)),
+  TypeAnnotation(TypeName),
+  Arrow,
+  VariableName)))
+
+# Template types {"dialect": "ts"}
+
+type Tmpl<T> = `${string} ${5}` | `one ${Two}`
+
+==>
+
+Script(TypeAliasDeclaration(type, TypeDefinition, TypeParamList(TypeDefinition), Equals,
+  UnionType(TemplateType(Interpolation(InterpolationStart,TypeName,InterpolationEnd), Interpolation(InterpolationStart,LiteralType(Number),InterpolationEnd)), LogicOp, TemplateType(Interpolation(InterpolationStart,TypeName,InterpolationEnd)))))
+
+# Extending complex types {"dialect": "ts"}
+
+class Foo extends A.B<Param> {}
+
+==>
+
+Script(ClassDeclaration(class, VariableDefinition,
+  extends, MemberExpression(VariableName, PropertyName), TypeArgList(TypeName),
+  ClassBody))
+
+# Object type {"dialect": "ts"}
+
+type A = {a: number, b: number}
+type B = {a: number; b: number;}
+
+==>
+
+Script(
+  TypeAliasDeclaration(type,TypeDefinition,Equals,ObjectType(
+    PropertyType(PropertyDefinition,TypeAnnotation(TypeName)),
+    PropertyType(PropertyDefinition,TypeAnnotation(TypeName)))),
+  TypeAliasDeclaration(type,TypeDefinition,Equals,ObjectType(
+    PropertyType(PropertyDefinition,TypeAnnotation(TypeName)),
+    PropertyType(PropertyDefinition,TypeAnnotation(TypeName)))))
+
+# Conditional Type {"dialect": "ts"}
+
+type X<T> = T extends E ? number : A
+
+==>
+
+Script(
+  TypeAliasDeclaration(type,TypeDefinition,TypeParamList(TypeDefinition),Equals,
+    ConditionalType(TypeName,extends,TypeName,LogicOp,TypeName,LogicOp,TypeName)))
+
+# Generic Function Type {"dialect": "ts"}
+
+let f: <T>() => T
+
+==>
+
+Script(
+  VariableDeclaration(let,VariableDefinition,TypeAnnotation(
+    FunctionSignature(TypeParamList(TypeDefinition),ParamList,Arrow,TypeName))))
+
+# Satisfies operator {"dialect": "ts"}
+
+let x = 1 satisfies number
+
+==>
+
+Script(VariableDeclaration(let,VariableDefinition,Equals,BinaryExpression(Number,satisfies,TypeName)))
+
+# Override modifier on properties {"dialect": "ts"}
+
+class A {
+  override accessor a;
+  static override b = 1;
+  override c = 2;
+}
+
+==>
+
+Script(ClassDeclaration(class,VariableDefinition,ClassBody(
+  PropertyDeclaration(override,accessor,PropertyDefinition),
+  PropertyDeclaration(static,override,PropertyDefinition,Equals,Number),
+  PropertyDeclaration(override,PropertyDefinition,Equals,Number))))
+
+# Class extending expression {"dialect": "ts"}
+
+class X extends class {} {}
+
+==>
+
+Script(ClassDeclaration(class,VariableDefinition,extends,ClassExpression(class,ClassBody),ClassBody))
+
+# Declare syntax {"dialect": "ts"}
+
+declare namespace myLib {
+  function makeGreeting(s: string): string;
+  let numberOfGreetings: number;
+}
+
+declare function greet(setting: GreetingSettings): void;
+
+declare class Greeter {
+  constructor(greeting: string);
+  greeting: string;
+  showGreeting(): void;
+}
+
+class X {
+  declare foo();
+  declare bar: number;
+}
+
+==>
+
+Script(
+  AmbientDeclaration(declare,NamespaceDeclaration(namespace,VariableDefinition,Block(
+    FunctionDeclaration(function,VariableDefinition,ParamList(VariableDefinition,TypeAnnotation(TypeName)),
+      TypeAnnotation(TypeName)),
+    VariableDeclaration(let,VariableDefinition,TypeAnnotation(TypeName))))),
+  AmbientDeclaration(declare,AmbientFunctionDeclaration(function,VariableDefinition,
+    ParamList(VariableDefinition,TypeAnnotation(TypeName)),TypeAnnotation(VoidType(void)))),
+  AmbientDeclaration(declare,ClassDeclaration(class,VariableDefinition,ClassBody(
+    MethodDeclaration(PropertyDefinition,ParamList(VariableDefinition,TypeAnnotation(TypeName))),
+    PropertyDeclaration(PropertyDefinition,TypeAnnotation(TypeName)),
+    MethodDeclaration(PropertyDefinition,ParamList,TypeAnnotation(VoidType(void)))))),
+  ClassDeclaration(class,VariableDefinition,ClassBody(
+    MethodDeclaration(declare,PropertyDefinition,ParamList),
+    PropertyDeclaration(declare,PropertyDefinition,TypeAnnotation(TypeName)))))
+
+# Declare this in a Function {"dialect": "ts"}
+
+function foo(this: User) {}
+
+==>
+
+Script(FunctionDeclaration(function,VariableDefinition,ParamList(this,TypeAnnotation(TypeName)),Block))
+
+# Prefers type parameters to comparison operators {"dialect": "ts jsx"}
+
+let a = useState<string>(1)
+return 2
+
+==>
+
+Script(
+  VariableDeclaration(let,VariableDefinition,Equals,
+    CallExpression(InstantiationExpression(VariableName,TypeArgList(TypeName)),ArgList(Number))),
+  ReturnStatement(return,Number))
+
+# Type parameters vs JSX {"dialect": "jsx ts"}
+
+let a = <T extends any>(f) => null
+let b = <T,>() => 1
+
+==>
+
+Script(
+  VariableDeclaration(let,VariableDefinition,Equals,ArrowFunction(
+    TypeParamList(TypeDefinition,extends,TypeName),ParamList(VariableDefinition),Arrow,null)),
+  VariableDeclaration(let,VariableDefinition,Equals,ArrowFunction(
+    TypeParamList(TypeDefinition),ParamList,Arrow,Number)))
+
+# Destructured parameters in function signature {"dialect": "ts"}
+
+type F = ([a, b]: [number, number]) => void
+
+==>
+
+Script(TypeAliasDeclaration(type,TypeDefinition,Equals,FunctionSignature(
+  ParamList(ArrayPattern(VariableDefinition,VariableDefinition),TypeAnnotation(TupleType(TypeName,TypeName))),
+  Arrow,
+  VoidType(void))))
+
+# Instantiated expression {"dialect": "ts"}
+
+let x = a<b>;
+
+type Foo = Bar<typeof baz<Bug<Quux>>>;
+
+==>
+
+Script(
+  VariableDeclaration(let,VariableDefinition,Equals,InstantiationExpression(VariableName,TypeArgList(TypeName))),
+  TypeAliasDeclaration(type,TypeDefinition,Equals,ParameterizedType(TypeName,TypeArgList(
+    TypeofType(typeof,InstantiationExpression(VariableName,TypeArgList(
+      ParameterizedType(TypeName,TypeArgList(TypeName)))))))))
+
+# Not instantiated {"dialect": "ts"}
+
+let x = a<b>c
+
+==>
+
+Script(VariableDeclaration(let,VariableDefinition,Equals,BinaryExpression(
+  BinaryExpression(VariableName,CompareOp,VariableName),CompareOp,VariableName)))
+
+# Allows computed properties in types {"dialect": "ts"}
+
+interface X {
+  [Symbol.iterator](): Iterator<number>
+  [1]: string
+}
+
+==>
+
+Script(InterfaceDeclaration(interface,TypeDefinition,ObjectType(
+  MethodType(MemberExpression(VariableName,PropertyName),ParamList,
+    TypeAnnotation(ParameterizedType(TypeName,TypeArgList(TypeName)))),
+  PropertyType(Number,TypeAnnotation(TypeName)))))
+
+# Binary type operators {"dialect": "ts"}
+
+log(foo as number, {} satisfies AbstractObjectFactory<ParticleEmitter>)
+
+==>
+
+Script(ExpressionStatement(CallExpression(VariableName,ArgList(
+  BinaryExpression(VariableName,as,TypeName),
+  BinaryExpression(ObjectExpression,satisfies,ParameterizedType(TypeName,TypeArgList(TypeName)))))))
+
+# Allows this parameters in function types {"dialect": "ts"}
+
+let x: (this: X, expression: string) => Promise<T[]>
+
+==>
+
+Script(VariableDeclaration(let,VariableDefinition,TypeAnnotation(FunctionSignature(
+  ParamList(this,TypeAnnotation(TypeName),VariableDefinition,TypeAnnotation(TypeName)),
+  Arrow,
+  ParameterizedType(TypeName,TypeArgList(ArrayType(TypeName)))))))

package/node_modules/@lezer/json/CHANGELOG.md

@@ -0,0 +1,79 @@
+## 1.0.3 (2024-12-29)
+
+### Bug fixes
+
+Emit tokens for colons and commas.
+
+## 1.0.2 (2023-12-28)
+
+### Bug fixes
+
+Tag strings as isolating for the purpose of bidirectional text.
+
+## 1.0.1 (2023-07-03)
+
+### Bug fixes
+
+Make the package work with new TS resolution styles.
+
+## 1.0.0 (2022-06-06)
+
+### New features
+
+First stable version.
+
+## 0.16.0 (2022-04-20)
+
+### Breaking changes
+
+Move to 0.16 serialized parser format.
+
+### New features
+
+The parser now includes syntax highlighting information in its node types.
+
+## 0.15.0 (2021-08-11)
+
+### Breaking changes
+
+The module's name changed from `lezer-json` to `@lezer/json`.
+
+Upgrade to the 0.15.0 lezer interfaces.
+
+## 0.13.2 (2021-06-14)
+
+### Bug fixes
+
+Include nodes for brackets and braces in the tree.
+
+## 0.13.1 (2020-12-04)
+
+### Bug fixes
+
+Fix versions of lezer packages depended on.
+
+## 0.13.0 (2020-12-04)
+
+## 0.12.0 (2020-10-23)
+
+### Breaking changes
+
+Adjust to changed serialized parser format.
+
+## 0.11.1 (2020-09-26)
+
+### Bug fixes
+
+Fix lezer depencency versions
+
+## 0.11.0 (2020-09-26)
+
+### Breaking changes
+
+Follow change in serialized parser format.
+
+## 0.10.0 (2020-09-23)
+
+### Breaking changes
+
+Upgrade to current parser package format.

package/node_modules/@lezer/json/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2020 by Marijn Haverbeke <marijn@haverbeke.berlin>, Arun Srinivasan <rulfzid@gmail.com>, and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/@lezer/json/README.md

@@ -0,0 +1,7 @@
+# @lezer/json
+
+This is a JSON grammar for the [lezer](https://lezer.codemirror.net/) parser system.
+
+Reference:
+- https://www.json.org/json-en.html
+- https://tools.ietf.org/html/rfc8259 (The latest IETF RFC – contains the latest full spec)

package/node_modules/@lezer/json/dist/index.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lr = require('@lezer/lr');
+var highlight = require('@lezer/highlight');
+
+const jsonHighlighting = highlight.styleTags({
+  String: highlight.tags.string,
+  Number: highlight.tags.number,
+  "True False": highlight.tags.bool,
+  PropertyName: highlight.tags.propertyName,
+  Null: highlight.tags.null,
+  ", :": highlight.tags.separator,
+  "[ ]": highlight.tags.squareBracket,
+  "{ }": highlight.tags.brace
+});
+
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+const parser = lr.LRParser.deserialize({
+  version: 14,
+  states: "$bOVQPOOOOQO'#Cb'#CbOnQPO'#CeOvQPO'#ClOOQO'#Cr'#CrQOQPOOOOQO'#Cg'#CgO}QPO'#CfO!SQPO'#CtOOQO,59P,59PO![QPO,59PO!aQPO'#CuOOQO,59W,59WO!iQPO,59WOVQPO,59QOqQPO'#CmO!nQPO,59`OOQO1G.k1G.kOVQPO'#CnO!vQPO,59aOOQO1G.r1G.rOOQO1G.l1G.lOOQO,59X,59XOOQO-E6k-E6kOOQO,59Y,59YOOQO-E6l-E6l",
+  stateData: "#O~OeOS~OQSORSOSSOTSOWQO_ROgPO~OVXOgUO~O^[O~PVO[^O~O]_OVhX~OVaO~O]bO^iX~O^dO~O]_OVha~O]bO^ia~O",
+  goto: "!kjPPPPPPkPPkqwPPPPk{!RPPP!XP!e!hXSOR^bQWQRf_TVQ_Q`WRg`QcZRicQTOQZRQe^RhbRYQR]R",
+  nodeNames: "⚠ JsonText True False Null Number String } { Object Property PropertyName : , ] [ Array",
+  maxTerm: 25,
+  nodeProps: [
+    ["isolate", -2,6,11,""],
+    ["openedBy", 7,"{",14,"["],
+    ["closedBy", 8,"}",15,"]"]
+  ],
+  propSources: [jsonHighlighting],
+  skippedNodes: [0],
+  repeatNodeCount: 2,
+  tokenData: "(|~RaXY!WYZ!W]^!Wpq!Wrs!]|}$u}!O$z!Q!R%T!R![&c![!]&t!}#O&y#P#Q'O#Y#Z'T#b#c'r#h#i(Z#o#p(r#q#r(w~!]Oe~~!`Wpq!]qr!]rs!xs#O!]#O#P!}#P;'S!];'S;=`$o<%lO!]~!}Og~~#QXrs!]!P!Q!]#O#P!]#U#V!]#Y#Z!]#b#c!]#f#g!]#h#i!]#i#j#m~#pR!Q![#y!c!i#y#T#Z#y~#|R!Q![$V!c!i$V#T#Z$V~$YR!Q![$c!c!i$c#T#Z$c~$fR!Q![!]!c!i!]#T#Z!]~$rP;=`<%l!]~$zO]~~$}Q!Q!R%T!R![&c~%YRT~!O!P%c!g!h%w#X#Y%w~%fP!Q![%i~%nRT~!Q![%i!g!h%w#X#Y%w~%zR{|&T}!O&T!Q![&Z~&WP!Q![&Z~&`PT~!Q![&Z~&hST~!O!P%c!Q![&c!g!h%w#X#Y%w~&yO[~~'OO_~~'TO^~~'WP#T#U'Z~'^P#`#a'a~'dP#g#h'g~'jP#X#Y'm~'rOR~~'uP#i#j'x~'{P#`#a(O~(RP#`#a(U~(ZOS~~(^P#f#g(a~(dP#i#j(g~(jP#X#Y(m~(rOQ~~(wOW~~(|OV~",
+  tokenizers: [0],
+  topRules: {"JsonText":[0,1]},
+  tokenPrec: 0
+});
+
+exports.parser = parser;

package/node_modules/@lezer/json/dist/index.d.cts

@@ -0,0 +1,3 @@
+import {LRParser} from "@lezer/lr"
+
+export const parser: LRParser

package/node_modules/@lezer/json/dist/index.d.ts

@@ -0,0 +1,3 @@
+import {LRParser} from "@lezer/lr"
+
+export const parser: LRParser

package/node_modules/@lezer/json/dist/index.js

@@ -0,0 +1,37 @@
+import { LRParser } from '@lezer/lr';
+import { styleTags, tags } from '@lezer/highlight';
+
+const jsonHighlighting = styleTags({
+  String: tags.string,
+  Number: tags.number,
+  "True False": tags.bool,
+  PropertyName: tags.propertyName,
+  Null: tags.null,
+  ", :": tags.separator,
+  "[ ]": tags.squareBracket,
+  "{ }": tags.brace
+});
+
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+const parser = LRParser.deserialize({
+  version: 14,
+  states: "$bOVQPOOOOQO'#Cb'#CbOnQPO'#CeOvQPO'#ClOOQO'#Cr'#CrQOQPOOOOQO'#Cg'#CgO}QPO'#CfO!SQPO'#CtOOQO,59P,59PO![QPO,59PO!aQPO'#CuOOQO,59W,59WO!iQPO,59WOVQPO,59QOqQPO'#CmO!nQPO,59`OOQO1G.k1G.kOVQPO'#CnO!vQPO,59aOOQO1G.r1G.rOOQO1G.l1G.lOOQO,59X,59XOOQO-E6k-E6kOOQO,59Y,59YOOQO-E6l-E6l",
+  stateData: "#O~OeOS~OQSORSOSSOTSOWQO_ROgPO~OVXOgUO~O^[O~PVO[^O~O]_OVhX~OVaO~O]bO^iX~O^dO~O]_OVha~O]bO^ia~O",
+  goto: "!kjPPPPPPkPPkqwPPPPk{!RPPP!XP!e!hXSOR^bQWQRf_TVQ_Q`WRg`QcZRicQTOQZRQe^RhbRYQR]R",
+  nodeNames: "⚠ JsonText True False Null Number String } { Object Property PropertyName : , ] [ Array",
+  maxTerm: 25,
+  nodeProps: [
+    ["isolate", -2,6,11,""],
+    ["openedBy", 7,"{",14,"["],
+    ["closedBy", 8,"}",15,"]"]
+  ],
+  propSources: [jsonHighlighting],
+  skippedNodes: [0],
+  repeatNodeCount: 2,
+  tokenData: "(|~RaXY!WYZ!W]^!Wpq!Wrs!]|}$u}!O$z!Q!R%T!R![&c![!]&t!}#O&y#P#Q'O#Y#Z'T#b#c'r#h#i(Z#o#p(r#q#r(w~!]Oe~~!`Wpq!]qr!]rs!xs#O!]#O#P!}#P;'S!];'S;=`$o<%lO!]~!}Og~~#QXrs!]!P!Q!]#O#P!]#U#V!]#Y#Z!]#b#c!]#f#g!]#h#i!]#i#j#m~#pR!Q![#y!c!i#y#T#Z#y~#|R!Q![$V!c!i$V#T#Z$V~$YR!Q![$c!c!i$c#T#Z$c~$fR!Q![!]!c!i!]#T#Z!]~$rP;=`<%l!]~$zO]~~$}Q!Q!R%T!R![&c~%YRT~!O!P%c!g!h%w#X#Y%w~%fP!Q![%i~%nRT~!Q![%i!g!h%w#X#Y%w~%zR{|&T}!O&T!Q![&Z~&WP!Q![&Z~&`PT~!Q![&Z~&hST~!O!P%c!Q![&c!g!h%w#X#Y%w~&yO[~~'OO_~~'TO^~~'WP#T#U'Z~'^P#`#a'a~'dP#g#h'g~'jP#X#Y'm~'rOR~~'uP#i#j'x~'{P#`#a(O~(RP#`#a(U~(ZOS~~(^P#f#g(a~(dP#i#j(g~(jP#X#Y(m~(rOQ~~(wOW~~(|OV~",
+  tokenizers: [0],
+  topRules: {"JsonText":[0,1]},
+  tokenPrec: 0
+});
+
+export { parser };

package/node_modules/@lezer/json/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@lezer/json",
+  "version": "1.0.3",
+  "description": "lezer-based JSON 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",
+  "author": "Arun Srinivasan <rulfzid@gmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@lezer/generator": "^1.0.0",
+    "mocha": "^10.2.0",
+    "rollup": "^2.52.2",
+    "@rollup/plugin-node-resolve": "^9.0.0"
+  },
+  "dependencies": {
+    "@lezer/common": "^1.2.0",
+    "@lezer/highlight": "^1.0.0",
+    "@lezer/lr": "^1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lezer-parser/json.git"
+  },
+  "scripts": {
+    "build": "lezer-generator src/json.grammar -o src/parser && rollup -c",
+    "build-debug": "lezer-generator src/json.grammar --names -o src/parser && rollup -c",
+    "prepare": "npm run build",
+    "test": "npm run build && mocha test/test-json.js"
+  }
+}

package/node_modules/@lezer/json/rollup.config.js

@@ -0,0 +1,15 @@
+import {nodeResolve} from "@rollup/plugin-node-resolve"
+
+export default {
+  input: "./src/parser.js",
+  output: [
+    { format: "cjs", file: "./dist/index.cjs" },
+    { format: "es", file: "./dist/index.js" }
+  ],
+  external(id) {
+    return !/^[\.\/]/.test(id)
+  },
+  plugins: [
+    nodeResolve()
+  ]
+}

package/node_modules/@lezer/json/src/highlight.js

@@ -0,0 +1,12 @@
+import {styleTags, tags as t} from "@lezer/highlight"
+
+export const jsonHighlighting = styleTags({
+  String: t.string,
+  Number: t.number,
+  "True False": t.bool,
+  PropertyName: t.propertyName,
+  Null: t.null,
+  ", :": t.separator,
+  "[ ]": t.squareBracket,
+  "{ }": t.brace
+})