clarity-pattern-parser 11.5.3 → 11.6.0

package/src/grammar/patterns/decoratorStatement.ts

@@ -1,85 +0,0 @@
-import { Literal } from "../../patterns/Literal";
-import { Optional } from "../../patterns/Optional";
-import { Options } from "../../patterns/Options";
-import { Reference } from "../../patterns/Reference";
-import { Regex } from "../../patterns/Regex";
-import { Repeat } from "../../patterns/Repeat";
-import { Sequence } from "../../patterns/Sequence";
-import { name } from "./name";
-import { allSpaces } from "./spaces";
-
-const colon = new Literal("colon", ":");
-const comma = new Regex("comma", "\\s*,\\s*");
-const openBracket = new Literal("open-bracket", "{");
-const closeBracket = new Literal("close-bracket", "}");
-const openSquareBracket = new Literal("open-square-bracket", "[");
-const closeSquareBracket = new Literal("close-square-bracket", "]");
-const optionalAllSpaces = new Optional("optional-all-spaces", allSpaces);
-
-const stringLiteral = new Regex("string-literal", '"(?:\\\\.|[^"\\\\])*"');
-const numberLiteral = new Regex("number-literal", '[+-]?\\d+(\\.\\d+)?([eE][+-]?\\d+)?');
-const nullLiteral = new Literal("null-literal", "null");
-const trueLiteral = new Literal("true-literal", "true");
-const falseLiteral = new Literal("false-literal", "false");
-const booleanLiteral = new Options("", [trueLiteral, falseLiteral]);
-
-const objectKey = stringLiteral.clone("object-key");
-const objectProperty = new Sequence("object-property", [
-    objectKey,
-    optionalAllSpaces,
-    colon,
-    optionalAllSpaces,
-    new Reference("literal"),
-]);
-const objectProperies = new Repeat("object-properties", objectProperty, { divider: comma });
-const objectLiteral = new Sequence("object-literal", [
-    openBracket,
-    optionalAllSpaces,
-    new Optional("optional-object-properties", objectProperies),
-    optionalAllSpaces,
-    closeBracket
-]);
-
-const arrayItems = new Repeat("array-items", new Reference("literal"), { divider: comma });
-const arrayLiteral = new Sequence("array-literal", [
-    openSquareBracket,
-    optionalAllSpaces,
-    new Optional("optional-array-items", arrayItems),
-    optionalAllSpaces,
-    closeSquareBracket,
-]);
-
-const literal = new Options("literal", [
-    objectLiteral,
-    arrayLiteral,
-    stringLiteral,
-    booleanLiteral,
-    nullLiteral,
-    numberLiteral,
-]);
-
-const decoratorPrefix = new Literal("decorator-prefix", "@");
-const decoratorName = name.clone("decorator-name");
-const openParen = new Literal("open-paren", "(");
-const closeParen = new Literal("close-paren", ")");
-
-const methodDecoration = new Sequence("method-decorator", [
-    decoratorPrefix,
-    decoratorName,
-    optionalAllSpaces,
-    openParen,
-    optionalAllSpaces,
-    new Optional("optional-args", literal),
-    optionalAllSpaces,
-    closeParen
-]);
-
-const nameDecoration = new Sequence("name-decorator", [
-    decoratorPrefix,
-    decoratorName,
-]);
-
-export const decoratorStatement = new Options("decorator-statement", [
-    methodDecoration,
-    nameDecoration,
-]);

package/src/grammar/patterns/import.ts

