clarity-pattern-parser 4.0.3 → 6.0.0

package/src/intellisense/javascript/arrayLiteral.ts

@@ -0,0 +1,25 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { optionalSpaces } from "./optionalSpaces";
+
+const divider = new Regex("array-divider", "\\s*,\\s*");
+const arrayItems = new Repeat("array-items", new Reference("expression"), divider, true);
+
+export const arrayLiteral = new Or("array-literal",
+    [new And("empty-array-literal", [
+        new Literal("open-square-bracket", "["),
+        optionalSpaces,
+        new Literal("close-square-bracket", "]"),
+    ]),
+    new And("array-literal", [
+        new Literal("open-square-bracket", "["),
+        optionalSpaces,
+        arrayItems,
+        optionalSpaces,
+        new Literal("close-square-bracket", "]"),
+    ])
+    ]);

package/src/intellisense/javascript/deleteStatement.ts

@@ -0,0 +1,14 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Regex } from "../../patterns/Regex";
+import { expression } from "./expression";
+import { propertyAccess } from "./propertyAccess";
+
+const space = new Regex("space", "\\s+");
+export const deleteStatement = new And("delete-statement", [
+    new Literal("delete-keyword", "delete"),
+    space,
+    expression,
+    propertyAccess
+]);
+

package/src/intellisense/javascript/escapedCharacter.ts

@@ -0,0 +1,49 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+
+const backslash = new Literal("backslash", "\\");
+const doubleQuote = new Literal("double-quote", "\"");
+const singleQuote = new Literal("single-quote", "'");
+const slash = new Literal("slash", "/");
+const backspace = new Literal("backspace", "b");
+const formFeed = new Literal("form-feed", "f");
+const newLine = new Literal("new-line", "n");
+const carriageReturn = new Literal("carriage-return", "r");
+const tab = new Literal("tab", "t");
+const hexDigit = new Regex("hex-digit", "[0-9a-fA-F]");
+
+hexDigit.setTokens([
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
+    "a", "b", "c", "d", "e", "f",
+    "A", "B", "C", "D", "E", "F",
+]);
+
+const unicode = new And("hex", [
+    new Literal("u", "u"),
+    hexDigit,
+    hexDigit,
+    hexDigit,
+    hexDigit
+]);
+
+const specialCharacter = new Or("special-character", [
+    doubleQuote,
+    singleQuote,
+    backslash,
+    slash,
+    backspace,
+    formFeed,
+    newLine,
+    carriageReturn,
+    tab,
+    unicode,
+]);
+
+const escapedCharacter = new And("escaped-character", [backslash, specialCharacter])
+
+export {
+    escapedCharacter
+}
+

package/src/intellisense/javascript/exponent.ts

@@ -0,0 +1,24 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+
+const e = new Or("e", [
+    new Literal("e", "e"),
+    new Literal("e", "E")
+]);
+
+const optionalSign = new Or("sign", [
+    new Literal("plus", "+"),
+    new Literal("minus", "-")
+], true);
+
+const digit = new Regex("digit", "\\d+");
+
+const exponent = new And("exponent", [
+    e,
+    optionalSign,
+    digit,
+]);
+
+export { exponent }

package/src/intellisense/javascript/expression.ts

@@ -0,0 +1,87 @@
+import { Regex } from "../..";
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Repeat } from "../../patterns/Repeat";
+import { infixOperator } from "./infixOperator";
+import { invocation } from "./invocation";
+import { literal } from "./literal";
+import { name } from "./name";
+import { optionalSpaces } from "./optionalSpaces";
+import { prefixOperator } from "./prefixOperator";
+import { propertyAccess } from "./propertyAccess";
+
+const space = new Regex("space", "\\s+")
+const newKeyword = new Literal("new-keyword", "new");
+const deleteKeyword = new Literal("delete-keyword", "delete");
+
+const newExpression = new And("new-expression", [
+    newKeyword,
+    space,
+    new Reference("expression")
+]);
+
+const deleteExpression = new And("delete-expression", [
+    deleteKeyword,
+    space,
+    new Reference("expression")
+]);
+
+const groupExpression = new And("group-expression", [
+    new Literal("open-paren", "("),
+    optionalSpaces,
+    new Reference("expression"),
+    optionalSpaces,
+    new Literal("close-paren", ")")
+]);
+
+const prefixExpression = new And("prefix-expression", [
+    prefixOperator,
+    new Reference("expression")
+]);
+
+const optionalInfix = new And("infix-expression", [
+    infixOperator,
+    optionalSpaces,
+    new Reference("expression"),
+], true);
+
+const optionalTernary = new And("ternary", [
+    new Literal("question-mark", "?"),
+    optionalSpaces,
+    new Reference("expression"),
+    optionalSpaces,
+    new Literal("colon", ":"),
+    optionalSpaces,
+    new Reference("expression")
+], true);
+
+const optionalMemberAccesses = new Repeat("object-member-accesses",
+    new Or("object-member-access", [
+        invocation,
+        propertyAccess,
+    ]),
+    undefined, true
+);
+
+var variableName = name.clone("variable-name");
+
+const expressions = new Or("expressions", [
+    newExpression,
+    deleteExpression,
+    groupExpression,
+    prefixExpression,
+    literal,
+    variableName,
+]);
+
+const expression = new And("expression", [
+    expressions,
+    optionalInfix,
+    optionalTernary,
+    optionalMemberAccesses
+]);
+
+export { expression }
+

