@nuraly/runtime 0.1.7 → 0.1.8

package/dist/{cypher-Dc4IMouD.js → cypher-uY0Mffat.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -154,18 +154,21 @@ var e = {
     "type"
   ],
   operators: [
+    // Math operators
     "+",
     "-",
     "*",
     "/",
     "%",
     "^",
+    // Comparison operators
     "=",
     "<>",
     "<",
     ">",
     "<=",
     ">=",
+    // Pattern operators
     "->",
     "<-",
     "-->",
@@ -181,6 +184,7 @@ var e = {
       { include: "@whitespace" },
       { include: "@numbers" },
       { include: "@strings" },
+      // Cypher labels on nodes/relationships, e.g. (n:NodeLabel)-[e:RelationshipLabel]
       [/:[a-zA-Z_][\w]*/, "type.identifier"],
       [
         /[a-zA-Z_][\w]*(?=\()/,
@@ -201,6 +205,7 @@ var e = {
         }
       ],
       [/`/, "identifier.escape", "@identifierBacktick"],
+      // delimiter and operator after number because of `.\d` floats and `:` in labels
       [/[;,.:|]/, "delimiter"],
       [
         /[<>=%+\-*/^]+/,
@@ -221,7 +226,9 @@ var e = {
     ],
     strings: [
       [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
       [/'([^'\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
       [/"/, "string", "@stringDouble"],
       [/'/, "string", "@stringSingle"]
     ],

package/dist/{dart-LhvE3yD2.js → dart-D27H-mX_.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -147,6 +147,7 @@ var e = {
     ":",
     "|="
   ],
+  // we include these common regular expressions
   symbols: /[=><!~?:&|+\-*\/\^%]+/,
   escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
   digits: /\d+(_+\d+)*/,
@@ -155,9 +156,11 @@ var e = {
   hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
   regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
   regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+  // The main tokenizer for our languages
   tokenizer: {
     root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
     common: [
+      // identifiers and keywords
       [
         /[a-z_$][\w$]*/,
         {
@@ -169,12 +172,19 @@ var e = {
         }
       ],
       [/[A-Z_$][\w\$]*/, "type.identifier"],
+      // show class names
+      // [/[A-Z][\w\$]*/, 'identifier'],
+      // whitespace
       { include: "@whitespace" },
+      // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
       [
         /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
         { token: "regexp", bracket: "@open", next: "@regexp" }
       ],
+      // @ annotations.
       [/@[a-zA-Z]+/, "annotation"],
+      // variable
+      // delimiters and operators
       [/[()\[\]]/, "@brackets"],
       [/[<>](?!@symbols)/, "@brackets"],
       [/!(?=([^=]|$))/, "delimiter"],
@@ -187,17 +197,23 @@ var e = {
           }
         }
       ],
+      // numbers
       [/(@digits)[eE]([\-+]?(@digits))?/, "number.float"],
       [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number.float"],
       [/0[xX](@hexdigits)n?/, "number.hex"],
       [/0[oO]?(@octaldigits)n?/, "number.octal"],
       [/0[bB](@binarydigits)n?/, "number.binary"],
       [/(@digits)n?/, "number"],
+      // delimiter: after number because of .\d floats
       [/[;,.]/, "delimiter"],
+      // strings
       [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
       [/'([^'\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
       [/"/, "string", "@string_double"],
       [/'/, "string", "@string_single"]
+      //   [/[a-zA-Z]+/, "variable"]
     ],
     whitespace: [
       [/[ \t\r\n]+/, ""],
@@ -216,6 +232,7 @@ var e = {
       [/\*\//, "comment.doc", "@pop"],
       [/[\/*]/, "comment.doc"]
     ],
+    // We match regular expression quite precisely
     regexp: [
       [
         /(\{)(\d+(?:,\d*)?)(\})/,

package/dist/{dockerfile-CwzplJeZ.js → dockerfile-CmV85WZK.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -70,6 +70,7 @@ var e = {
         }
       ]
     ],
+    // Deal with white space, including comments
     whitespace: [
       [
         /\s+/,
@@ -82,9 +83,12 @@ var e = {
       ]
     ],
     comment: [[/(^#.*$)/, "comment", "@popall"]],
+    // Recognize strings, including those broken across lines with \ (but not without)
     strings: [
       [/\\'$/, "", "@popall"],
+      // \' leaves @arguments at eol
       [/\\'/, ""],
+      // \' is not a string
       [/'$/, "string", "@popall"],
       [/'/, "string", "@stringBody"],
       [/"$/, "string", "@popall"],

package/dist/{ecl-DxW3FiJi.js → ecl--fKn7yzB.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -391,7 +391,9 @@ var e = {
   ].join("|"),
   operators: ["+", "-", "/", ":=", "<", "<>", "=", ">", "\\", "and", "in", "not", "or"],
   symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  // escape sequences
   escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  // The main tokenizer for our languages
   tokenizer: {
     root: [
       [/@typesint[4|8]/, "type"],
@@ -407,6 +409,7 @@ var e = {
           }
         }
       ],
+      // whitespace
       { include: "@whitespace" },
       [/[{}()\[\]]/, "@brackets"],
       [/[<>](?!@symbols)/, "@brackets"],
@@ -419,13 +422,18 @@ var e = {
           }
         }
       ],
+      // numbers
       [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?/, "number.float"],
       [/0[xX][0-9a-fA-F_]+/, "number.hex"],
       [/0[bB][01]+/, "number.hex"],
+      // binary: use same theme style as hex
       [/[0-9_]+/, "number"],
+      // delimiter: after number because of .\d floats
       [/[;,.]/, "delimiter"],
+      // strings
       [/"([^"\\]|\\.)*$/, "string.invalid"],
       [/"/, "string", "@string"],
+      // characters
       [/'[^\\']'/, "string"],
       [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
       [/'/, "string.invalid"]

package/dist/{elixir-BI40g7TU.js → elixir-DUhH17ON.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -43,6 +43,7 @@ var e = {
     { open: "{", close: "}", token: "delimiter.curly" },
     { open: "<<", close: ">>", token: "delimiter.angle.special" }
   ],
+  // Below are lists/regexps to which we reference later.
   declarationKeywords: [
     "def",
     "defp",
@@ -88,12 +89,17 @@ var e = {
   ],
   constants: ["true", "false", "nil"],
   nameBuiltin: ["__MODULE__", "__DIR__", "__ENV__", "__CALLER__", "__STACKTRACE__"],
+  // Matches any of the operator names:
+  // <<< >>> ||| &&& ^^^ ~~~ === !== ~>> <~> |~> <|> == != <= >= && || \\ <> ++ -- |> =~ -> <- ~> <~ :: .. = < > + - * / | . ^ & !
   operator: /-[->]?|!={0,2}|\*{1,2}|\/|\\\\|&{1,3}|\.\.?|\^(?:\^\^)?|\+\+?|<(?:-|<<|=|>|\|>|~>?)?|=~|={1,3}|>(?:=|>>)?|\|~>|\|>|\|{1,3}|~>>?|~~~|::/,
+  // See https://hexdocs.pm/elixir/syntax-reference.html#variables
   variableName: /[a-z_][a-zA-Z0-9_]*[?!]?/,
+  // See https://hexdocs.pm/elixir/syntax-reference.html#atoms
   atomName: /[a-zA-Z_][a-zA-Z0-9_@]*[?!]?|@specialAtomName|@operator/,
   specialAtomName: /\.\.\.|<<>>|%\{\}|%|\{\}/,
   aliasPart: /[A-Z][a-zA-Z0-9_]*/,
   moduleName: /@aliasPart(?:\.@aliasPart)*/,
+  // Sigil pairs are: """ """, ''' ''', " ", ' ', / /, | |, < >, { }, [ ], ( )
   sigilSymmetricDelimiter: /"""|'''|"|'|\/|\|/,
   sigilStartDelimiter: /@sigilSymmetricDelimiter|<|\{|\[|\(/,
   sigilEndDelimiter: /@sigilSymmetricDelimiter|>|\}|\]|\)/,
@@ -102,11 +108,19 @@ var e = {
   hex: /[0-9a-fA-F](_?[0-9a-fA-F])*/,
   octal: /[0-7](_?[0-7])*/,
   binary: /[01](_?[01])*/,
+  // See https://hexdocs.pm/elixir/master/String.html#module-escape-characters
   escape: /\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}|\\./,
+  // The keys below correspond to tokenizer states.
+  // We start from the root state and match against its rules
+  // until we explicitly transition into another state.
+  // The `include` simply brings in all operations from the given state
+  // and is useful for improving readability.
   tokenizer: {
     root: [
       { include: "@whitespace" },
       { include: "@comments" },
+      // Keywords start as either an identifier or a string,
+      // but end with a : so it's important to match this first.
       { include: "@keywordsShorthand" },
       { include: "@numbers" },
       { include: "@identifiers" },
@@ -116,10 +130,15 @@ var e = {
       { include: "@attributes" },
       { include: "@symbols" }
     ],
+    // Whitespace
     whitespace: [[/\s+/, "white"]],
+    // Comments
     comments: [[/(#)(.*)/, ["comment.punctuation", "comment"]]],
+    // Keyword list shorthand
     keywordsShorthand: [
       [/(@atomName)(:)(\s+)/, ["constant", "constant.punctuation", "white"]],
+      // Use positive look-ahead to ensure the string is followed by :
+      // and should be considered a keyword.
       [
         /"(?=([^"]|#\{.*?\}|\\")*":)/,
         { token: "constant.delimiter", next: "@doubleQuotedStringKeyword" }
@@ -137,6 +156,7 @@ var e = {
       [/':/, { token: "constant.delimiter", next: "@pop" }],
       { include: "@stringConstantContentInterpol" }
     ],
+    // Numbers
     numbers: [
       [/0b@binary/, "number.binary"],
       [/0o@octal/, "number.octal"],
@@ -144,7 +164,11 @@ var e = {
       [/@decimal\.@decimal([eE]-?@decimal)?/, "number.float"],
       [/@decimal/, "number"]
     ],
+    // Identifiers
     identifiers: [
+      // Tokenize identifier name in function-like definitions.
+      // Note: given `def a + b, do: nil`, `a` is not a function name,
+      // so we use negative look-ahead to ensure there's no operator.
       [
         /\b(defp?|defnp?|defmacrop?|defguardp?|defdelegate)(\s+)(@variableName)(?!\s+@operator)/,
         [
@@ -158,10 +182,13 @@ var e = {
           }
         ]
       ],
+      // Tokenize function calls
       [
+        // In-scope call - an identifier followed by ( or .(
         /(@variableName)(?=\s*\.?\s*\()/,
         {
           cases: {
+            // Tokenize as keyword in cases like `if(..., do: ..., else: ...)`
             "@declarationKeywords": "keyword.declaration",
             "@namespaceKeywords": "keyword",
             "@otherKeywords": "keyword",
@@ -170,14 +197,17 @@ var e = {
         }
       ],
       [
+        // Referencing function in a module
         /(@moduleName)(\s*)(\.)(\s*)(@variableName)/,
         ["type.identifier", "white", "operator", "white", "function.call"]
       ],
       [
+        // Referencing function in an Erlang module
         /(:)(@atomName)(\s*)(\.)(\s*)(@variableName)/,
         ["constant.punctuation", "constant", "white", "operator", "white", "function.call"]
       ],
       [
+        // Piping into a function (tokenized separately as it may not have parentheses)
         /(\|>)(\s*)(@variableName)/,
         [
           "operator",
@@ -191,9 +221,11 @@ var e = {
         ]
       ],
       [
+        // Function reference passed to another function
         /(&)(\s*)(@variableName)/,
         ["operator", "white", "function.call"]
       ],
+      // Language keywords, builtins, constants and variables
       [
         /@variableName/,
         {
@@ -209,8 +241,10 @@ var e = {
           }
         }
       ],
+      // Module names
       [/@moduleName/, "type.identifier"]
     ],
+    // Strings
     strings: [
       [/"""/, { token: "string.delimiter", next: "@doubleQuotedHeredoc" }],
       [/'''/, { token: "string.delimiter", next: "@singleQuotedHeredoc" }],
@@ -233,6 +267,7 @@ var e = {
       [/'/, { token: "string.delimiter", next: "@pop" }],
       { include: "@stringContentInterpol" }
     ],
+    // Atoms
     atoms: [
       [/(:)(@atomName)/, ["constant.punctuation", "constant"]],
       [/:"/, { token: "constant.delimiter", next: "@doubleQuotedStringAtom" }],
@@ -246,6 +281,27 @@ var e = {
       [/'/, { token: "constant.delimiter", next: "@pop" }],
       { include: "@stringConstantContentInterpol" }
     ],
+    // Sigils
+    // See https://elixir-lang.org/getting-started/sigils.html
+    // Sigils allow for typing values using their textual representation.
+    // All sigils start with ~ followed by a letter or
+    // multi-letter uppercase starting at Elixir v1.15.0, indicating sigil type
+    // and then a delimiter pair enclosing the textual representation.
+    // Optional modifiers are allowed after the closing delimiter.
+    // For instance a regular expressions can be written as:
+    // ~r/foo|bar/ ~r{foo|bar} ~r/foo|bar/g
+    //
+    // In general lowercase sigils allow for interpolation
+    // and escaped characters, whereas uppercase sigils don't
+    //
+    // During tokenization we want to distinguish some
+    // specific sigil types, namely string and regexp,
+    // so that they cen be themed separately.
+    //
+    // To reasonably handle all those combinations we leverage
+    // dot-separated states, so if we transition to @sigilStart.interpol.s.{.}
+    // then "sigilStart.interpol.s" state will match and also all
+    // the individual dot-separated parameters can be accessed.
     sigils: [
       [/~[a-z]@sigilStartDelimiter/, { token: "@rematch", next: "@sigil.interpol" }],
       [/~([A-Z]+)@sigilStartDelimiter/, { token: "@rematch", next: "@sigil.noInterpol" }]
@@ -260,6 +316,14 @@ var e = {
         { token: "@rematch", switchTo: "@sigilStart.$S2.$1.$2.$2" }
       ]
     ],
+    // The definitions below expect states to be of the form:
+    //
+    // sigilStart.<interpol-or-noInterpol>.<sigil-letter>.<start-delimiter>.<end-delimiter>
+    // sigilContinue.<interpol-or-noInterpol>.<sigil-letter>.<start-delimiter>.<end-delimiter>
+    //
+    // The sigilStart state is used only to properly classify the token (as string/regex/sigil)
+    // and immediately switches to the sigilContinue sate, which handles the actual content
+    // and waits for the corresponding end delimiter.
     "sigilStart.interpol.s": [
       [
         /~s@sigilStartDelimiter/,
@@ -291,6 +355,7 @@ var e = {
       ]
     ],
     "sigilContinue.noInterpol.S": [
+      // Ignore escaped sigil end
       [/(^|[^\\])\\@sigilEndDelimiter/, "string"],
       [
         /(@sigilEndDelimiter)@sigilModifiers/,
@@ -334,6 +399,7 @@ var e = {
       ]
     ],
     "sigilContinue.noInterpol.R": [
+      // Ignore escaped sigil end
       [/(^|[^\\])\\@sigilEndDelimiter/, "regexp"],
       [
         /(@sigilEndDelimiter)@sigilModifiers/,
@@ -346,6 +412,7 @@ var e = {
       ],
       { include: "@regexpContent" }
     ],
+    // Fallback to the generic sigil by default
     "sigilStart.interpol": [
       [
         /~([a-z]|[A-Z]+)@sigilStartDelimiter/,
@@ -377,6 +444,7 @@ var e = {
       ]
     ],
     "sigilContinue.noInterpol": [
+      // Ignore escaped sigil end
       [/(^|[^\\])\\@sigilEndDelimiter/, "sigil"],
       [
         /(@sigilEndDelimiter)@sigilModifiers/,
@@ -389,7 +457,9 @@ var e = {
       ],
       { include: "@sigilContent" }
     ],
+    // Attributes
     attributes: [
+      // Module @doc* attributes - tokenized as comments
       [
         /\@(module|type)?doc (~[sS])?"""/,
         {
@@ -419,6 +489,7 @@ var e = {
         }
       ],
       [/\@(module|type)?doc false/, "comment.block.documentation"],
+      // Module attributes
       [/\@(@variableName)/, "variable"]
     ],
     doubleQuotedHeredocDocstring: [
@@ -437,16 +508,26 @@ var e = {
       [/'/, { token: "comment.block.documentation", next: "@pop" }],
       { include: "@docstringContent" }
     ],
+    // Operators, punctuation, brackets
     symbols: [
+      // Code point operator (either with regular character ?a or an escaped one ?\n)
       [/\?(\\.|[^\\\s])/, "number.constant"],
+      // Anonymous function arguments
       [/&\d+/, "operator"],
+      // Bitshift operators (must go before delimiters, so that << >> don't match first)
       [/<<<|>>>/, "operator"],
+      // Delimiter pairs
       [/[()\[\]\{\}]|<<|>>/, "@brackets"],
+      // Triple dot is a valid name (must go before operators, so that .. doesn't match instead)
       [/\.\.\./, "identifier"],
+      // Punctuation => (must go before operators, so it's not tokenized as = then >)
       [/=>/, "punctuation"],
+      // Operators
       [/@operator/, "operator"],
+      // Punctuation
       [/[:;,.%]/, "punctuation"]
     ],
+    // Generic helpers
     stringContentInterpol: [
       { include: "@interpolation" },
       { include: "@escapeChar" },
@@ -465,6 +546,8 @@ var e = {
       { include: "@regexpContent" }
     ],
     regexpContent: [
+      // # may be a regular regexp char, so we use a heuristic
+      // assuming a # surrounded by whitespace is actually a comment.
       [/(\s)(#)(\s.*)$/, ["white", "comment.punctuation", "comment"]],
       [/./, "regexp"]
     ],
@@ -479,6 +562,9 @@ var e = {
     interpolation: [[/#{/, { token: "delimiter.bracket.embed", next: "@interpolationContinue" }]],
     interpolationContinue: [
       [/}/, { token: "delimiter.bracket.embed", next: "@pop" }],
+      // Interpolation brackets may contain arbitrary code,
+      // so we simply match against all the root rules,
+      // until we reach interpolation end (the above matches).
       { include: "@root" }
     ]
   }

package/dist/{flow9-tR2v0bGz.js → flow9-B3Dx2LLe.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -88,8 +88,10 @@ var e = {
   ],
   symbols: /[@$=><!~?:&|+\-*\\\/\^%]+/,
   escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  // The main tokenizer for our languages
   tokenizer: {
     root: [
+      // identifiers and keywords
       [
         /[a-zA-Z_]\w*/,
         {
@@ -100,7 +102,9 @@ var e = {
           }
         }
       ],
+      // whitespace
       { include: "@whitespace" },
+      // delimiters and operators
       [/[{}()\[\]]/, "delimiter"],
       [/[<>](?!@symbols)/, "delimiter"],
       [
@@ -112,8 +116,11 @@ var e = {
           }
         }
       ],
+      // numbers
       [/((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)/, "number"],
+      // delimiter: after number because of .\d floats
       [/[;,.]/, "delimiter"],
+      // strings
       [/"([^"\\]|\\.)*$/, "string.invalid"],
       [/"/, "string", "@string"]
     ],