@@ -1,88 +0,0 @@
-import { Sequence } from "../../patterns/Sequence";
-import { Repeat } from "../../patterns/Repeat";
-import { Literal } from "../../patterns/Literal";
-import { Regex } from "../../patterns/Regex";
-import { literal } from "./literal";
-import { Options } from "../../patterns/Options";
-import { body } from "./body";
-import { allSpaces, lineSpaces } from "./spaces";
-import { Optional } from "../../patterns/Optional";
-
-const optionalSpaces = new Optional("optional-spaces", allSpaces);
-const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
-
-const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
-importNameDivider.setTokens([", "]);
-
-const name = new Regex("import-name", "[^}\\s,]+");
-name.setTokens(["[IMPORT_NAME]"]);
-
-const importKeyword = new Literal("import", "import");
-const useParamsKeyword = new Literal("use-params", "use params");
-const asKeyword = new Literal("as", "as");
-const fromKeyword = new Literal("from", "from");
-const openBracket = new Literal("open-bracket", "{");
-const closeBracket = new Literal("close-bracket", "}");
-const equal = new Literal("equal", "=");
-
-const importNameAlias = name.clone("import-name-alias");
-const importAlias = new Sequence("import-alias", [name, lineSpaces, asKeyword, lineSpaces, importNameAlias]);
-const importedNames = new Repeat("imported-names", new Options("import-names", [importAlias, name]), { divider: importNameDivider });
-const paramName = name.clone("param-name");
-const defaultParamName = name.clone("default-param-name");
-
-const paramNameWithDefault = new Sequence("param-name-with-default-value", [
-    paramName,
-    new Optional("optional-param-default", new Sequence("param-default", [
-        optionalLineSpaces,
-        equal,
-        optionalLineSpaces,
-        defaultParamName,
-    ])),
-]);
-const paramNames = new Repeat("param-names", paramNameWithDefault, { divider: importNameDivider });
-const resource = literal.clone("resource");
-
-const useParams = new Sequence("import-params", [
-    useParamsKeyword,
-    optionalLineSpaces,
-    openBracket,
-    optionalSpaces,
-    paramNames,
-    optionalSpaces,
-    closeBracket
-]);
-
-const withParamsKeyword = new Literal("with-params", "with params");
-const withParamsStatement = new Optional("optional-with-params-statement", new Sequence("with-params-statement", [
-    withParamsKeyword,
-    optionalLineSpaces,
-    openBracket,
-    optionalSpaces,
-    body,
-    optionalSpaces,
-    closeBracket
-]));
-
-const importFromStatement = new Sequence("import-from", [
-    importKeyword,
-    optionalLineSpaces,
-    openBracket,
-    optionalSpaces,
-    importedNames,
-    optionalSpaces,
-    closeBracket,
-    optionalLineSpaces,
-    fromKeyword,
-    optionalLineSpaces,
-    resource,
-    optionalLineSpaces,
-    withParamsStatement
-]);
-
-export const importStatement = new Options("import-statement", [
-    useParams,
-    importFromStatement
-]);
-
-

package/src/grammar/patterns/literal.ts

@@ -1,4 +0,0 @@
-import { Regex } from "../../patterns/Regex";
-
-export const literal = new Regex("literal", '"(?:\\\\.|[^"\\\\])*"');
-literal.setTokens(["[LITERAL]"]);

package/src/grammar/patterns/literals.ts

@@ -1,21 +0,0 @@
-import { Options } from "../../patterns/Options";
-import { Reference } from "../../patterns/Reference";
-import { literal } from "./literal";
-import { name } from "./name";
-import { regexLiteral } from "./regexLiteral";
-
-const patternName = name.clone("pattern-name");
-
-export const anonymousLiterals = new Options("anonymous-literals", [
-    literal,
-    regexLiteral,
-    patternName,
-    new Reference("repeat-literal"),
-]);
-
-export const anonymousWrappedLiterals = new Options("anonymous-wrapped-literals", [
-    new Reference("take-until-literal"),
-    new Reference("options-literal"),
-    new Reference("sequence-literal"),
-    new Reference("complex-anonymous-pattern")
-]);

package/src/grammar/patterns/name.ts

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

package/src/grammar/patterns/optionsLiteral.ts

@@ -1,25 +0,0 @@
-import { Repeat } from "../../patterns/Repeat";
-import { Regex } from "../../patterns/Regex";
-import { name } from "./name";
-import { anonymousPattern } from "./anonymousPattern";
-import { Options } from "../../patterns/Options";
-import { Sequence } from "../../patterns/Sequence";
-import { Optional } from "../../patterns/Optional";
-import { Literal } from "../../patterns/Literal";
-
-const patternName = name.clone("pattern-name");
-patternName.setTokens(["[PATTERN_NAME]"]);
-
-const patterns = new Sequence("patterns", [
-    new Options("options-patterns", [patternName, anonymousPattern]),
-    new Optional("optional-right-associated", new Literal("right-associated", " right"))
-]);
-const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
-defaultDivider.setTokens(["|"]);
-
-const greedyDivider = new Regex("greedy-divider", "\\s*[<][|][>]\\s*");
-greedyDivider.setTokens(["<|>"]);
-
-const divider = new Options("options-divider", [defaultDivider, greedyDivider]);
-
-export const optionsLiteral = new Repeat("options-literal", patterns, { divider, min: 2, trimDivider: true });

