groove-dev 0.15.0 → 0.16.0

package/node_modules/@lezer/python/src/python.grammar

@@ -0,0 +1,381 @@
+@precedence {
+  cond,
+  trail,
+  power @right,
+  prefix,
+  times @left,
+  plus @left,
+  shift @left,
+  bitand @left,
+  xor @left,
+  bitor @left,
+  compare @left,
+  as @left,
+  and @left,
+  or @left
+}
+
+@top Script { statement+ }
+
+@skip { space | newlineBracketed | Comment | blankLine }
+
+Decorator { At dottedName ArgList? newline }
+
+FunctionDefinition {
+  kw<"async">? kw<"def"> VariableName TypeParamList?
+  ParamList
+  TypeDef { "->" test }?
+  Body
+}
+
+ParamList { "(" commaSep<param>? ")" }
+
+TypeParamList { "[" commaSep<TypeParam> "]" }
+
+TypeParam {
+  ("*" | "**") VariableName |
+  VariableName TypeDef?
+}
+
+MatchStatement {
+  skw<"match"> "*"? expression MatchBody { ":" newline indent MatchClause+ (dedent | eof) }
+}
+
+MatchClause {
+  skw<"case"> commaSep<pattern> Guard { kw<"if"> test }? Body
+}
+
+pattern[@isGroup=Pattern] {
+  CapturePattern { VariableName } |
+  LiteralPattern |
+  AsPattern { pattern !as kw<"as"> VariableName } |
+  OrPattern { pattern (!or LogicOp{"|"} pattern)+ } |
+  AttributePattern |
+  SequencePattern |
+  MappingPattern |
+  StarPattern { "*" !prefix pattern } |
+  ClassPattern { (VariableName | AttributePattern) PatternArgList }
+}
+
+AttributePattern { VariableName ("." PropertyName)+ }
+
+LiteralPattern {
+  ArithOp{"-"}? Number (ArithOp{"+"|"-"} Number)? |
+  String |
+  kw<"None"> |
+  @specialize[@name=Boolean]<identifier, "True" | "False">
+}
+
+PatternArgList { "(" commaSep<pattern | KeywordPattern { VariableName "=" pattern }> ")" }
+
+SequencePattern { "[" commaSep<pattern> "]" | "(" commaSep<pattern> ")" }
+
+MappingPattern { "{" commaSep<"**" pattern | (VariableName | LiteralPattern) ":" pattern> "}" }
+
+ClassDefinition { kw<"class"> VariableName TypeParamList? ArgList? Body }
+
+param { VariableName TypeDef? (AssignOp{"="} test)? | "*" (VariableName TypeDef?)? | "**" VariableName TypeDef? | "/" }
+
+TypeDef { ":" test }
+
+statement[@isGroup=Statement] { simpleStatement | compoundStatement }
+
+simpleStatement {
+  smallStatement (newline | eof) |
+  StatementGroup { smallStatement (";" smallStatement?)+ (newline | eof) }
+}
+
+smallStatement {
+  AssignStatement { expressions (TypeDef? (AssignOp{"="} (YieldExpression | expressions))+ | TypeDef) } |
+  UpdateStatement { expressions UpdateOp (YieldExpression | commaSep<test>) } |
+  ExpressionStatement { expressions } |
+  DeleteStatement { kw<"del"> commaSep<expression> } |
+  PassStatement { kw<"pass"> } |
+  BreakStatement { kw<"break"> } |
+  ContinueStatement { kw<"continue"> } |
+  ReturnStatement { kw<"return"> commaSep<test | "*" expression>? } |
+  YieldStatement { yield } |
+  PrintStatement { printKeyword test } |
+  RaiseStatement { kw<"raise"> (test (kw<"from"> test | ("," test ("," test)?))?)? } |
+  ImportStatement |
+  ScopeStatement { (kw<"global"> | kw<"nonlocal">) commaSep<VariableName> } |
+  AssertStatement { kw<"assert"> commaSep<test> } |
+  TypeDefinition { skw<"type"> VariableName TypeParamList? "=" test }
+}
+
+expressions { commaSep<"*" expression | test> }
+
+ImportStatement {
+  kw<"import"> (importList | importedNames) |
+  kw<"from"> (("." | "...")+ dottedName? | dottedName) kw<"import"> ("*" | importList | importedNames)
+}
+importedNames { commaSep<dottedName | dottedName kw<"as"> VariableName> }
+importList[@export] { "(" importedNames ")" }
+
+commaSep<expr> { expr ("," expr)* ","? }
+
+compoundStatement {
+  IfStatement |
+  WhileStatement { kw<"while"> testNamed Body elseClause? } |
+  ForStatement { kw<"async">? kw<"for"> commaSep<"*"? expression> kw<"in"> commaSep<test> Body elseClause? } |
+  TryStatement |
+  WithStatement { kw<"async">? kw<"with"> commaSep<test (kw<"as"> VariableName)?> Body } |
+  FunctionDefinition |
+  ClassDefinition |
+  DecoratedStatement { Decorator+ (ClassDefinition | FunctionDefinition) } |
+  MatchStatement
+}
+
+elseClause { kw<"else"> Body }
+
+IfStatement {
+  kw<"if"> testNamed Body
+  (kw<"elif"> testNamed? Body)*
+  elseClause?
+}
+
+TryStatement {
+  kw<"try"> Body
+  (kw<"except"> "*"? (test ((kw<"as"> | ",") VariableName)?)? Body)*
+  elseClause?
+  (kw<"finally"> Body)?
+}
+
+Body { ":" (simpleStatement | newline indent statement+ (dedent | eof)) }
+
+lambdaParam { VariableName (AssignOp{"="} test)? | "*" VariableName? | "**" VariableName }
+
+lambdaParams[@name="ParamList"] { (lambdaParam ("," lambdaParam)*)? }
+
+test {
+ testInner |
+ ConditionalExpression { testInner !cond kw<"if"> testInner kw<"else"> test } |
+ LambdaExpression { kw<"lambda"> lambdaParams ":" test }
+}
+
+testNoCond {
+  testInner |
+  LambdaExpression { kw<"lambda"> lambdaParams ":" testNoCond }
+}
+
+testNamed {
+  test | NamedExpression { test AssignOp{":="} test }
+}
+
+testInner { binaryTest | unaryTest | expression }
+
+binaryTest[@name="BinaryExpression"] {
+  testInner !or kw<"or"> testInner |
+  testInner !and kw<"and"> testInner |
+  testInner !compare (CompareOp | kw<"in"> | kw<"not"> kw<"in"> | kw<"is"> kw<"not">?) testInner
+}
+
+unaryTest[@name="UnaryExpression"] { kw<"not"> testInner }
+
+expression[@isGroup=Expression] {
+  BinaryExpression |
+  UnaryExpression { !prefix (ArithOp{"+" | "-"} | BitOp{"~"}) expression } |
+  AwaitExpression { kw<"await"> expression } |
+  ParenthesizedExpression |
+  TupleExpression |
+  ComprehensionExpression |
+  ArrayExpression |
+  ArrayComprehensionExpression |
+  DictionaryExpression |
+  DictionaryComprehensionExpression |
+  SetExpression |
+  SetComprehensionExpression |
+  CallExpression { expression !trail ArgList } |
+  MemberExpression { expression !trail (subscript | "." PropertyName) } |
+  VariableName |
+  Number |
+  String | FormatString |
+  ContinuedString { (String | FormatString) (String | FormatString)+ } |
+  "..." |
+  kw<"None"> |
+  @specialize[@name=Boolean]<identifier, "True" | "False">
+}
+
+subscript[@export] {
+  "[" commaSep<testNamed | testNamed? ":" testNamed? (":" testNamed?)?> "]"
+}
+
+ParenthesizedExpression { "(" (testNamed | "*" expression | YieldExpression) ")" }
+
+TupleExpression { "(" ((testNamed | "*" expression) (("," (testNamed | "*" expression))+ ","? | ","))? ")" }
+ComprehensionExpression { "(" (testNamed | "*" expression) compFor ")" }
+
+ArrayExpression { "[" commaSep<testNamed | "*" expression>? "]" }
+ArrayComprehensionExpression { "[" (testNamed | "*" expression) compFor "]" }
+
+DictionaryExpression { "{" commaSep<test ":" test | "**" expression>? "}" }
+DictionaryComprehensionExpression { "{" (test ":" test | "**" expression) compFor "}" }
+
+SetExpression { "{" commaSep<test | "*" expression> "}" }
+SetComprehensionExpression { "{" (test | "*" expression) compFor "}" }
+
+yield { kw<"yield"> (kw<"from"> test | commaSep<test | "*" expression>) }
+
+YieldExpression { yield }
+
+BinaryExpression {
+  expression !bitor BitOp{"|"} expression |
+  expression !xor BitOp{"^"} expression |
+  expression !bitand BitOp{"&"} expression |
+  expression !shift BitOp{"<<" | ">>"} expression |
+  expression !plus ArithOp{"+" | "-"} expression |
+  expression !times ArithOp{"*" | "@" | "/" | "%" | "//"} expression |
+  expression !power ArithOp{"**"} expression
+}
+
+ArgList { "(" commaSep<argument>? ")" }
+
+argument { test compFor? | VariableName AssignOp{"=" | ":="} test compFor? | "**" test | "*" test }
+
+compFor {
+  kw<"async">? kw<"for"> commaSep<expression> kw<"in"> testInner (compFor | compIf)?
+}
+
+compIf {
+  kw<"if"> testNoCond (compFor | compIf)?
+}
+
+// FIXME Is it possible to distinguish between VariableName and VariableDefinition?
+
+VariableName { identifier }
+
+PropertyName { word }
+
+dottedName { VariableName ("." VariableName)* }
+
+kw<term> { @specialize[@name={term}]<identifier, term> }
+
+skw<term> { @extend[@name={term}]<identifier, term> }
+
+@skip {} {
+  String[isolate] {
+    (stringStart | stringStartD | stringStartL | stringStartLD |
+     stringStartR | stringStartRD | stringStartRL | stringStartRLD)
+    (stringContent | Escape)*
+    stringEnd
+  }
+
+  FormatString[isolate] {
+    (stringStartF | stringStartFD | stringStartFL | stringStartFLD |
+     stringStartFR | stringStartFRD | stringStartFRL | stringStartFRLD)
+    (stringContent | Escape | FormatReplacement)*
+    stringEnd
+  }
+
+  formatStringSpec { FormatSpec { ":" (formatStringSpecChars | nestedFormatReplacement)* } "}" }
+
+  blankLine {
+    blankLineStart space? Comment? (newline | eof)
+  }
+}
+
+formatReplacement<start> {
+  start
+  (YieldExpression | commaSep<"*"? test>)
+  FormatSelfDoc {"="}?
+  FormatConversion?
+  (formatStringSpec | "}")
+}
+
+FormatReplacement[isolate] { formatReplacement<replacementStart> }
+nestedFormatReplacement[isolate,@name=FormatReplacement,@export] { formatReplacement<"{"> }
+
+@context trackIndent from "./tokens.js"
+
+@external tokens legacyPrint from "./tokens.js" { printKeyword[@name="print"] }
+
+@external tokens indentation from "./tokens" { indent, dedent }
+
+@external tokens newlines from "./tokens" { newline, blankLineStart, newlineBracketed, eof }
+
+@external tokens strings from "./tokens" {
+  stringContent
+  Escape
+  replacementStart[@name="{"]
+  stringEnd
+}
+
+@tokens {
+  CompareOp { "<" | ">" | $[<>=!] "=" | "<>" }
+
+  UpdateOp { ($[+\-@%&|^] | "<<" | ">>" | "*" "*"? | "/" "/"?) "=" }
+
+  // String types are identified by letter suffixes:
+  //   D: double quoted
+  //   L: long string
+  //   R: raw string
+  //   F: format string
+  stringStart[@export] { stringPrefix? "'" }
+  stringStartD[@export] { stringPrefix? '"' }
+  stringStartL[@export] { stringPrefix? "'''" }
+  stringStartLD[@export] { stringPrefix? '"""' }
+  stringStartR[@export] { stringPrefixR "'" }
+  stringStartRD[@export] { stringPrefixR '"' }
+  stringStartRL[@export] { stringPrefixR "'''" }
+  stringStartRLD[@export] { stringPrefixR '"""' }
+  stringStartF[@export] { stringPrefixF "'" }
+  stringStartFD[@export] { stringPrefixF '"' }
+  stringStartFL[@export] { stringPrefixF "'''" }
+  stringStartFLD[@export] { stringPrefixF '"""' }
+  stringStartFR[@export] { stringPrefixFR "'" }
+  stringStartFRD[@export] { stringPrefixFR '"' }
+  stringStartFRL[@export] { stringPrefixFR "'''" }
+  stringStartFRLD[@export] { stringPrefixFR '"""' }
+
+  stringPrefix { $[uUbB] }
+  stringPrefixR { $[rR] $[bB]? | $[bB] $[rR] }
+  stringPrefixF { $[fF] }
+  stringPrefixFR { $[rR] $[fF] | $[fF] $[rR] }
+
+  // Give string quotes a higher precedence than identifiers, and long
+  // strings a higher precedence than short strings
+  @precedence { stringStartL, stringStart, identifier }
+  @precedence { stringStartLD, stringStartD, identifier }
+  @precedence { stringStartRL, stringStartR, identifier }
+  @precedence { stringStartRLD, stringStartRD, identifier }
+  @precedence { stringStartFL, stringStartF, identifier }
+  @precedence { stringStartFLD, stringStartFD, identifier }
+  @precedence { stringStartFRL, stringStartFR, identifier }
+  @precedence { stringStartFRLD, stringStartFRD, identifier }
+
+  identifierChar { @asciiLetter | $[_\u{a1}-\u{10ffff}] }
+
+  word { identifierChar (@digit | identifierChar)* }
+
+  identifier { word }
+
+  FormatConversion { "!" $[sra] }
+
+  formatStringSpecChars { ![{}]+ }
+
+  Number {
+    (@digit ("_" | @digit)* ("." @digit ("_" | @digit)*)? | "." @digit ("_" | @digit)*)
+      ($[eE] $[+\-]? @digit ("_" | @digit)*)? $[jJ]? |
+    "0" $[bB] $[_01]+ |
+    "0" $[oO] $[_0-7]+ |
+    "0" $[xX] $[_0-9a-fA-F]+
+  }
+
+  Comment[isolate] { "#" ![\n\r]* }
+
+  space { ($[ \t\f] | "\\" $[\n\r])+ }
+
+  At { "@" }
+
+  "..."[@name=Ellipsis]
+
+  "("[@export=ParenL] ")"
+  "["[@export=BracketL] "]"
+  "{"[@export=BraceL] "}"
+
+  "." "," ";" ":" "@" "*" "**"
+}
+
+@external propSource pythonHighlighting from "./highlight"
+
+@detectDelim

