@lowgular/code-graph 0.1.1 → 0.1.2

package/cypher/lib/lexer.js

@@ -1,376 +0,0 @@
-var TokenType = /* @__PURE__ */ ((TokenType2) => {
-  TokenType2["MATCH"] = "MATCH";
-  TokenType2["OPTIONAL"] = "OPTIONAL";
-  TokenType2["RETURN"] = "RETURN";
-  TokenType2["DISTINCT"] = "DISTINCT";
-  TokenType2["WHERE"] = "WHERE";
-  TokenType2["AND"] = "AND";
-  TokenType2["OR"] = "OR";
-  TokenType2["AS"] = "AS";
-  TokenType2["IN"] = "IN";
-  TokenType2["NOT"] = "NOT";
-  TokenType2["IS"] = "IS";
-  TokenType2["NULL"] = "NULL";
-  TokenType2["TRUE"] = "TRUE";
-  TokenType2["FALSE"] = "FALSE";
-  TokenType2["STARTS"] = "STARTS";
-  TokenType2["ENDS"] = "ENDS";
-  TokenType2["CONTAINS"] = "CONTAINS";
-  TokenType2["WITH"] = "WITH";
-  TokenType2["LIMIT"] = "LIMIT";
-  TokenType2["ORDER"] = "ORDER";
-  TokenType2["BY"] = "BY";
-  TokenType2["ASC"] = "ASC";
-  TokenType2["DESC"] = "DESC";
-  TokenType2["IDENTIFIER"] = "IDENTIFIER";
-  TokenType2["LABEL"] = "LABEL";
-  TokenType2["LPAREN"] = "LPAREN";
-  TokenType2["RPAREN"] = "RPAREN";
-  TokenType2["LBRACKET"] = "LBRACKET";
-  TokenType2["RBRACKET"] = "RBRACKET";
-  TokenType2["LBRACE"] = "LBRACE";
-  TokenType2["RBRACE"] = "RBRACE";
-  TokenType2["DASH"] = "DASH";
-  TokenType2["ARROW"] = "ARROW";
-  TokenType2["EQUALS"] = "EQUALS";
-  TokenType2["NOT_EQUALS"] = "NOT_EQUALS";
-  TokenType2["GT"] = "GT";
-  TokenType2["LT"] = "LT";
-  TokenType2["GTE"] = "GTE";
-  TokenType2["LTE"] = "LTE";
-  TokenType2["COMMA"] = "COMMA";
-  TokenType2["DOT"] = "DOT";
-  TokenType2["PIPE"] = "PIPE";
-  TokenType2["ASTERISK"] = "ASTERISK";
-  TokenType2["REGEX_MATCH"] = "REGEX_MATCH";
-  TokenType2["STRING"] = "STRING";
-  TokenType2["NUMBER"] = "NUMBER";
-  TokenType2["EOF"] = "EOF";
-  return TokenType2;
-})(TokenType || {});
-class Lexer {
-  constructor(input) {
-    this.input = input;
-    this.position = 0;
-    this.currentChar = input.length > 0 ? input[0] : null;
-  }
-  advance() {
-    this.position++;
-    this.currentChar = this.position >= this.input.length ? null : this.input[this.position];
-  }
-  skipWhitespace() {
-    while (this.currentChar && /\s/.test(this.currentChar)) {
-      this.advance();
-    }
-  }
-  readIdentifier() {
-    let result = "";
-    while (this.currentChar && /[a-zA-Z0-9_]/.test(this.currentChar)) {
-      result += this.currentChar;
-      this.advance();
-    }
-    return result;
-  }
-  readString() {
-    const quote = this.currentChar;
-    this.advance();
-    let result = "";
-    while (this.currentChar && this.currentChar !== quote) {
-      if (this.currentChar === "\\") {
-        this.advance();
-        if (this.currentChar === "n") {
-          result += "\n";
-        } else if (this.currentChar === "t") {
-          result += "	";
-        } else {
-          result += this.currentChar;
-        }
-        this.advance();
-      } else {
-        result += this.currentChar;
-        this.advance();
-      }
-    }
-    if (this.currentChar === quote) {
-      this.advance();
-    }
-    return result;
-  }
-  readNumber() {
-    let result = "";
-    while (this.currentChar && /[0-9.]/.test(this.currentChar)) {
-      result += this.currentChar;
-      this.advance();
-    }
-    return result;
-  }
-  peekKeyword() {
-    const savedPos = this.position;
-    const savedChar = this.currentChar;
-    const keyword = this.readIdentifier();
-    this.position = savedPos;
-    this.currentChar = savedChar;
-    return keyword.length > 0 ? keyword.toUpperCase() : null;
-  }
-  tokenize() {
-    const tokens = [];
-    this.position = 0;
-    this.currentChar = this.input.length > 0 ? this.input[0] : null;
-    while (this.currentChar !== null) {
-      this.skipWhitespace();
-      if (!this.currentChar)
-        break;
-      const startPos = this.position;
-      const keyword = this.peekKeyword();
-      const keywordMap = {
-        MATCH: "MATCH" /* MATCH */,
-        OPTIONAL: "OPTIONAL" /* OPTIONAL */,
-        RETURN: "RETURN" /* RETURN */,
-        DISTINCT: "DISTINCT" /* DISTINCT */,
-        WHERE: "WHERE" /* WHERE */,
-        AND: "AND" /* AND */,
-        OR: "OR" /* OR */,
-        AS: "AS" /* AS */,
-        IN: "IN" /* IN */,
-        NOT: "NOT" /* NOT */,
-        IS: "IS" /* IS */,
-        NULL: "NULL" /* NULL */,
-        TRUE: "TRUE" /* TRUE */,
-        FALSE: "FALSE" /* FALSE */,
-        STARTS: "STARTS" /* STARTS */,
-        ENDS: "ENDS" /* ENDS */,
-        CONTAINS: "CONTAINS" /* CONTAINS */,
-        WITH: "WITH" /* WITH */,
-        LIMIT: "LIMIT" /* LIMIT */,
-        ORDER: "ORDER" /* ORDER */,
-        BY: "BY" /* BY */,
-        ASC: "ASC" /* ASC */,
-        DESC: "DESC" /* DESC */
-      };
-      if (keyword && keywordMap[keyword]) {
-        tokens.push({
-          type: keywordMap[keyword],
-          value: keyword,
-          position: startPos
-        });
-        this.readIdentifier();
-        continue;
-      }
-      switch (this.currentChar) {
-        case "(":
-          tokens.push({
-            type: "LPAREN" /* LPAREN */,
-            value: "(",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case ")":
-          tokens.push({
-            type: "RPAREN" /* RPAREN */,
-            value: ")",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case "[":
-          tokens.push({
-            type: "LBRACKET" /* LBRACKET */,
-            value: "[",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case "]":
-          tokens.push({
-            type: "RBRACKET" /* RBRACKET */,
-            value: "]",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case "{":
-          tokens.push({
-            type: "LBRACE" /* LBRACE */,
-            value: "{",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case "}":
-          tokens.push({
-            type: "RBRACE" /* RBRACE */,
-            value: "}",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case "<":
-          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "-") {
-            tokens.push({
-              type: "ARROW" /* ARROW */,
-              value: "<-",
-              position: startPos
-            });
-            this.advance();
-            this.advance();
-          } else if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
-            tokens.push({
-              type: "LTE" /* LTE */,
-              value: "<=",
-              position: startPos
-            });
-            this.advance();
-            this.advance();
-          } else {
-            tokens.push({
-              type: "LT" /* LT */,
-              value: "<",
-              position: startPos
-            });
-            this.advance();
-          }
-          break;
-        case "-":
-          if (this.position + 1 < this.input.length && this.input[this.position + 1] === ">") {
-            tokens.push({
-              type: "ARROW" /* ARROW */,
-              value: "->",
-              position: startPos
-            });
-            this.advance();
-            this.advance();
-          } else {
-            tokens.push({
-              type: "DASH" /* DASH */,
-              value: "-",
-              position: startPos
-            });
-            this.advance();
-          }
-          break;
-        case "=":
-          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "~") {
-            tokens.push({
-              type: "REGEX_MATCH" /* REGEX_MATCH */,
-              value: "=~",
-              position: startPos
-            });
-            this.advance();
-            this.advance();
-          } else {
-            tokens.push({
-              type: "EQUALS" /* EQUALS */,
-              value: "=",
-              position: startPos
-            });
-            this.advance();
-          }
-          break;
-        case "!":
-          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
-            tokens.push({
-              type: "NOT_EQUALS" /* NOT_EQUALS */,
-              value: "!=",
-              position: startPos
-            });
-            this.advance();
-            this.advance();
-          } else {
-            throw new Error(`Unexpected character: ! at position ${startPos}`);
-          }
-          break;
-        case ">":
-          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
-            tokens.push({
-              type: "GTE" /* GTE */,
-              value: ">=",
-              position: startPos
-            });
-            this.advance();
-            this.advance();
-          } else {
-            tokens.push({
-              type: "GT" /* GT */,
-              value: ">",
-              position: startPos
-            });
-            this.advance();
-          }
-          break;
-        case ",":
-          tokens.push({
-            type: "COMMA" /* COMMA */,
-            value: ",",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case ".":
-          tokens.push({
-            type: "DOT" /* DOT */,
-            value: ".",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case "|":
-          tokens.push({
-            type: "PIPE" /* PIPE */,
-            value: "|",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case "*":
-          tokens.push({
-            type: "ASTERISK" /* ASTERISK */,
-            value: "*",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case ":":
-          tokens.push({
-            type: "LABEL" /* LABEL */,
-            value: ":",
-            position: startPos
-          });
-          this.advance();
-          break;
-        case '"':
-        case "'":
-          tokens.push({
-            type: "STRING" /* STRING */,
-            value: this.readString(),
-            position: startPos
-          });
-          break;
-        default:
-          if (/[0-9]/.test(this.currentChar)) {
-            tokens.push({
-              type: "NUMBER" /* NUMBER */,
-              value: this.readNumber(),
-              position: startPos
-            });
-          } else if (/[a-zA-Z_]/.test(this.currentChar)) {
-            tokens.push({
-              type: "IDENTIFIER" /* IDENTIFIER */,
-              value: this.readIdentifier(),
-              position: startPos
-            });
-          } else {
-            throw new Error(
-              `Unexpected character: ${this.currentChar} at position ${startPos}`
-            );
-          }
-      }
-    }
-    tokens.push({ type: "EOF" /* EOF */, value: "", position: this.position });
-    return tokens;
-  }
-}
-export {
-  Lexer,
-  TokenType
-};