package/src/grammar/patterns/pattern.ts

@@ -1,29 +0,0 @@
-import { Options } from "../../patterns/Options";
-import { literal } from "./literal";
-import { regexLiteral } from "./regexLiteral";
-import { repeatLiteral } from "./repeatLiteral";
-import { sequenceLiteral } from "./sequenceLiteral";
-import { optionsLiteral } from "./optionsLiteral";
-import { anonymousPattern } from "./anonymousPattern";
-import { takeUntilLiteral } from "./takeUtilLiteral";
-import { Sequence } from "../../patterns/Sequence";
-import { Literal } from "../../patterns/Literal";
-import { name } from "./name";
-import { Optional } from "../../patterns/Optional";
-
-const aliasLiteral = name.clone("alias-literal");
-aliasLiteral.setTokens(["[ALIAS_LITERAL]"]);
-
-const optionalIsOptional = new Optional("optional-flag", new Literal("is-optional", "?"));
-const configurableAnonymousPattern = new Sequence("configurable-anonymous-pattern", [anonymousPattern, optionalIsOptional]);
-
-export const pattern = new Options("pattern", [
-    literal,
-    regexLiteral,
-    repeatLiteral,
-    takeUntilLiteral,
-    aliasLiteral,
-    optionsLiteral,
-    sequenceLiteral,
-    configurableAnonymousPattern,
-], true);

package/src/grammar/patterns/regexLiteral.ts

@@ -1,5 +0,0 @@
-import { Regex } from "../../patterns/Regex";
-
-export const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
-regexLiteral.setTokens(["[REGEX_EXPRESSION]"]);
-

package/src/grammar/patterns/repeatLiteral.ts