package/node_modules/@lezer/python/src/tokens.js

@@ -0,0 +1,224 @@
+import {ExternalTokenizer, ContextTracker} from "@lezer/lr"
+import {
+  newline as newlineToken, eof, newlineBracketed, blankLineStart, indent, dedent, printKeyword,
+  ParenthesizedExpression, TupleExpression, ComprehensionExpression,
+  PatternArgList, SequencePattern, MappingPattern, TypeParamList,
+  ArrayExpression, ArrayComprehensionExpression, ArgList, ParamList, importList, subscript,
+  DictionaryExpression, DictionaryComprehensionExpression, SetExpression, SetComprehensionExpression,
+  String as StringTerm, FormatString, FormatReplacement, nestedFormatReplacement,
+  stringStart, stringStartD, stringStartL, stringStartLD,
+  stringStartR, stringStartRD, stringStartRL, stringStartRLD,
+  stringStartF, stringStartFD, stringStartFL, stringStartFLD,
+  stringStartFR, stringStartFRD, stringStartFRL, stringStartFRLD,
+  stringContent, Escape, replacementStart, stringEnd,
+  ParenL, BraceL, BracketL
+} from "./parser.terms.js"
+
+const newline = 10, carriageReturn = 13, space = 32, tab = 9, hash = 35, parenOpen = 40, dot = 46,
+      braceOpen = 123, braceClose = 125, singleQuote = 39, doubleQuote = 34, backslash = 92,
+      letter_o = 111, letter_x = 120, letter_N = 78, letter_u = 117, letter_U = 85
+
+const bracketed = new Set([
+  ParenthesizedExpression, TupleExpression, ComprehensionExpression, importList, ArgList, ParamList,
+  ArrayExpression, ArrayComprehensionExpression, subscript,
+  SetExpression, SetComprehensionExpression, FormatString, FormatReplacement, nestedFormatReplacement,
+  DictionaryExpression, DictionaryComprehensionExpression,
+  SequencePattern, MappingPattern, PatternArgList, TypeParamList
+])
+
+function isLineBreak(ch) {
+  return ch == newline || ch == carriageReturn
+}
+
+function isHex(ch) {
+  return ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+}
+
+export const newlines = new ExternalTokenizer((input, stack) => {
+  let prev
+  if (input.next < 0) {
+    input.acceptToken(eof)
+  } else if (stack.context.flags & cx_Bracketed) {
+    if (isLineBreak(input.next)) input.acceptToken(newlineBracketed, 1)
+  } else if (((prev = input.peek(-1)) < 0 || isLineBreak(prev)) &&
+             stack.canShift(blankLineStart)) {
+    let spaces = 0
+    while (input.next == space || input.next == tab) { input.advance(); spaces++ }
+    if (input.next == newline || input.next == carriageReturn || input.next == hash)
+      input.acceptToken(blankLineStart, -spaces)
+  } else if (isLineBreak(input.next)) {
+    input.acceptToken(newlineToken, 1)
+  }
+}, {contextual: true})
+
+export const indentation = new ExternalTokenizer((input, stack) => {
+  let context = stack.context
+  if (context.flags) return
+  let prev = input.peek(-1), depth
+  if (prev == newline || prev == carriageReturn) {
+    let depth = 0, chars = 0
+    for (;;) {
+      if (input.next == space) depth++
+      else if (input.next == tab) depth += 8 - (depth % 8)
+      else break
+      input.advance()
+      chars++
+    }
+    if (depth != context.indent &&
+        input.next != newline && input.next != carriageReturn && input.next != hash) {
+      if (depth < context.indent) input.acceptToken(dedent, -chars)
+      else input.acceptToken(indent)
+    }
+  }
+})
+
+// Flags used in Context objects
+const cx_Bracketed = 1, cx_String = 2, cx_DoubleQuote = 4, cx_Long = 8, cx_Raw = 16, cx_Format = 32
+
+function Context(parent, indent, flags) {
+  this.parent = parent
+  this.indent = indent
+  this.flags = flags
+  this.hash = (parent ? parent.hash + parent.hash << 8 : 0) + indent + (indent << 4) + flags + (flags << 6)
+}
+
+const topIndent = new Context(null, 0, 0)
+
+function countIndent(space) {
+  let depth = 0
+  for (let i = 0; i < space.length; i++)
+    depth += space.charCodeAt(i) == tab ? 8 - (depth % 8) : 1
+  return depth
+}
+
+const stringFlags = new Map([
+  [stringStart, 0],
+  [stringStartD, cx_DoubleQuote],
+  [stringStartL, cx_Long],
+  [stringStartLD, cx_Long | cx_DoubleQuote],
+  [stringStartR, cx_Raw],
+  [stringStartRD, cx_Raw | cx_DoubleQuote],
+  [stringStartRL, cx_Raw | cx_Long],
+  [stringStartRLD, cx_Raw | cx_Long | cx_DoubleQuote],
+  [stringStartF, cx_Format],
+  [stringStartFD, cx_Format | cx_DoubleQuote],
+  [stringStartFL, cx_Format | cx_Long],
+  [stringStartFLD, cx_Format | cx_Long | cx_DoubleQuote],
+  [stringStartFR, cx_Format | cx_Raw],
+  [stringStartFRD, cx_Format | cx_Raw | cx_DoubleQuote],
+  [stringStartFRL, cx_Format | cx_Raw | cx_Long],
+  [stringStartFRLD, cx_Format | cx_Raw | cx_Long | cx_DoubleQuote]
+].map(([term, flags]) => [term, flags | cx_String]))
+
+export const trackIndent = new ContextTracker({
+  start: topIndent,
+  reduce(context, term, _, input) {
+    if ((context.flags & cx_Bracketed) && bracketed.has(term) ||
+        (term == StringTerm || term == FormatString) && (context.flags & cx_String))
+      return context.parent
+    return context
+  },
+  shift(context, term, stack, input) {
+    if (term == indent)
+      return new Context(context, countIndent(input.read(input.pos, stack.pos)), 0)
+    if (term == dedent)
+      return context.parent
+    if (term == ParenL || term == BracketL || term == BraceL || term == replacementStart)
+      return new Context(context, 0, cx_Bracketed)
+    if (stringFlags.has(term))
+      return new Context(context, 0, stringFlags.get(term) | (context.flags & cx_Bracketed))
+    return context
+  },
+  hash(context) { return context.hash }
+})
+
+export const legacyPrint = new ExternalTokenizer(input => {
+  for (let i = 0; i < 5; i++) {
+    if (input.next != "print".charCodeAt(i)) return
+    input.advance()
+  }
+  if (/\w/.test(String.fromCharCode(input.next))) return
+  for (let off = 0;; off++) {
+    let next = input.peek(off)
+    if (next == space || next == tab) continue
+    if (next != parenOpen && next != dot && next != newline && next != carriageReturn && next != hash)
+      input.acceptToken(printKeyword)
+    return
+  }
+})
+
+export const strings = new ExternalTokenizer((input, stack) => {
+  let {flags} = stack.context
+  let quote = (flags & cx_DoubleQuote) ? doubleQuote : singleQuote
+  let long = (flags & cx_Long) > 0
+  let escapes = !(flags & cx_Raw)
+  let format = (flags & cx_Format) > 0
+
+  let start = input.pos
+  for (;;) {
+    if (input.next < 0) {
+      break
+    } else if (format && input.next == braceOpen) {
+      if (input.peek(1) == braceOpen) {
+        input.advance(2)
+      } else {
+        if (input.pos == start) {
+          input.acceptToken(replacementStart, 1)
+          return
+        }
+        break
+      }
+    } else if (escapes && input.next == backslash) {
+      if (input.pos == start) {
+        input.advance()
+        let escaped = input.next
+        if (escaped >= 0) {
+          input.advance()
+          skipEscape(input, escaped)
+        }
+        input.acceptToken(Escape)
+        return
+      }
+      break
+    } else if (input.next == backslash && !escapes && input.peek(1) > -1) {
+      // Raw strings still ignore escaped quotes, weirdly.
+      input.advance(2)
+    } else if (input.next == quote && (!long || input.peek(1) == quote && input.peek(2) == quote)) {
+      if (input.pos == start) {
+        input.acceptToken(stringEnd, long ? 3 : 1)
+        return
+      }
+      break
+    } else if (input.next == newline) {
+      if (long) {
+        input.advance()
+      } else if (input.pos == start) {
+        input.acceptToken(stringEnd)
+        return
+      }
+      break
+    } else {
+      input.advance()
+    }
+  }
+  if (input.pos > start) input.acceptToken(stringContent)
+})
+
+function skipEscape(input, ch) {
+  if (ch == letter_o) {
+    for (let i = 0; i < 2 && input.next >= 48 && input.next <= 55; i++) input.advance()
+  } else if (ch == letter_x) {
+    for (let i = 0; i < 2 && isHex(input.next); i++) input.advance()
+  } else if (ch == letter_u) {
+    for (let i = 0; i < 4 && isHex(input.next); i++) input.advance()
+  } else if (ch == letter_U) {
+    for (let i = 0; i < 8 && isHex(input.next); i++) input.advance()
+  } else if (ch == letter_N) {
+    if (input.next == braceOpen) {
+      input.advance()
+      while (input.next >= 0 && input.next != braceClose && input.next != singleQuote &&
+             input.next != doubleQuote && input.next != newline) input.advance()
+      if (input.next == braceClose) input.advance()
+    }
+  }
+}