clarity-pattern-parser 11.5.4 → 11.6.0

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")
-]);

package/src/grammar/spec.md

@@ -1,331 +0,0 @@
-# Grammar Documentation
-
-This guide describes the syntax rules and composition patterns supported by cpat. Each section shows how to define reusable parsing rules.
-
----
-
-## Literals
-
-A **literal** matches an exact string.
-
-```grammar
-name = "Literal"
-```
-
----
-
-## Regex
-
-A **regex** pattern matches text using a regular expression.
-
-```grammar
-digits = /\d+/
-```
-
-### Regex Caveats
-Do **not** use `^` at the start or `$` at the end of your regex. If you want to constrain the beginning or end of the input, use a dedicated pattern instead.
-
----
-
-## Sequence
-
-A **sequence** succeeds only if all patterns match in the given order.
-
-```grammar
-space = " "
-first-name = "John"
-last-name = "Doe"
-full-name = first-name + space + last-name
-```
-
----
-
-## Optional Pattern
-
-Patterns in a sequence may be marked **optional**.
-
-```grammar
-space = " "
-first-name = /\w+/
-last-name = /\w+/
-middle-name = /\w+/
-middle-name-with-space = middle-name + space
-
-full-name = first-name + space + middle-name-with-space? + last-name
-```
-
----
-
-## Negative Lookahead
-
-Use `!` to prevent a specific pattern from matching.
-
-```grammar
-space = " "
-first-name = /\w+/
-last-name = /\w+/
-jack = "Jack"
-
-full-name = !jack + first-name + space + last-name
-```
-
-This ensures the first name is not `"Jack"`.
-
----
-
-## Options
-
-An **options** pattern succeeds if *any one* of the choices matches.
-
-```grammar
-multiply = "*"
-divide = "/"
-operators = multiply | divide
-```
-
----
-
-## Repeat
-
-### Zero or More
-
-```grammar
-digit = /\d/
-digits = (digit)*
-```
-
-### Zero or More with Delimiters
-
-```grammar
-digit = /\d/
-comma = ","
-digits = (digit, comma)*
-```
-
-### One or More with Trimmed Trailing Delimiter
-
-```grammar
-digit = /\d/
-comma = ","
-digits = (digit, comma trim)+
-```
-
-This prevents trailing commas from being accepted.
-
----
-
-### One or More
-
-```grammar
-digit = /\d/
-digits = (digit)+
-```
-
-### Exact Count
-
-```grammar
-digit = /\d/
-digits = (digit){2}
-```
-
-### Bounded Repeats
-
-```grammar
-digit = /\d/
-digits = (digit){1,3}   # between 1 and 3
-digits = (digit){,3}    # up to 3
-```
-
----
-
-## Expressions
-
-Expressions support **prefix**, **infix**, **postfix**, and **right-associative** notation, with operator precedence and recursion.
-
-- **Prefix**: Operator(s) come before the expression. The sequence must end with the name of the expression being made.  
-- **Infix**: Operator(s) come between expressions.  
-- **Postfix**: Operator(s) come after the expression.  
-- **Right-associative**: Operator(s) group toward the right.  
-
-### Prefix Expression
-
-```grammar
-increment = "++"
-integer = /[1-9][0-9]*/
-space = /\s+/
-
-prefix-expr = increment + space? + expr
-expr = prefix-expr | integer
-```
-
-Examples:  
-- `++5`  
-- `++ 10`
-
----
-
-### Infix Expression
-
-```grammar
-add-sub = "+" | "-"
-mul-div = "*" | "/"
-integer = /[1-9][0-9]*/
-space = /\s+/
-
-add-sub-expr = expr + space? + add-sub + space? + expr
-mul-div-expr = expr + space? + mul-div + space? + expr
-
-expr = mul-div-expr | add-sub-expr | integer
-```
-
-Examples:  
-- `4 * 2`  
-- `7 + 3`  
-
----
-
-### Postfix Expression
-
-```grammar
-factorial = "!"
-integer = /[1-9][0-9]?/
-space = /\s+/
-
-postfix-expr = expr + space? + factorial
-expr = postfix-expr | integer
-```
-
-Examples:  
-- `5!`  
-- `10 !`  
-
----
-
-### Combined Expressions
-
-By layering them into a single `expr` rule, you can combine prefix, infix, and postfix with precedence:
-
-```grammar
-increment = "++"
-factorial = "!"
-add-sub = "+" | "-"
-mul-div = "*" | "/"
-
-integer = /[1-9][0-9]*/
-space = /\s+/
-
-prefix-expr   = increment + space? + expr
-postfix-expr  = expr + space? + factorial
-mul-div-expr  = expr + space? + mul-div + space? + expr
-add-sub-expr  = expr + space? + add-sub + space? + expr
-
-expr = postfix-expr 
-     | prefix-expr 
-     | mul-div-expr 
-     | add-sub-expr 
-     | integer
-```
-
-Examples:  
-- `++5`  
-- `5!`  
-- `++5!`  
-- `2 + 3 * 4`  
-
----
-
-### Recursive Expressions
-
-Since each rule references `expr`, the grammar is recursive and can handle deeply nested inputs.
-
-Examples:  
-- `7++` → `postfix-expr`  
-- `7++ * 9` → `mul-div-expr`  
-- `7++ * 9 + 10` → `(7++) * 9 + 10` with correct precedence  
-
----
-
-### Right-Associative Expressions
-
-Some operators must associate to the **right**. Mark the operator with `right` to enforce this.
-
-```grammar
-power = "^"
-integer = /[1-9][0-9]*/
-space = /\s+/
-
-power-expr = expr + space? + power + space? + expr
-expr = power-expr right | integer
-```
-
-Examples:  
-- `2 ^ 3 ^ 2`  
-  - Right-associative → `2 ^ (3 ^ 2)` = `512`  
-  - Left-associative → `(2 ^ 3) ^ 2` = `64`  
-
----
-
-
-## Imports
-
-### Basic Import
-
-```grammar
-import { spaces } from "https://some.cdn.com/some/spaces.cpat"
-
-first-name = "John"
-last-name = "Doe"
-full-name = first-name + spaces + last-name
-```
-
-### Multiple Named Imports
-
-```grammar
-import { spaces, first-name } from "https://some.cdn.com/some/spaces.cpat"
-
-last-name = "Doe"
-full-name = first-name + spaces + last-name
-```
-
-### Multiple Imports
-
-```grammar
-import { spaces, first-name } from "https://some.cdn.com/some/patterns.cpat"
-import { last-name } from "https://some.cdn.com/some/last-name.cpat"
-
-full-name = first-name + spaces + last-name
-```
-
----
-
-## Import Parameters
-
-You can inject parameters into imported patterns.
-
-**File:** `main.ts`
-```ts
-const firstName = new Literal("first-name", "John");
-const lastName = new Literal("last-name", "Doe");
-const grammar = Grammar.import('file.cpat', { params: [firstName, LastName] });
-```
-
-**File:** `file.cpat`
-```grammar
-use params { first-name, last-name }
-
-full-name = first-name + spaces + last-name
-```
-
-### Imports with Params
-
-```grammar
-use params { other-pattern }
-import { first-names, last-names } from "some-file.cpat" with params {
-    some-pattern = "Some Pattern"
-    some-pattern2 = other-pattern
-}
-
-full-name = first-names + spaces + last-names
-```
-
----