Several fixes

src/Regexer.js

@@ -94,13 +94,17 @@ export default class Regexer {
     }
 
     /**
-     * @param {Regexer<Parser<any>>} lhs
-     * @param {Regexer<Parser<any>>} rhs
+     * @param {Regexer<Parser<any>> | Parser<any>} lhs
+     * @param {Regexer<Parser<any>> | Parser<any>} rhs
      */
     static equals(lhs, rhs, strict = false) {
-        const a = lhs.getParser()
-        const b = rhs.getParser()
-        return a.equals(Reply.makeContext(lhs), b, strict)
+        const a = lhs instanceof Regexer ? lhs.getParser() : lhs
+        const b = rhs instanceof Regexer ? rhs.getParser() : rhs
+        return a.equals(
+            Reply.makeContext(lhs instanceof Regexer ? lhs : rhs instanceof Regexer ? rhs : null),
+            b,
+            strict
+        )
     }
 
     getParser() {
@@ -146,11 +150,11 @@ export default class Regexer {
     }
 
     static success(value = undefined) {
-        return new this(new SuccessParser(value))
+        return new this(value === undefined ? SuccessParser.instance : new SuccessParser())
     }
 
     static failure() {
-        return new this(new FailureParser())
+        return new this(FailureParser.instance)
     }
 
     // Combinators
@@ -265,7 +269,7 @@ export default class Regexer {
      */
     assert(fn) {
         return this.chain((v, input, position) => fn(v, input, position)
-            ? this.Self.success(v)
+            ? this.Self.success().map(() => v)
             : this.Self.failure()
         )
     }
@@ -275,6 +279,7 @@ export default class Regexer {
     }
 
     toString(indent = 0, newline = false) {
-        return (newline ? "\n" + Parser.indentation.repeat(indent) : "") + this.#parser.toString(indent)
+        return (newline ? "\n" + Parser.indentation.repeat(indent) : "")
+            + this.#parser.toString(Reply.makeContext(this, ""), indent)
     }
 }

src/Reply.js

@@ -41,7 +41,8 @@ export default class Reply {
         return /** @type {Context} */({
             regexer: regexer,
             input: input,
-            visited: new PairMap()
+            equals: new PairMap(),
+            visited: new Set(),
         })
     }
 }

src/parser/AlternativeParser.js

@@ -1,5 +1,7 @@
 import Parser from "./Parser.js"
 import Reply from "../Reply.js"
