cubing 0.23.0 → 0.24.0-pre1

package/src/cubing/alg/test/alg.spec.ts

@@ -1,348 +0,0 @@
-import { Alg } from "../Alg";
-import { setAlgPartTypeMismatchReportingLevel } from "../debug";
-import { Example as Ex } from "../example";
-import { Commutator, Grouping, Move, QuantumMove, Pause } from "../units";
-import "./alg-comparison";
-
-setAlgPartTypeMismatchReportingLevel("error");
-
-const UU = new Alg([new Move("U", 1), new Move("U", 1)]);
-const U2 = new Alg([new Move("U", 2)]);
-
-describe("Alg", () => {
-  it("allows an empty Alg", () => {
-    expect(() => new Alg()).not.toThrow();
-    expect(() => new Alg([])).not.toThrow();
-    expect(() => new Commutator(new Alg(), new Alg([]))).not.toThrow();
-  });
-
-  it("throws an error for a nested Alg", () => {
-    expect(() => new Alg([new Alg([new Move("R", 1)])])).toThrowError(
-      /An alg can only contain units./,
-    );
-  });
-});
-
-describe("BlockMove", () => {
-  it("allows constructing: x, U, u", () => {
-    expect(new Move("x", 1).toString()).toBe("x");
-    expect(new Move("U", 1).toString()).toBe("U");
-    expect(new Move("u", 1).toString()).toBe("u");
-  });
-
-  it("allows constructing: 2U, 2u", () => {
-    expect(new Move(new QuantumMove("U", 2), 1).toString()).toBe("2U");
-    expect(new Move("2U", 1).toString()).toBe("2U");
-    expect(new Move(new QuantumMove("u", 2), 1).toString()).toBe("2u");
-    expect(new Move("2u", 1).toString()).toBe("2u");
-  });
-
-  it("prevents constructing: [-2]U, [-2]u", () => {
-    expect(() => new QuantumMove("U", -2)).toThrowError(
-      /QuantumMove inner layer must be a positive integer/,
-    );
-  });
-
-  it("allows constructing: 2-3u", () => {
-    expect(new Move(new QuantumMove("u", 3, 2), 1).toString()).toBe("2-3u");
-  });
-
-  it("prevents constructing: 2-3x, 2-3U, [-2]-3u, 4-3u", () => {
-    // expect(() =>
-    //   validateSiGNMoves(new Alg([new Move(new QuantumMove("x",  3, 2, 1)])),
-    // ).toThrowError(/cannot have an outer and inner layer/);
-    // expect(() =>
-    //   validateSiGNMoves(new Alg([new Move(new QuantumMove("U",  3, 2, 1)])),
-    // ).toThrowError(/cannot have an outer and inner layer/);
-    // expect(() =>
-    //   validateSiGNMoves(new Alg([new Move(new QuantumMove("u", 3, -2), 1)])),
-    // ).toThrowError(/Cannot have an outer layer of 0 or less/);
-    // expect(() =>
-    //   validateSiGNMoves(new Alg([new Move(new QuantumMove("u", 3, 4), 1)])),
-    // ).toThrowError(/The outer layer must be less than the inner layer/);
-  });
-
-  it("prevents constructing: w, 2T, 2-3q", () => {
-    // expect(() =>algPartToStringForTesting(new Move("w", 1))).toThrowError(/Invalid SiGN plain move family: w/);
-    // expect(() =>algPartToStringForTesting(new Move(new QuantumMove("T", 2), 1))).toThrowError(/The provided SiGN move family is invalid, or cannot have an inner slice: T/);
-    // expect(() =>algPartToStringForTesting(new Move(new QuantumMove("q",  3, 2, 1))).toThrowError(/The provided SiGN move family is invalid, or cannot have an outer and inner layer: q/);
-  });
-
-  it("supports a default amount of 1.", () => {
-    expect(new Alg([new Move("U")])).toBeIdentical(new Alg([new Move("U", 1)]));
-  });
-
-  it("throws an error for an invalid family", () => {
-    // expect(() => new Move("Q", 1)).toThrowError(/Invalid SiGN plain move family/);
-  });
-
-  it("has a default amount of 1", () => {
-    expect(new Move("x").amount).toBe(1);
-    expect(new Move("R").amount).toBe(1);
-    expect(new Move("u").amount).toBe(1);
-    expect(new Move(new QuantumMove("R", 2)).amount).toBe(1);
-    expect(new Move(new QuantumMove("u", 3)).amount).toBe(1);
-    expect(new Move(new QuantumMove("u", 3, 2)).amount).toBe(1);
-  });
-
-  it("allows different amounts 1", () => {
-    expect(new Move("x", 2).amount).toBe(2);
-    expect(new Move("R", 3).amount).toBe(3);
-    expect(new Move("u", -5).amount).toBe(-5);
-    expect(new Move(new QuantumMove("R", 2), 10).amount).toBe(10);
-    expect(new Move(new QuantumMove("L", 3), -13).amount).toBe(-13);
-    expect(new Move(new QuantumMove("u", 12, 2), 15).amount).toBe(15);
-  });
-
-  it("catches invalid moves with parseSiGN().", () => {
-    // expect(() => parseSiGN("R")).not.toThrowError();
-    // expect(() => parseSiGN("g")).toThrowError(/Invalid SiGN plain move family/);
-    // expect(() => parseSiGN("2Ww")).toThrowError(
-    //   /The provided SiGN move family is invalid/,
-    // );
-    // expect(() => parseSiGN("2-3T")).toThrowError(
-    //   /The provided SiGN move family is invalid/,
-    // );
-    // expect(() => parseSiGN("2-3UF")).toThrowError(
-    //   /The provided SiGN move family is invalid/,
-    // );
-    // expect(() => parseSiGN("4TEST_Hello")).toThrowError(
-    //   /The provided SiGN move family is invalid/,
-    // );
-    // expect(() => parseSiGN("_R")).toThrowError(
-    //   /Invalid SiGN plain move family/,
-    // );
-  });
-
-  it("prevents construction a move quantum with only outer layer", () => {
-    expect(() => new QuantumMove("R", undefined, 1)).toThrow();
-  });
-});
-
-describe("algToString()", () => {
-  it("converts all move types correctly", () => {
-    expect(new Move("x", 2).toString()).toBe("x2");
-    expect(new Move("R", 3).toString()).toBe("R3");
-    expect(new Move("u", -5).toString()).toBe("u5'");
-    expect(new Move(new QuantumMove("R", 2), 10).toString()).toBe("2R10");
-    expect(new Move(new QuantumMove("L", 3), -13).toString()).toBe("3L13'");
-    expect(new Move(new QuantumMove("u", 12, 2), 15).toString()).toBe(
-      "2-12u15",
-    );
-  });
-
-  it("distinguishes between 1R and R", () => {
-    expect(new Move(new QuantumMove("R", 1)).toString()).toBe("1R");
-    expect(new Move("R").toString()).toBe("R");
-  });
-
-  it("handles empty Algs", () => {
-    expect(new Alg().toString()).toBe("");
-    expect(new Alg([]).toString()).toBe("");
-    expect(new Grouping(new Alg([])).toString()).toBe("()");
-    // TODO: Should this be "[,]"
-    expect(new Alg([new Commutator(new Alg([]), new Alg([]))]).toString()).toBe(
-      "[, ]",
-    );
-  });
-
-  it("converts Sune to string", () => {
-    expect(Ex.Sune.toString()).toBe("R U R' U R U2' R'");
-  });
-
-  it("converts U U to string", () => {
-    expect(UU.toString()).toBe("U U");
-  });
-
-  it("converts E-Perm to string", () => {
-    expect(Ex.EPerm.toString()).toBe("x' [[R: U'], D] [[R: U], D] x");
-  });
-
-  it("converts triple pause to . . . (with spaces)", () => {
-    expect(Ex.TriplePause.toString()).toBe(". . .");
-  });
-});
-
-describe("invert()", () => {
-  it("correctly inverts", () => {
-    expect(Ex.Sune.invert()).toBeIdentical(Ex.AntiSune);
-    expect(Ex.Sune.invert().invert()).toBeIdentical(Ex.Sune);
-    expect(Ex.Sune.invert().invert()).not.toBeIdentical(Ex.AntiSune);
-  });
-});
-
-describe("expand()", () => {
-  it("correctly expands", () => {
-    expect(Ex.FURURFCompact.expand()).toBeIdentical(Ex.FURURFMoves);
-    expect(Ex.Sune.expand()).toBeIdentical(Ex.Sune);
-    expect(Ex.SuneCommutator.expand()).not.toBeIdentical(Ex.Sune);
-    expect(Ex.FURURFCompact.expand()).not.toBeIdentical(Ex.SuneCommutator);
-  });
-
-  it("correctly expands a group with two units", () => {
-    expect(new Alg("(R U)2").expand()).toBeIdentical(new Alg("R U R U"));
-  });
-
-  it("correctly expands an E-Perm", () => {
-    expect(Ex.EPerm.expand()).toBeIdentical(
-      new Alg("x' R U' R' D R U R' D' R U R' D R U' R' D' x"),
-    );
-  });
-});
-
-describe("toBeIdentical", () => {
-  it("correctly compares algs", () => {
-    expect(Ex.FURURFCompact).not.toBeIdentical(Ex.FURURFMoves);
-    expect(Ex.FURURFMoves).not.toBeIdentical(Ex.FURURFCompact);
-    expect(Ex.FURURFMoves).toBeIdentical(Ex.FURURFMoves);
-    expect(Ex.FURURFCompact).toBeIdentical(Ex.FURURFCompact);
-  });
-});
-
-describe("move collapsing ()", () => {
-  it("coalesces U U to U2", () => {
-    expect(UU.simplify({ collapseMoves: true })).toBeIdentical(U2);
-  });
-
-  it("coalesces expanded commutator Sune corectly", () => {
-    expect(
-      Ex.SuneCommutator.expand().simplify({ collapseMoves: true }),
-    ).toBeIdentical(Ex.Sune);
-  });
-});
-
-describe("JSON", () => {
-  // it("round-trips an alg through JSON stringification", () => {
-  //   e(
-  //     fromJSON(JSON.parse(JSON.stringify(Ex.FURURFCompact))),
-  //     Ex.FURURFCompact,
-  //   ).toBe(true);
-  // });
-});
-
-describe("Object Freezing", () => {
-  it("freezes all example alg types", () => {
-    // // Update this based on the length of AllAlgParts.
-    // expect(Ex.AllAlgParts.length).toBe(8);
-    // for (const a of Ex.AllAlgParts) {
-    //   expect(Object.isFrozen(a)).toBe(true);
-    // }
-  });
-
-  it("freezes `nestedUnits` list on Alg", () => {
-    // // Update this based on the length of AllAlgParts.
-    // expect(Object.isFrozen(new Alg([new Move("R", 1)]).nestedUnits)).toBe(true);
-  });
-
-  // it("makes it impossible to modify a BaseMove", () => {
-  //   const b = new Move("R", 4);
-  //   let caughtErr: Error | undefined;
-  //   try {
-  //     b.effectiveAmount = 2;
-  //   } catch (err) {
-  //     caughtErr = err;
-  //   }
-  //   expect(caughtErr instanceof TypeError).toBe(true);
-  // });
-});
-
-describe("Parser", () => {
-  it("parses an empty Alg", () => {
-    expect(new Alg("")).toBeIdentical(new Alg());
-    expect(Alg.fromString("()")).toBeIdentical(
-      new Alg([new Grouping(new Alg([]))]),
-    );
-    expect(new Alg("")).toBeIdentical(new Alg());
-    expect(Alg.fromString("()")).toBeIdentical(
-      new Alg([new Grouping(new Alg([]))]),
-    );
-  });
-
-  it("parses a Sune", () => {
-    expect(new Alg("R U R' U R U2' R'")).toBeIdentical(Ex.Sune);
-    expect(Alg.fromString("R U R' U R U2' R'")).toBeIdentical(Ex.Sune);
-    expect(new Alg("R U R' U R U2' R'")).toBeIdentical(
-      Alg.fromString("R U R' U R U2' R'"),
-    );
-  });
-
-  it("parses U u Uw x 2U 2u 2Uw 2-3u 2-3Uw", () => {
-    const s = "U u Uw x 2U 2u 2Uw 2-3u 2-3Uw";
-    expect(new Alg(s).toString()).toBe(s);
-  });
-
-  it("parses . . .", () => {
-    const p = new Pause();
-    expect(new Alg(". . .")).toBeIdentical(new Alg([p, p, p]));
-  });
-
-  // TODO: Should these be parsed differently?
-  it("parses R and R1 as the same (for now)", () => {
-    expect(new Alg("R")).toBeIdentical(new Alg("R1"));
-  });
-
-  it("round-trips algs through a string", () => {
-    expect(new Alg(Ex.SuneCommutator.toString())).toBeIdentical(
-      Ex.SuneCommutator,
-    );
-    expect(new Alg(Ex.Niklas.toString())).toBeIdentical(Ex.Niklas);
-    expect(new Alg(Ex.FURURFCompact.toString())).toBeIdentical(
-      Ex.FURURFCompact,
-    );
-    expect(new Alg(Ex.APermCompact.toString())).toBeIdentical(Ex.APermCompact);
-    expect(new Alg(Ex.TPerm.toString())).toBeIdentical(Ex.TPerm);
-    expect(new Alg(Ex.HeadlightSwaps.toString())).toBeIdentical(
-      Ex.HeadlightSwaps,
-    );
-    expect(new Alg(Ex.TriplePause.toString())).toBeIdentical(Ex.TriplePause);
-  });
-
-  // it("round-trips all alg types through a string", () => {
-  //   // Update this based on the length of AllAlgParts.
-  //   for (const a of Ex.AllAlgParts) {
-  //     const seq = matchesAlgType(a, "Alg") ? (a as Alg) : new Alg([a]);
-  //     expect(new Alg(algToString(seq))).toBeIdentical(seq);
-  //   }
-  // });
-});
-
-describe("Validator", () => {
-  // it("can validate flat algs", () => {
-  //   expect(
-  //     () => new Alg("(R)", { validators: [validateFlatAlg] }),
-  //   ).toThrowError(/cannot contain a group/); // toThrowError(ValidationError, /cannot contain a group/);
-  //   expect(
-  //     () => new Alg("Qw", { validators: [validateFlatAlg] }),
-  //   ).not.toThrow(); // not.toThrowError();
-  //   expect(
-  //     () => new Alg("(Qw)", { validators: [validateFlatAlg] }),
-  //   ).toThrowError(/cannot contain a group/); // toThrowError(ValidationError, );
-  // });
-  // it("can validate cube base moves alg", () => {
-  //   expect(
-  //     () => new Alg("(R)", { validators: [validateSiGNMoves] }),
-  //   ).not.toThrowError();
-  //   expect(
-  //     () => new Alg("Qw", { validators: [validateSiGNMoves] }),
-  //   ).toThrowError(/Invalid SiGN plain move family/);
-  //   expect(
-  //     () => new Alg("(Qw)", { validators: [validateSiGNMoves] }),
-  //   ).toThrowError(/Invalid SiGN plain move family/);
-  // });
-  // it("can validate cube algs", () => {
-  //   expect(
-  //     () => new Alg("(R)", { validators: [validateSiGNAlg] }),
-  //   ).toThrowError(/cannot contain a group/);
-  //   expect(() => new Alg("Qw", { validators: [validateSiGNAlg] })).toThrowError(
-  //     /Invalid SiGN plain move family/,
-  //   );
-  //   expect(
-  //     () => new Alg("(Qw)", { validators: [validateSiGNAlg] }),
-  //   ).toThrowError(ValidationError);
-  // });
-  // it("throws ValidationError", () => {
-  //   expect(
-  //     () => new Alg("(R)", { validators: [validateFlatAlg] }),
-  //   ).toThrowError(ValidationError);
-  // });
-});

