{"version":3,"sources":["webpack:///./node_modules/monaco-editor/esm/vs/basic-languages/elixir/elixir.js"],"names":["conf","comments","lineComment","brackets","surroundingPairs","open","close","autoClosingPairs","notIn","indentationRules","increaseIndentPattern","decreaseIndentPattern","language","defaultToken","tokenPostfix","token","declarationKeywords","operatorKeywords","namespaceKeywords","otherKeywords","constants","nameBuiltin","operator","variableName","atomName","specialAtomName","aliasPart","moduleName","sigilSymmetricDelimiter","sigilStartDelimiter","sigilEndDelimiter","decimal","hex","octal","binary","escape","tokenizer","root","include","whitespace","keywordsShorthand","next","doubleQuotedStringKeyword","singleQuotedStringKeyword","numbers","identifiers","cases","unquote","strings","doubleQuotedHeredoc","singleQuotedHeredoc","doubleQuotedString","singleQuotedString","atoms","doubleQuotedStringAtom","singleQuotedStringAtom","sigils","sigil","switchTo","attributes","doubleQuotedHeredocDocstring","doubleQuotedStringDocstring","symbols","stringContentInterpol","stringContent","stringConstantContentInterpol","stringConstantContent","regexpContentInterpol","regexpContent","sigilContentInterpol","sigilContent","docstringContent","escapeChar","interpolation","interpolationContinue"],"mappings":"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","file":"js/chunk-2d0e5b34.9cdfc939.js","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport var conf = {\n comments: {\n lineComment: '#'\n },\n brackets: [\n ['{', '}'],\n ['[', ']'],\n ['(', ')']\n ],\n surroundingPairs: [\n { open: '{', close: '}' },\n { open: '[', close: ']' },\n { open: '(', close: ')' },\n { open: \"'\", close: \"'\" },\n { open: '\"', close: '\"' }\n ],\n autoClosingPairs: [\n { open: \"'\", close: \"'\", notIn: ['string', 'comment'] },\n { open: '\"', close: '\"', notIn: ['comment'] },\n { open: '\"\"\"', close: '\"\"\"' },\n { open: '`', close: '`', notIn: ['string', 'comment'] },\n { open: '(', close: ')' },\n { open: '{', close: '}' },\n { open: '[', close: ']' },\n { open: '<<', close: '>>' }\n ],\n indentationRules: {\n increaseIndentPattern: /^\\s*(after|else|catch|rescue|fn|[^#]*(do|<\\-|\\->|\\{|\\[|\\=))\\s*$/,\n decreaseIndentPattern: /^\\s*((\\}|\\])\\s*$|(after|else|catch|rescue|end)\\b)/\n }\n};\n/**\n * A Monarch lexer for the Elixir language.\n *\n * References:\n *\n * * Monarch documentation - https://microsoft.github.io/monaco-editor/monarch.html\n * * Elixir lexer - https://github.com/elixir-makeup/makeup_elixir/blob/master/lib/makeup/lexers/elixir_lexer.ex\n * * TextMate lexer (elixir-tmbundle) - https://github.com/elixir-editors/elixir-tmbundle/blob/master/Syntaxes/Elixir.tmLanguage\n * * TextMate lexer (vscode-elixir-ls) - https://github.com/elixir-lsp/vscode-elixir-ls/blob/master/syntaxes/elixir.json\n */\nexport var language = {\n defaultToken: 'source',\n tokenPostfix: '.elixir',\n brackets: [\n { open: '[', close: ']', token: 'delimiter.square' },\n { open: '(', close: ')', token: 'delimiter.parenthesis' },\n { open: '{', close: '}', token: 'delimiter.curly' },\n { open: '<<', close: '>>', token: 'delimiter.angle.special' }\n ],\n // Below are lists/regexps to which we reference later.\n declarationKeywords: [\n 'def',\n 'defp',\n 'defn',\n 'defnp',\n 'defguard',\n 'defguardp',\n 'defmacro',\n 'defmacrop',\n 'defdelegate',\n 'defcallback',\n 'defmacrocallback',\n 'defmodule',\n 'defprotocol',\n 'defexception',\n 'defimpl',\n 'defstruct'\n ],\n operatorKeywords: ['and', 'in', 'not', 'or', 'when'],\n namespaceKeywords: ['alias', 'import', 'require', 'use'],\n otherKeywords: [\n 'after',\n 'case',\n 'catch',\n 'cond',\n 'do',\n 'else',\n 'end',\n 'fn',\n 'for',\n 'if',\n 'quote',\n 'raise',\n 'receive',\n 'rescue',\n 'super',\n 'throw',\n 'try',\n 'unless',\n 'unquote_splicing',\n 'unquote',\n 'with'\n ],\n constants: ['true', 'false', 'nil'],\n nameBuiltin: ['__MODULE__', '__DIR__', '__ENV__', '__CALLER__', '__STACKTRACE__'],\n // Matches any of the operator names:\n // <<< >>> ||| &&& ^^^ ~~~ === !== ~>> <~> |~> <|> == != <= >= && || \\\\ <> ++ -- |> =~ -> <- ~> <~ :: .. = < > + - * / | . ^ & !\n operator: /-[->]?|!={0,2}|\\*|\\/|\\\\\\\\|&{1,3}|\\.\\.?|\\^(?:\\^\\^)?|\\+\\+?|<(?:-|<<|=|>|\\|>|~>?)?|=~|={1,3}|>(?:=|>>)?|\\|~>|\\|>|\\|{1,3}|~>>?|~~~|::/,\n // See https://hexdocs.pm/elixir/syntax-reference.html#variables\n variableName: /[a-z_][a-zA-Z0-9_]*[?!]?/,\n // See https://hexdocs.pm/elixir/syntax-reference.html#atoms\n atomName: /[a-zA-Z_][a-zA-Z0-9_@]*[?!]?|@specialAtomName|@operator/,\n specialAtomName: /\\.\\.\\.|<<>>|%\\{\\}|%|\\{\\}/,\n aliasPart: /[A-Z][a-zA-Z0-9_]*/,\n moduleName: /@aliasPart(?:\\.@aliasPart)*/,\n // Sigil pairs are: \"\"\" \"\"\", ''' ''', \" \", ' ', / /, | |, < >, { }, [ ], ( )\n sigilSymmetricDelimiter: /\"\"\"|'''|\"|'|\\/|\\|/,\n sigilStartDelimiter: /@sigilSymmetricDelimiter|<|\\{|\\[|\\(/,\n sigilEndDelimiter: /@sigilSymmetricDelimiter|>|\\}|\\]|\\)/,\n decimal: /\\d(?:_?\\d)*/,\n hex: /[0-9a-fA-F](_?[0-9a-fA-F])*/,\n octal: /[0-7](_?[0-7])*/,\n binary: /[01](_?[01])*/,\n // See https://hexdocs.pm/elixir/master/String.html#module-escape-characters\n escape: /\\\\u[0-9a-fA-F]{4}|\\\\x[0-9a-fA-F]{2}|\\\\./,\n // The keys below correspond to tokenizer states.\n // We start from the root state and match against its rules\n // until we explicitly transition into another state.\n // The `include` simply brings in all operations from the given state\n // and is useful for improving readability.\n tokenizer: {\n root: [\n { include: '@whitespace' },\n { include: '@comments' },\n // Keywords start as either an identifier or a string,\n // but end with a : so it's important to match this first.\n { include: '@keywordsShorthand' },\n { include: '@numbers' },\n { include: '@identifiers' },\n { include: '@strings' },\n { include: '@atoms' },\n { include: '@sigils' },\n { include: '@attributes' },\n { include: '@symbols' }\n ],\n // Whitespace\n whitespace: [[/\\s+/, 'white']],\n // Comments\n comments: [[/(#)(.*)/, ['comment.punctuation', 'comment']]],\n // Keyword list shorthand\n keywordsShorthand: [\n [/(@atomName)(:)/, ['constant', 'constant.punctuation']],\n // Use positive look-ahead to ensure the string is followed by :\n // and should be considered a keyword.\n [\n /\"(?=([^\"]|#\\{.*?\\}|\\\\\")*\":)/,\n { token: 'constant.delimiter', next: '@doubleQuotedStringKeyword' }\n ],\n [\n /'(?=([^']|#\\{.*?\\}|\\\\')*':)/,\n { token: 'constant.delimiter', next: '@singleQuotedStringKeyword' }\n ]\n ],\n doubleQuotedStringKeyword: [\n [/\":/, { token: 'constant.delimiter', next: '@pop' }],\n { include: '@stringConstantContentInterpol' }\n ],\n singleQuotedStringKeyword: [\n [/':/, { token: 'constant.delimiter', next: '@pop' }],\n { include: '@stringConstantContentInterpol' }\n ],\n // Numbers\n numbers: [\n [/0b@binary/, 'number.binary'],\n [/0o@octal/, 'number.octal'],\n [/0x@hex/, 'number.hex'],\n [/@decimal\\.@decimal([eE]-?@decimal)?/, 'number.float'],\n [/@decimal/, 'number']\n ],\n // Identifiers\n identifiers: [\n // Tokenize identifier name in function-like definitions.\n // Note: given `def a + b, do: nil`, `a` is not a function name,\n // so we use negative look-ahead to ensure there's no operator.\n [\n /\\b(defp?|defnp?|defmacrop?|defguardp?|defdelegate)(\\s+)(@variableName)(?!\\s+@operator)/,\n [\n 'keyword.declaration',\n 'white',\n {\n cases: {\n unquote: 'keyword',\n '@default': 'function'\n }\n }\n ]\n ],\n // Tokenize function calls\n [\n // In-scope call - an identifier followed by ( or .(\n /(@variableName)(?=\\s*\\.?\\s*\\()/,\n {\n cases: {\n // Tokenize as keyword in cases like `if(..., do: ..., else: ...)`\n '@declarationKeywords': 'keyword.declaration',\n '@namespaceKeywords': 'keyword',\n '@otherKeywords': 'keyword',\n '@default': 'function.call'\n }\n }\n ],\n [\n // Referencing function in a module\n /(@moduleName)(\\s*)(\\.)(\\s*)(@variableName)/,\n ['type.identifier', 'white', 'operator', 'white', 'function.call']\n ],\n [\n // Referencing function in an Erlang module\n /(:)(@atomName)(\\s*)(\\.)(\\s*)(@variableName)/,\n ['constant.punctuation', 'constant', 'white', 'operator', 'white', 'function.call']\n ],\n [\n // Piping into a function (tokenized separately as it may not have parentheses)\n /(\\|>)(\\s*)(@variableName)/,\n [\n 'operator',\n 'white',\n {\n cases: {\n '@otherKeywords': 'keyword',\n '@default': 'function.call'\n }\n }\n ]\n ],\n [\n // Function reference passed to another function\n /(&)(\\s*)(@variableName)/,\n ['operator', 'white', 'function.call']\n ],\n // Language keywords, builtins, constants and variables\n [\n /@variableName/,\n {\n cases: {\n '@declarationKeywords': 'keyword.declaration',\n '@operatorKeywords': 'keyword.operator',\n '@namespaceKeywords': 'keyword',\n '@otherKeywords': 'keyword',\n '@constants': 'constant.language',\n '@nameBuiltin': 'variable.language',\n '_.*': 'comment.unused',\n '@default': 'identifier'\n }\n }\n ],\n // Module names\n [/@moduleName/, 'type.identifier']\n ],\n // Strings\n strings: [\n [/\"\"\"/, { token: 'string.delimiter', next: '@doubleQuotedHeredoc' }],\n [/'''/, { token: 'string.delimiter', next: '@singleQuotedHeredoc' }],\n [/\"/, { token: 'string.delimiter', next: '@doubleQuotedString' }],\n [/'/, { token: 'string.delimiter', next: '@singleQuotedString' }]\n ],\n doubleQuotedHeredoc: [\n [/\"\"\"/, { token: 'string.delimiter', next: '@pop' }],\n { include: '@stringContentInterpol' }\n ],\n singleQuotedHeredoc: [\n [/'''/, { token: 'string.delimiter', next: '@pop' }],\n { include: '@stringContentInterpol' }\n ],\n doubleQuotedString: [\n [/\"/, { token: 'string.delimiter', next: '@pop' }],\n { include: '@stringContentInterpol' }\n ],\n singleQuotedString: [\n [/'/, { token: 'string.delimiter', next: '@pop' }],\n { include: '@stringContentInterpol' }\n ],\n // Atoms\n atoms: [\n [/(:)(@atomName)/, ['constant.punctuation', 'constant']],\n [/:\"/, { token: 'constant.delimiter', next: '@doubleQuotedStringAtom' }],\n [/:'/, { token: 'constant.delimiter', next: '@singleQuotedStringAtom' }]\n ],\n doubleQuotedStringAtom: [\n [/\"/, { token: 'constant.delimiter', next: '@pop' }],\n { include: '@stringConstantContentInterpol' }\n ],\n singleQuotedStringAtom: [\n [/'/, { token: 'constant.delimiter', next: '@pop' }],\n { include: '@stringConstantContentInterpol' }\n ],\n // Sigils\n // See https://elixir-lang.org/getting-started/sigils.html\n // Sigils allow for typing values using their textual representation.\n // All sigils start with ~ followed by a letter indicating sigil type\n // and then a delimiter pair enclosing the textual representation.\n // Optional modifiers are allowed after the closing delimiter.\n // For instance a regular expressions can be written as:\n // ~r/foo|bar/ ~r{foo|bar} ~r/foo|bar/g\n //\n // In general lowercase sigils allow for interpolation\n // and escaped characters, whereas uppercase sigils don't\n //\n // During tokenization we want to distinguish some\n // specific sigil types, namely string and regexp,\n // so that they cen be themed separately.\n //\n // To reasonably handle all those combinations we leverage\n // dot-separated states, so if we transition to @sigilStart.interpol.s.{.}\n // then \"sigilStart.interpol.s\" state will match and also all\n // the individual dot-separated parameters can be accessed.\n sigils: [\n [/~[a-z]@sigilStartDelimiter/, { token: '@rematch', next: '@sigil.interpol' }],\n [/~[A-Z]@sigilStartDelimiter/, { token: '@rematch', next: '@sigil.noInterpol' }]\n ],\n sigil: [\n [/~([a-zA-Z])\\{/, { token: '@rematch', switchTo: '@sigilStart.$S2.$1.{.}' }],\n [/~([a-zA-Z])\\[/, { token: '@rematch', switchTo: '@sigilStart.$S2.$1.[.]' }],\n [/~([a-zA-Z])\\(/, { token: '@rematch', switchTo: '@sigilStart.$S2.$1.(.)' }],\n [/~([a-zA-Z])\\' }],\n [\n /~([a-zA-Z])(@sigilSymmetricDelimiter)/,\n { token: '@rematch', switchTo: '@sigilStart.$S2.$1.$2.$2' }\n ]\n ],\n // The definitions below expect states to be of the form:\n //\n // sigilStart....\n // sigilContinue....\n //\n // The sigilStart state is used only to properly classify the token (as string/regex/sigil)\n // and immediately switches to the sigilContinue sate, which handles the actual content\n // and waits for the corresponding end delimiter.\n 'sigilStart.interpol.s': [\n [\n /~s@sigilStartDelimiter/,\n {\n token: 'string.delimiter',\n switchTo: '@sigilContinue.$S2.$S3.$S4.$S5'\n }\n ]\n ],\n 'sigilContinue.interpol.s': [\n [\n /(@sigilEndDelimiter)[a-zA-Z]*/,\n {\n cases: {\n '$1==$S5': { token: 'string.delimiter', next: '@pop' },\n '@default': 'string'\n }\n }\n ],\n { include: '@stringContentInterpol' }\n ],\n 'sigilStart.noInterpol.S': [\n [\n /~S@sigilStartDelimiter/,\n {\n token: 'string.delimiter',\n switchTo: '@sigilContinue.$S2.$S3.$S4.$S5'\n }\n ]\n ],\n 'sigilContinue.noInterpol.S': [\n // Ignore escaped sigil end\n [/(^|[^\\\\])\\\\@sigilEndDelimiter/, 'string'],\n [\n /(@sigilEndDelimiter)[a-zA-Z]*/,\n {\n cases: {\n '$1==$S5': { token: 'string.delimiter', next: '@pop' },\n '@default': 'string'\n }\n }\n ],\n { include: '@stringContent' }\n ],\n 'sigilStart.interpol.r': [\n [\n /~r@sigilStartDelimiter/,\n {\n token: 'regexp.delimiter',\n switchTo: '@sigilContinue.$S2.$S3.$S4.$S5'\n }\n ]\n ],\n 'sigilContinue.interpol.r': [\n [\n /(@sigilEndDelimiter)[a-zA-Z]*/,\n {\n cases: {\n '$1==$S5': { token: 'regexp.delimiter', next: '@pop' },\n '@default': 'regexp'\n }\n }\n ],\n { include: '@regexpContentInterpol' }\n ],\n 'sigilStart.noInterpol.R': [\n [\n /~R@sigilStartDelimiter/,\n {\n token: 'regexp.delimiter',\n switchTo: '@sigilContinue.$S2.$S3.$S4.$S5'\n }\n ]\n ],\n 'sigilContinue.noInterpol.R': [\n // Ignore escaped sigil end\n [/(^|[^\\\\])\\\\@sigilEndDelimiter/, 'regexp'],\n [\n /(@sigilEndDelimiter)[a-zA-Z]*/,\n {\n cases: {\n '$1==$S5': { token: 'regexp.delimiter', next: '@pop' },\n '@default': 'regexp'\n }\n }\n ],\n { include: '@regexpContent' }\n ],\n // Fallback to the generic sigil by default\n 'sigilStart.interpol': [\n [\n /~([a-zA-Z])@sigilStartDelimiter/,\n {\n token: 'sigil.delimiter',\n switchTo: '@sigilContinue.$S2.$S3.$S4.$S5'\n }\n ]\n ],\n 'sigilContinue.interpol': [\n [\n /(@sigilEndDelimiter)[a-zA-Z]*/,\n {\n cases: {\n '$1==$S5': { token: 'sigil.delimiter', next: '@pop' },\n '@default': 'sigil'\n }\n }\n ],\n { include: '@sigilContentInterpol' }\n ],\n 'sigilStart.noInterpol': [\n [\n /~([a-zA-Z])@sigilStartDelimiter/,\n {\n token: 'sigil.delimiter',\n switchTo: '@sigilContinue.$S2.$S3.$S4.$S5'\n }\n ]\n ],\n 'sigilContinue.noInterpol': [\n // Ignore escaped sigil end\n [/(^|[^\\\\])\\\\@sigilEndDelimiter/, 'sigil'],\n [\n /(@sigilEndDelimiter)[a-zA-Z]*/,\n {\n cases: {\n '$1==$S5': { token: 'sigil.delimiter', next: '@pop' },\n '@default': 'sigil'\n }\n }\n ],\n { include: '@sigilContent' }\n ],\n // Attributes\n attributes: [\n // Module @doc* attributes - tokenized as comments\n [\n /\\@(module|type)?doc (~[sS])?\"\"\"/,\n {\n token: 'comment.block.documentation',\n next: '@doubleQuotedHeredocDocstring'\n }\n ],\n [\n /\\@(module|type)?doc (~[sS])?\"/,\n {\n token: 'comment.block.documentation',\n next: '@doubleQuotedStringDocstring'\n }\n ],\n [/\\@(module|type)?doc false/, 'comment.block.documentation'],\n // Module attributes\n [/\\@(@variableName)/, 'variable']\n ],\n doubleQuotedHeredocDocstring: [\n [/\"\"\"/, { token: 'comment.block.documentation', next: '@pop' }],\n { include: '@docstringContent' }\n ],\n doubleQuotedStringDocstring: [\n [/\"/, { token: 'comment.block.documentation', next: '@pop' }],\n { include: '@docstringContent' }\n ],\n // Operators, punctuation, brackets\n symbols: [\n // Code point operator (either with regular character ?a or an escaped one ?\\n)\n [/\\?(\\\\.|[^\\\\\\s])/, 'number.constant'],\n // Anonymous function arguments\n [/&\\d+/, 'operator'],\n // Bitshift operators (must go before delimiters, so that << >> don't match first)\n [/<<<|>>>/, 'operator'],\n // Delimiter pairs\n [/[()\\[\\]\\{\\}]|<<|>>/, '@brackets'],\n // Triple dot is a valid name (must go before operators, so that .. doesn't match instead)\n [/\\.\\.\\./, 'identifier'],\n // Punctuation => (must go before operators, so it's not tokenized as = then >)\n [/=>/, 'punctuation'],\n // Operators\n [/@operator/, 'operator'],\n // Punctuation\n [/[:;,.%]/, 'punctuation']\n ],\n // Generic helpers\n stringContentInterpol: [\n { include: '@interpolation' },\n { include: '@escapeChar' },\n { include: '@stringContent' }\n ],\n stringContent: [[/./, 'string']],\n stringConstantContentInterpol: [\n { include: '@interpolation' },\n { include: '@escapeChar' },\n { include: '@stringConstantContent' }\n ],\n stringConstantContent: [[/./, 'constant']],\n regexpContentInterpol: [\n { include: '@interpolation' },\n { include: '@escapeChar' },\n { include: '@regexpContent' }\n ],\n regexpContent: [\n // # may be a regular regexp char, so we use a heuristic\n // assuming a # surrounded by whitespace is actually a comment.\n [/(\\s)(#)(\\s.*)$/, ['white', 'comment.punctuation', 'comment']],\n [/./, 'regexp']\n ],\n sigilContentInterpol: [\n { include: '@interpolation' },\n { include: '@escapeChar' },\n { include: '@sigilContent' }\n ],\n sigilContent: [[/./, 'sigil']],\n docstringContent: [[/./, 'comment.block.documentation']],\n escapeChar: [[/@escape/, 'constant.character.escape']],\n interpolation: [[/#{/, { token: 'delimiter.bracket.embed', next: '@interpolationContinue' }]],\n interpolationContinue: [\n [/}/, { token: 'delimiter.bracket.embed', next: '@pop' }],\n // Interpolation brackets may contain arbitrary code,\n // so we simply match against all the root rules,\n // until we reach interpolation end (the above matches).\n { include: '@root' }\n ]\n }\n};\n"],"sourceRoot":""}