yukigo-prolog-parser 0.2.3 → 0.2.7

package/dist/bundle.iife.js

@@ -0,0 +1,4920 @@
+var YukigoPrologParser = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // ../yukigo-ast/dist/globals/generics.js
+  var ASTNode, SourceLocation;
+  var init_generics = __esm({
+    "../yukigo-ast/dist/globals/generics.js"() {
+      ASTNode = class {
+        /** @hidden */
+        loc;
+        /** @hidden */
+        metadata = /* @__PURE__ */ new Map();
+        constructor(loc, metadata) {
+          this.loc = loc;
+          this.metadata = metadata ?? /* @__PURE__ */ new Map();
+        }
+        setMetadata(key, value) {
+          this.metadata.set(key, value);
+        }
+        getMetadata(key) {
+          return this.metadata.get(key);
+        }
+        hasMetadata(key) {
+          return this.metadata.has(key);
+        }
+        static [Symbol.hasInstance](instance) {
+          if (!instance || typeof instance !== "object")
+            return false;
+          let proto = Object.getPrototypeOf(instance);
+          while (proto) {
+            if (proto.constructor.name === this.name)
+              return true;
+            proto = Object.getPrototypeOf(proto);
+          }
+          return false;
+        }
+        is(nodeType) {
+          return this instanceof nodeType || this.constructor.name === nodeType.name;
+        }
+        dispatchVisit(visitor, callback) {
+          return callback ? callback.call(visitor, this) : visitor.fallback(this);
+        }
+      };
+      SourceLocation = class {
+        line;
+        column;
+        constructor(line, column) {
+          this.line = line;
+          this.column = column;
+        }
+        toJSON() {
+          return {
+            type: "SourceLocation",
+            line: this.line,
+            column: this.column
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/globals/expressions.js
+  var TupleExpression, FieldExpression, DataExpression, ConsExpression, LetInExpression, Otherwise, ListComprehension, Generator, RangeExpression, NamedArgument, GuardedExpression, Guard;
+  var init_expressions = __esm({
+    "../yukigo-ast/dist/globals/expressions.js"() {
+      init_generics();
+      TupleExpression = class extends ASTNode {
+        /** @hidden */
+        elements;
+        constructor(elements, loc) {
+          super(loc);
+          this.elements = elements;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTupleExpr);
+        }
+        toJSON() {
+          return {
+            type: "TupleExpression",
+            elements: this.elements.map((expr) => expr.toJSON())
+          };
+        }
+      };
+      FieldExpression = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        name;
+        constructor(name, expression, loc) {
+          super(loc);
+          this.name = name;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitFieldExpr);
+        }
+        toJSON() {
+          return {
+            type: "FieldExpression",
+            name: this.name.toJSON(),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      DataExpression = class extends ASTNode {
+        /** @hidden */
+        contents;
+        /** @hidden */
+        name;
+        constructor(name, contents, loc) {
+          super(loc);
+          this.name = name;
+          this.contents = contents;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitDataExpr);
+        }
+        toJSON() {
+          return {
+            type: "DataExpression",
+            name: this.name.toJSON(),
+            contents: this.contents.map((expr) => expr.toJSON())
+          };
+        }
+      };
+      ConsExpression = class extends ASTNode {
+        /** @hidden */
+        tail;
+        /** @hidden */
+        head;
+        constructor(head, tail, loc) {
+          super(loc);
+          this.head = head;
+          this.tail = tail;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitConsExpr);
+        }
+        toJSON() {
+          return {
+            type: "ConsExpression",
+            head: this.head.toJSON(),
+            tail: this.tail.toJSON()
+          };
+        }
+      };
+      LetInExpression = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        declarations;
+        constructor(declarations, expression, loc) {
+          super(loc);
+          this.declarations = declarations;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitLetInExpr);
+        }
+        toJSON() {
+          return {
+            type: "LetInExpression",
+            declarations: this.declarations.toJSON(),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Otherwise = class extends ASTNode {
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitOtherwise);
+        }
+        toJSON() {
+          return {
+            type: "Otherwise"
+          };
+        }
+      };
+      ListComprehension = class extends ASTNode {
+        /** @hidden */
+        generators;
+        /** @hidden */
+        projection;
+        constructor(projection, generators, loc) {
+          super(loc);
+          this.projection = projection;
+          this.generators = generators;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitListComprehension);
+        }
+        toJSON() {
+          return {
+            type: "ListComprehension",
+            projection: this.projection.toJSON(),
+            generators: this.generators.map((gen) => gen.toJSON())
+          };
+        }
+      };
+      Generator = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        variable;
+        constructor(variable2, expression, loc) {
+          super(loc);
+          this.variable = variable2;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitGenerator);
+        }
+        toJSON() {
+          return {
+            type: "Generator",
+            variable: this.variable.toJSON(),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      RangeExpression = class extends ASTNode {
+        /** @hidden */
+        step;
+        /** @hidden */
+        end;
+        /** @hidden */
+        start;
+        constructor(start, end, step, loc) {
+          super(loc);
+          this.start = start;
+          this.end = end;
+          this.step = step;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitRangeExpression);
+        }
+        toJSON() {
+          return {
+            type: "RangeExpression",
+            start: this.start.toJSON(),
+            end: this.end?.toJSON(),
+            step: this.step?.toJSON()
+          };
+        }
+      };
+      NamedArgument = class extends ASTNode {
+        identifier;
+        expression;
+        constructor(identifier, expression, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitNamedArgument);
+        }
+        toJSON() {
+          return {
+            type: "NamedArgument",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      GuardedExpression = class extends ASTNode {
+        guards;
+        constructor(guards, loc) {
+          super(loc);
+          this.guards = guards;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitGuardedExpression);
+        }
+        toJSON() {
+          return {
+            type: "GuardedExpression",
+            guards: this.guards.map((g) => g.toJSON())
+          };
+        }
+      };
+      Guard = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        condition;
+        constructor(condition, body, loc) {
+          super(loc);
+          this.condition = condition;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitGuard);
+        }
+        toJSON() {
+          return {
+            type: "Guard",
+            condition: this.condition.toJSON(),
+            body: this.body.toJSON()
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/globals/primitives.js
+  function isYukigoPrimitive(node) {
+    return node instanceof BasePrimitive;
+  }
+  var BasePrimitive, NumberPrimitive, BooleanPrimitive, CharPrimitive, StringPrimitive, NilPrimitive, SymbolPrimitive, ListPrimitive;
+  var init_primitives = __esm({
+    "../yukigo-ast/dist/globals/primitives.js"() {
+      init_generics();
+      BasePrimitive = class extends ASTNode {
+        value;
+        constructor(value, loc) {
+          super(loc);
+          this.value = value;
+        }
+        /**
+         * Generic equality check.
+         */
+        equals(other) {
+          if (this.constructor !== other.constructor)
+            return false;
+          return this.value === other.value;
+        }
+        toJSON() {
+          return {
+            type: this.jsonType,
+            value: this.value
+          };
+        }
+      };
+      NumberPrimitive = class extends BasePrimitive {
+        get jsonType() {
+          return "YuNumber";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitNumberPrimitive);
+        }
+      };
+      BooleanPrimitive = class extends BasePrimitive {
+        get jsonType() {
+          return "YuBoolean";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitBooleanPrimitive);
+        }
+      };
+      CharPrimitive = class extends BasePrimitive {
+        get jsonType() {
+          return "YuChar";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitCharPrimitive);
+        }
+      };
+      StringPrimitive = class extends BasePrimitive {
+        get jsonType() {
+          return "YuString";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitStringPrimitive);
+        }
+      };
+      NilPrimitive = class extends BasePrimitive {
+        get jsonType() {
+          return "YuNil";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitNilPrimitive);
+        }
+      };
+      SymbolPrimitive = class extends BasePrimitive {
+        get jsonType() {
+          return "YuSymbol";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitSymbolPrimitive);
+        }
+      };
+      ListPrimitive = class _ListPrimitive extends BasePrimitive {
+        get jsonType() {
+          return "YuList";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitListPrimitive);
+        }
+        equals(other) {
+          if (!(other instanceof _ListPrimitive))
+            return false;
+          if (this.value.length !== other.value.length)
+            return false;
+          return this.value.every((elem, i) => {
+            const otherElem = other.value[i];
+            if (!isYukigoPrimitive(otherElem))
+              return false;
+            if ("equals" in elem && typeof elem.equals === "function")
+              return elem.equals(otherElem);
+            return elem === otherElem;
+          });
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/globals/statements.js
+  var If, Return, Field, Constructor, Record, UnguardedBody, NativeBody, Equation, Function, Case, Switch, Catch, Try, Raise, Print, Input, For, Break, Continue, Variable, Assignment, Sequence;
+  var init_statements = __esm({
+    "../yukigo-ast/dist/globals/statements.js"() {
+      init_generics();
+      init_primitives();
+      If = class extends ASTNode {
+        /** @hidden */
+        elseExpr;
+        /** @hidden */
+        then;
+        /** @hidden */
+        condition;
+        constructor(condition, then, elseExpr, loc) {
+          super(loc);
+          this.condition = condition;
+          this.then = then;
+          this.elseExpr = elseExpr;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitIf);
+        }
+        toJSON() {
+          return {
+            type: "If",
+            condition: this.condition.toJSON(),
+            then: this.then.toJSON(),
+            else: this.elseExpr.toJSON()
+          };
+        }
+      };
+      Return = class extends ASTNode {
+        /** @hidden */
+        body;
+        constructor(body = new NilPrimitive(null), loc) {
+          super(loc);
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitReturn);
+        }
+        toJSON() {
+          return {
+            type: "Return",
+            body: this.body?.toJSON()
+          };
+        }
+      };
+      Field = class extends ASTNode {
+        /** @hidden */
+        value;
+        /** @hidden */
+        name;
+        constructor(name, value, loc) {
+          super(loc);
+          this.name = name;
+          this.value = value;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitField);
+        }
+        toJSON() {
+          return {
+            type: "Field",
+            name: this.name?.toJSON(),
+            value: this.value.toJSON()
+          };
+        }
+      };
+      Constructor = class extends ASTNode {
+        /** @hidden */
+        fields;
+        /** @hidden */
+        name;
+        constructor(name, fields, loc) {
+          super(loc);
+          this.name = name;
+          this.fields = fields;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitConstructor);
+        }
+        toJSON() {
+          return {
+            type: "Constructor",
+            name: this.name.toJSON(),
+            fields: this.fields.map((f) => f.toJSON())
+          };
+        }
+      };
+      Record = class extends ASTNode {
+        /** @hidden */
+        deriving;
+        /** @hidden */
+        contents;
+        /** @hidden */
+        name;
+        constructor(name, contents, deriving, loc) {
+          super(loc);
+          this.name = name;
+          this.contents = contents;
+          this.deriving = deriving;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitRecord);
+        }
+        toJSON() {
+          return {
+            type: "Record",
+            name: this.name.toJSON(),
+            contents: this.contents.map((constructor) => constructor.toJSON()),
+            deriving: this.deriving?.map((d) => d.toJSON())
+          };
+        }
+      };
+      UnguardedBody = class extends ASTNode {
+        /** @hidden */
+        sequence;
+        constructor(sequence, loc) {
+          super(loc);
+          this.sequence = sequence;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitUnguardedBody);
+        }
+        toJSON() {
+          return {
+            type: "UnguardedBody",
+            sequence: this.sequence.toJSON()
+          };
+        }
+      };
+      NativeBody = class extends ASTNode {
+        constructor(loc) {
+          super(loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitNativeBody);
+        }
+        toJSON() {
+          return {
+            type: "NativeBody"
+          };
+        }
+      };
+      Equation = class extends ASTNode {
+        /** @hidden */
+        patterns;
+        /** @hidden */
+        body;
+        /** @hidden */
+        returnExpr;
+        constructor(patterns, body, returnExpr, loc) {
+          super(loc);
+          this.patterns = patterns;
+          this.body = body;
+          this.returnExpr = returnExpr;
+        }
+        /** @hidden */
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitEquation);
+        }
+        /** @hidden */
+        toJSON() {
+          return {
+            type: "Equation",
+            patterns: this.patterns.map((pattern) => pattern.toJSON()),
+            body: Array.isArray(this.body) ? this.body.map((guard) => guard.toJSON()) : this.body.toJSON(),
+            return: this.returnExpr?.toJSON()
+          };
+        }
+      };
+      Function = class extends ASTNode {
+        /** @hidden */
+        equations;
+        /** @hidden */
+        identifier;
+        constructor(identifier, equations, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.equations = equations;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitFunction);
+        }
+        toJSON() {
+          return {
+            type: "Function",
+            identifier: this.identifier.toJSON(),
+            equations: this.equations.map((eq) => eq.toJSON())
+          };
+        }
+      };
+      Case = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        condition;
+        constructor(condition, body, loc) {
+          super(loc);
+          this.condition = condition;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitCase);
+        }
+        toJSON() {
+          return {
+            type: "Case",
+            condition: this.condition.toJSON(),
+            body: this.body.toJSON()
+          };
+        }
+      };
+      Switch = class extends ASTNode {
+        /** @hidden */
+        defaultExpr;
+        /** @hidden */
+        cases;
+        /** @hidden */
+        value;
+        constructor(value, cases, defaultExpr, loc) {
+          super(loc);
+          this.value = value;
+          this.cases = cases;
+          this.defaultExpr = defaultExpr;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitSwitch);
+        }
+        toJSON() {
+          return {
+            type: "Switch",
+            value: this.value.toJSON(),
+            cases: this.cases.map((caseVal) => ({
+              condition: caseVal.condition.toJSON(),
+              body: caseVal.body.toJSON()
+            })),
+            default: this.defaultExpr?.toJSON()
+          };
+        }
+      };
+      Catch = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        patterns;
+        constructor(patterns, body, loc) {
+          super(loc);
+          this.patterns = patterns;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitCatch);
+        }
+        toJSON() {
+          return {
+            type: "Catch",
+            patterns: this.patterns.map((pat) => pat.toJSON()),
+            body: this.body.toJSON()
+          };
+        }
+      };
+      Try = class extends ASTNode {
+        /** @hidden */
+        finallyExpr;
+        /** @hidden */
+        catchExpr;
+        /** @hidden */
+        body;
+        constructor(body, catchExpr, finallyExpr, loc) {
+          super(loc);
+          this.body = body;
+          this.catchExpr = catchExpr;
+          this.finallyExpr = finallyExpr;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTry);
+        }
+        toJSON() {
+          return {
+            type: "Try",
+            body: this.body.toJSON(),
+            catch: this.catchExpr.map(({ patterns, body }) => ({
+              condition: patterns.map((pattern) => pattern.toJSON()),
+              body: body.toJSON()
+            })),
+            finally: this.finallyExpr.toJSON()
+          };
+        }
+      };
+      Raise = class extends ASTNode {
+        /** @hidden */
+        body;
+        constructor(body, loc) {
+          super(loc);
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitRaise);
+        }
+        toJSON() {
+          return {
+            type: "Raise",
+            body: this.body.toJSON()
+          };
+        }
+      };
+      Print = class extends ASTNode {
+        /** @hidden */
+        expression;
+        constructor(expression, loc) {
+          super(loc);
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitPrint);
+        }
+        toJSON() {
+          return {
+            type: "Print",
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Input = class extends ASTNode {
+        /** @hidden */
+        variable;
+        /** @hidden */
+        message;
+        constructor(message, variable2, loc) {
+          super(loc);
+          this.message = message;
+          this.variable = variable2;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitInput);
+        }
+        toJSON() {
+          return {
+            type: "Input",
+            message: this.message.toJSON(),
+            variable: this.variable.toJSON()
+          };
+        }
+      };
+      For = class extends ASTNode {
+        /** @hidden */
+        statements;
+        /** @hidden */
+        body;
+        constructor(body, statements, loc) {
+          super(loc);
+          this.body = body;
+          this.statements = statements;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitFor);
+        }
+        toJSON() {
+          return {
+            type: "For",
+            body: this.body.toJSON(),
+            statements: this.statements.map((stmt) => stmt.toJSON())
+          };
+        }
+      };
+      Break = class extends ASTNode {
+        /** @hidden */
+        body;
+        constructor(body = new NilPrimitive(null), loc) {
+          super(loc);
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitBreak);
+        }
+        toJSON() {
+          return {
+            type: "Break",
+            body: this.body?.toJSON()
+          };
+        }
+      };
+      Continue = class extends ASTNode {
+        /** @hidden */
+        body;
+        constructor(body = new NilPrimitive(null), loc) {
+          super(loc);
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitContinue);
+        }
+        toJSON() {
+          return {
+            type: "Continue",
+            body: this.body?.toJSON()
+          };
+        }
+      };
+      Variable = class extends ASTNode {
+        /** @hidden */
+        variableType;
+        /** @hidden */
+        expression;
+        /** @hidden */
+        identifier;
+        constructor(identifier, expression, variableType, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.expression = expression;
+          this.variableType = variableType;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitVariable);
+        }
+        toJSON() {
+          return {
+            type: "Variable",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON(),
+            variableType: this.variableType?.toJSON()
+          };
+        }
+      };
+      Assignment = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        identifier;
+        constructor(identifier, expression, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitAssignment);
+        }
+        toJSON() {
+          return {
+            type: "Assignment",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Sequence = class extends ASTNode {
+        /** @hidden */
+        statements;
+        constructor(statements, loc) {
+          super(loc);
+          this.statements = statements;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitSequence);
+        }
+        toJSON() {
+          return {
+            type: "Sequence",
+            statements: this.statements.map((stmt) => stmt.toJSON())
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/globals/operators.js
+  var ArithmeticUnaryOperation, ArithmeticBinaryOperation, ListUnaryOperation, ListBinaryOperation, ComparisonOperation, LogicalBinaryOperation, LogicalUnaryOperation, BitwiseBinaryOperation, BitwiseUnaryOperation, StringOperation, UnifyOperation, AssignOperation;
+  var init_operators = __esm({
+    "../yukigo-ast/dist/globals/operators.js"() {
+      init_generics();
+      ArithmeticUnaryOperation = class extends ASTNode {
+        /** @hidden */
+        operand;
+        /** @hidden */
+        operator;
+        constructor(operator, operand, loc) {
+          super(loc);
+          this.operator = operator;
+          this.operand = operand;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitArithmeticUnaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "ArithmeticUnaryOperation",
+            operator: this.operator,
+            operand: this.operand
+          };
+        }
+      };
+      ArithmeticBinaryOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitArithmeticBinaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "ArithmeticBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+      ListUnaryOperation = class extends ASTNode {
+        /** @hidden */
+        operand;
+        /** @hidden */
+        operator;
+        constructor(operator, operand, loc) {
+          super(loc);
+          this.operator = operator;
+          this.operand = operand;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitListUnaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "ListUnaryOperation",
+            operator: this.operator,
+            operand: this.operand
+          };
+        }
+      };
+      ListBinaryOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitListBinaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "ListBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+      ComparisonOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitComparisonOperation);
+        }
+        toJSON() {
+          return {
+            type: "ComparisonOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+      LogicalBinaryOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitLogicalBinaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "LogicalBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+      LogicalUnaryOperation = class extends ASTNode {
+        /** @hidden */
+        operand;
+        /** @hidden */
+        operator;
+        constructor(operator, operand, loc) {
+          super(loc);
+          this.operator = operator;
+          this.operand = operand;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitLogicalUnaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "LogicalUnaryOperation",
+            operator: this.operator,
+            operand: this.operand
+          };
+        }
+      };
+      BitwiseBinaryOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitBitwiseBinaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "BitwiseBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+      BitwiseUnaryOperation = class extends ASTNode {
+        /** @hidden */
+        operand;
+        /** @hidden */
+        operator;
+        constructor(operator, operand, loc) {
+          super(loc);
+          this.operator = operator;
+          this.operand = operand;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitBitwiseUnaryOperation);
+        }
+        toJSON() {
+          return {
+            type: "BitwiseUnaryOperation",
+            operator: this.operator,
+            operand: this.operand
+          };
+        }
+      };
+      StringOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitStringOperation);
+        }
+        toJSON() {
+          return {
+            type: "StringOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+      UnifyOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitUnifyOperation);
+        }
+        toJSON() {
+          return {
+            type: "UnifyOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+      AssignOperation = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        /** @hidden */
+        operator;
+        constructor(operator, left, right, loc) {
+          super(loc);
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitAssignOperation);
+        }
+        toJSON() {
+          return {
+            type: "AssignOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/globals/patterns.js
+  function isPattern(node) {
+    return node instanceof BasePattern;
+  }
+  var BasePattern, NamedPattern, ArgsPattern, ListBasedPattern, BinaryPattern, VariablePattern, LiteralPattern, ApplicationPattern, TuplePattern, ListPattern, FunctorPattern, AsPattern, WildcardPattern, UnionPattern, ConstructorPattern, ConsPattern, TypePattern;
+  var init_patterns = __esm({
+    "../yukigo-ast/dist/globals/patterns.js"() {
+      init_generics();
+      BasePattern = class extends ASTNode {
+        constructor(loc) {
+          super(loc);
+        }
+      };
+      NamedPattern = class extends BasePattern {
+        name;
+        constructor(name, loc) {
+          super(loc);
+          this.name = name;
+        }
+        toJSON() {
+          return {
+            type: this.jsonType,
+            name: this.name.toJSON()
+          };
+        }
+      };
+      ArgsPattern = class extends BasePattern {
+        /** @hidden */
+        identifier;
+        /** @hidden */
+        args;
+        constructor(identifier, args, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.args = args;
+        }
+        toJSON() {
+          return {
+            type: this.jsonType,
+            identifier: this.identifier.toJSON(),
+            args: this.args.map((arg) => arg.toJSON())
+          };
+        }
+      };
+      ListBasedPattern = class extends BasePattern {
+        /** @hidden */
+        elements;
+        constructor(elements, loc) {
+          super(loc);
+          this.elements = elements;
+        }
+        toJSON() {
+          return {
+            type: this.jsonType,
+            elements: this.elements.map((arg) => arg.toJSON())
+          };
+        }
+      };
+      BinaryPattern = class extends BasePattern {
+        /** @hidden */
+        left;
+        /** @hidden */
+        right;
+        constructor(left, right, loc) {
+          super(loc);
+          this.left = left;
+          this.right = right;
+        }
+        toJSON() {
+          return {
+            type: this.jsonType,
+            left: this.left.toJSON(),
+            right: this.right.toJSON()
+          };
+        }
+      };
+      VariablePattern = class extends NamedPattern {
+        get jsonType() {
+          return "VariablePattern";
+        }
+        constructor(name, loc) {
+          super(name, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitVariablePattern);
+        }
+        toString() {
+          return this.name.value;
+        }
+      };
+      LiteralPattern = class extends NamedPattern {
+        get jsonType() {
+          return "LiteralPattern";
+        }
+        constructor(name, loc) {
+          super(name, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitLiteralPattern);
+        }
+        toString() {
+          const { name } = this;
+          return String(name.value);
+        }
+      };
+      ApplicationPattern = class extends ArgsPattern {
+        get jsonType() {
+          return "ApplicationPattern";
+        }
+        constructor(symbol, args, loc) {
+          super(symbol, args, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitApplicationPattern);
+        }
+        toString() {
+          const constr = this.identifier.value;
+          const args = this.args.map((pat) => pat.toString()).join(" ");
+          return `${constr} ${args}`;
+        }
+      };
+      TuplePattern = class extends ListBasedPattern {
+        get jsonType() {
+          return "TuplePattern";
+        }
+        constructor(elements, loc) {
+          super(elements, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTuplePattern);
+        }
+        toString() {
+          return `(${this.elements.map((e) => e.toString()).join(", ")})`;
+        }
+      };
+      ListPattern = class extends ListBasedPattern {
+        get jsonType() {
+          return "ListPattern";
+        }
+        constructor(elements, loc) {
+          super(elements, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitListPattern);
+        }
+        toString() {
+          const { elements } = this;
+          if (elements.length === 0)
+            return "[]";
+          return `[${this.elements.map((e) => e.toString()).join(", ")}]`;
+        }
+      };
+      FunctorPattern = class extends ArgsPattern {
+        get jsonType() {
+          return "FunctorPattern";
+        }
+        constructor(symbol, args, loc) {
+          super(symbol, args, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitFunctorPattern);
+        }
+        toString() {
+          const constr = this.identifier.value;
+          const args = this.args.map((pat) => pat.toString()).join(" ");
+          return `${constr} ${args}`;
+        }
+      };
+      AsPattern = class extends BinaryPattern {
+        get jsonType() {
+          return "AsPattern";
+        }
+        constructor(left, right, loc) {
+          super(left, right, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitAsPattern);
+        }
+        toString() {
+          const alias = this.left.toString();
+          const pattern = this.right.toString();
+          return `${alias}@${pattern}`;
+        }
+      };
+      WildcardPattern = class extends BasePattern {
+        get jsonType() {
+          return "WildcardPattern";
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitWildcardPattern);
+        }
+        toJSON() {
+          return {
+            type: "WildcardPattern",
+            name: "_"
+          };
+        }
+        toString() {
+          return "_";
+        }
+      };
+      UnionPattern = class extends ListBasedPattern {
+        get jsonType() {
+          return "UnionPattern";
+        }
+        constructor(patterns, loc) {
+          super(patterns, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitUnionPattern);
+        }
+        toString() {
+          const inner = this.elements.map((pat) => pat.toString()).join(" | ");
+          return `(${inner})`;
+        }
+      };
+      ConstructorPattern = class extends ArgsPattern {
+        get jsonType() {
+          return "ConstructorPattern";
+        }
+        constructor(symbol, args, loc) {
+          super(symbol, args, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitConstructorPattern);
+        }
+        toString() {
+          const constr = this.identifier.value;
+          const args = this.args.map((pat) => pat.toString()).join(" ");
+          return `${constr} ${args}`;
+        }
+      };
+      ConsPattern = class extends BinaryPattern {
+        get jsonType() {
+          return "ConsPattern";
+        }
+        constructor(left, right, loc) {
+          super(left, right, loc);
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitConsPattern);
+        }
+        toString() {
+          const head = this.left.toString();
+          const tail = this.right.toString();
+          return `(${head}:${tail})`;
+        }
+      };
+      TypePattern = class extends BasePattern {
+        get jsonType() {
+          return "TypePattern";
+        }
+        /** @hidden */
+        targetType;
+        /** @hidden */
+        innerPattern;
+        constructor(targetType, innerPattern, loc) {
+          super(loc);
+          this.targetType = targetType;
+          this.innerPattern = innerPattern;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTypePattern);
+        }
+        toJSON() {
+          return {
+            type: "TypePattern",
+            targetType: this.targetType.toJSON(),
+            innerPattern: this.innerPattern?.toJSON()
+          };
+        }
+        toString() {
+          const typeStr = this.targetType.toString();
+          return this.innerPattern ? `(${typeStr} ${this.innerPattern.toString()})` : typeStr;
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/globals/types.js
+  var SimpleType, TypeVar, TypeApplication, ListType, TupleType, Constraint, ParameterizedType, ConstrainedType, TypeAlias, TypeSignature, TypeCast;
+  var init_types = __esm({
+    "../yukigo-ast/dist/globals/types.js"() {
+      init_generics();
+      SimpleType = class extends ASTNode {
+        /** @hidden */
+        constraints;
+        /** @hidden */
+        value;
+        constructor(value, constraints, loc) {
+          super(loc);
+          this.value = value;
+          this.constraints = constraints;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitSimpleType);
+        }
+        toString() {
+          return this.value;
+        }
+        toJSON() {
+          return {
+            type: "SimpleType",
+            value: this.value,
+            constraints: this.constraints.map((c) => c.toJSON())
+          };
+        }
+      };
+      TypeVar = class extends ASTNode {
+        /** @hidden */
+        constraints;
+        /** @hidden */
+        value;
+        constructor(value, constraints, loc) {
+          super(loc);
+          this.value = value;
+          this.constraints = constraints;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTypeVar);
+        }
+        toString() {
+          return this.value;
+        }
+        toJSON() {
+          return {
+            type: "TypeVar",
+            value: this.value,
+            constraints: this.constraints.map((c) => c.toJSON())
+          };
+        }
+      };
+      TypeApplication = class _TypeApplication extends ASTNode {
+        /** @hidden */
+        argument;
+        /** @hidden */
+        functionType;
+        constructor(functionType, argument, loc) {
+          super(loc);
+          this.functionType = functionType;
+          this.argument = argument;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTypeApplication);
+        }
+        toString() {
+          const func = this.functionType.toString();
+          let arg = this.argument.toString();
+          if (this.argument instanceof _TypeApplication || this.argument instanceof ParameterizedType) {
+            arg = `(${arg})`;
+          }
+          return `${func} ${arg}`;
+        }
+        toJSON() {
+          return {
+            type: "TypeApplication",
+            function: this.functionType.toJSON(),
+            argument: this.argument.toJSON()
+          };
+        }
+      };
+      ListType = class extends ASTNode {
+        /** @hidden */
+        constraints;
+        /** @hidden */
+        values;
+        constructor(values, constraints, loc) {
+          super(loc);
+          this.values = values;
+          this.constraints = constraints;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitListType);
+        }
+        toString() {
+          return `[${this.values.toString()}]`;
+        }
+        toJSON() {
+          return {
+            type: "ListType",
+            values: this.values.toJSON(),
+            constraints: this.constraints.map((c) => c.toJSON())
+          };
+        }
+      };
+      TupleType = class extends ASTNode {
+        /** @hidden */
+        constraints;
+        /** @hidden */
+        values;
+        constructor(values, constraints, loc) {
+          super(loc);
+          this.values = values;
+          this.constraints = constraints;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTupleType);
+        }
+        toString() {
+          return `(${this.values.map((t) => t.toString()).join(", ")})`;
+        }
+        toJSON() {
+          return {
+            type: "TupleType",
+            values: this.values.map((val) => val.toJSON()),
+            constraints: this.constraints.map((c) => c.toJSON())
+          };
+        }
+      };
+      Constraint = class extends ASTNode {
+        /** @hidden */
+        parameters;
+        /** @hidden */
+        name;
+        constructor(name, parameters, loc) {
+          super(loc);
+          this.name = name;
+          this.parameters = parameters;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitConstraint);
+        }
+        toJSON() {
+          return {
+            type: "Constraint",
+            name: this.name,
+            parameters: this.parameters.map((p) => p.toJSON())
+          };
+        }
+      };
+      ParameterizedType = class _ParameterizedType extends ASTNode {
+        /** @hidden */
+        constraints;
+        /** @hidden */
+        returnType;
+        /** @hidden */
+        inputs;
+        constructor(inputs, returnType, constraints, loc) {
+          super(loc);
+          this.inputs = inputs;
+          this.returnType = returnType;
+          this.constraints = constraints;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitParameterizedType);
+        }
+        toString() {
+          const inputs = this.inputs.map((t) => {
+            const str = t.toString();
+            return t instanceof _ParameterizedType ? `(${str})` : str;
+          });
+          const ret = this.returnType.toString();
+          const signature = [...inputs, ret].join(" -> ");
+          if (this.constraints.length > 0) {
+            const constraints = this.constraints.map((c) => {
+              const params = c.parameters.map((p) => p.toString()).join(" ");
+              return params ? `${c.name} ${params}` : c.name;
+            }).join(", ");
+            const context = this.constraints.length > 1 ? `(${constraints})` : constraints;
+            return `${context} => ${signature}`;
+          }
+          return signature;
+        }
+        toJSON() {
+          return {
+            type: "ParameterizedType",
+            inputs: this.inputs.map((p) => p.toJSON()),
+            return: this.returnType.toJSON(),
+            constraints: this.constraints.map((p) => p.toJSON())
+          };
+        }
+      };
+      ConstrainedType = class extends ASTNode {
+        /** @hidden */
+        constraints;
+        constructor(constraints, loc) {
+          super(loc);
+          this.constraints = constraints;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitConstrainedType);
+        }
+        toJSON() {
+          return {
+            type: "ConstrainedType",
+            constraints: this.constraints.map((p) => p.toJSON())
+          };
+        }
+      };
+      TypeAlias = class extends ASTNode {
+        /** @hidden */
+        value;
+        /** @hidden */
+        variables;
+        /** @hidden */
+        identifier;
+        constructor(identifier, variables, value, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.variables = variables;
+          this.value = value;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTypeAlias);
+        }
+        toJSON() {
+          return {
+            type: "TypeAlias",
+            identifier: this.identifier.toJSON(),
+            variables: this.variables,
+            value: this.value.toJSON()
+          };
+        }
+      };
+      TypeSignature = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        identifier;
+        constructor(identifier, body, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTypeSignature);
+        }
+        toJSON() {
+          return {
+            type: "TypeSignature",
+            identifier: this.identifier.toJSON(),
+            body: this.body.toJSON()
+          };
+        }
+      };
+      TypeCast = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        expression;
+        constructor(expression, body, loc) {
+          super(loc);
+          this.expression = expression;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTypeCast);
+        }
+        toJSON() {
+          return {
+            type: "TypeCast",
+            expression: this.expression.toJSON(),
+            body: this.body.toJSON()
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/globals/testing.js
+  var TestGroup, Test, Assert, Truth, Equality, Failure;
+  var init_testing = __esm({
+    "../yukigo-ast/dist/globals/testing.js"() {
+      init_generics();
+      TestGroup = class extends ASTNode {
+        name;
+        group;
+        constructor(name, group, loc) {
+          super(loc);
+          this.name = name;
+          this.group = group;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTestGroup);
+        }
+        toJSON() {
+          return {
+            type: "TestGroup",
+            name: this.name,
+            group: this.group
+          };
+        }
+      };
+      Test = class extends ASTNode {
+        name;
+        body;
+        args;
+        constructor(name, body, args = [], loc) {
+          super(loc);
+          this.name = name;
+          this.body = body;
+          this.args = args;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTest);
+        }
+        toJSON() {
+          return {
+            type: "Test",
+            name: this.name,
+            body: this.body,
+            args: this.args
+          };
+        }
+      };
+      Assert = class extends ASTNode {
+        negated;
+        body;
+        constructor(negated, body, loc) {
+          super(loc);
+          this.negated = negated;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitAssert);
+        }
+        toJSON() {
+          return {
+            type: "Assert",
+            negated: this.negated,
+            body: this.body
+          };
+        }
+      };
+      Truth = class extends ASTNode {
+        body;
+        constructor(body, loc) {
+          super(loc);
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTruth);
+        }
+        toJSON() {
+          return {
+            type: "Truth",
+            body: this.body
+          };
+        }
+      };
+      Equality = class extends ASTNode {
+        expected;
+        value;
+        constructor(expected, value, loc) {
+          super(loc);
+          this.expected = expected;
+          this.value = value;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitEquality);
+        }
+        toJSON() {
+          return {
+            type: "Equality",
+            expected: this.expected,
+            value: this.value
+          };
+        }
+      };
+      Failure = class extends ASTNode {
+        func;
+        message;
+        constructor(func, message, loc) {
+          super(loc);
+          this.func = func;
+          this.message = message;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitFailure);
+        }
+        toJSON() {
+          return {
+            type: "Failure",
+            func: this.func,
+            message: this.message
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/paradigms/functional.js
+  var CompositionExpression, Lambda, Yield, Application;
+  var init_functional = __esm({
+    "../yukigo-ast/dist/paradigms/functional.js"() {
+      init_generics();
+      CompositionExpression = class extends ASTNode {
+        /** @hidden */
+        right;
+        /** @hidden */
+        left;
+        constructor(left, right, loc) {
+          super(loc);
+          this.left = left;
+          this.right = right;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitCompositionExpression);
+        }
+        toJSON() {
+          return {
+            type: "CompositionExpression",
+            left: this.left.toJSON(),
+            right: this.right.toJSON()
+          };
+        }
+      };
+      Lambda = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        parameters;
+        constructor(parameters, body, loc) {
+          super(loc);
+          this.parameters = parameters;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitLambda);
+        }
+        toJSON() {
+          return {
+            type: "Lambda",
+            body: this.body.toJSON(),
+            parameters: this.parameters.map((p) => p.toJSON())
+          };
+        }
+      };
+      Yield = class extends ASTNode {
+        /** @hidden */
+        expression;
+        constructor(expression, loc) {
+          super(loc);
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitYield);
+        }
+        toJSON() {
+          return {
+            type: "Yield",
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Application = class extends ASTNode {
+        /** @hidden */
+        parameter;
+        /** @hidden */
+        functionExpr;
+        constructor(functionExpr, parameter, loc) {
+          super(loc);
+          this.functionExpr = functionExpr;
+          this.parameter = parameter;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitApplication);
+        }
+        toJSON() {
+          return {
+            type: "Application",
+            function: this.functionExpr.toJSON(),
+            parameter: this.parameter.toJSON()
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/paradigms/object.js
+  var Method, Attribute, Object2, Class, Interface, Send, New, Implement, Self, Super, PrimitiveMethod;
+  var init_object = __esm({
+    "../yukigo-ast/dist/paradigms/object.js"() {
+      init_generics();
+      Method = class extends ASTNode {
+        /** @hidden */
+        equations;
+        /** @hidden */
+        identifier;
+        /** @hidden */
+        isAbstract;
+        constructor(identifier, equations, loc, isAbstract = false) {
+          super(loc);
+          this.identifier = identifier;
+          this.equations = equations;
+          this.isAbstract = isAbstract;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitMethod);
+        }
+        toJSON() {
+          return {
+            type: "Method",
+            identifier: this.identifier.toJSON(),
+            equations: this.equations.map((eq) => eq.toJSON())
+          };
+        }
+      };
+      Attribute = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        identifier;
+        constructor(identifier, expression, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitAttribute);
+        }
+        toJSON() {
+          return {
+            type: "Attribute",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Object2 = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        identifier;
+        /** @hidden */
+        extendsSymbol;
+        /** @hidden */
+        extendsArgs;
+        constructor(identifier, expression, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitObject);
+        }
+        toJSON() {
+          return {
+            type: "Object",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON(),
+            extendsSymbol: this.extendsSymbol ? this.extendsSymbol.toJSON() : void 0,
+            extendsArgs: this.extendsArgs ? this.extendsArgs.map((a) => a.toJSON()) : void 0
+          };
+        }
+      };
+      Class = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        implementsNode;
+        /** @hidden */
+        extendsSymbol;
+        /** @hidden */
+        identifier;
+        /** @hidden */
+        includes;
+        constructor(identifier, extendsSymbol, implementsNode, includes, expression, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.extendsSymbol = extendsSymbol;
+          this.implementsNode = implementsNode;
+          this.includes = includes;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitClass);
+        }
+        toJSON() {
+          return {
+            type: "Class",
+            identifier: this.identifier.toJSON(),
+            extends: this.extendsSymbol?.toJSON(),
+            implements: this.implementsNode?.toJSON(),
+            includes: this.includes.map((s) => s.toJSON()),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Interface = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        extendsSymbol;
+        /** @hidden */
+        identifier;
+        constructor(identifier, extendsSymbol, expression, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.extendsSymbol = extendsSymbol;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitInterface);
+        }
+        toJSON() {
+          return {
+            type: "Interface",
+            identifier: this.identifier.toJSON(),
+            extends: this.extendsSymbol.map((symbol) => symbol.toJSON()),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Send = class extends ASTNode {
+        /** @hidden */
+        args;
+        /** @hidden */
+        selector;
+        /** @hidden */
+        receiver;
+        /** @hidden */
+        constructor(receiver, selector, args, loc) {
+          super(loc);
+          this.receiver = receiver;
+          this.selector = selector;
+          this.args = args;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitSend);
+        }
+        toJSON() {
+          return {
+            type: "Send",
+            receiver: this.receiver.toJSON(),
+            selector: this.selector.toJSON(),
+            arguments: this.args.map((arg) => arg.toJSON())
+          };
+        }
+      };
+      New = class extends ASTNode {
+        /** @hidden */
+        args;
+        /** @hidden */
+        identifier;
+        constructor(identifier, args, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.args = args;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitNew);
+        }
+        toJSON() {
+          return {
+            type: "New",
+            identifier: this.identifier.toJSON(),
+            arguments: this.args.map((arg) => arg.toJSON())
+          };
+        }
+      };
+      Implement = class extends ASTNode {
+        /** @hidden */
+        identifier;
+        constructor(identifier, loc) {
+          super(loc);
+          this.identifier = identifier;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitImplement);
+        }
+        toJSON() {
+          return {
+            type: "Implement",
+            identifier: this.identifier.toJSON()
+          };
+        }
+      };
+      Self = class extends ASTNode {
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitSelf);
+        }
+        toJSON() {
+          return {
+            type: "Self"
+          };
+        }
+      };
+      Super = class extends ASTNode {
+        /** @hidden */
+        args;
+        constructor(args, loc) {
+          super(loc);
+          this.args = args;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitSuper);
+        }
+        toJSON() {
+          return {
+            type: "Super",
+            args: this.args
+          };
+        }
+      };
+      PrimitiveMethod = class extends ASTNode {
+        operator;
+        equations;
+        constructor(operator, equations, loc) {
+          super(loc);
+          this.operator = operator;
+          this.equations = equations;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitPrimitiveMethod);
+        }
+        toJSON() {
+          return {
+            type: "PrimitiveMethod",
+            operator: this.operator,
+            equations: this.equations
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/paradigms/imperative.js
+  var EntryPoint, Procedure, Structure, Enumeration, While, Repeat, ForLoop;
+  var init_imperative = __esm({
+    "../yukigo-ast/dist/paradigms/imperative.js"() {
+      init_generics();
+      EntryPoint = class extends ASTNode {
+        /** @hidden */
+        expression;
+        /** @hidden */
+        identifier;
+        constructor(identifier, expression, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitEntryPoint);
+        }
+        toJSON() {
+          return {
+            type: "EntryPoint",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Procedure = class extends ASTNode {
+        /** @hidden */
+        equations;
+        /** @hidden */
+        identifier;
+        constructor(identifier, equations, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.equations = equations;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitProcedure);
+        }
+        toJSON() {
+          return {
+            type: "Procedure",
+            identifier: this.identifier.toJSON(),
+            equations: this.equations.map((eq) => eq.toJSON())
+          };
+        }
+      };
+      Structure = class extends ASTNode {
+        /** @hidden */
+        elements;
+        /** @hidden */
+        identifier;
+        constructor(identifier, elements, loc) {
+          super();
+          this.identifier = identifier;
+          this.elements = elements;
+          this.loc = loc;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitStructure);
+        }
+        toJSON() {
+          return {
+            type: "Structure",
+            identifier: this.identifier.toJSON(),
+            expressions: this.elements.map((elem) => elem.toJSON())
+          };
+        }
+      };
+      Enumeration = class extends ASTNode {
+        /** @hidden */
+        contents;
+        /** @hidden */
+        identifier;
+        constructor(identifier, contents, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.contents = contents;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitEnumeration);
+        }
+        toJSON() {
+          return {
+            type: "Enumeration",
+            identifier: this.identifier.toJSON(),
+            expressions: this.contents.map((c) => c.toJSON())
+          };
+        }
+      };
+      While = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        condition;
+        constructor(condition, body, loc) {
+          super(loc);
+          this.condition = condition;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitWhile);
+        }
+        toJSON() {
+          return {
+            type: "While",
+            condition: this.condition.toJSON(),
+            body: this.body.toJSON()
+          };
+        }
+      };
+      Repeat = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        count;
+        constructor(count, body, loc) {
+          super(loc);
+          this.count = count;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitRepeat);
+        }
+        toJSON() {
+          return {
+            type: "Repeat",
+            count: this.count.toJSON(),
+            body: this.body.toJSON()
+          };
+        }
+      };
+      ForLoop = class extends ASTNode {
+        /** @hidden */
+        body;
+        /** @hidden */
+        update;
+        /** @hidden */
+        condition;
+        /** @hidden */
+        initialization;
+        constructor(initialization, condition, update, body, loc) {
+          super(loc);
+          this.initialization = initialization;
+          this.condition = condition;
+          this.update = update;
+          this.body = body;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitForLoop);
+        }
+        toJSON() {
+          return {
+            type: "ForLoop",
+            initialization: this.initialization.toJSON(),
+            condition: this.condition.toJSON(),
+            update: this.update.toJSON(),
+            body: this.body.toJSON()
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/paradigms/logic.js
+  var Rule, Call, Fact, Query, Exist, Not, Findall, Forall, Goal, LogicConstraint;
+  var init_logic = __esm({
+    "../yukigo-ast/dist/paradigms/logic.js"() {
+      init_generics();
+      Rule = class extends ASTNode {
+        /** @hidden */
+        equations;
+        /** @hidden */
+        identifier;
+        constructor(identifier, equations, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.equations = equations;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitRule);
+        }
+        toJSON() {
+          return {
+            type: "Rule",
+            identifier: this.identifier.toJSON(),
+            equations: this.equations.map((expr) => expr.toJSON())
+          };
+        }
+      };
+      Call = class extends ASTNode {
+        /** @hidden */
+        args;
+        /** @hidden */
+        callee;
+        constructor(callee, args, loc) {
+          super(loc);
+          this.callee = callee;
+          this.args = args;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitCall);
+        }
+        toJSON() {
+          return {
+            type: "Call",
+            callee: this.callee.toJSON(),
+            patterns: this.args.map((p) => p.toJSON())
+          };
+        }
+      };
+      Fact = class extends ASTNode {
+        /** @hidden */
+        patterns;
+        /** @hidden */
+        identifier;
+        constructor(identifier, patterns, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.patterns = patterns;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitFact);
+        }
+        toJSON() {
+          return {
+            type: "Fact",
+            identifier: this.identifier.toJSON(),
+            patterns: this.patterns.map((p) => p.toJSON())
+          };
+        }
+      };
+      Query = class extends ASTNode {
+        /** @hidden */
+        expressions;
+        constructor(expressions, loc) {
+          super(loc);
+          this.expressions = expressions;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitQuery);
+        }
+        toJSON() {
+          return {
+            type: "Query",
+            expressions: this.expressions.map((expr) => expr.toJSON())
+          };
+        }
+      };
+      Exist = class extends ASTNode {
+        /** @hidden */
+        patterns;
+        /** @hidden */
+        identifier;
+        constructor(identifier, patterns, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.patterns = patterns;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitExist);
+        }
+        toJSON() {
+          return {
+            type: "Exist",
+            identifier: this.identifier.toJSON(),
+            patterns: this.patterns.map((p) => p.toJSON())
+          };
+        }
+      };
+      Not = class extends ASTNode {
+        /** @hidden */
+        expression;
+        constructor(expression, loc) {
+          super(loc);
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitNot);
+        }
+        toJSON() {
+          return {
+            type: "Not",
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+      Findall = class extends ASTNode {
+        /** @hidden */
+        bag;
+        /** @hidden */
+        goal;
+        /** @hidden */
+        template;
+        constructor(template, goal, bag, loc) {
+          super(loc);
+          this.template = template;
+          this.goal = goal;
+          this.bag = bag;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitFindall);
+        }
+        toJSON() {
+          return {
+            type: "Findall",
+            template: this.template.toJSON(),
+            goal: this.goal.toJSON(),
+            bag: this.bag.toJSON()
+          };
+        }
+      };
+      Forall = class extends ASTNode {
+        /** @hidden */
+        action;
+        /** @hidden */
+        condition;
+        constructor(condition, action, loc) {
+          super(loc);
+          this.condition = condition;
+          this.action = action;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitForall);
+        }
+        toJSON() {
+          return {
+            type: "Forall",
+            condition: this.condition.toJSON(),
+            action: this.action.toJSON()
+          };
+        }
+      };
+      Goal = class extends ASTNode {
+        /** @hidden */
+        args;
+        /** @hidden */
+        identifier;
+        constructor(identifier, args, loc) {
+          super(loc);
+          this.identifier = identifier;
+          this.args = args;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitGoal);
+        }
+        toJSON() {
+          return {
+            type: "Goal",
+            identifier: this.identifier.toJSON(),
+            arguments: this.args.map((arg) => arg.toJSON())
+          };
+        }
+      };
+      LogicConstraint = class extends ASTNode {
+        /** @hidden */
+        expression;
+        constructor(expression, loc) {
+          super(loc);
+          this.expression = expression;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitLogicConstraint);
+        }
+        toJSON() {
+          return {
+            type: "LogicConstraint",
+            expression: this.expression.toJSON()
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/paradigms/typeclasses.js
+  var TypeClass, Instance;
+  var init_typeclasses = __esm({
+    "../yukigo-ast/dist/paradigms/typeclasses.js"() {
+      init_generics();
+      TypeClass = class extends ASTNode {
+        /** @hidden */
+        name;
+        /** @hidden */
+        variable;
+        /** @hidden */
+        signatures;
+        constructor(name, variable2, signatures, loc) {
+          super(loc);
+          this.name = name;
+          this.variable = variable2;
+          this.signatures = signatures;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitTypeClass);
+        }
+        toJSON() {
+          return {
+            type: "TypeClass",
+            name: this.name.toJSON(),
+            variable: this.variable.toJSON(),
+            signatures: this.signatures.map((sig) => sig.toJSON())
+          };
+        }
+      };
+      Instance = class extends ASTNode {
+        /** @hidden */
+        className;
+        /** @hidden */
+        type;
+        /** @hidden */
+        functions;
+        constructor(className, type, functions, loc) {
+          super(loc);
+          this.className = className;
+          this.type = type;
+          this.functions = functions;
+        }
+        accept(visitor) {
+          return this.dispatchVisit(visitor, visitor.visitInstance);
+        }
+        toJSON() {
+          return {
+            type: "Instance",
+            className: this.className.toJSON(),
+            targetType: this.type.toJSON(),
+            functions: this.functions.map((func) => func.toJSON())
+          };
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/base.js
+  var TraverseBase;
+  var init_base = __esm({
+    "../yukigo-ast/dist/visitor/base.js"() {
+      TraverseBase = class {
+        visit(node) {
+          node.accept(this);
+        }
+        traverseCollection(nodes) {
+          nodes.forEach((node) => node.accept(this));
+        }
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/expressions.js
+  function ExpressionTraverser(Base) {
+    class ExpressionTraverser2 extends Base {
+      visitTupleExpr(node) {
+        this.traverseCollection(node.elements);
+      }
+      visitFieldExpr(node) {
+        node.name.accept(this);
+        node.expression.accept(this);
+      }
+      visitDataExpr(node) {
+        node.name.accept(this);
+        this.traverseCollection(node.contents);
+      }
+      visitConsExpr(node) {
+        node.head.accept(this);
+        node.tail.accept(this);
+      }
+      visitLetInExpr(node) {
+        node.expression.accept(this);
+        node.declarations.accept(this);
+      }
+      visitGuardedExpression(node) {
+        this.traverseCollection(node.guards);
+      }
+      visitGuard(node) {
+        node.condition.accept(this);
+        node.body.accept(this);
+      }
+      visitCall(node) {
+        node.callee.accept(this);
+        this.traverseCollection(node.args);
+      }
+      visitOtherwise(node) {
+      }
+      visitCompositionExpression(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+      }
+      visitLambda(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.parameters);
+      }
+      visitApplication(node) {
+        node.functionExpr.accept(this);
+        node.parameter.accept(this);
+      }
+      visitExist(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.patterns);
+      }
+      visitNot(node) {
+        node.expression.accept(this);
+      }
+      visitFindall(node) {
+        node.template.accept(this);
+        node.goal.accept(this);
+        node.bag.accept(this);
+      }
+      visitForall(node) {
+        node.condition.accept(this);
+        node.action.accept(this);
+      }
+      visitGoal(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.args);
+      }
+      visitSend(node) {
+        node.selector.accept(this);
+        node.receiver.accept(this);
+        this.traverseCollection(node.args);
+      }
+      visitNew(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.args);
+      }
+      visitImplement(node) {
+        node.identifier.accept(this);
+      }
+      visitListComprehension(node) {
+        node.projection.accept(this);
+        this.traverseCollection(node.generators);
+      }
+      visitGenerator(node) {
+        node.variable.accept(this);
+        node.expression.accept(this);
+      }
+      visitRangeExpression(node) {
+        node.start.accept(this);
+        node.step?.accept(this);
+        node.end?.accept(this);
+      }
+      visitNamedArgument(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+      }
+      visitYield(node) {
+        node.expression.accept(this);
+      }
+    }
+    ;
+    return ExpressionTraverser2;
+  }
+  var init_expressions2 = __esm({
+    "../yukigo-ast/dist/visitor/expressions.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/operations.js
+  function OperationTraverser(Base) {
+    class OperationTraverser2 extends Base {
+      traverseBinary(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+      }
+      traverseUnary(node) {
+        node.operand.accept(this);
+      }
+      visitArithmeticUnaryOperation(node) {
+        this.traverseUnary(node);
+      }
+      visitArithmeticBinaryOperation(node) {
+        this.traverseBinary(node);
+      }
+      visitListUnaryOperation(node) {
+        this.traverseUnary(node);
+      }
+      visitListBinaryOperation(node) {
+        this.traverseBinary(node);
+      }
+      visitComparisonOperation(node) {
+        this.traverseBinary(node);
+      }
+      visitLogicalBinaryOperation(node) {
+        this.traverseBinary(node);
+      }
+      visitLogicalUnaryOperation(node) {
+        this.traverseUnary(node);
+      }
+      visitBitwiseBinaryOperation(node) {
+        this.traverseBinary(node);
+      }
+      visitBitwiseUnaryOperation(node) {
+        this.traverseUnary(node);
+      }
+      visitStringOperation(node) {
+        this.traverseBinary(node);
+      }
+      visitUnifyOperation(node) {
+        this.traverseBinary(node);
+      }
+      visitAssignOperation(node) {
+        this.traverseBinary(node);
+      }
+    }
+    return OperationTraverser2;
+  }
+  var init_operations = __esm({
+    "../yukigo-ast/dist/visitor/operations.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/patterns.js
+  function PatternTraverser(Base) {
+    class PatternTraverser2 extends Base {
+      visitVariablePattern(node) {
+        node.name.accept(this);
+      }
+      visitLiteralPattern(node) {
+        node.name.accept(this);
+      }
+      visitApplicationPattern(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.args);
+      }
+      visitTuplePattern(node) {
+        this.traverseCollection(node.elements);
+      }
+      visitListPattern(node) {
+        this.traverseCollection(node.elements);
+      }
+      visitFunctorPattern(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.args);
+      }
+      visitAsPattern(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+      }
+      visitWildcardPattern(node) {
+      }
+      visitUnionPattern(node) {
+        this.traverseCollection(node.elements);
+      }
+      visitConstructorPattern(node) {
+        this.traverseCollection(node.args);
+      }
+      visitConsPattern(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+      }
+      visitTypePattern(node) {
+        node.targetType.accept(this);
+        node.innerPattern?.accept(this);
+      }
+    }
+    ;
+    return PatternTraverser2;
+  }
+  var init_patterns2 = __esm({
+    "../yukigo-ast/dist/visitor/patterns.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/primitives.js
+  function PrimitiveTraverser(Base) {
+    class PrimitiveTraverser2 extends Base {
+      visitNumberPrimitive(node) {
+      }
+      visitBooleanPrimitive(node) {
+      }
+      visitStringPrimitive(node) {
+      }
+      visitListPrimitive(node) {
+        this.traverseCollection(node.value);
+      }
+      visitNilPrimitive(node) {
+      }
+      visitSymbolPrimitive(node) {
+      }
+      visitCharPrimitive(node) {
+      }
+    }
+    return PrimitiveTraverser2;
+  }
+  var init_primitives2 = __esm({
+    "../yukigo-ast/dist/visitor/primitives.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/statements.js
+  function StatementTraverser(Base) {
+    class StatementTraverser2 extends Base {
+      visitSequence(node) {
+        this.traverseCollection(node.statements);
+      }
+      visitSelf(node) {
+      }
+      visitSuper(node) {
+      }
+      visitIf(node) {
+        node.condition.accept(this);
+        node.then.accept(this);
+        node.elseExpr.accept(this);
+      }
+      visitReturn(node) {
+        node.body?.accept(this);
+      }
+      visitFunction(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.equations);
+      }
+      visitField(node) {
+        node.name?.accept(this);
+        node.value.accept(this);
+      }
+      visitConstructor(node) {
+        node.name.accept(this);
+        this.traverseCollection(node.fields);
+      }
+      visitRecord(node) {
+        node.name.accept(this);
+        this.traverseCollection(node.contents);
+        if (node.deriving)
+          this.traverseCollection(node.deriving);
+      }
+      visitUnguardedBody(node) {
+        node.sequence.accept(this);
+      }
+      visitNativeBody(node) {
+      }
+      visitEquation(node) {
+        if (Array.isArray(node.body)) {
+          this.traverseCollection(node.body);
+        } else {
+          node.body.accept(this);
+        }
+        this.traverseCollection(node.patterns);
+        node.returnExpr?.accept(this);
+      }
+      visitSwitch(node) {
+        node.value.accept(this);
+        this.traverseCollection(node.cases);
+      }
+      visitCase(node) {
+        node.condition.accept(this);
+        node.body.accept(this);
+      }
+      visitTry(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.catchExpr);
+        node.finallyExpr.accept(this);
+      }
+      visitCatch(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.patterns);
+      }
+      visitRaise(node) {
+        node.body.accept(this);
+      }
+      visitPrint(node) {
+        node.expression.accept(this);
+      }
+      visitInput(node) {
+        node.message.accept(this);
+      }
+      visitFor(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.statements);
+      }
+      visitBreak(node) {
+        node.body?.accept(this);
+      }
+      visitContinue(node) {
+        node.body?.accept(this);
+      }
+      visitVariable(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+        node.variableType?.accept(this);
+      }
+      visitAssignment(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+      }
+      visitStructure(node) {
+        this.traverseCollection(node.elements);
+      }
+      visitEntryPoint(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+      }
+      visitProcedure(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.equations);
+      }
+      visitEnumeration(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.contents);
+      }
+      visitWhile(node) {
+        node.condition.accept(this);
+        node.body.accept(this);
+      }
+      visitRepeat(node) {
+        node.body.accept(this);
+        node.count.accept(this);
+      }
+      visitForLoop(node) {
+        node.initialization.accept(this);
+        node.condition.accept(this);
+        node.update.accept(this);
+        node.body.accept(this);
+      }
+      visitRule(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.equations);
+      }
+      visitFact(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.patterns);
+      }
+      visitQuery(node) {
+        this.traverseCollection(node.expressions);
+      }
+      visitMethod(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.equations);
+      }
+      visitPrimitiveMethod(node) {
+        this.traverseCollection(node.equations);
+      }
+      visitAttribute(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+      }
+      visitObject(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+        node.extendsSymbol?.accept(this);
+        if (node.extendsArgs) {
+          this.traverseCollection(node.extendsArgs);
+        }
+      }
+      visitClass(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+        node.extendsSymbol?.accept(this);
+        node.implementsNode?.accept(this);
+      }
+      visitInterface(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.extendsSymbol);
+        node.expression.accept(this);
+      }
+      visitLogicConstraint(node) {
+        node.expression.accept(this);
+      }
+    }
+    ;
+    return StatementTraverser2;
+  }
+  var init_statements2 = __esm({
+    "../yukigo-ast/dist/visitor/statements.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/types.js
+  function TypeTraverser(Base) {
+    class TypeTraverser2 extends Base {
+      visitSimpleType(node) {
+        this.traverseCollection(node.constraints);
+      }
+      visitTypeVar(node) {
+        this.traverseCollection(node.constraints);
+      }
+      visitTypeApplication(node) {
+        node.functionType.accept(this);
+        node.argument.accept(this);
+      }
+      visitListType(node) {
+        this.traverseCollection(node.constraints);
+      }
+      visitTupleType(node) {
+        this.traverseCollection(node.constraints);
+        this.traverseCollection(node.values);
+      }
+      visitConstraint(node) {
+        this.traverseCollection(node.parameters);
+      }
+      visitParameterizedType(node) {
+        this.traverseCollection(node.inputs);
+        this.traverseCollection(node.constraints);
+        node.returnType.accept(this);
+      }
+      visitConstrainedType(node) {
+        this.traverseCollection(node.constraints);
+      }
+      visitTypeAlias(node) {
+        node.identifier.accept(this);
+        node.value.accept(this);
+      }
+      visitTypeSignature(node) {
+        node.body.accept(this);
+        node.identifier.accept(this);
+      }
+      visitTypeCast(node) {
+        node.body.accept(this);
+        node.expression.accept(this);
+      }
+    }
+    return TypeTraverser2;
+  }
+  var init_types2 = __esm({
+    "../yukigo-ast/dist/visitor/types.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/testing.js
+  function TestingTraverser(Base) {
+    class TestingTraverser2 extends Base {
+      visitTestGroup(node) {
+        node.name.accept(this);
+        node.group.accept(this);
+      }
+      visitTest(node) {
+        node.name.accept(this);
+        this.traverseCollection(node.args);
+        node.body.accept(this);
+      }
+      visitAssert(node) {
+        node.negated.accept(this);
+        node.body.accept(this);
+      }
+      visitTruth(node) {
+        node.body.accept(this);
+      }
+      visitEquality(node) {
+        node.expected.accept(this);
+        node.value.accept(this);
+      }
+      visitFailure(node) {
+        node.func.accept(this);
+        node.message.accept(this);
+      }
+    }
+    ;
+    return TestingTraverser2;
+  }
+  var init_testing2 = __esm({
+    "../yukigo-ast/dist/visitor/testing.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/typeclasses.js
+  function TypeClassTraverser(Base) {
+    class TypeClassTraverser2 extends Base {
+      visitTypeClass(node) {
+        this.traverseCollection(node.signatures);
+      }
+      visitInstance(node) {
+        this.traverseCollection(node.functions);
+      }
+    }
+    ;
+    return TypeClassTraverser2;
+  }
+  var init_typeclasses2 = __esm({
+    "../yukigo-ast/dist/visitor/typeclasses.js"() {
+    }
+  });
+
+  // ../yukigo-ast/dist/visitor/index.js
+  var StopTraversalException, TraverseVisitor;
+  var init_visitor = __esm({
+    "../yukigo-ast/dist/visitor/index.js"() {
+      init_base();
+      init_expressions2();
+      init_operations();
+      init_patterns2();
+      init_primitives2();
+      init_statements2();
+      init_types2();
+      init_testing2();
+      init_typeclasses2();
+      init_base();
+      init_expressions2();
+      init_operations();
+      init_patterns2();
+      init_primitives2();
+      init_statements2();
+      init_types2();
+      init_testing2();
+      init_typeclasses2();
+      StopTraversalException = class extends Error {
+        constructor() {
+          super("Inspection found, aborting traversal.");
+        }
+      };
+      TraverseVisitor = class extends TypeClassTraverser(TestingTraverser(TypeTraverser(StatementTraverser(PatternTraverser(OperationTraverser(PrimitiveTraverser(ExpressionTraverser(TraverseBase)))))))) {
+      };
+    }
+  });
+
+  // ../yukigo-ast/dist/index.js
+  var dist_exports = {};
+  __export(dist_exports, {
+    ASTNode: () => ASTNode,
+    Application: () => Application,
+    ApplicationPattern: () => ApplicationPattern,
+    ArithmeticBinaryOperation: () => ArithmeticBinaryOperation,
+    ArithmeticUnaryOperation: () => ArithmeticUnaryOperation,
+    AsPattern: () => AsPattern,
+    Assert: () => Assert,
+    AssignOperation: () => AssignOperation,
+    Assignment: () => Assignment,
+    Attribute: () => Attribute,
+    BitwiseBinaryOperation: () => BitwiseBinaryOperation,
+    BitwiseUnaryOperation: () => BitwiseUnaryOperation,
+    BooleanPrimitive: () => BooleanPrimitive,
+    Break: () => Break,
+    Call: () => Call,
+    Case: () => Case,
+    Catch: () => Catch,
+    CharPrimitive: () => CharPrimitive,
+    Class: () => Class,
+    ComparisonOperation: () => ComparisonOperation,
+    CompositionExpression: () => CompositionExpression,
+    ConsExpression: () => ConsExpression,
+    ConsPattern: () => ConsPattern,
+    ConstrainedType: () => ConstrainedType,
+    Constraint: () => Constraint,
+    Constructor: () => Constructor,
+    ConstructorPattern: () => ConstructorPattern,
+    Continue: () => Continue,
+    DataExpression: () => DataExpression,
+    EntryPoint: () => EntryPoint,
+    Enumeration: () => Enumeration,
+    Equality: () => Equality,
+    Equation: () => Equation,
+    Exist: () => Exist,
+    ExpressionTraverser: () => ExpressionTraverser,
+    Fact: () => Fact,
+    Failure: () => Failure,
+    Field: () => Field,
+    FieldExpression: () => FieldExpression,
+    Findall: () => Findall,
+    For: () => For,
+    ForLoop: () => ForLoop,
+    Forall: () => Forall,
+    Function: () => Function,
+    FunctorPattern: () => FunctorPattern,
+    Generator: () => Generator,
+    Goal: () => Goal,
+    Guard: () => Guard,
+    GuardedExpression: () => GuardedExpression,
+    If: () => If,
+    Implement: () => Implement,
+    Input: () => Input,
+    Instance: () => Instance,
+    Interface: () => Interface,
+    Lambda: () => Lambda,
+    LetInExpression: () => LetInExpression,
+    ListBinaryOperation: () => ListBinaryOperation,
+    ListComprehension: () => ListComprehension,
+    ListPattern: () => ListPattern,
+    ListPrimitive: () => ListPrimitive,
+    ListType: () => ListType,
+    ListUnaryOperation: () => ListUnaryOperation,
+    LiteralPattern: () => LiteralPattern,
+    LogicConstraint: () => LogicConstraint,
+    LogicalBinaryOperation: () => LogicalBinaryOperation,
+    LogicalUnaryOperation: () => LogicalUnaryOperation,
+    Method: () => Method,
+    NamedArgument: () => NamedArgument,
+    NativeBody: () => NativeBody,
+    New: () => New,
+    NilPrimitive: () => NilPrimitive,
+    Not: () => Not,
+    NumberPrimitive: () => NumberPrimitive,
+    Object: () => Object2,
+    OperationTraverser: () => OperationTraverser,
+    Otherwise: () => Otherwise,
+    ParameterizedType: () => ParameterizedType,
+    PatternTraverser: () => PatternTraverser,
+    PrimitiveMethod: () => PrimitiveMethod,
+    PrimitiveTraverser: () => PrimitiveTraverser,
+    Print: () => Print,
+    Procedure: () => Procedure,
+    Query: () => Query,
+    Raise: () => Raise,
+    RangeExpression: () => RangeExpression,
+    Record: () => Record,
+    Repeat: () => Repeat,
+    Return: () => Return,
+    Rule: () => Rule,
+    Self: () => Self,
+    Send: () => Send,
+    Sequence: () => Sequence,
+    SimpleType: () => SimpleType,
+    SourceLocation: () => SourceLocation,
+    StatementTraverser: () => StatementTraverser,
+    StopTraversalException: () => StopTraversalException,
+    StringOperation: () => StringOperation,
+    StringPrimitive: () => StringPrimitive,
+    Structure: () => Structure,
+    Super: () => Super,
+    Switch: () => Switch,
+    SymbolPrimitive: () => SymbolPrimitive,
+    Test: () => Test,
+    TestGroup: () => TestGroup,
+    TestingTraverser: () => TestingTraverser,
+    TraverseBase: () => TraverseBase,
+    TraverseVisitor: () => TraverseVisitor,
+    Truth: () => Truth,
+    Try: () => Try,
+    TupleExpression: () => TupleExpression,
+    TuplePattern: () => TuplePattern,
+    TupleType: () => TupleType,
+    TypeAlias: () => TypeAlias,
+    TypeApplication: () => TypeApplication,
+    TypeCast: () => TypeCast,
+    TypeClass: () => TypeClass,
+    TypeClassTraverser: () => TypeClassTraverser,
+    TypePattern: () => TypePattern,
+    TypeSignature: () => TypeSignature,
+    TypeTraverser: () => TypeTraverser,
+    TypeVar: () => TypeVar,
+    UnguardedBody: () => UnguardedBody,
+    UnifyOperation: () => UnifyOperation,
+    UnionPattern: () => UnionPattern,
+    Variable: () => Variable,
+    VariablePattern: () => VariablePattern,
+    While: () => While,
+    WildcardPattern: () => WildcardPattern,
+    Yield: () => Yield,
+    isPattern: () => isPattern,
+    isYukigoPrimitive: () => isYukigoPrimitive
+  });
+  var init_dist = __esm({
+    "../yukigo-ast/dist/index.js"() {
+      init_generics();
+      init_expressions();
+      init_statements();
+      init_primitives();
+      init_operators();
+      init_patterns();
+      init_types();
+      init_testing();
+      init_functional();
+      init_object();
+      init_imperative();
+      init_logic();
+      init_typeclasses();
+      init_visitor();
+    }
+  });
+
+  // ../../node_modules/nearley/lib/nearley.js
+  var require_nearley = __commonJS({
+    "../../node_modules/nearley/lib/nearley.js"(exports, module) {
+      (function(root, factory) {
+        if (typeof module === "object" && module.exports) {
+          module.exports = factory();
+        } else {
+          root.nearley = factory();
+        }
+      })(exports, function() {
+        function Rule2(name, symbols, postprocess) {
+          this.id = ++Rule2.highestId;
+          this.name = name;
+          this.symbols = symbols;
+          this.postprocess = postprocess;
+          return this;
+        }
+        Rule2.highestId = 0;
+        Rule2.prototype.toString = function(withCursorAt) {
+          var symbolSequence = typeof withCursorAt === "undefined" ? this.symbols.map(getSymbolShortDisplay).join(" ") : this.symbols.slice(0, withCursorAt).map(getSymbolShortDisplay).join(" ") + " \u25CF " + this.symbols.slice(withCursorAt).map(getSymbolShortDisplay).join(" ");
+          return this.name + " \u2192 " + symbolSequence;
+        };
+        function State(rule, dot, reference, wantedBy) {
+          this.rule = rule;
+          this.dot = dot;
+          this.reference = reference;
+          this.data = [];
+          this.wantedBy = wantedBy;
+          this.isComplete = this.dot === rule.symbols.length;
+        }
+        State.prototype.toString = function() {
+          return "{" + this.rule.toString(this.dot) + "}, from: " + (this.reference || 0);
+        };
+        State.prototype.nextState = function(child) {
+          var state = new State(this.rule, this.dot + 1, this.reference, this.wantedBy);
+          state.left = this;
+          state.right = child;
+          if (state.isComplete) {
+            state.data = state.build();
+            state.right = void 0;
+          }
+          return state;
+        };
+        State.prototype.build = function() {
+          var children = [];
+          var node = this;
+          do {
+            children.push(node.right.data);
+            node = node.left;
+          } while (node.left);
+          children.reverse();
+          return children;
+        };
+        State.prototype.finish = function() {
+          if (this.rule.postprocess) {
+            this.data = this.rule.postprocess(this.data, this.reference, Parser.fail);
+          }
+        };
+        function Column(grammar2, index) {
+          this.grammar = grammar2;
+          this.index = index;
+          this.states = [];
+          this.wants = {};
+          this.scannable = [];
+          this.completed = {};
+        }
+        Column.prototype.process = function(nextColumn) {
+          var states = this.states;
+          var wants = this.wants;
+          var completed = this.completed;
+          for (var w = 0; w < states.length; w++) {
+            var state = states[w];
+            if (state.isComplete) {
+              state.finish();
+              if (state.data !== Parser.fail) {
+                var wantedBy = state.wantedBy;
+                for (var i = wantedBy.length; i--; ) {
+                  var left = wantedBy[i];
+                  this.complete(left, state);
+                }
+                if (state.reference === this.index) {
+                  var exp = state.rule.name;
+                  (this.completed[exp] = this.completed[exp] || []).push(state);
+                }
+              }
+            } else {
+              var exp = state.rule.symbols[state.dot];
+              if (typeof exp !== "string") {
+                this.scannable.push(state);
+                continue;
+              }
+              if (wants[exp]) {
+                wants[exp].push(state);
+                if (completed.hasOwnProperty(exp)) {
+                  var nulls = completed[exp];
+                  for (var i = 0; i < nulls.length; i++) {
+                    var right = nulls[i];
+                    this.complete(state, right);
+                  }
+                }
+              } else {
+                wants[exp] = [state];
+                this.predict(exp);
+              }
+            }
+          }
+        };
+        Column.prototype.predict = function(exp) {
+          var rules = this.grammar.byName[exp] || [];
+          for (var i = 0; i < rules.length; i++) {
+            var r = rules[i];
+            var wantedBy = this.wants[exp];
+            var s = new State(r, 0, this.index, wantedBy);
+            this.states.push(s);
+          }
+        };
+        Column.prototype.complete = function(left, right) {
+          var copy = left.nextState(right);
+          this.states.push(copy);
+        };
+        function Grammar(rules, start) {
+          this.rules = rules;
+          this.start = start || this.rules[0].name;
+          var byName = this.byName = {};
+          this.rules.forEach(function(rule) {
+            if (!byName.hasOwnProperty(rule.name)) {
+              byName[rule.name] = [];
+            }
+            byName[rule.name].push(rule);
+          });
+        }
+        Grammar.fromCompiled = function(rules, start) {
+          var lexer = rules.Lexer;
+          if (rules.ParserStart) {
+            start = rules.ParserStart;
+            rules = rules.ParserRules;
+          }
+          var rules = rules.map(function(r) {
+            return new Rule2(r.name, r.symbols, r.postprocess);
+          });
+          var g = new Grammar(rules, start);
+          g.lexer = lexer;
+          return g;
+        };
+        function StreamLexer() {
+          this.reset("");
+        }
+        StreamLexer.prototype.reset = function(data, state) {
+          this.buffer = data;
+          this.index = 0;
+          this.line = state ? state.line : 1;
+          this.lastLineBreak = state ? -state.col : 0;
+        };
+        StreamLexer.prototype.next = function() {
+          if (this.index < this.buffer.length) {
+            var ch = this.buffer[this.index++];
+            if (ch === "\n") {
+              this.line += 1;
+              this.lastLineBreak = this.index;
+            }
+            return { value: ch };
+          }
+        };
+        StreamLexer.prototype.save = function() {
+          return {
+            line: this.line,
+            col: this.index - this.lastLineBreak
+          };
+        };
+        StreamLexer.prototype.formatError = function(token, message) {
+          var buffer = this.buffer;
+          if (typeof buffer === "string") {
+            var lines = buffer.split("\n").slice(
+              Math.max(0, this.line - 5),
+              this.line
+            );
+            var nextLineBreak = buffer.indexOf("\n", this.index);
+            if (nextLineBreak === -1) nextLineBreak = buffer.length;
+            var col = this.index - this.lastLineBreak;
+            var lastLineDigits = String(this.line).length;
+            message += " at line " + this.line + " col " + col + ":\n\n";
+            message += lines.map(function(line, i) {
+              return pad(this.line - lines.length + i + 1, lastLineDigits) + " " + line;
+            }, this).join("\n");
+            message += "\n" + pad("", lastLineDigits + col) + "^\n";
+            return message;
+          } else {
+            return message + " at index " + (this.index - 1);
+          }
+          function pad(n, length) {
+            var s = String(n);
+            return Array(length - s.length + 1).join(" ") + s;
+          }
+        };
+        function Parser(rules, start, options) {
+          if (rules instanceof Grammar) {
+            var grammar2 = rules;
+            var options = start;
+          } else {
+            var grammar2 = Grammar.fromCompiled(rules, start);
+          }
+          this.grammar = grammar2;
+          this.options = {
+            keepHistory: false,
+            lexer: grammar2.lexer || new StreamLexer()
+          };
+          for (var key in options || {}) {
+            this.options[key] = options[key];
+          }
+          this.lexer = this.options.lexer;
+          this.lexerState = void 0;
+          var column = new Column(grammar2, 0);
+          var table = this.table = [column];
+          column.wants[grammar2.start] = [];
+          column.predict(grammar2.start);
+          column.process();
+          this.current = 0;
+        }
+        Parser.fail = {};
+        Parser.prototype.feed = function(chunk) {
+          var lexer = this.lexer;
+          lexer.reset(chunk, this.lexerState);
+          var token;
+          while (true) {
+            try {
+              token = lexer.next();
+              if (!token) {
+                break;
+              }
+            } catch (e) {
+              var nextColumn = new Column(this.grammar, this.current + 1);
+              this.table.push(nextColumn);
+              var err = new Error(this.reportLexerError(e));
+              err.offset = this.current;
+              err.token = e.token;
+              throw err;
+            }
+            var column = this.table[this.current];
+            if (!this.options.keepHistory) {
+              delete this.table[this.current - 1];
+            }
+            var n = this.current + 1;
+            var nextColumn = new Column(this.grammar, n);
+            this.table.push(nextColumn);
+            var literal = token.text !== void 0 ? token.text : token.value;
+            var value = lexer.constructor === StreamLexer ? token.value : token;
+            var scannable = column.scannable;
+            for (var w = scannable.length; w--; ) {
+              var state = scannable[w];
+              var expect = state.rule.symbols[state.dot];
+              if (expect.test ? expect.test(value) : expect.type ? expect.type === token.type : expect.literal === literal) {
+                var next = state.nextState({ data: value, token, isToken: true, reference: n - 1 });
+                nextColumn.states.push(next);
+              }
+            }
+            nextColumn.process();
+            if (nextColumn.states.length === 0) {
+              var err = new Error(this.reportError(token));
+              err.offset = this.current;
+              err.token = token;
+              throw err;
+            }
+            if (this.options.keepHistory) {
+              column.lexerState = lexer.save();
+            }
+            this.current++;
+          }
+          if (column) {
+            this.lexerState = lexer.save();
+          }
+          this.results = this.finish();
+          return this;
+        };
+        Parser.prototype.reportLexerError = function(lexerError) {
+          var tokenDisplay, lexerMessage;
+          var token = lexerError.token;
+          if (token) {
+            tokenDisplay = "input " + JSON.stringify(token.text[0]) + " (lexer error)";
+            lexerMessage = this.lexer.formatError(token, "Syntax error");
+          } else {
+            tokenDisplay = "input (lexer error)";
+            lexerMessage = lexerError.message;
+          }
+          return this.reportErrorCommon(lexerMessage, tokenDisplay);
+        };
+        Parser.prototype.reportError = function(token) {
+          var tokenDisplay = (token.type ? token.type + " token: " : "") + JSON.stringify(token.value !== void 0 ? token.value : token);
+          var lexerMessage = this.lexer.formatError(token, "Syntax error");
+          return this.reportErrorCommon(lexerMessage, tokenDisplay);
+        };
+        Parser.prototype.reportErrorCommon = function(lexerMessage, tokenDisplay) {
+          var lines = [];
+          lines.push(lexerMessage);
+          var lastColumnIndex = this.table.length - 2;
+          var lastColumn = this.table[lastColumnIndex];
+          var expectantStates = lastColumn.states.filter(function(state) {
+            var nextSymbol = state.rule.symbols[state.dot];
+            return nextSymbol && typeof nextSymbol !== "string";
+          });
+          if (expectantStates.length === 0) {
+            lines.push("Unexpected " + tokenDisplay + ". I did not expect any more input. Here is the state of my parse table:\n");
+            this.displayStateStack(lastColumn.states, lines);
+          } else {
+            lines.push("Unexpected " + tokenDisplay + ". Instead, I was expecting to see one of the following:\n");
+            var stateStacks = expectantStates.map(function(state) {
+              return this.buildFirstStateStack(state, []) || [state];
+            }, this);
+            stateStacks.forEach(function(stateStack) {
+              var state = stateStack[0];
+              var nextSymbol = state.rule.symbols[state.dot];
+              var symbolDisplay = this.getSymbolDisplay(nextSymbol);
+              lines.push("A " + symbolDisplay + " based on:");
+              this.displayStateStack(stateStack, lines);
+            }, this);
+          }
+          lines.push("");
+          return lines.join("\n");
+        };
+        Parser.prototype.displayStateStack = function(stateStack, lines) {
+          var lastDisplay;
+          var sameDisplayCount = 0;
+          for (var j = 0; j < stateStack.length; j++) {
+            var state = stateStack[j];
+            var display = state.rule.toString(state.dot);
+            if (display === lastDisplay) {
+              sameDisplayCount++;
+            } else {
+              if (sameDisplayCount > 0) {
+                lines.push("    ^ " + sameDisplayCount + " more lines identical to this");
+              }
+              sameDisplayCount = 0;
+              lines.push("    " + display);
+            }
+            lastDisplay = display;
+          }
+        };
+        Parser.prototype.getSymbolDisplay = function(symbol) {
+          return getSymbolLongDisplay(symbol);
+        };
+        Parser.prototype.buildFirstStateStack = function(state, visited) {
+          if (visited.indexOf(state) !== -1) {
+            return null;
+          }
+          if (state.wantedBy.length === 0) {
+            return [state];
+          }
+          var prevState = state.wantedBy[0];
+          var childVisited = [state].concat(visited);
+          var childResult = this.buildFirstStateStack(prevState, childVisited);
+          if (childResult === null) {
+            return null;
+          }
+          return [state].concat(childResult);
+        };
+        Parser.prototype.save = function() {
+          var column = this.table[this.current];
+          column.lexerState = this.lexerState;
+          return column;
+        };
+        Parser.prototype.restore = function(column) {
+          var index = column.index;
+          this.current = index;
+          this.table[index] = column;
+          this.table.splice(index + 1);
+          this.lexerState = column.lexerState;
+          this.results = this.finish();
+        };
+        Parser.prototype.rewind = function(index) {
+          if (!this.options.keepHistory) {
+            throw new Error("set option `keepHistory` to enable rewinding");
+          }
+          this.restore(this.table[index]);
+        };
+        Parser.prototype.finish = function() {
+          var considerations = [];
+          var start = this.grammar.start;
+          var column = this.table[this.table.length - 1];
+          column.states.forEach(function(t) {
+            if (t.rule.name === start && t.dot === t.rule.symbols.length && t.reference === 0 && t.data !== Parser.fail) {
+              considerations.push(t);
+            }
+          });
+          return considerations.map(function(c) {
+            return c.data;
+          });
+        };
+        function getSymbolLongDisplay(symbol) {
+          var type = typeof symbol;
+          if (type === "string") {
+            return symbol;
+          } else if (type === "object") {
+            if (symbol.literal) {
+              return JSON.stringify(symbol.literal);
+            } else if (symbol instanceof RegExp) {
+              return "character matching " + symbol;
+            } else if (symbol.type) {
+              return symbol.type + " token";
+            } else if (symbol.test) {
+              return "token matching " + String(symbol.test);
+            } else {
+              throw new Error("Unknown symbol type: " + symbol);
+            }
+          }
+        }
+        function getSymbolShortDisplay(symbol) {
+          var type = typeof symbol;
+          if (type === "string") {
+            return symbol;
+          } else if (type === "object") {
+            if (symbol.literal) {
+              return JSON.stringify(symbol.literal);
+            } else if (symbol instanceof RegExp) {
+              return symbol.toString();
+            } else if (symbol.type) {
+              return "%" + symbol.type;
+            } else if (symbol.test) {
+              return "<" + String(symbol.test) + ">";
+            } else {
+              throw new Error("Unknown symbol type: " + symbol);
+            }
+          }
+        }
+        return {
+          Parser,
+          Grammar,
+          Rule: Rule2
+        };
+      });
+    }
+  });
+
+  // ../../node_modules/moo/moo.js
+  var require_moo = __commonJS({
+    "../../node_modules/moo/moo.js"(exports, module) {
+      (function(root, factory) {
+        if (typeof define === "function" && define.amd) {
+          define([], factory);
+        } else if (typeof module === "object" && module.exports) {
+          module.exports = factory();
+        } else {
+          root.moo = factory();
+        }
+      })(exports, function() {
+        "use strict";
+        var hasOwnProperty = Object.prototype.hasOwnProperty;
+        var toString = Object.prototype.toString;
+        var hasSticky = typeof new RegExp().sticky === "boolean";
+        function isRegExp(o) {
+          return o && toString.call(o) === "[object RegExp]";
+        }
+        function isObject(o) {
+          return o && typeof o === "object" && !isRegExp(o) && !Array.isArray(o);
+        }
+        function reEscape(s) {
+          return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, function(x) {
+            if (x === "-") return "\\x2d";
+            return "\\" + x;
+          });
+        }
+        function reGroups(s) {
+          var re = new RegExp("|" + s);
+          return re.exec("").length - 1;
+        }
+        function reCapture(s) {
+          return "(" + s + ")";
+        }
+        function reUnion(regexps) {
+          if (!regexps.length) return "(?!)";
+          var source = regexps.map(function(s) {
+            return "(?:" + s + ")";
+          }).join("|");
+          return "(?:" + source + ")";
+        }
+        function regexpOrLiteral(obj) {
+          if (typeof obj === "string") {
+            return "(?:" + reEscape(obj) + ")";
+          } else if (isRegExp(obj)) {
+            if (obj.ignoreCase) throw new Error("RegExp /i flag not allowed");
+            if (obj.global) throw new Error("RegExp /g flag is implied");
+            if (obj.sticky) throw new Error("RegExp /y flag is implied");
+            if (obj.multiline) throw new Error("RegExp /m flag is implied");
+            return obj.source;
+          } else {
+            throw new Error("Not a pattern: " + obj);
+          }
+        }
+        function pad(s, length) {
+          if (s.length > length) {
+            return s;
+          }
+          return Array(length - s.length + 1).join(" ") + s;
+        }
+        function lastNLines(string2, numLines) {
+          var position = string2.length;
+          var lineBreaks = 0;
+          while (true) {
+            var idx = string2.lastIndexOf("\n", position - 1);
+            if (idx === -1) {
+              break;
+            } else {
+              lineBreaks++;
+            }
+            position = idx;
+            if (lineBreaks === numLines) {
+              break;
+            }
+            if (position === 0) {
+              break;
+            }
+          }
+          var startPosition = lineBreaks < numLines ? 0 : position + 1;
+          return string2.substring(startPosition).split("\n");
+        }
+        function objectToRules(object) {
+          var keys = Object.getOwnPropertyNames(object);
+          var result = [];
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            var thing = object[key];
+            var rules = [].concat(thing);
+            if (key === "include") {
+              for (var j = 0; j < rules.length; j++) {
+                result.push({ include: rules[j] });
+              }
+              continue;
+            }
+            var match = [];
+            rules.forEach(function(rule) {
+              if (isObject(rule)) {
+                if (match.length) result.push(ruleOptions(key, match));
+                result.push(ruleOptions(key, rule));
+                match = [];
+              } else {
+                match.push(rule);
+              }
+            });
+            if (match.length) result.push(ruleOptions(key, match));
+          }
+          return result;
+        }
+        function arrayToRules(array) {
+          var result = [];
+          for (var i = 0; i < array.length; i++) {
+            var obj = array[i];
+            if (obj.include) {
+              var include = [].concat(obj.include);
+              for (var j = 0; j < include.length; j++) {
+                result.push({ include: include[j] });
+              }
+              continue;
+            }
+            if (!obj.type) {
+              throw new Error("Rule has no type: " + JSON.stringify(obj));
+            }
+            result.push(ruleOptions(obj.type, obj));
+          }
+          return result;
+        }
+        function ruleOptions(type, obj) {
+          if (!isObject(obj)) {
+            obj = { match: obj };
+          }
+          if (obj.include) {
+            throw new Error("Matching rules cannot also include states");
+          }
+          var options = {
+            defaultType: type,
+            lineBreaks: !!obj.error || !!obj.fallback,
+            pop: false,
+            next: null,
+            push: null,
+            error: false,
+            fallback: false,
+            value: null,
+            type: null,
+            shouldThrow: false
+          };
+          for (var key in obj) {
+            if (hasOwnProperty.call(obj, key)) {
+              options[key] = obj[key];
+            }
+          }
+          if (typeof options.type === "string" && type !== options.type) {
+            throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')");
+          }
+          var match = options.match;
+          options.match = Array.isArray(match) ? match : match ? [match] : [];
+          options.match.sort(function(a, b) {
+            return isRegExp(a) && isRegExp(b) ? 0 : isRegExp(b) ? -1 : isRegExp(a) ? 1 : b.length - a.length;
+          });
+          return options;
+        }
+        function toRules(spec) {
+          return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec);
+        }
+        var defaultErrorRule = ruleOptions("error", { lineBreaks: true, shouldThrow: true });
+        function compileRules(rules, hasStates) {
+          var errorRule = null;
+          var fast = /* @__PURE__ */ Object.create(null);
+          var fastAllowed = true;
+          var unicodeFlag = null;
+          var groups = [];
+          var parts = [];
+          for (var i = 0; i < rules.length; i++) {
+            if (rules[i].fallback) {
+              fastAllowed = false;
+            }
+          }
+          for (var i = 0; i < rules.length; i++) {
+            var options = rules[i];
+            if (options.include) {
+              throw new Error("Inheritance is not allowed in stateless lexers");
+            }
+            if (options.error || options.fallback) {
+              if (errorRule) {
+                if (!options.fallback === !errorRule.fallback) {
+                  throw new Error("Multiple " + (options.fallback ? "fallback" : "error") + " rules not allowed (for token '" + options.defaultType + "')");
+                } else {
+                  throw new Error("fallback and error are mutually exclusive (for token '" + options.defaultType + "')");
+                }
+              }
+              errorRule = options;
+            }
+            var match = options.match.slice();
+            if (fastAllowed) {
+              while (match.length && typeof match[0] === "string" && match[0].length === 1) {
+                var word = match.shift();
+                fast[word.charCodeAt(0)] = options;
+              }
+            }
+            if (options.pop || options.push || options.next) {
+              if (!hasStates) {
+                throw new Error("State-switching options are not allowed in stateless lexers (for token '" + options.defaultType + "')");
+              }
+              if (options.fallback) {
+                throw new Error("State-switching options are not allowed on fallback tokens (for token '" + options.defaultType + "')");
+              }
+            }
+            if (match.length === 0) {
+              continue;
+            }
+            fastAllowed = false;
+            groups.push(options);
+            for (var j = 0; j < match.length; j++) {
+              var obj = match[j];
+              if (!isRegExp(obj)) {
+                continue;
+              }
+              if (unicodeFlag === null) {
+                unicodeFlag = obj.unicode;
+              } else if (unicodeFlag !== obj.unicode && options.fallback === false) {
+                throw new Error("If one rule is /u then all must be");
+              }
+            }
+            var pat = reUnion(match.map(regexpOrLiteral));
+            var regexp = new RegExp(pat);
+            if (regexp.test("")) {
+              throw new Error("RegExp matches empty string: " + regexp);
+            }
+            var groupCount = reGroups(pat);
+            if (groupCount > 0) {
+              throw new Error("RegExp has capture groups: " + regexp + "\nUse (?: \u2026 ) instead");
+            }
+            if (!options.lineBreaks && regexp.test("\n")) {
+              throw new Error("Rule should declare lineBreaks: " + regexp);
+            }
+            parts.push(reCapture(pat));
+          }
+          var fallbackRule = errorRule && errorRule.fallback;
+          var flags = hasSticky && !fallbackRule ? "ym" : "gm";
+          var suffix = hasSticky || fallbackRule ? "" : "|";
+          if (unicodeFlag === true) flags += "u";
+          var combined = new RegExp(reUnion(parts) + suffix, flags);
+          return { regexp: combined, groups, fast, error: errorRule || defaultErrorRule };
+        }
+        function compile(rules) {
+          var result = compileRules(toRules(rules));
+          return new Lexer({ start: result }, "start");
+        }
+        function checkStateGroup(g, name, map) {
+          var state = g && (g.push || g.next);
+          if (state && !map[state]) {
+            throw new Error("Missing state '" + state + "' (in token '" + g.defaultType + "' of state '" + name + "')");
+          }
+          if (g && g.pop && +g.pop !== 1) {
+            throw new Error("pop must be 1 (in token '" + g.defaultType + "' of state '" + name + "')");
+          }
+        }
+        function compileStates(states, start) {
+          var all = states.$all ? toRules(states.$all) : [];
+          delete states.$all;
+          var keys = Object.getOwnPropertyNames(states);
+          if (!start) start = keys[0];
+          var ruleMap = /* @__PURE__ */ Object.create(null);
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            ruleMap[key] = toRules(states[key]).concat(all);
+          }
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            var rules = ruleMap[key];
+            var included = /* @__PURE__ */ Object.create(null);
+            for (var j = 0; j < rules.length; j++) {
+              var rule = rules[j];
+              if (!rule.include) continue;
+              var splice = [j, 1];
+              if (rule.include !== key && !included[rule.include]) {
+                included[rule.include] = true;
+                var newRules = ruleMap[rule.include];
+                if (!newRules) {
+                  throw new Error("Cannot include nonexistent state '" + rule.include + "' (in state '" + key + "')");
+                }
+                for (var k = 0; k < newRules.length; k++) {
+                  var newRule = newRules[k];
+                  if (rules.indexOf(newRule) !== -1) continue;
+                  splice.push(newRule);
+                }
+              }
+              rules.splice.apply(rules, splice);
+              j--;
+            }
+          }
+          var map = /* @__PURE__ */ Object.create(null);
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            map[key] = compileRules(ruleMap[key], true);
+          }
+          for (var i = 0; i < keys.length; i++) {
+            var name = keys[i];
+            var state = map[name];
+            var groups = state.groups;
+            for (var j = 0; j < groups.length; j++) {
+              checkStateGroup(groups[j], name, map);
+            }
+            var fastKeys = Object.getOwnPropertyNames(state.fast);
+            for (var j = 0; j < fastKeys.length; j++) {
+              checkStateGroup(state.fast[fastKeys[j]], name, map);
+            }
+          }
+          return new Lexer(map, start);
+        }
+        function keywordTransform(map) {
+          var isMap = typeof Map !== "undefined";
+          var reverseMap = isMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
+          var types = Object.getOwnPropertyNames(map);
+          for (var i = 0; i < types.length; i++) {
+            var tokenType = types[i];
+            var item = map[tokenType];
+            var keywordList = Array.isArray(item) ? item : [item];
+            keywordList.forEach(function(keyword) {
+              if (typeof keyword !== "string") {
+                throw new Error("keyword must be string (in keyword '" + tokenType + "')");
+              }
+              if (isMap) {
+                reverseMap.set(keyword, tokenType);
+              } else {
+                reverseMap[keyword] = tokenType;
+              }
+            });
+          }
+          return function(k) {
+            return isMap ? reverseMap.get(k) : reverseMap[k];
+          };
+        }
+        var Lexer = function(states, state) {
+          this.startState = state;
+          this.states = states;
+          this.buffer = "";
+          this.stack = [];
+          this.reset();
+        };
+        Lexer.prototype.reset = function(data, info) {
+          this.buffer = data || "";
+          this.index = 0;
+          this.line = info ? info.line : 1;
+          this.col = info ? info.col : 1;
+          this.queuedToken = info ? info.queuedToken : null;
+          this.queuedText = info ? info.queuedText : "";
+          this.queuedThrow = info ? info.queuedThrow : null;
+          this.setState(info ? info.state : this.startState);
+          this.stack = info && info.stack ? info.stack.slice() : [];
+          return this;
+        };
+        Lexer.prototype.save = function() {
+          return {
+            line: this.line,
+            col: this.col,
+            state: this.state,
+            stack: this.stack.slice(),
+            queuedToken: this.queuedToken,
+            queuedText: this.queuedText,
+            queuedThrow: this.queuedThrow
+          };
+        };
+        Lexer.prototype.setState = function(state) {
+          if (!state || this.state === state) return;
+          this.state = state;
+          var info = this.states[state];
+          this.groups = info.groups;
+          this.error = info.error;
+          this.re = info.regexp;
+          this.fast = info.fast;
+        };
+        Lexer.prototype.popState = function() {
+          this.setState(this.stack.pop());
+        };
+        Lexer.prototype.pushState = function(state) {
+          this.stack.push(this.state);
+          this.setState(state);
+        };
+        var eat = hasSticky ? function(re, buffer) {
+          return re.exec(buffer);
+        } : function(re, buffer) {
+          var match = re.exec(buffer);
+          if (match[0].length === 0) {
+            return null;
+          }
+          return match;
+        };
+        Lexer.prototype._getGroup = function(match) {
+          var groupCount = this.groups.length;
+          for (var i = 0; i < groupCount; i++) {
+            if (match[i + 1] !== void 0) {
+              return this.groups[i];
+            }
+          }
+          throw new Error("Cannot find token type for matched text");
+        };
+        function tokenToString() {
+          return this.value;
+        }
+        Lexer.prototype.next = function() {
+          var index = this.index;
+          if (this.queuedGroup) {
+            var token = this._token(this.queuedGroup, this.queuedText, index);
+            this.queuedGroup = null;
+            this.queuedText = "";
+            return token;
+          }
+          var buffer = this.buffer;
+          if (index === buffer.length) {
+            return;
+          }
+          var group = this.fast[buffer.charCodeAt(index)];
+          if (group) {
+            return this._token(group, buffer.charAt(index), index);
+          }
+          var re = this.re;
+          re.lastIndex = index;
+          var match = eat(re, buffer);
+          var error = this.error;
+          if (match == null) {
+            return this._token(error, buffer.slice(index, buffer.length), index);
+          }
+          var group = this._getGroup(match);
+          var text = match[0];
+          if (error.fallback && match.index !== index) {
+            this.queuedGroup = group;
+            this.queuedText = text;
+            return this._token(error, buffer.slice(index, match.index), index);
+          }
+          return this._token(group, text, index);
+        };
+        Lexer.prototype._token = function(group, text, offset) {
+          var lineBreaks = 0;
+          if (group.lineBreaks) {
+            var matchNL = /\n/g;
+            var nl = 1;
+            if (text === "\n") {
+              lineBreaks = 1;
+            } else {
+              while (matchNL.exec(text)) {
+                lineBreaks++;
+                nl = matchNL.lastIndex;
+              }
+            }
+          }
+          var token = {
+            type: typeof group.type === "function" && group.type(text) || group.defaultType,
+            value: typeof group.value === "function" ? group.value(text) : text,
+            text,
+            toString: tokenToString,
+            offset,
+            lineBreaks,
+            line: this.line,
+            col: this.col
+          };
+          var size = text.length;
+          this.index += size;
+          this.line += lineBreaks;
+          if (lineBreaks !== 0) {
+            this.col = size - nl + 1;
+          } else {
+            this.col += size;
+          }
+          if (group.shouldThrow) {
+            var err = new Error(this.formatError(token, "invalid syntax"));
+            throw err;
+          }
+          if (group.pop) this.popState();
+          else if (group.push) this.pushState(group.push);
+          else if (group.next) this.setState(group.next);
+          return token;
+        };
+        if (typeof Symbol !== "undefined" && Symbol.iterator) {
+          var LexerIterator = function(lexer) {
+            this.lexer = lexer;
+          };
+          LexerIterator.prototype.next = function() {
+            var token = this.lexer.next();
+            return { value: token, done: !token };
+          };
+          LexerIterator.prototype[Symbol.iterator] = function() {
+            return this;
+          };
+          Lexer.prototype[Symbol.iterator] = function() {
+            return new LexerIterator(this);
+          };
+        }
+        Lexer.prototype.formatError = function(token, message) {
+          if (token == null) {
+            var text = this.buffer.slice(this.index);
+            var token = {
+              text,
+              offset: this.index,
+              lineBreaks: text.indexOf("\n") === -1 ? 0 : 1,
+              line: this.line,
+              col: this.col
+            };
+          }
+          var numLinesAround = 2;
+          var firstDisplayedLine = Math.max(token.line - numLinesAround, 1);
+          var lastDisplayedLine = token.line + numLinesAround;
+          var lastLineDigits = String(lastDisplayedLine).length;
+          var displayedLines = lastNLines(
+            this.buffer,
+            this.line - token.line + numLinesAround + 1
+          ).slice(0, 5);
+          var errorLines = [];
+          errorLines.push(message + " at line " + token.line + " col " + token.col + ":");
+          errorLines.push("");
+          for (var i = 0; i < displayedLines.length; i++) {
+            var line = displayedLines[i];
+            var lineNo = firstDisplayedLine + i;
+            errorLines.push(pad(String(lineNo), lastLineDigits) + "  " + line);
+            if (lineNo === token.line) {
+              errorLines.push(pad("", lastLineDigits + token.col + 1) + "^");
+            }
+          }
+          return errorLines.join("\n");
+        };
+        Lexer.prototype.clone = function() {
+          return new Lexer(this.states, this.state);
+        };
+        Lexer.prototype.has = function(tokenType) {
+          return true;
+        };
+        return {
+          compile,
+          states: compileStates,
+          error: Object.freeze({ error: true }),
+          fallback: Object.freeze({ fallback: true }),
+          keywords: keywordTransform
+        };
+      });
+    }
+  });
+
+  // ../../node_modules/moo-ignore/index.js
+  var require_moo_ignore = __commonJS({
+    "../../node_modules/moo-ignore/index.js"(exports, module) {
+      var moo2 = require_moo();
+      function makeLexer2(tokens, ignoreTokens, options = {}) {
+        let lexer;
+        let oldnext;
+        let newTokens = {};
+        lexer = moo2.compile(tokens);
+        oldnext = lexer.next;
+        lexer.ignore = function(...types) {
+          if (this.ignoreSet) {
+            this.ignoreSet = /* @__PURE__ */ new Set([...this.ignoreSet, ...types]);
+          } else this.ignoreSet = new Set(types);
+        };
+        lexer.next = function() {
+          while (true) {
+            let token = oldnext.call(this);
+            if (token == void 0 || !this.ignoreSet.has(token.type)) {
+              return token;
+            }
+          }
+        };
+        if (options.eof) {
+          let oldReset = lexer.reset;
+          lexer.reset = function(input) {
+            if (tokens.EOF) input += tokens.EOF;
+            return oldReset.call(this, input);
+          };
+        }
+        if (ignoreTokens) {
+          lexer.ignoreSet = new Set(ignoreTokens);
+        }
+        return lexer;
+      }
+      module.exports = {
+        /**
+         * The lexer constructor
+         */
+        makeLexer: makeLexer2,
+        /**
+         * The moo object (as built in `const moo = require("moo")`)
+         */
+        moo: moo2
+      };
+    }
+  });
+
+  // src/parser/lexer.ts
+  var lexer_exports = {};
+  __export(lexer_exports, {
+    PrologLexer: () => PrologLexer,
+    PrologLexerConfig: () => PrologLexerConfig
+  });
+  var import_moo_ignore, import_moo, PrologLexerConfig, PrologLexer;
+  var init_lexer = __esm({
+    "src/parser/lexer.ts"() {
+      import_moo_ignore = __toESM(require_moo_ignore(), 1);
+      import_moo = __toESM(require_moo(), 1);
+      PrologLexerConfig = {
+        WS: /[ \t]+/,
+        wildcard: "_",
+        notOperator: { match: ["\\+", "not"] },
+        forallRule: "forall",
+        findallRule: "findall",
+        comment: /%.*|\/\*[\s\S]*?\*\//,
+        number: /\b(?:[0-9]+(?:\.[0-9]+(?:e[+-]?[0-9]+)?)?|0o[0-7]+|0x[0-9a-fA-F]+|0b[01]+)\b/,
+        string: /(?:'(?:[^']|'')*'|"(?:[^"]|"")*")/,
+        backtick: "`",
+        lparen: "(",
+        rparen: ")",
+        lbracket: "{",
+        rbracket: "}",
+        lsquare: "[",
+        rsquare: "]",
+        comma: ",",
+        arrow: "->",
+        period: ".",
+        semicolon: ";",
+        colonDash: ":-",
+        colon: ":",
+        consOp: "|",
+        queryOp: "?-",
+        comparisonOp: /@<|@=<|@>=|@>|<|=<|>=|>|=@=|\\=@=|=:=|=\\=|==|\\==|\\=|=/,
+        op: /\+|-|\*|\/|\/\/|~|\^|\?|\$|''|\.\./,
+        variable: /[A-Z][a-zA-Z0-9_\u00C0-\u00FF]*/,
+        atom: {
+          match: /[a-z!][a-zA-Z0-9_\u00C0-\u00FF]*/,
+          type: import_moo.default.keywords({
+            primitiveOperator: ["round", "abs", "sqrt", "call", "max", "assertion"],
+            testKeyword: ["test"]
+          })
+        },
+        NL: { match: /\r?\n/, lineBreaks: true }
+      };
+      PrologLexer = (0, import_moo_ignore.makeLexer)(PrologLexerConfig, ["comment", "NL"]);
+    }
+  });
+
+  // src/parser/grammar.cjs
+  var require_grammar = __commonJS({
+    "src/parser/grammar.cjs"(exports, module) {
+      (function() {
+        function id(x) {
+          return x[0];
+        }
+        const {
+          NumberPrimitive: NumberPrimitive2,
+          BooleanPrimitive: BooleanPrimitive2,
+          StringPrimitive: StringPrimitive2,
+          Rule: Rule2,
+          Fact: Fact2,
+          Query: Query2,
+          ListPrimitive: ListPrimitive2,
+          ConsExpression: ConsExpression2,
+          ArithmeticBinaryOperation: ArithmeticBinaryOperation2,
+          ArithmeticUnaryOperation: ArithmeticUnaryOperation2,
+          ComparisonOperation: ComparisonOperation2,
+          Exist: Exist2,
+          Not: Not2,
+          Findall: Findall2,
+          Sequence: Sequence2,
+          UnguardedBody: UnguardedBody2,
+          Equation: Equation2,
+          If: If2,
+          Call: Call2,
+          Forall: Forall2,
+          SymbolPrimitive: SymbolPrimitive2,
+          AssignOperation: AssignOperation2,
+          UnifyOperation: UnifyOperation2,
+          VariablePattern: VariablePattern2,
+          FunctorPattern: FunctorPattern2,
+          ConsPattern: ConsPattern2,
+          ListPattern: ListPattern2,
+          LogicConstraint: LogicConstraint2,
+          LiteralPattern: LiteralPattern2,
+          WildcardPattern: WildcardPattern2,
+          TuplePattern: TuplePattern2,
+          Test: Test2,
+          Assert: Assert2,
+          Truth: Truth2
+        } = (init_dist(), __toCommonJS(dist_exports));
+        const { PrologLexer: PrologLexer2 } = (init_lexer(), __toCommonJS(lexer_exports));
+        const asSequence = (d) => {
+          if (d instanceof Sequence2) return d;
+          if (Array.isArray(d)) return d.length === 1 ? d[0] : new Sequence2(d);
+          return new Sequence2([d]);
+        };
+        var grammar2 = {
+          Lexer: PrologLexer2,
+          ParserRules: [
+            { "name": "program$ebnf$1", "symbols": [] },
+            { "name": "program$ebnf$1$subexpression$1", "symbols": ["clause", "_"] },
+            { "name": "program$ebnf$1", "symbols": ["program$ebnf$1", "program$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {
+              return d[0].concat([d[1]]);
+            } },
+            { "name": "program", "symbols": ["_", "program$ebnf$1"], "postprocess": (d) => d[1].map((x) => x[0]).filter((x) => x !== null).flat(Infinity) },
+            { "name": "clause$subexpression$1", "symbols": ["fact"] },
+            { "name": "clause$subexpression$1", "symbols": ["rule"] },
+            { "name": "clause$subexpression$1", "symbols": ["query"] },
+            { "name": "clause$subexpression$1", "symbols": ["test_rule"] },
+            { "name": "clause", "symbols": ["clause$subexpression$1"], "postprocess": (d) => d[0][0] },
+            { "name": "fact$ebnf$1", "symbols": ["arguments"], "postprocess": id },
+            { "name": "fact$ebnf$1", "symbols": [], "postprocess": function(d) {
+              return null;
+            } },
+            { "name": "fact", "symbols": ["any_atom", "fact$ebnf$1", "_", PrologLexer2.has("period") ? { type: "period" } : period], "postprocess": (d) => new Fact2(d[0], d[1] ?? []) },
+            { "name": "rule", "symbols": ["any_atom", "equation", "_", PrologLexer2.has("period") ? { type: "period" } : period], "postprocess": (d) => new Rule2(d[0], [d[1]]) },
+            { "name": "test_rule$ebnf$1", "symbols": ["test_args"], "postprocess": id },
+            { "name": "test_rule$ebnf$1", "symbols": [], "postprocess": function(d) {
+              return null;
+            } },
+            { "name": "test_rule$subexpression$1", "symbols": [PrologLexer2.has("colonDash") ? { type: "colonDash" } : colonDash] },
+            { "name": "test_rule$subexpression$1", "symbols": [PrologLexer2.has("colon") ? { type: "colon" } : colon] },
+            { "name": "test_rule", "symbols": [PrologLexer2.has("testKeyword") ? { type: "testKeyword" } : testKeyword, PrologLexer2.has("lparen") ? { type: "lparen" } : lparen, "_", "structural_literal", "test_rule$ebnf$1", "_", PrologLexer2.has("rparen") ? { type: "rparen" } : rparen, "_", "test_rule$subexpression$1", "_", "body", "_", PrologLexer2.has("period") ? { type: "period" } : period], "postprocess": (d) => new Test2(d[3], new Sequence2(d[10]), d[4] ? [d[4]] : []) },
+            { "name": "test_args", "symbols": ["_", PrologLexer2.has("comma") ? { type: "comma" } : comma, "_", "pattern"], "postprocess": (d) => d[3] },
+            { "name": "equation$ebnf$1", "symbols": ["arguments"], "postprocess": id },
+            { "name": "equation$ebnf$1", "symbols": [], "postprocess": function(d) {
+              return null;
+            } },
+            { "name": "equation", "symbols": ["equation$ebnf$1", "_", PrologLexer2.has("colonDash") ? { type: "colonDash" } : colonDash, "_", "body"], "postprocess": (d) => new Equation2(d[0] || [], new UnguardedBody2(new Sequence2(d[4]))) },
+            { "name": "query", "symbols": [PrologLexer2.has("queryOp") ? { type: "queryOp" } : queryOp, "_", "body", "_", PrologLexer2.has("period") ? { type: "period" } : period], "postprocess": (d) => new Query2(d[2]) },
+            { "name": "body$ebnf$1", "symbols": [] },
+            { "name": "body$ebnf$1$subexpression$1$subexpression$1", "symbols": [PrologLexer2.has("comma") ? { type: "comma" } : comma] },
+            { "name": "body$ebnf$1$subexpression$1$subexpression$1", "symbols": [PrologLexer2.has("semicolon") ? { type: "semicolon" } : semicolon] },
+            { "name": "body$ebnf$1$subexpression$1", "symbols": ["_", "body$ebnf$1$subexpression$1$subexpression$1", "_", "expression"] },
+            { "name": "body$ebnf$1", "symbols": ["body$ebnf$1", "body$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {
+              return d[0].concat([d[1]]);
+            } },
+            { "name": "body", "symbols": ["expression", "body$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map((x) => x[3])] },
+            { "name": "expression$subexpression$1", "symbols": ["conditional"] },
+            { "name": "expression$subexpression$1", "symbols": ["forall"] },
+            { "name": "expression$subexpression$1", "symbols": ["findall"] },
+            { "name": "expression$subexpression$1", "symbols": ["unification"] },
+            { "name": "expression$subexpression$1", "symbols": ["assignment"] },
+            { "name": "expression$subexpression$1", "symbols": ["comparison"] },
+            { "name": "expression$subexpression$1", "symbols": ["not"] },
+            { "name": "expression$subexpression$1", "symbols": ["exist"] },
+            { "name": "expression$subexpression$1", "symbols": ["assertion"] },
+            { "name": "expression", "symbols": ["expression$subexpression$1"], "postprocess": (d) => d[0][0] },
+            { "name": "expression", "symbols": [{ "literal": "(" }, "_", "body", "_", { "literal": ")" }], "postprocess": (d) => new Sequence2(d[2]) },
+            {
+              "name": "conditional",
+              "symbols": [{ "literal": "(" }, "_", "body", "_", { "literal": "->" }, "_", "body", "_", PrologLexer2.has("semicolon") ? { type: "semicolon" } : semicolon, "_", "body", "_", { "literal": ")" }],
+              "postprocess": (d) => new If2(
+                asSequence(d[2]),
+                asSequence(d[6]),
+                asSequence(d[10])
+              )
+            },
+            { "name": "forall", "symbols": [PrologLexer2.has("forallRule") ? { type: "forallRule" } : forallRule, { "literal": "(" }, "_", "expression", "_", PrologLexer2.has("comma") ? { type: "comma" } : comma, "_", "expression", "_", { "literal": ")" }], "postprocess": (d) => new Forall2(d[3], d[7]) },
+            { "name": "findall", "symbols": [PrologLexer2.has("findallRule") ? { type: "findallRule" } : findallRule, { "literal": "(" }, "_", "pattern", "_", PrologLexer2.has("comma") ? { type: "comma" } : comma, "_", "expression", "_", PrologLexer2.has("comma") ? { type: "comma" } : comma, "_", "pattern", "_", { "literal": ")" }], "postprocess": (d) => new Findall2(d[3], d[7], d[11]) },
+            { "name": "not", "symbols": [{ "literal": "not" }, { "literal": "(" }, "_", "expression", "_", { "literal": ")" }], "postprocess": (d) => new Not2(asSequence(d[3])) },
+            { "name": "not", "symbols": [{ "literal": "\\+" }, "_", "expression"], "postprocess": (d) => new Not2(d[2]) },
+            { "name": "exist", "symbols": [{ "literal": "call" }, PrologLexer2.has("lparen") ? { type: "lparen" } : lparen, "_", "pattern_list", "_", PrologLexer2.has("rparen") ? { type: "rparen" } : rparen], "postprocess": (d) => {
+              const [callee, ...rest] = d[3];
+              return new Call2(callee.name, rest);
+            } },
+            { "name": "exist$ebnf$1", "symbols": ["arguments"], "postprocess": id },
+            { "name": "exist$ebnf$1", "symbols": [], "postprocess": function(d) {
+              return null;
+            } },
+            { "name": "exist", "symbols": ["any_atom", "exist$ebnf$1"], "postprocess": (d, l, reject) => {
+              const val = d[0].value;
+              if (["not", "\\+", "call", "assertion"].includes(val)) return reject;
+              return new Exist2(d[0], d[1] ?? []);
+            } },
+            { "name": "exist", "symbols": ["variable"], "postprocess": (d) => new Exist2(d[0], []) },
+            {
+              "name": "assertion",
+              "symbols": [{ "literal": "assertion" }, PrologLexer2.has("lparen") ? { type: "lparen" } : lparen, "_", "expression", "_", PrologLexer2.has("rparen") ? { type: "rparen" } : rparen],
+              "postprocess": (d) => new Assert2(new BooleanPrimitive2(false), new Truth2(asSequence(d[3])))
+            },
+            {
+              "name": "assignment",
+              "symbols": ["addition", "_", { "literal": "is" }, "_", "addition"],
+              "postprocess": (d) => new LogicConstraint2(new AssignOperation2("Assign", d[0], d[4]))
+            },
+            { "name": "unification", "symbols": ["addition", "_", { "literal": "=" }, "_", "addition"], "postprocess": (d) => new LogicConstraint2(new UnifyOperation2("Unify", d[0], d[4])) },
+            {
+              "name": "comparison",
+              "symbols": ["addition", "_", "comparison_op", "_", "addition"],
+              "postprocess": (d) => new LogicConstraint2(new ComparisonOperation2(d[2], d[0], d[4]))
+            },
+            { "name": "addition", "symbols": ["multiplication", "_", { "literal": "+" }, "_", "addition"], "postprocess": (d) => new ArithmeticBinaryOperation2("Plus", d[0], d[4]) },
+            { "name": "addition", "symbols": ["multiplication", "_", { "literal": "-" }, "_", "addition"], "postprocess": (d) => new ArithmeticBinaryOperation2("Minus", d[0], d[4]) },
+            { "name": "addition", "symbols": ["multiplication"], "postprocess": id },
+            { "name": "multiplication", "symbols": ["primary", "_", { "literal": "*" }, "_", "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation2("Multiply", d[0], d[4]) },
+            { "name": "multiplication", "symbols": ["primary", "_", { "literal": "/" }, "_", "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation2("Divide", d[0], d[4]) },
+            { "name": "multiplication", "symbols": ["primary"], "postprocess": id },
+            { "name": "primary", "symbols": ["arithmetic_literal"], "postprocess": id },
+            { "name": "primary", "symbols": ["variable"], "postprocess": id },
+            { "name": "primary", "symbols": [{ "literal": "-" }, "_", "primary"], "postprocess": (d) => new ArithmeticUnaryOperation2("Negation", d[2]) },
+            { "name": "primary", "symbols": ["strict_atom", "arguments"], "postprocess": (d, l, reject) => {
+              const val = d[0].value;
+              if (["abs", "round", "sqrt", "max", "assertion"].includes(val)) return reject;
+              return new Exist2(d[0], d[1] ?? []);
+            } },
+            { "name": "primary", "symbols": ["primitiveOperation"], "postprocess": id },
+            { "name": "primary", "symbols": ["cons_expr"], "postprocess": id },
+            { "name": "primary", "symbols": ["list_expr"], "postprocess": id },
+            { "name": "primary", "symbols": [{ "literal": "(" }, "_", "addition", "_", { "literal": ")" }], "postprocess": (d) => d[2] },
+            { "name": "list_expr$ebnf$1", "symbols": ["primary_list"], "postprocess": id },
+            { "name": "list_expr$ebnf$1", "symbols": [], "postprocess": function(d) {
+              return null;
+            } },
+            { "name": "list_expr", "symbols": [{ "literal": "[" }, "_", "list_expr$ebnf$1", "_", { "literal": "]" }], "postprocess": (d) => new ListPrimitive2(d[2] || []) },
+            { "name": "cons_expr", "symbols": [{ "literal": "[" }, "_", "primary_list", "_", PrologLexer2.has("consOp") ? { type: "consOp" } : consOp, "_", "addition", "_", { "literal": "]" }], "postprocess": (d) => {
+              const heads = d[2];
+              const tail = d[6];
+              let current = tail;
+              for (let i = heads.length - 1; i >= 0; i--) {
+                current = new ConsExpression2(heads[i], current);
+              }
+              return current;
+            } },
+            { "name": "primitiveOperation", "symbols": [{ "literal": "round" }, "__", "addition"], "postprocess": (d) => new ArithmeticUnaryOperation2("Round", d[2]) },
+            { "name": "primitiveOperation", "symbols": [{ "literal": "abs" }, "__", "addition"], "postprocess": (d) => new ArithmeticUnaryOperation2("Absolute", d[2]) },
+            { "name": "primitiveOperation", "symbols": [{ "literal": "sqrt" }, "__", "addition"], "postprocess": (d) => new ArithmeticUnaryOperation2("Sqrt", d[2]) },
+            { "name": "primitiveOperation", "symbols": [{ "literal": "max" }, { "literal": "(" }, "_", "addition", "_", { "literal": "," }, "_", "addition", "_", { "literal": ")" }], "postprocess": (d) => new ArithmeticBinaryOperation2("Max", d[3], d[7]) },
+            { "name": "primitiveArguments", "symbols": [PrologLexer2.has("lparen") ? { type: "lparen" } : lparen, "_", "primary_list", "_", PrologLexer2.has("rparen") ? { type: "rparen" } : rparen], "postprocess": (d) => d[2] },
+            { "name": "primary_list$ebnf$1", "symbols": [] },
+            { "name": "primary_list$ebnf$1$subexpression$1", "symbols": ["_", PrologLexer2.has("comma") ? { type: "comma" } : comma, "_", "addition"] },
+            { "name": "primary_list$ebnf$1", "symbols": ["primary_list$ebnf$1", "primary_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {
+              return d[0].concat([d[1]]);
+            } },
+            { "name": "primary_list", "symbols": ["addition", "primary_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map((x) => x[3])] },
+            { "name": "arguments", "symbols": [PrologLexer2.has("lparen") ? { type: "lparen" } : lparen, "_", "pattern_list", "_", PrologLexer2.has("rparen") ? { type: "rparen" } : rparen], "postprocess": (d) => d[2] },
+            { "name": "pattern_list$ebnf$1", "symbols": [] },
+            { "name": "pattern_list$ebnf$1$subexpression$1", "symbols": ["_", PrologLexer2.has("comma") ? { type: "comma" } : comma, "_", "pattern"] },
+            { "name": "pattern_list$ebnf$1", "symbols": ["pattern_list$ebnf$1", "pattern_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {
+              return d[0].concat([d[1]]);
+            } },
+            { "name": "pattern_list", "symbols": ["pattern", "pattern_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map((x) => x[3])] },
+            { "name": "pattern", "symbols": ["infix_pattern"], "postprocess": id },
+            { "name": "pattern", "symbols": ["primary_pattern"], "postprocess": id },
+            { "name": "primary_pattern", "symbols": ["variable"], "postprocess": (d) => new VariablePattern2(d[0]) },
+            { "name": "primary_pattern", "symbols": ["structural_literal"], "postprocess": (d) => new LiteralPattern2(d[0]) },
+            { "name": "primary_pattern", "symbols": [PrologLexer2.has("wildcard") ? { type: "wildcard" } : wildcard], "postprocess": (d) => new WildcardPattern2() },
+            { "name": "primary_pattern", "symbols": ["any_atom", "arguments"], "postprocess": (d) => new FunctorPattern2(d[0], d[1]) },
+            { "name": "primary_pattern", "symbols": [{ "literal": "(" }, "_", "pattern_list", "_", { "literal": ")" }], "postprocess": (d) => new TuplePattern2(d[2]) },
+            { "name": "primary_pattern", "symbols": [{ "literal": "[" }, "_", "pattern_list", "_", PrologLexer2.has("consOp") ? { type: "consOp" } : consOp, "_", "pattern", "_", { "literal": "]" }], "postprocess": (d) => {
+              const heads = d[2];
+              const tail = d[6];
+              let current = tail;
+              for (let i = heads.length - 1; i >= 0; i--) {
+                current = new ConsPattern2(heads[i], current);
+              }
+              return current;
+            } },
+            { "name": "primary_pattern$ebnf$1", "symbols": ["pattern_list"], "postprocess": id },
+            { "name": "primary_pattern$ebnf$1", "symbols": [], "postprocess": function(d) {
+              return null;
+            } },
+            { "name": "primary_pattern", "symbols": [{ "literal": "[" }, "_", "primary_pattern$ebnf$1", "_", { "literal": "]" }], "postprocess": (d) => new ListPattern2(d[2] ? d[2] : []) },
+            { "name": "infix_pattern", "symbols": ["primary_pattern", "_", "any_atom", "_", "pattern"], "postprocess": (d) => new FunctorPattern2(d[2], [d[0], d[4]]) },
+            { "name": "variable", "symbols": [PrologLexer2.has("variable") ? { type: "variable" } : variable], "postprocess": (d) => new SymbolPrimitive2(d[0].value) },
+            { "name": "strict_atom", "symbols": [PrologLexer2.has("atom") ? { type: "atom" } : atom], "postprocess": (d) => new SymbolPrimitive2(d[0].value) },
+            { "name": "strict_atom", "symbols": [PrologLexer2.has("primitiveOperator") ? { type: "primitiveOperator" } : primitiveOperator], "postprocess": (d) => new SymbolPrimitive2(d[0].value) },
+            { "name": "any_atom", "symbols": ["strict_atom"], "postprocess": id },
+            { "name": "any_atom$subexpression$1", "symbols": [PrologLexer2.has("op") ? { type: "op" } : op] },
+            { "name": "any_atom$subexpression$1", "symbols": [PrologLexer2.has("comparisonOp") ? { type: "comparisonOp" } : comparisonOp] },
+            { "name": "any_atom", "symbols": ["any_atom$subexpression$1"], "postprocess": (d) => new SymbolPrimitive2(d[0][0].value) },
+            { "name": "arithmetic_literal", "symbols": ["strict_atom"], "postprocess": id },
+            { "name": "arithmetic_literal", "symbols": [PrologLexer2.has("number") ? { type: "number" } : number], "postprocess": (d) => new NumberPrimitive2(Number(d[0].value)) },
+            { "name": "arithmetic_literal", "symbols": [PrologLexer2.has("string") ? { type: "string" } : string], "postprocess": (d) => new StringPrimitive2(d[0].value) },
+            { "name": "structural_literal", "symbols": ["any_atom"], "postprocess": id },
+            { "name": "structural_literal", "symbols": [PrologLexer2.has("number") ? { type: "number" } : number], "postprocess": (d) => new NumberPrimitive2(Number(d[0].value)) },
+            { "name": "structural_literal", "symbols": [PrologLexer2.has("string") ? { type: "string" } : string], "postprocess": (d) => new StringPrimitive2(d[0].value) },
+            { "name": "comparison_op", "symbols": [{ "literal": "=:=" }], "postprocess": (d) => "Equal" },
+            { "name": "comparison_op", "symbols": [{ "literal": "=\\=" }], "postprocess": (d) => "NotEqual" },
+            { "name": "comparison_op", "symbols": [{ "literal": "==" }], "postprocess": (d) => "Same" },
+            { "name": "comparison_op", "symbols": [{ "literal": "\\==" }], "postprocess": (d) => "NotSame" },
+            { "name": "comparison_op", "symbols": [{ "literal": "\\=" }], "postprocess": (d) => "NotSame" },
+            { "name": "comparison_op", "symbols": [{ "literal": "@<" }], "postprocess": (d) => "LessThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": "@=<" }], "postprocess": (d) => "LessOrEqualThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": "@>" }], "postprocess": (d) => "GreaterThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": "@>=" }], "postprocess": (d) => "GreaterOrEqualThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": "<" }], "postprocess": (d) => "LessThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": "=<" }], "postprocess": (d) => "LessOrEqualThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": ">" }], "postprocess": (d) => "GreaterThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": ">=" }], "postprocess": (d) => "GreaterOrEqualThan" },
+            { "name": "comparison_op", "symbols": [{ "literal": "=@=" }], "postprocess": (d) => "Same" },
+            { "name": "comparison_op", "symbols": [{ "literal": "\\=@=" }], "postprocess": (d) => "NotSame" },
+            { "name": "_$ebnf$1", "symbols": [] },
+            { "name": "_$ebnf$1", "symbols": ["_$ebnf$1", PrologLexer2.has("WS") ? { type: "WS" } : WS], "postprocess": function arrpush(d) {
+              return d[0].concat([d[1]]);
+            } },
+            { "name": "_", "symbols": ["_$ebnf$1"] },
+            { "name": "__$ebnf$1", "symbols": [PrologLexer2.has("WS") ? { type: "WS" } : WS], "postprocess": id },
+            { "name": "__$ebnf$1", "symbols": [], "postprocess": function(d) {
+              return null;
+            } },
+            { "name": "__", "symbols": ["__$ebnf$1"] }
+          ],
+          ParserStart: "program"
+        };
+        if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
+          module.exports = grammar2;
+        } else {
+          window.grammar = grammar2;
+        }
+      })();
+    }
+  });
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    YukigoPrologParser: () => YukigoPrologParser,
+    groupRuleDeclarations: () => groupRuleDeclarations
+  });
+  init_dist();
+  var import_nearley = __toESM(require_nearley(), 1);
+  var import_grammar = __toESM(require_grammar(), 1);
+
+  // src/std.ts
+  var stdCode = `
+% between(+Low, +High, ?Value)
+% True if Low =< Value =< High (assuming integers)
+between(Low, High, Low) :- Low =< High.
+between(Low, High, Value) :-
+    Low < High,
+    NextLow is Low + 1,
+    between(NextLow, High, Value).
+
+% union(+List1, +List2, -Union)
+% Union of two lists without duplicates (order not preserved)
+union([], L, L).
+union([H|T], L2, Union) :-
+    (   member(H, L2)
+    ->  union(T, L2, Union)
+    ;   Union = [H|Rest],
+        union(T, L2, Rest)
+    ).
+
+% intersection(+List1, +List2, -Intersection)
+intersection([], _, []).
+intersection([H|T], L2, [H|Rest]) :-
+    member(H, L2),
+    !,
+    intersection(T, L2, Rest).
+intersection([_|T], L2, Rest) :-
+    intersection(T, L2, Rest).
+
+% max_member(-Max, +List)
+max_member(Max, [Max]) :- !.
+max_member(Max, [H|T]) :-
+    max_member(M, T),
+    (   H > M
+    ->  Max = H
+    ;   Max = M
+    ).
+
+% min_member(-Min, +List)
+min_member(Min, [Min]) :- !.
+min_member(Min, [H|T]) :-
+    min_member(M, T),
+    (   H < M
+    ->  Min = H
+    ;   Min = M
+    ).
+
+% sumlist(+List, -Sum)
+sumlist([], 0).
+sumlist([H|T], Sum) :-
+    sumlist(T, RestSum),
+    Sum is H + RestSum.
+
+% length(?List, ?Length)
+length([], 0).
+length([_|Tail], N) :-
+    length(Tail, M),
+    N is M + 1.
+
+% flatten(+NestedList, -FlatList)
+flatten([], []).
+flatten([H|T], Flat) :-
+    !,
+    flatten(H, FlatH),
+    flatten(T, FlatT),
+    append(FlatH, FlatT, Flat).
+flatten(X, [X]).
+
+% reverse(+List, -Reversed)
+reverse(List, Reversed) :-
+    reverse_acc(List, [], Reversed).
+
+reverse_acc([], Acc, Acc).
+reverse_acc([H|T], Acc, Reversed) :-
+    reverse_acc(T, [H|Acc], Reversed).
+
+% list_to_set(+List, -Set)
+% Removes duplicates, keeps first occurrence
+list_to_set([], []).
+list_to_set([H|T], [H|Rest]) :-
+    exclude(==(H), T, T1),
+    list_to_set(T1, Rest).
+
+==(H, T) :-
+    H == T.
+
+% nth0(?Index, ?List, ?Elem)
+% Index starts at 0
+nth0(0, [H|_], H).
+nth0(N, [_|T], Elem) :-
+    N > 0,
+    N1 is N - 1,
+    nth0(N1, T, Elem).
+
+% nth1(?Index, ?List, ?Elem)
+% Index starts at 1
+nth1(1, [H|_], H).
+nth1(N, [_|T], Elem) :-
+    N > 1,
+    N1 is N - 1,
+    nth1(N1, T, Elem).
+
+% append/3 (needed for flatten and union)
+append([], L, L).
+append([H|T], L, [H|R]) :-
+    append(T, L, R).
+
+% member/2 (needed for many predicates)
+member(H, [H|_]).
+member(H, [_|T]) :-
+    member(H, T).
+
+% exclude(+Pred, +List, -Filtered)
+% Removes elements satisfying Pred
+exclude(_, [], []).
+exclude(Pred, [H|T], Rest) :-
+    (   call(Pred, H)
+    ->  exclude(Pred, T, Rest)
+    ;   Rest = [H|Rest2],
+        exclude(Pred, T, Rest2)
+    ).
+
+% Arithmetic predicates
+abs(X, Y) :- Y is abs(X).
+round(X, Y) :- Y is round(X).
+sqrt(X, Y) :- Y is sqrt(X).
+
+
+max_list([X], X).
+max_list([H|T], Max) :-
+    max_list(T, MaxTail),
+    Max is max(H, MaxTail).
+`;
+
+  // src/index.ts
+  var UnexpectedToken = class extends Error {
+    constructor(token) {
+      super(
+        `Parser: Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`
+      );
+    }
+  };
+  var AmbiguityError = class extends Error {
+    constructor(amountAST) {
+      super(
+        `Parser: Too much ambiguity. ${amountAST} ASTs parsed. Output not generated.`
+      );
+    }
+  };
+  var YukigoPrologParser = class {
+    errors = [];
+    std;
+    constructor(std = stdCode) {
+      this.errors = [];
+      this.std = this.feedParser(std);
+    }
+    parse(code) {
+      const result = this.feedParser(code);
+      const ast = groupRuleDeclarations(this.std.concat(result));
+      return ast;
+    }
+    parseExpression(code) {
+      const expr = this.feedParser(code)[0];
+      return expr;
+    }
+    feedParser(code) {
+      const parser = new import_nearley.default.Parser(
+        import_nearley.default.Grammar.fromCompiled(import_grammar.default)
+      );
+      try {
+        parser.feed(code);
+        parser.finish();
+      } catch (e) {
+        const error = e;
+        if (error.token) {
+          throw new UnexpectedToken(error.token);
+        }
+        throw error;
+      }
+      const { results } = parser;
+      if (results.length > 1) throw new AmbiguityError(results.length);
+      if (results.length == 0) return [];
+      return results[0];
+    }
+  };
+  function groupRuleDeclarations(ast) {
+    const groups = {};
+    const others = [];
+    for (const node of ast) {
+      if (node instanceof Rule) {
+        const name = node.identifier.value;
+        if (!groups[name]) {
+          groups[name] = [];
+        }
+        groups[name].push(node);
+      } else {
+        others.push(node);
+      }
+    }
+    const ruleGroups = Object.values(groups).map((rules) => {
+      const identifier = rules[0].identifier;
+      const allEquations = rules.flatMap((r) => r.equations);
+      return new Rule(identifier, allEquations, identifier.loc);
+    });
+    return [...others, ...ruleGroups];
+  }
+  return __toCommonJS(index_exports);
+})();