package/src/cubing/alg/traversal.ts

@@ -1,284 +0,0 @@
-import type { Alg } from "./Alg";
-import { Grouping } from "./units/containers/Grouping";
-import type { Comparable } from "./common";
-import { Commutator } from "./units/containers/Commutator";
-import { Move, QuantumMove } from "./units/leaves/Move";
-import { Newline } from "./units/leaves/Newline";
-import { Pause } from "./units/leaves/Pause";
-import { Conjugate } from "./units/containers/Conjugate";
-import { LineComment } from "./units/leaves/LineComment";
-import type { Unit } from "./units/Unit";
-
-function dispatch<DataDown, DataAlgUp, DataUnitUp>(
-  t: TraversalDownUp<DataDown, DataAlgUp, DataUnitUp>,
-  unit: Unit,
-  dataDown: DataDown,
-): DataUnitUp {
-  // TODO: Can we turn this back into a `switch` or something more efficiently?
-  if (unit.is(Grouping)) {
-    return t.traverseGrouping(unit as Grouping, dataDown);
-  }
-  if (unit.is(Move)) {
-    return t.traverseMove(unit as Move, dataDown);
-  }
-  if (unit.is(Commutator)) {
-    return t.traverseCommutator(unit as Commutator, dataDown);
-  }
-  if (unit.is(Conjugate)) {
-    return t.traverseConjugate(unit as Conjugate, dataDown);
-  }
-  if (unit.is(Pause)) {
-    return t.traversePause(unit as Pause, dataDown);
-  }
-  if (unit.is(Newline)) {
-    return t.traverseNewline(unit as Newline, dataDown);
-  }
-  if (unit.is(LineComment)) {
-    return t.traverseLineComment(unit as LineComment, dataDown);
-  }
-  throw new Error(`unknown unit`);
-}
-
-function assertIsUnit(t: Comparable): Unit {
-  if (
-    t.is(Grouping) ||
-    t.is(Move) ||
-    t.is(Commutator) ||
-    t.is(Conjugate) ||
-    t.is(Pause) ||
-    t.is(Newline) ||
-    t.is(LineComment)
-  ) {
-    return t as Unit;
-  }
-  throw "internal error: expected unit"; // TODO: Make more helpful, add tests
-}
-
-export abstract class TraversalDownUp<
-  DataDown,
-  DataAlgUp,
-  DataUnitUp = DataAlgUp,
-> {
-  // Immediate subclasses should overwrite this.
-  public traverseUnit(unit: Unit, dataDown: DataDown): DataUnitUp {
-    return dispatch(this, unit, dataDown);
-  }
-
-  public traverseIntoUnit(unit: Unit, dataDown: DataDown): Unit {
-    return assertIsUnit(this.traverseUnit(unit, dataDown) as any);
-  }
-
-  public abstract traverseAlg(alg: Alg, dataDown: DataDown): DataAlgUp;
-
-  public abstract traverseGrouping(
-    grouping: Grouping,
-    dataDown: DataDown,
-  ): DataUnitUp;
-
-  public abstract traverseMove(move: Move, dataDown: DataDown): DataUnitUp;
-
-  public abstract traverseCommutator(
-    commutator: Commutator,
-    dataDown: DataDown,
-  ): DataUnitUp;
-
-  public abstract traverseConjugate(
-    conjugate: Conjugate,
-    dataDown: DataDown,
-  ): DataUnitUp;
-
-  public abstract traversePause(pause: Pause, dataDown: DataDown): DataUnitUp;
-  public abstract traverseNewline(
-    newline: Newline,
-    dataDown: DataDown,
-  ): DataUnitUp;
-
-  public abstract traverseLineComment(
-    comment: LineComment,
-    dataDown: DataDown,
-  ): DataUnitUp;
-}
-
-export abstract class TraversalUp<
-  DataAlgUp,
-  DataUnitUp = DataAlgUp,
-> extends TraversalDownUp<undefined, DataAlgUp, DataUnitUp> {
-  public traverseUnit(unit: Unit): DataUnitUp {
-    return dispatch<unknown, DataAlgUp, DataUnitUp>(this, unit, undefined);
-  }
-
-  public traverseIntoUnit(unit: Unit): Unit {
-    return assertIsUnit(this.traverseUnit(unit) as any);
-  }
-
-  public abstract traverseAlg(alg: Alg): DataAlgUp;
-  public abstract traverseGrouping(grouping: Grouping): DataUnitUp;
-  public abstract traverseMove(move: Move): DataUnitUp;
-  public abstract traverseCommutator(commutator: Commutator): DataUnitUp;
-  public abstract traverseConjugate(conjugate: Conjugate): DataUnitUp;
-  public abstract traversePause(pause: Pause): DataUnitUp;
-  public abstract traverseNewline(newline: Newline): DataUnitUp;
-  public abstract traverseLineComment(comment: LineComment): DataUnitUp;
-}
-
-export interface SimplifyOptions {
-  collapseMoves?: boolean;
-  quantumMoveOrder?: (quantumMove: QuantumMove) => number;
-  depth?: number | null; // TODO: test
-}
-
-// TODO: Test that inverses are bijections.
-class Simplify extends TraversalDownUp<SimplifyOptions, Generator<Unit>> {
-  static #newAmount(
-    move: Move,
-    deltaAmount: number,
-    options: SimplifyOptions,
-  ): number {
-    let newAmount = move.amount + deltaAmount;
-    if (options?.quantumMoveOrder) {
-      const order = options.quantumMoveOrder(move.quantum);
-      // Examples:
-      // • order 4 → min -1 (e.g. cube)
-      // • order 5 → min -2 (e.g. Megaminx)
-      // • order 3 → min -1 (e.g. Pyraminx)
-      const min = Math.floor(order / 2) + 1 - order;
-      newAmount = (((newAmount % order) + order - min) % order) + min; // TODO
-    }
-    return newAmount;
-  }
-
-  // TODO: Handle
-  public *traverseAlg(alg: Alg, options: SimplifyOptions): Generator<Unit> {
-    if (options.depth === 0) {
-      yield* alg.units();
-      return;
-    }
-
-    const newUnits: Unit[] = [];
-    let lastUnit: Unit | null = null;
-    const collapseMoves = options?.collapseMoves ?? true;
-    function appendMoveWithNewAmount(move: Move, deltaAmount: number): boolean {
-      const newAmount = Simplify.#newAmount(move, deltaAmount, options);
-      if (newAmount === 0) {
-        return false;
-      }
-      const newMove = new Move(move.quantum, newAmount);
-      newUnits.push(newMove);
-      lastUnit = newMove;
-      return true;
-    }
-    function appendCollapsed(newUnit: Unit) {
-      if (
-        collapseMoves &&
-        lastUnit?.is(Move) &&
-        newUnit.is(Move) &&
-        (lastUnit as Move).quantum.isIdentical((newUnit as Move).quantum)
-      ) {
-        newUnits.pop();
-        if (
-          !appendMoveWithNewAmount(lastUnit as Move, (newUnit as Move).amount)
-        ) {
-          lastUnit = newUnits.slice(-1)[0];
-        }
-      } else {
-        if (newUnit.is(Move)) {
-          appendMoveWithNewAmount(newUnit as Move, 0);
-        } else {
-          newUnits.push(newUnit);
-          lastUnit = newUnit;
-        }
-      }
-    }
-
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null,
-    }; // TODO: avoid allocations?
-    for (const unit of alg.units()) {
-      for (const ancestorUnit of this.traverseUnit(unit, newOptions)) {
-        appendCollapsed(ancestorUnit);
-      }
-    }
-    for (const unit of newUnits) {
-      yield unit;
-    }
-  }
-
-  public *traverseGrouping(
-    grouping: Grouping,
-    options: SimplifyOptions,
-  ): Generator<Unit> {
-    if (options.depth === 0) {
-      yield grouping;
-      return;
-    }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null,
-    }; // TODO: avoid allocations?
-    yield new Grouping(this.traverseAlg(grouping.alg, newOptions));
-  }
-
-  public *traverseMove(move: Move, _options: SimplifyOptions): Generator<Unit> {
-    yield move;
-  }
-
-  public *traverseCommutator(
-    commutator: Commutator,
-    options: SimplifyOptions,
-  ): Generator<Unit> {
-    if (options.depth === 0) {
-      yield commutator;
-      return;
-    }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null,
-    }; // TODO: avoid allocations?
-    yield new Commutator(
-      this.traverseAlg(commutator.A, newOptions),
-      this.traverseAlg(commutator.B, newOptions),
-    );
-  }
-
-  public *traverseConjugate(
-    conjugate: Conjugate,
-    options: SimplifyOptions,
-  ): Generator<Unit> {
-    if (options.depth === 0) {
-      yield conjugate;
-      return;
-    }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null,
-    }; // TODO: avoid allocations?
-    yield new Conjugate(
-      this.traverseAlg(conjugate.A, newOptions),
-      this.traverseAlg(conjugate.B, newOptions),
-    );
-  }
-
-  public *traversePause(
-    pause: Pause,
-    _options: SimplifyOptions,
-  ): Generator<Unit> {
-    yield pause;
-  }
-
-  public *traverseNewline(
-    newline: Newline,
-    _options: SimplifyOptions,
-  ): Generator<Unit> {
-    yield newline;
-  }
-
-  public *traverseLineComment(
-    comment: LineComment,
-    _options: SimplifyOptions,
-  ): Generator<Unit> {
-    yield comment;
-  }
-}
-
-const simplifyInstance = new Simplify();
-export const simplify = simplifyInstance.traverseAlg.bind(simplifyInstance) as (
-  alg: Alg,
-  options: SimplifyOptions,
-) => Generator<Unit>;