+import StringParser from "./StringParser.js"
+import SuccessParser from "./SuccessParser.js"
 
 /**
  * @template {Parser<any>[]} T
@@ -21,6 +23,27 @@ export default class AlternativeParser extends Parser {
     constructor(...parsers) {
         super()
         this.#parsers = parsers
+        if (this.#parsers.length === 1) {
+            this.isActualParser = false
+        }
+    }
+
+    /** @protected */
+    doMatchesEmpty() {
+        return this.#parsers.some(p => p.matchesEmpty())
+    }
+
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doStarterList(context, additional = /** @type {Parser<any>[]} */([])) {
+        return this.#parsers
+            .flatMap(p => p.starterList(context))
+            .reduce(
+                (acc, cur) => acc.some(p => p.equals(context, cur, true)) ? acc : (acc.push(cur), acc),
+                /** @type {Parser<any>[]} */([])
+            )
     }
 
     unwrap() {
@@ -61,6 +84,7 @@ export default class AlternativeParser extends Parser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -81,13 +105,25 @@ export default class AlternativeParser extends Parser {
         return true
     }
 
-    toString(indent = 0) {
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
         const indentation = Parser.indentation.repeat(indent)
         const deeperIndentation = Parser.indentation.repeat(indent + 1)
+        if (this.#parsers.length === 2 && this.#parsers[1] instanceof SuccessParser) {
+            let result = this.#parsers[0].toString(context, indent)
+            if (!(this.#parsers[0] instanceof StringParser) && !context.visited.has(this.#parsers[0])) {
+                result = "<" + result + ">"
+            }
+            result += "?"
+            return result
+        }
         return "ALT<\n"
-            + this.#parsers
-                .map(p => deeperIndentation + p.toString(indent + 1))
-                .join("\n" + deeperIndentation + "|\n")
+            + deeperIndentation + this.#parsers
+                .map(p => p.toString(context, indent + 1))
+                .join("\n" + deeperIndentation + "| ")
             + "\n" + indentation + ">"
     }
 }

src/parser/AnchorParser.js

@@ -17,6 +17,8 @@ export const AnchorType = {
  */
 export default class AnchorParser extends Parser {
 
+    static isTerminal = true
+
     #type
 
     /** @param {T} type */
@@ -25,6 +27,19 @@ export default class AnchorParser extends Parser {
         this.#type = type
     }
 
+    /** @protected */
+    doMatchesEmpty() {
+        return true
+    }
+
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doStarterList(context, additional = /** @type {Parser<any>[]} */([])) {
+        return [this]
+    }
+
     /**
      * @param {Context} context
      * @param {Number} position
@@ -43,6 +58,7 @@ export default class AnchorParser extends Parser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -51,7 +67,11 @@ export default class AnchorParser extends Parser {
         return other instanceof AnchorParser && this.#type === other.#type
     }
 
-    toString(indent = 0) {
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
         return this.#type
     }
 }

src/parser/AnyCharParser.js

@@ -1,9 +1,10 @@
-import Reply from "../Reply.js"
 import RegExpParser from "./RegExpParser.js"
 
 /** @extends RegExpParser<0> */
 export default class AnyCharParser extends RegExpParser {
 
+    static isTerminal = true
+
     #dotAll
 
     /** @param {Boolean} dotAll */
@@ -13,14 +14,18 @@ export default class AnyCharParser extends RegExpParser {
     }
 
     /**
-     * In an alternative, this would always match parser could might
-     * @param {Parser<any>} parser
+     * @protected
+     * @param {Context} context
      */
-    dominates(parser) {
-        return this.#dotAll || !parser.actualParser().parse(Reply.makeContext("\n"), 0).status
+    doStarterList(context, additional = /** @type {Parser<any>[]} */([])) {
+        return [this]
     }
 
-    toString(indent = 0) {
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
         return "."
     }
 }

src/parser/AtomicGroupParser.js

@@ -40,6 +40,7 @@ export default class AtomicGroupParser extends Parser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -48,7 +49,11 @@ export default class AtomicGroupParser extends Parser {
         return other instanceof AtomicGroupParser && this.#parser.equals(context, other.#parser, strict)
     }
 
-    toString(indent = 0) {
-        return "(?>" + this.#parser.toString(indent) + ")"
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
+        return "(?>" + this.#parser.toString(context, indent) + ")"
     }
 }

src/parser/CapturingGroupParser.js

@@ -44,6 +44,7 @@ export default class CapturingGroupParser extends Parser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -54,7 +55,11 @@ export default class CapturingGroupParser extends Parser {
             && this.#parser.equals(context, other.#parser, strict)
     }
 
-    toString(indent = 0) {
-        return "(" + (this.#id !== "" ? `?<${this.#id}>` : "") + this.#parser.toString(indent) + ")"
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
+        return "(" + (this.#id !== "" ? `?<${this.#id}>` : "") + this.#parser.toString(context, indent) + ")"
     }
 }

src/parser/ChainedParser.js

@@ -25,6 +25,11 @@ export default class ChainedParser extends Parser {
         this.#fn = chained
     }
 
+    /** @protected */
+    doMatchesEmpty() {
+        return false
+    }
+
     unwrap() {
         return [this.#parser]
     }
@@ -52,6 +57,7 @@ export default class ChainedParser extends Parser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -62,7 +68,11 @@ export default class ChainedParser extends Parser {
             && this.#parser.equals(context, other.parser, strict)
     }
 
-    toString(indent = 0) {
-        return this.#parser.toString(indent) + " => chained<f()>"
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
+        return this.#parser.toString(context, indent) + " => chained<f()>"
     }
 }

src/parser/ClassParser.js

@@ -1,6 +1,6 @@
-import Reply from "../Reply.js"
 import AlternativeParser from "./AlternativeParser.js"
 import Parser from "./Parser.js"
+import Reply from "../Reply.js"
 
 /**
  * @template {Parser<any>[]} T
@@ -45,6 +45,7 @@ export default class ClassParser extends AlternativeParser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -57,9 +58,13 @@ export default class ClassParser extends AlternativeParser {
             && super.doEquals(context, other, strict)
     }
 
-    toString(indent = 0) {
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
         return "["
-            + this.parsers.map(p => p.toString(indent)).join("")
+            + this.parsers.map(p => p.toString(context, indent)).join("")
             + "]"
     }
 }

src/parser/ClassShorthandParser.js

@@ -32,6 +32,7 @@ export default class ClassShorthandParser extends RegExpParser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -40,7 +41,11 @@ export default class ClassShorthandParser extends RegExpParser {
         return other instanceof ClassShorthandParser && this.#char == other.#char
     }
 
-    toString(indent = 0) {
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
         return "\\" + this.#char
     }
 }

src/parser/EscapedCharParser.js

@@ -43,6 +43,7 @@ export default class EscapedCharParser extends StringParser {
     }
 
     /**
+     * @protected
      * @param {Context} context
      * @param {Parser<any>} other
      * @param {Boolean} strict
@@ -52,14 +53,18 @@ export default class EscapedCharParser extends StringParser {
             && super.doEquals(context, other, strict)
     }
 
-    toString(indent = 0) {
+    /**
+     * @protected
+     * @param {Context} context
+     */
+    doToString(context, indent = 0) {
         switch (this.#type) {
             case EscapedCharParser.Type.NORMAL:
                 return "\\" + (
                     Object.entries(EscapedCharParser.specialEscapedCharacters)
                         .find(([k, v]) => this.value === v)
                     ?.[0]
-                    ?? super.toString(indent)
+                    ?? super.doToString(context, indent)
                 )
             case EscapedCharParser.Type.HEX:
                 return "\\x" + this.value.codePointAt(0).toString(16)
@@ -68,6 +73,6 @@ export default class EscapedCharParser extends StringParser {
             case EscapedCharParser.Type.UNICODE_FULL:
                 return "\\u{" + this.value.codePointAt(0).toString(16) + "}"
         }
-        return super.toString(indent)
+        return super.doToString(context, indent)
     }
 }