@@ -1,71 +0,0 @@
-import { Sequence } from "../../patterns/Sequence";
-import { Literal } from "../../patterns/Literal";
-import { Options } from "../../patterns/Options";
-import { Regex } from "../../patterns/Regex";
-import { anonymousPattern } from "./anonymousPattern";
-import { name } from "./name";
-import { lineSpaces, spaces } from "./spaces";
-import { Optional } from "../../patterns/Optional";
-
-const optionalSpaces = new Optional("optional-spaces", spaces);
-const openBracket = new Literal("repeat-open-bracket", "{");
-const closeBracket = new Literal("repeat-close-bracket", "}");
-const comma = new Literal("comma", ",");
-
-const integer = new Regex("integer", "([1-9][0-9]*)|0");
-integer.setTokens(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
-
-const min = new Optional("optional-min", integer.clone("min"));
-const max = new Optional("optional-max", integer.clone("max"));
-const trimKeyword = new Literal("trim-keyword", "trim");
-const trimFlag = new Optional("optional-trim-flag", new Sequence("trim-flag", [lineSpaces, trimKeyword]));
-
-const bounds = new Sequence("bounds", [
-    openBracket,
-    optionalSpaces,
-    min,
-    optionalSpaces,
-    comma,
-    optionalSpaces,
-    max,
-    closeBracket
-]);
-
-const exactCount = new Sequence("exact-count", [
-    openBracket,
-    optionalSpaces,
-    integer,
-    optionalSpaces,
-    closeBracket,
-]);
-
-const quantifierShorthand = new Regex("quantifier-shorthand", "\\*|\\+");
-quantifierShorthand.setTokens(["*", "+"]);
-
-const quantifier = new Options("quantifier", [
-    quantifierShorthand,
-    exactCount,
-    bounds
-]);
-
-const openParen = new Literal("repeat-open-paren", "(");
-const closeParen = new Literal("repeat-close-paren", ")");
-const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
-dividerComma.setTokens([", "]);
-
-
-const patternName = name.clone("pattern-name");
-const repeatPattern = new Options("repeat-pattern", [patternName, anonymousPattern]);
-const repeatDividerPattern = repeatPattern.clone("repeat-divider-pattern");
-const repeatDividerSection = new Sequence("repeat-divider-section", [dividerComma, repeatDividerPattern, trimFlag]);
-const repeatOptionalDividerSection = new Optional("repeat-optional-divider-section", repeatDividerSection);
-
-export const repeatLiteral = new Sequence("repeat-literal", [
-    openParen,
-    optionalSpaces,
-    repeatPattern,
-    repeatOptionalDividerSection,
-    optionalSpaces,
-    closeParen,
-    new Sequence("quantifier-section", [quantifier]),
-]);

package/src/grammar/patterns/sequenceLiteral.ts

@@ -1,24 +0,0 @@
-import { Repeat } from "../../patterns/Repeat";
-import { Regex } from "../../patterns/Regex";
-import { name } from "./name";
-import { anonymousPattern } from "./anonymousPattern";
-import { Options } from "../../patterns/Options";
-import { Sequence } from "../../patterns/Sequence";
-import { Literal } from "../../patterns/Literal";
-import { Optional } from "../../patterns/Optional";
-
-const optionalNot = new Optional("optional-not", new Literal("not", "!"));
-const optionalIsOptional = new Optional("optional-is-optional", new Literal("is-optional", "?"));
-const patternName = name.clone("pattern-name");
-const patterns = new Options("sequence-patterns", [patternName, anonymousPattern]);
-
-export const pattern = new Sequence("sequence-child-pattern", [
-    optionalNot,
-    patterns,
-    optionalIsOptional,
-]);
-
-const divider = new Regex("sequence-divider", "\\s*[+]\\s*");
-divider.setTokens([" + "]);
-
-export const sequenceLiteral = new Repeat("sequence-literal", pattern, { divider, min: 2, trimDivider: true });

package/src/grammar/patterns/spaces.ts

@@ -1,16 +0,0 @@
-import { Options } from "../../patterns/Options";
-import { Regex } from "../../patterns/Regex";
-import { Repeat } from "../../patterns/Repeat";
-
-export const tabs = new Regex("tabs", "\\t+");
-tabs.setTokens(["\t"]);
-
-export const spaces = new Regex("spaces", "[ ]+");
-spaces.setTokens([" "]);
-
-export const newLine = new Regex("new-line", "(\\r?\\n)+");
-newLine.setTokens(["\n"]);
-
-export const lineSpaces = new Repeat("line-spaces", new Options("line-space", [tabs, spaces]));
-export const allSpaces = new Regex("all-spaces", "\\s+");
-allSpaces.setTokens([" "]);

package/src/grammar/patterns/statement.ts

@@ -1,22 +0,0 @@
-import { Sequence } from "../../patterns/Sequence";
-import { Literal } from "../../patterns/Literal";
-import { Options } from "../../patterns/Options";
-import { name } from "./name";
-import { spaces } from "./spaces";
-import { pattern } from "./pattern";
-import { Optional } from "../../patterns/Optional";
-import {decoratorStatement} from './decoratorStatement';
-
-const optionalSpaces = new Optional("optional-spaces", spaces);
-const assignOperator = new Literal("assign-operator", "=");
-
-const assignStatement = new Sequence("assign-statement", [
-    optionalSpaces,
-    name,
-    optionalSpaces,
-    assignOperator,
-    optionalSpaces,
-    pattern,
-]);
-
-export const statement = new Options("statement", [decoratorStatement, assignStatement, name.clone("export-name")]);

package/src/grammar/patterns/takeUtilLiteral.ts

@@ -1,20 +0,0 @@
-import { Literal } from "../../patterns/Literal"
-import { Optional } from "../../patterns/Optional";
-import { Sequence } from "../../patterns/Sequence";
-import { lineSpaces } from "./spaces";
-import { Reference } from "../../patterns/Reference";
-
-const anyChar = new Literal("any-char", "?");
-const upTo = new Literal("up-to", "->");
-const wall = new Literal("wall", "|");
-const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
-
-export const takeUntilLiteral = new Sequence("take-until-literal", [
-    anyChar,
-    optionalLineSpaces,
-    upTo,
-    optionalLineSpaces,
-    wall,
-    optionalLineSpaces,
-    new Reference("pattern")
-]);