@lvce-editor/shared-process 0.18.8 → 0.18.10

package/extensions/builtin.language-basics-dotenv/src/tokenizeDotenv.js

@@ -1,301 +0,0 @@
-/**
- * @enum number
- */
-export const State = {
-  TopLevelContent: 1,
-  InsideLineComment: 2,
-  AfterVariableName: 3,
-  AfterAssignmentEqualSign: 4,
-  AfterVariableValue: 5,
-  AfterKeyword: 6,
-  AfterKeywordAndHasSeenWhitespace: 7,
-  InsideDoubleQuoteString: 8,
-  InsideSingleQuoteString: 9,
-  InsideDoubleQuoteStringAfterBackslash: 10,
-  InsideSingleQuoteStringAfterBackslash: 11,
-}
-
-/**
- * @enum {number}
- */
-export const TokenType = {
-  Whitespace /* Whitespace */: 0,
-  TypeName /* TypeName */: 35,
-  PlainText /* Text */: 117,
-  Comment /* Comment */: 60,
-  String /* String */: 50,
-  Numeric /* Numeric */: 30,
-  FunctionName /* FunctionName */: 112,
-  TypeNamePrimitive /* TypeNamePrimitive */: 36,
-  Text /* Text */: 117,
-  PunctuationTag /* PunctuationTag */: 228,
-  TagName /* TagName */: 118,
-  AttributeName /* AttributeName */: 119,
-  Punctuation /* Punctuation */: 10,
-  Error /* Error */: 141,
-  PunctuationString /* PunctuationString */: 11,
-  Keyword: /* Keyword */ 951,
-  VariableName: /* VariableName */ 952,
-  None: 57,
-  KeywordExport: 90,
-  VariableValueString: 91,
-  LanguageConstant: 92,
-  VariableValue: 93,
-  NewLine: 94,
-}
-
-export const TokenMap = {
-  [TokenType.Whitespace]: 'Whitespace',
-  [TokenType.TypeName]: 'TypeName',
-  [TokenType.PlainText]: 'PlainText',
-  [TokenType.Comment]: 'Comment',
-  [TokenType.String]: 'String',
-  [TokenType.Numeric]: 'Numeric',
-  [TokenType.FunctionName]: 'FunctionName',
-  [TokenType.TypeNamePrimitive]: 'TypeNamePrimitive',
-  [TokenType.Text]: 'Text',
-  [TokenType.PunctuationTag]: 'PunctuationTag',
-  [TokenType.TagName]: 'TagName',
-  [TokenType.AttributeName]: 'AttributeName',
-  [TokenType.Punctuation]: 'Punctuation',
-  [TokenType.Error]: 'Error',
-  [TokenType.PunctuationString]: 'PunctuationString',
-  [TokenType.Keyword]: 'Keyword',
-  [TokenType.None]: 'None',
-  [TokenType.KeywordExport]: 'KeywordExport',
-  [TokenType.VariableValueString]: 'String',
-  [TokenType.LanguageConstant]: 'LanguageConstant',
-  [TokenType.VariableValue]: 'String',
-  [TokenType.VariableName]: 'JsonPropertyName',
-  [TokenType.NewLine]: 'NewLine',
-}
-
-const RE_WHITESPACE_NEWLINE = /^\n/
-const RE_CURLY_OPEN = /^\{/
-const RE_CURLY_CLOSE = /^\}/
-const RE_SQUARE_OPEN = /^\[/
-const RE_SQUARE_CLOSE = /^\]/
-const RE_COMMA = /^,/
-const RE_COLON = /^:/
-const RE_NUMERIC =
-  /^((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)/
-const RE_NEWLINE_WHITESPACE = /^\n\s*/
-const RE_BLOCK_COMMENT_START = /^\/\*/
-const RE_BLOCK_COMMENT_CONTENT = /^.+(?=\*\/|$)/s
-const RE_BLOCK_COMMENT_END = /^\*\//
-const RE_UNKNOWN_VALUE = /^[^\}\{\s,"]+/
-const RE_IMPORT = /^[a-zA-Z\.]+/
-const RE_SEMICOLON = /^;/
-const RE_LINE_COMMENT = /^\/\//
-const RE_ROUND_OPEN = /^\(/
-const RE_ROUND_CLOSE = /^\)/
-const RE_DOT = /^\./
-const RE_PUNCTUATION = /^[\(\)=\+\-><\.,\/\*\^\[\]\{\}\|:]/
-const RE_ANYTHING_UNTIL_END = /^.+/s
-const RE_START_OF_FUNCTION = /^( )*\(/
-const RE_COLON_COLON = /^::/
-const RE_BASH_SLASH = /^\\/
-const RE_ANY_CHAR = /^./
-const RE_SQUARE_OPEN_SQUARE_OPEN = /^\[\[/
-const RE_SQUARE_CLOSE_SQUARE_CLOSE = /^\]\]/
-const RE_STRING_MULTILINE_CONTENT = /^.+?(?=\]\]|$)/s
-const RE_KEYWORD =
-  /^(?:var|type|switch|struct|select|return|range|package|map|interface|import|if|goto|go|func|default|continue|const|chan|case|break)\b/
-const RE_TEXT = /^.+/s
-const RE_WHITESPACE = /^\s+/
-const RE_WHITESPACE_SINGLE_LINE = /^( |\t)+/
-const RE_DOUBLE_QUOTE = /^"/
-const RE_LINE_COMMENT_START = /^#/
-const RE_LINE_COMMENT_CONTENT = /^[^\n]+/
-const RE_VARIABLE_NAME = /^[a-zA-Z\_]+/
-const RE_EQUAL_SIGN = /^=/
-const RE_NUMBER =
-  /^\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b/
-const RE_KEYWORD_EXPORT = /^export(?=(\t| ))/
-const RE_CONSTANT = /^(true|false|null)(?=\s|$)/i
-const RE_VARIABLE_VALUE = /^[^\n"'#]+/
-const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^\n\\"]+/
-const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^\n\\']+/
-const RE_SINGLE_QUOTE = /^'/
-const RE_NEWLINE_AND_WHITESPACE = /^\n\s*/
-const RE_BACKSLASH = /^\\/
-const RE_EVERYTHING = /^./
-
-export const initialLineState = {
-  state: State.TopLevelContent,
-}
-
-export const hasArrayReturn = true
-
-/**
- * @param {string} line
- */
-export const tokenizeLine = (line, lineState) => {
-  let next = null
-  let index = 0
-  let tokens = []
-  let token = TokenType.None
-  let state = lineState.state
-  while (index < line.length) {
-    const part = line.slice(index)
-    switch (state) {
-      case State.TopLevelContent:
-        if ((next = part.match(RE_KEYWORD_EXPORT))) {
-          token = TokenType.KeywordExport
-          state = State.AfterKeyword
-        } else if ((next = part.match(RE_LINE_COMMENT_START))) {
-          token = TokenType.Comment
-          state = State.InsideLineComment
-        } else if ((next = part.match(RE_VARIABLE_NAME))) {
-          token = TokenType.VariableName
-          state = State.AfterVariableName
-        } else if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.TopLevelContent
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.AfterKeyword:
-        if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.AfterKeywordAndHasSeenWhitespace
-        } else {
-          line
-          throw new Error('no')
-        }
-        break
-      case State.AfterKeywordAndHasSeenWhitespace:
-        if ((next = part.match(RE_VARIABLE_NAME))) {
-          token = TokenType.VariableName
-          state = State.AfterVariableName
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.AfterVariableName:
-        if ((next = part.match(RE_EQUAL_SIGN))) {
-          token = TokenType.Punctuation
-          state = State.AfterAssignmentEqualSign
-        } else if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          // TODO what about newline
-          state = State.AfterVariableName
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.InsideDoubleQuoteString:
-        if ((next = part.match(RE_DOUBLE_QUOTE))) {
-          token = TokenType.PunctuationString
-          state = State.AfterVariableValue
-        } else if ((next = part.match(RE_STRING_DOUBLE_QUOTE_CONTENT))) {
-          token = TokenType.VariableValueString
-          state = State.InsideDoubleQuoteString
-        } else if ((next = part.match(RE_BACKSLASH))) {
-          token = TokenType.VariableValueString
-          state = State.InsideDoubleQuoteStringAfterBackslash
-        } else {
-          part.startsWith('\n') //?
-          throw new Error('no')
-        }
-        break
-      case State.InsideDoubleQuoteStringAfterBackslash:
-        if ((next = part.match(RE_EVERYTHING))) {
-          token = TokenType.VariableValueString
-          state = State.InsideDoubleQuoteString
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.InsideSingleQuoteStringAfterBackslash:
-        if ((next = part.match(RE_EVERYTHING))) {
-          token = TokenType.VariableValueString
-          state = State.InsideSingleQuoteString
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.InsideSingleQuoteString:
-        if ((next = part.match(RE_SINGLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = State.AfterVariableValue
-        } else if ((next = part.match(RE_STRING_SINGLE_QUOTE_CONTENT))) {
-          token = TokenType.VariableValueString
-          state = State.InsideSingleQuoteString
-        } else if ((next = part.match(RE_BACKSLASH))) {
-          token = TokenType.VariableValueString
-          state = State.InsideSingleQuoteStringAfterBackslash
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.AfterAssignmentEqualSign:
-        if ((next = part.match(RE_DOUBLE_QUOTE))) {
-          token = TokenType.PunctuationString
-          state = State.InsideDoubleQuoteString
-        } else if ((next = part.match(RE_SINGLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = State.InsideSingleQuoteString
-        } else if ((next = part.match(RE_NUMBER))) {
-          token = TokenType.Numeric
-          state = State.AfterVariableValue
-        } else if ((next = part.match(RE_CONSTANT))) {
-          token = TokenType.LanguageConstant
-          state = State.AfterVariableValue
-        } else if ((next = part.match(RE_WHITESPACE_SINGLE_LINE))) {
-          token = TokenType.Whitespace
-          state = State.AfterAssignmentEqualSign
-        } else if ((next = part.match(RE_VARIABLE_VALUE))) {
-          token = TokenType.VariableValue
-          state = State.AfterVariableValue
-        } else if ((next = part.match(RE_NEWLINE_AND_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.TopLevelContent
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.InsideLineComment:
-        if ((next = part.match(RE_LINE_COMMENT_CONTENT))) {
-          token = TokenType.Comment
-          state = State.TopLevelContent
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.AfterVariableValue:
-        if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_ANYTHING_UNTIL_END))) {
-          token = TokenType.Error
-          state = State.TopLevelContent
-        } else {
-          throw new Error('no')
-        }
-        break
-      default:
-        state
-        throw new Error('no')
-    }
-    const tokenLength = next[0].length
-    index += tokenLength
-    tokens.push(token, tokenLength)
-  }
-  switch (state) {
-    case State.AfterVariableName:
-    case State.AfterAssignmentEqualSign:
-      state = State.TopLevelContent
-      break
-    default:
-      break
-  }
-  if (state === State.AfterVariableValue) {
-    state = State.TopLevelContent
-  }
-  return {
-    state,
-    tokens,
-  }
-}

package/extensions/builtin.language-basics-editorconfig/README.md

@@ -1,14 +0,0 @@
-# Language Basics Editorconfig
-
-## Contributing
-
-```sh
-git clone git@github.com:lvce-editor/language-basics-editorconfig.git &&
-cd language-basics-editorconfig &&
-npm ci &&
-npm test
-```
-
-## Gitpod
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/language-basics-editorconfig)

package/extensions/builtin.language-basics-editorconfig/extension.json

@@ -1,12 +0,0 @@
-{
-  "id": "builtin.language-basics-editorconfig",
-  "name": "Language Basics Editorconfig",
-  "description": "Provides syntax highlighting and bracket matching in Editorconfig files.",
-  "languages": [
-    {
-      "id": "editorconfig",
-      "extensions": [".editorconfig"],
-      "tokenize": "src/tokenizeEditorConfig.js"
-    }
-  ]
-}

package/extensions/builtin.language-basics-editorconfig/src/tokenizeEditorConfig.js

@@ -1,173 +0,0 @@
-/**
- * @enum number
- */
-export const State = {
-  TopLevelContent: 1,
-  InsideLineComment: 2,
-  AfterPropertyName: 3,
-  AfterPropertyNameAfterEqualSign: 4,
-}
-
-export const StateMap = {
-  [State.TopLevelContent]: 'TopLevelContent',
-  [State.InsideLineComment]: 'InsideLineComment',
-}
-
-/**
- * @enum number
- */
-export const TokenType = {
-  CssSelector: 1,
-  Whitespace: 2,
-  None: 57,
-  Unknown: 881,
-  NewLine: 884,
-  Comment: 885,
-  Query: 886,
-  Text: 887,
-  LanguageConstant: 11,
-  Numeric: 15,
-  PropertyName: 12,
-  PropertyValueString: 14,
-  Punctuation: 13,
-  String: 188,
-}
-
-export const TokenMap = {
-  [TokenType.Comment]: 'Comment',
-  [TokenType.LanguageConstant]: 'LanguageConstant',
-  [TokenType.NewLine]: 'NewLine',
-  [TokenType.None]: 'None',
-  [TokenType.Numeric]: 'Numeric',
-  [TokenType.PropertyName]: 'JsonPropertyName',
-  [TokenType.Query]: 'Query',
-  [TokenType.Text]: 'Text',
-  [TokenType.Unknown]: 'Unknown',
-  [TokenType.Whitespace]: 'Whitespace',
-  [TokenType.Punctuation]: 'Punctuation',
-  [TokenType.PropertyValueString]: 'String',
-  [TokenType.String]: 'String',
-}
-
-const RE_LANGUAGE_CONSTANT = /^(?:true|false)/
-const RE_LINE_COMMENT_START = /^#/
-const RE_WHITESPACE = /^ +/
-const RE_CURLY_OPEN = /^\{/
-const RE_CURLY_CLOSE = /^\}/
-const RE_PROPERTY_NAME = /^[a-zA-Z\-\_\d\s]+\b(?=\s*\=)/
-const RE_COLON = /^:/
-const RE_PROPERTY_VALUE = /^[^;\}]+/
-const RE_SEMICOLON = /^;/
-const RE_COMMA = /^,/
-const RE_ANYTHING = /^.+/s
-const RE_NUMERIC = /^(([0-9]+\.?[0-9]*)|(\.[0-9]+))/
-const RE_ANYTHING_UNTIL_CLOSE_BRACE = /^[^\}]+/
-const RE_BLOCK_COMMENT_START = /^\/\*/
-const RE_BLOCK_COMMENT_END = /^\*\//
-const RE_BLOCK_COMMENT_CONTENT = /^.+?(?=\*\/|$)/s
-const RE_ROUND_OPEN = /^\(/
-const RE_ROUND_CLOSE = /^\)/
-const RE_PSEUDO_SELECTOR_CONTENT = /^[^\)]+/
-const RE_SQUARE_OPEN = /^\[/
-const RE_SQUARE_CLOSE = /^\]/
-const RE_ATTRIBUTE_SELECTOR_CONTENT = /^[^\]]+/
-const RE_QUERY = /^@[a-z\-]+/
-const RE_STAR = /^\*/
-const RE_QUERY_NAME = /^[a-z\-]+/
-const RE_QUERY_CONTENT = /^[^\)]+/
-const RE_COMBINATOR = /^[\+\>\~]/
-const RE_EQUAL_SIGN = /^\=/
-
-export const initialLineState = {
-  state: State.TopLevelContent,
-  tokens: [],
-  stack: [],
-}
-
-export const hasArrayReturn = true
-
-/**
- * @param {string} line
- * @param {any} lineState
- */
-export const tokenizeLine = (line, lineState) => {
-  let next = null
-  let index = 0
-  let tokens = []
-  let token = TokenType.None
-  let state = lineState.state
-  while (index < line.length) {
-    const part = line.slice(index)
-    switch (state) {
-      case State.TopLevelContent:
-        if ((next = part.match(RE_LINE_COMMENT_START))) {
-          token = TokenType.Comment
-          state = State.InsideLineComment
-        } else if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_PROPERTY_NAME))) {
-          part
-          token = TokenType.PropertyName
-          state = State.AfterPropertyName
-        } else if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.Text
-          state = State.TopLevelContent
-        } else {
-          part //?
-          throw new Error('no')
-        }
-        break
-      case State.InsideLineComment:
-        if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.Comment
-          state = State.TopLevelContent
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.AfterPropertyName:
-        if ((next = part.match(RE_EQUAL_SIGN))) {
-          token = TokenType.Punctuation
-          state = State.AfterPropertyNameAfterEqualSign
-        } else if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.AfterPropertyName
-        } else {
-          part
-          throw new Error('no')
-        }
-        break
-      case State.AfterPropertyNameAfterEqualSign:
-        if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.AfterPropertyNameAfterEqualSign
-        } else if ((next = part.match(RE_LANGUAGE_CONSTANT))) {
-          token = TokenType.LanguageConstant
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_NUMERIC))) {
-          token = TokenType.Numeric
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_LINE_COMMENT_START))) {
-          token = TokenType.Comment
-          state = State.InsideLineComment
-        } else if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.PropertyValueString
-          state = State.TopLevelContent
-        } else {
-          throw new Error('no')
-        }
-        break
-      default:
-        console.log({ state, line })
-        throw new Error('no')
-    }
-    const tokenLength = next[0].length
-    index += tokenLength
-    tokens.push(token, tokenLength)
-  }
-  return {
-    state,
-    tokens,
-  }
-}