package/src/intellisense/javascript/expressionStatement.ts

@@ -0,0 +1,29 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Repeat } from "../../patterns/Repeat";
+import { expression } from "./expression";
+import { optionalSpaces } from "./optionalSpaces";
+
+const assignmentOperators = new Or("assignment-operators", [
+    new Literal("assign", "="),
+    new Literal("addition-assign", "+="),
+    new Literal("subtraction-assign", "-="),
+]);
+
+const assignment = new And("assignment", [
+    expression,
+    optionalSpaces,
+    assignmentOperators,
+    optionalSpaces,
+]);
+
+const expressionStatement = new And("expressionStatement", [
+    new Repeat("assignments",
+        assignment),
+    optionalSpaces,
+    expression
+]);
+
+
+export { expressionStatement }

package/src/intellisense/javascript/fraction.ts

@@ -0,0 +1,11 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Regex } from "../../patterns/Regex";
+
+const period = new Literal("period", ".");
+const digit = new Regex("digit", "\\d+");
+const fraction = new And("fraction", [period, digit]);
+
+export {
+    fraction
+}

package/src/intellisense/javascript/infixOperator.ts

@@ -0,0 +1,36 @@
+import { Literal } from "../../patterns/Literal"
+import { Or } from "../../patterns/Or";
+
+const multiply = new Literal("multiply", "*");
+const divide = new Literal("divide", "/");
+const remainder = new Literal("remainder", "%");
+const add = new Literal("add", "+");
+const subtract = new Literal("subtract", "-");
+const greaterOrEqual = new Literal("greater-or-equal", ">=");
+const lessOrEqual = new Literal("less-or-equal", "<=");
+const greater = new Literal("greater", ">");
+const less = new Literal("less", "<");
+const equal = new Literal("equal", "===");
+const notEqual = new Literal("not-equal", "!==");
+const logicalOr = new Literal("logical-or", "||");
+const logicalAnd = new Literal("logical-and", "&&");
+
+const infixOperator = new Or("infix-operator", [
+    multiply,
+    divide,
+    remainder,
+    add,
+    subtract,
+    greaterOrEqual,
+    lessOrEqual,
+    greater,
+    less,
+    equal,
+    notEqual,
+    logicalOr,
+    logicalAnd
+]);
+
+export { infixOperator }
+
+

package/src/intellisense/javascript/integer.ts

@@ -0,0 +1,7 @@
+import { Regex } from "../../patterns/Regex";
+
+const integer = new Regex("integer", "([1-9][0-9]*)|0");
+
+export {
+    integer
+}

package/src/intellisense/javascript/invocation.ts

@@ -0,0 +1,28 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { optionalSpaces } from "./optionalSpaces";
+
+const divider = new Regex("invocation-divider", "\\s*,\\s*");
+
+const invocationWithArguments = new And("invocation-with-arguments", [
+    new Literal("open-paren", "("),
+    optionalSpaces,
+    new Repeat("expressions", new Reference("expression"), divider, true),
+    optionalSpaces,
+    new Literal("close-paren", ")"),
+]);
+
+const emptyInvocation = new And("empty-invocation", [
+    new Literal("open-paren", "("),
+    optionalSpaces,
+    new Literal("close-paren", ")"),
+]);
+
+export const invocation = new Or("invocation", [
+    emptyInvocation,
+    invocationWithArguments
+])

package/src/intellisense/javascript/literal.ts

@@ -0,0 +1,14 @@
+import { Or } from "../../patterns/Or";
+import { arrayLiteral } from "./arrayLiteral";
+import { numberLiteral } from "./numberLiteral";
+import { objectLiteral } from "./objectLiteral";
+import { stringLiteral } from "./stringLiteral";
+
+const literal = new Or("literal", [
+    numberLiteral,
+    stringLiteral,
+    arrayLiteral,
+    objectLiteral,
+]);
+
+export { literal }