package/src/cubing/alg/units/QuantumWithAmount.ts

@@ -1,55 +0,0 @@
-import type { Repeatable } from "../common";
-import { IterationDirection, toggleDirection } from "../iteration";
-import { MAX_INT, MAX_INT_DESCRIPTION, MIN_INT } from "../limits";
-import type { LeafUnit } from "./Unit";
-
-export class QuantumWithAmount<Q extends Repeatable> {
-  readonly quantum: Q;
-  readonly amount: number;
-
-  constructor(quantum: Q, amount: number = 1) {
-    this.quantum = quantum;
-    this.amount = amount;
-
-    if (
-      !Number.isInteger(this.amount) ||
-      this.amount < MIN_INT ||
-      this.amount > MAX_INT
-    ) {
-      throw new Error(
-        `Unit amount absolute value must be a non-negative integer from ${MAX_INT_DESCRIPTION} to ${MAX_INT_DESCRIPTION}.`,
-      );
-    }
-  }
-
-  suffix(): string {
-    let s: string = "";
-    // TODO
-    const absAmount = Math.abs(this.amount);
-    if (absAmount !== 1) {
-      s += absAmount;
-    }
-    if (this.amount < 0) {
-      s += "'";
-    }
-    return s;
-  }
-
-  isIdentical(other: QuantumWithAmount<Q>): boolean {
-    return (
-      this.quantum.isIdentical(other.quantum) && this.amount === other.amount
-    );
-  }
-
-  // TODO: `Conjugate` and `Commutator` decrement `depth` inside the quantum, `Grouping` has to do it outside the quantum.
-  *experimentalExpand(
-    iterDir: IterationDirection,
-    depth: number,
-  ): Generator<LeafUnit> {
-    const absAmount = Math.abs(this.amount);
-    const newIterDir = toggleDirection(iterDir, this.amount < 0);
-    for (let i = 0; i < absAmount; i++) {
-      yield* this.quantum.experimentalExpand(newIterDir, depth);
-    }
-  }
-}

package/src/cubing/alg/units/Unit.ts

@@ -1,11 +0,0 @@
-import type { Grouping } from "./containers/Grouping";
-import type { LineComment } from "./leaves/LineComment";
-import type { Commutator } from "./containers/Commutator";
-import type { Conjugate } from "./containers/Conjugate";
-import type { Move } from "./leaves/Move";
-import type { Newline } from "./leaves/Newline";
-import type { Pause } from "./leaves/Pause";
-
-export type LeafUnit = Move | LineComment | Newline | Pause;
-
-export type Unit = LeafUnit | Grouping | Conjugate | Commutator;