package/extensions/builtin.language-basics-elixir/README.md

@@ -1,14 +0,0 @@
-# Language Basics Elixir
-
-## Contributing
-
-```sh
-git clone git@github.com:lvce-editor/language-basics-elixir.git &&
-cd language-basics-elixir &&
-npm ci &&
-npm test
-```
-
-## Gitpod
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/language-basics-elixir)

package/extensions/builtin.language-basics-elixir/extension.json

@@ -1,12 +0,0 @@
-{
-  "id": "builtin.language-basics-elixir",
-  "name": "Language Basics Elixir",
-  "description": "Provides syntax highlighting and bracket matching in Elixir files.",
-  "languages": [
-    {
-      "id": "elixir",
-      "extensions": [".ex"],
-      "tokenize": "src/tokenizeElixir.js"
-    }
-  ]
-}

package/extensions/builtin.language-basics-elixir/src/tokenizeElixir.js

@@ -1,150 +0,0 @@
-/**
- * @enum number
- */
-const State = {
-  None: 0,
-  TopLevelContent: 1,
-  InsideSingleQuoteString: 2,
-  InsideDoubleQuoteString: 3,
-  InsideTripleQuoteString: 4,
-}
-
-/**
- * @enum number
- */
-export const TokenType = {
-  None: 99999999,
-  Keyword: 951,
-  Whitespace: 0,
-  NewLine: 771,
-  VariableName: 2,
-  Punctuation: 3,
-  String: 4,
-  Numeric: 5,
-  Attribute: 6,
-}
-
-export const TokenMap = {
-  [TokenType.None]: 'None',
-  [TokenType.Keyword]: 'Keyword',
-  [TokenType.Whitespace]: 'Whitespace',
-  [TokenType.NewLine]: 'NewLine',
-  [TokenType.VariableName]: 'VariableName',
-  [TokenType.Punctuation]: 'Punctuation',
-  [TokenType.String]: 'String',
-  [TokenType.Numeric]: 'Numeric',
-  [TokenType.Attribute]: 'Attribute',
-}
-
-export const initialLineState = {
-  state: State.TopLevelContent,
-}
-
-const RE_KEYWORD =
-  /^(?:after|alias|and|case|catch|cond|defmodule|defimpl|defprotocol|defrecord|defstruct|do|else|end|fn|for|if|import|in|not|or|quote|raise|receive|require|reraise|rescue|try|unless|unquote|unquote_splicing|use|when|with\|0)\b/
-const RE_WHITESPACE = /^\s+/
-const RE_VARIABLE_NAME = /^[a-zA-Z]+/
-const RE_PUNCTUATION = /^[:,;\{\}\[\]\.=\(\)>]/
-const RE_QUOTE_SINGLE = /^'/
-const RE_QUOTE_DOUBLE = /^"/
-const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^']+/
-const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^"]+/
-const RE_NUMERIC = /^\d+/
-const RE_TRIPLE_DOUBLE_QUOTE = /^"""/
-const RE_STRING_TRIPLE_CONTENT = /^.+?(?="""|$)/s
-const RE_ATTRIBUTE = /^@\w+/
-
-/**
- * @param {string} line
- * @param {any} lineState
- */
-export const tokenizeLine = (line, lineState) => {
-  let next = null
-  let index = 0
-  let tokens = []
-  let token = TokenType.None
-  let state = lineState.state
-  while (index < line.length) {
-    const part = line.slice(index)
-    switch (state) {
-      case State.TopLevelContent:
-        if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_KEYWORD))) {
-          token = TokenType.Keyword
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_VARIABLE_NAME))) {
-          token = TokenType.VariableName
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_PUNCTUATION))) {
-          token = TokenType.Punctuation
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_NUMERIC))) {
-          token = TokenType.Numeric
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_QUOTE_SINGLE))) {
-          token = TokenType.Punctuation
-          state = State.InsideSingleQuoteString
-        } else if ((next = part.match(RE_TRIPLE_DOUBLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = State.InsideTripleQuoteString
-        } else if ((next = part.match(RE_QUOTE_DOUBLE))) {
-          token = TokenType.Punctuation
-          state = State.InsideDoubleQuoteString
-        } else if ((next = part.match(RE_ATTRIBUTE))) {
-          token = TokenType.Attribute
-          state = State.TopLevelContent
-        } else {
-          part //?
-          throw new Error('no')
-        }
-        break
-      case State.InsideTripleQuoteString:
-        if ((next = part.match(RE_TRIPLE_DOUBLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_STRING_TRIPLE_CONTENT))) {
-          token = TokenType.String
-          state = State.InsideTripleQuoteString
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.InsideSingleQuoteString:
-        if ((next = part.match(RE_QUOTE_SINGLE))) {
-          token = TokenType.Punctuation
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_STRING_SINGLE_QUOTE_CONTENT))) {
-          token = TokenType.String
-          state = State.InsideSingleQuoteString
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.InsideDoubleQuoteString:
-        if ((next = part.match(RE_QUOTE_DOUBLE))) {
-          token = TokenType.Punctuation
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_STRING_DOUBLE_QUOTE_CONTENT))) {
-          token = TokenType.String
-          state = State.InsideDoubleQuoteString
-        } else {
-          throw new Error('no')
-        }
-        break
-      default:
-        state
-        throw new Error('no')
-    }
-    index += next[0].length
-    tokens.push({
-      type: token,
-      length: next[0].length,
-    })
-  }
-  return {
-    state,
-    tokens,
-  }
-}

package/extensions/builtin.language-basics-elm/README.md

@@ -1,14 +0,0 @@
-# Language Basics Elm
-
-## Contributing
-
-```sh
-git clone git@github.com:lvce-editor/language-basics-elm.git &&
-cd language-basics-elm &&
-npm ci &&
-npm test
-```
-
-## Gitpod
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/language-basics-elm)