package/src/intellisense/javascript/name.ts

@@ -0,0 +1,3 @@
+import { Regex } from "../../patterns/Regex";
+
+export const name = new Regex("name", "[a-zA-Z_]+[a-zA-Z0-9_]*");

package/src/intellisense/javascript/numberLiteral.ts

@@ -0,0 +1,10 @@
+import { And } from "../../patterns/And";
+import { exponent } from "./exponent";
+import { fraction } from "./fraction";
+import { integer } from "./integer";
+
+export const numberLiteral = new And("number-literal", [
+    integer,
+    fraction.clone("number-fraction", true),
+    exponent.clone("number-exponent", true)
+]);

package/src/intellisense/javascript/objectLiteral.ts

@@ -0,0 +1,30 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { name } from "./name";
+import { optionalSpaces } from "./optionalSpaces";
+import { stringLiteral } from "./stringLiteral";
+
+const propertyName = new Or("property-name", [stringLiteral, name]);
+const property = new And("property", [
+    propertyName,
+    optionalSpaces,
+    new Literal("colon", ":"),
+    optionalSpaces,
+    new Reference("expression"),
+]);
+const divider = new Regex("property-divider", "\\s*,\\s*");
+const properties = new Repeat("properties", property, divider, true);
+
+const objectLiteral = new And("object-literal", [
+    new Literal("open-curly-bracket", "{"),
+    optionalSpaces,
+    properties,
+    optionalSpaces,
+    new Literal("close-curly-bracket", "}"),
+]);
+
+export { objectLiteral }

package/src/intellisense/javascript/optionalSpaces.ts

@@ -0,0 +1,3 @@
+import { Regex } from "../../patterns/Regex";
+
+export const optionalSpaces = new Regex("optional-spaces", "\\s+", true);

package/src/intellisense/javascript/parameters.ts

@@ -0,0 +1,20 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { name } from "./name";
+
+const divider = new Regex(",", "\\s*[,]\\s*");
+divider.setTokens([", "]);
+
+const optionalSpace = new Regex("optional-space", "\\s", true)
+
+const parameters = new And("parameters", [
+    new Literal("open-paren", "("),
+    optionalSpace,
+    new Repeat("arguments", name, divider),
+    optionalSpace,
+    new Literal("close-paren", ")"),
+]);
+
+export { parameters }

package/src/intellisense/javascript/prefixOperator.ts

@@ -0,0 +1,13 @@
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+
+const prefixOperator = new Or("prefix-operator", [
+    new Literal("typeof", "typeof "),
+    new Literal("to-number", "+"),
+    new Literal("negate", "-"),
+    new Literal("logical-not", "!"),
+]);
+
+export { prefixOperator }
+

package/src/intellisense/javascript/propertyAccess.ts

@@ -0,0 +1,23 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Reference } from "../../patterns/Reference";
+import { name } from "./name";
+
+const dotPropertyAccess = new And("dot-property-access", [
+    new Literal("period", "."),
+    name
+]);
+
+const bracketPropertyAccess = new And("bracket-property-access", [
+    new Literal("open-square-bracket", "["),
+    new Reference("expression"),
+    new Literal("close-square-bracket", "]"),
+]);
+
+const propertyAccess = new Or("property-access", [
+    dotPropertyAccess,
+    bracketPropertyAccess,
+]);
+
+export { propertyAccess }

package/src/intellisense/javascript/stringLiteral.ts

@@ -0,0 +1,28 @@
+import { And } from "../../patterns/And";
+import { Literal } from "../../patterns/Literal";
+import { Or } from "../../patterns/Or";
+import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+import { escapedCharacter } from "./escapedCharacter";
+
+const doubleQuoteStringLiteral = new And("double-string-literal", [
+    new Literal("double-quote", "\""),
+    new Repeat("characters", new Or("characters", [
+        new Regex("normal-characters", "[^\\\"]+"),
+        escapedCharacter
+    ])),
+    new Literal("double-quote", "\""),
+]);
+
+const singleQuoteStringLiteral = new And("single-string-literal", [
+    new Literal("single-quote", "'"),
+    new Repeat("characters", new Or("characters", [
+        new Regex("normal-characters", "[^\\']+"),
+        escapedCharacter
+    ])),
+    new Literal("single-quote", "'"),
+]);
+
+const stringLiteral = new Or("string-literal", [doubleQuoteStringLiteral, singleQuoteStringLiteral]);
+
+export { stringLiteral }