cubing 0.34.3 → 0.34.5

package/dist/types/src/cubing/alg/Alg.d.ts

@@ -0,0 +1,176 @@
+import { AlgCommon, Comparable } from "./common";
+import { IterationDirection } from "./iteration";
+import { SimplifyOptions } from "./simplify";
+import { Move } from "./alg-nodes/leaves/Move";
+import type { AlgLeaf, AlgNode } from "./alg-nodes/AlgNode";
+export declare type FlexibleAlgSource = string | Iterable<AlgNode> | Alg;
+export declare function experimentalEnsureAlg(alg: FlexibleAlgSource): Alg;
+/**
+ * `Alg` is a class that encapsulates a structured alg. To create an `Alg` from a string, use:
+ *
+ *     new Alg("R U R'"); // Convenient
+ *     Alg.fromString(dynamicString); // Recommended when the string input is user-provided.
+ *
+ * Once you have an `Alg`, you can call methods to transform it:
+ *
+ *     new Alg("[[R: U], R U R2']").expand().experimentalSimplify({cancel: true}).invert().log()
+ *
+ * To convert an `Alg` to a string, use .toString():
+ *
+ *     new Alg("R U F").invert().toString();
+ *
+ * If you need to debug, you may also find it convenient to use .log():
+ *
+ *     if (alg.isIdentical(alg.invert())) {
+ *       alg.log("A self-inverse!")
+ *     }
+ *
+ * For more information, see: {@link https://js.cubing.net/cubing/alg/}
+ *
+ * @category Alg
+ */
+export declare class Alg extends AlgCommon<Alg> {
+    #private;
+    constructor(alg?: FlexibleAlgSource);
+    /**
+     * Checks whether this Alg is structurally identical to another Alg. This
+     * essentially means that they are written identically apart from whitespace.
+     *
+     *     const alg1 = new Alg("R U L'");
+     *     const alg2 = new Alg("L U' R'").invert();
+     *     // true
+     *     alg1.isIdentical(alg2);
+     *
+     *     // false
+     *     new Alg("[R, U]").isIdentical(new Alg("R U R' U'"));
+     *     // true
+     *     new Alg("[R, U]").expand().isIdentical(new Alg("R U R' U'"));
+     *
+     * Note that .isIdentical() efficiently compares algorithms, but mainly exists
+     * to help optimize code when the structure of an algorithm hasn't changed.
+     * There are many ways to write the "same" alg on most puzzles, but is
+     * *highly* recommended to avoid expanding two Alg instances to compare them,
+     * since that can easily slow your program to a crawl if someone inputs an alg
+     * containing a large repetition. In general, you should use `cubing/kpuzzle`
+     * to compare if two algs have the same effect on a puzzle.
+     *
+     * Also note that parser annotations are not taken into account while comparing
+     * algs:
+     *
+     *     const alg = new Alg([new Move("R"), new Move("U2")]);
+     *     // true, even though one of the algs has parser annotations
+     *     alg.isIdentical(new Alg("R U2"))
+     *
+     */
+    isIdentical(other: Comparable): boolean;
+    /**
+     * Returns the inverse of the given alg.
+     *
+     * Note that that this does not make any assumptions about what puzzle the alg
+     * is for. For example, U2 is its own inverse on a cube, but U2' has the same
+     * effect U3 (and not U2) on Megaminx:
+     *
+     *     // Outputs: R U2' L'
+     *     new Alg("L U2 R'").invert().log();
+     */
+    invert(): Alg;
+    /** @deprecated Use {@link Alg.expand} instead. */
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<AlgLeaf>;
+    /**
+     * Expands all Grouping, Commutator, and Conjugate parts nested inside the
+     * alg.
+     *
+     *     // F R U R' U' F'
+     *     new Alg("[F: [R, U]]").expand().log();
+     *
+     *     // F [R, U] F'
+     *     new Alg("[F: [R, U]]").expand(({ depth: 1 }).log();
+     *
+     * Avoid calling this on a user-provided alg unless the user explicitly asks
+     * to see the expanded alg. Otherwise, it's easy to make your program freeze
+     * when someone passes in an alg like: (R U)10000000
+     *
+     * Generally, if you want to perform an operation on an entire alg, you'll
+     * want to use something based on the `Traversal` mechanism, like countMoves()
+     * from `cubing/notation`.
+     */
+    expand(options?: {
+        depth?: number;
+    }): Alg;
+    /** @deprecated */
+    experimentalLeafMoves(): Generator<Move>;
+    concat(input: FlexibleAlgSource): Alg;
+    /** @deprecated */
+    experimentalIsEmpty(): boolean;
+    static fromString(s: string): Alg;
+    /** @deprecated */
+    units(): Generator<AlgNode>;
+    childAlgNodes(): Generator<AlgNode>;
+    /** @deprecated */
+    experimentalNumUnits(): number;
+    experimentalNumChildAlgNodes(): number;
+    /** @deprecated */
+    get type(): string;
+    /**
+     * Converts the Alg to a string:
+     *
+     *     const alg = new Alg([new Move("R"), new Move("U2"), new Move("L")])
+     *     // R U2 L
+     *     console.log(alg.toString())
+     */
+    toString(): string;
+    /**
+     * `experimentalSimplify` can perform several mostly-syntactic simplifications on an alg:
+     *
+     *     // Logs: R' U3
+     *     import { Alg } from "cubing/alg";
+     *     new Alg("R R2' U U2").experimentalSimplify({ cancel: true }).log()
+     *
+     * You can pass in a `PuzzleLoader` (currently only for 3x3x3) for puzzle-specific simplifications:
+     *
+     *     // Logs: R' U'
+     *     import { Alg } from "cubing/alg";
+     *     import { cube3x3x3 } from "cubing/puzzles";
+     *     new Alg("R R2' U U2").experimentalSimplify({ cancel: true, puzzleLoader: cube3x3x3 }).log()
+     *
+     * You can also cancel only moves that are in the same direction:
+     *
+     *     // Logs: R R2' U'
+     *     import { Alg } from "cubing/alg";
+     *     import { cube3x3x3 } from "cubing/puzzles";
+     *     new Alg("R R2' U U2").experimentalSimplify({
+     *       cancel: { directional: "same-direction" },
+     *       puzzleLoader: cube3x3x3
+     *     }).log()
+     *
+     * Additionally, you can specify how moves are "wrapped":
+     *
+     *     import { Alg } from "cubing/alg";
+     *     import { cube3x3x3 } from "cubing/puzzles";
+     *
+     *     function example(puzzleSpecificModWrap) {
+     *       alg.experimentalSimplify({
+     *         cancel: { puzzleSpecificModWrap },
+     *         puzzleLoader: cube3x3x3
+     *       }).log()
+     *     }
+     *
+     *     const alg = new Alg("R7' . R6' . R5' . R6")
+     *     example("none")               // R7' . R6' . R5' . R6
+     *     example("gravity")            // R . R2' . R' . R2
+     *     example("canonical-centered") // R . R2 . R' . R2
+     *     example("canonical-positive") // R . R2 . R3 . R2
+     *     example("preserve-sign")      // R3' . R2' . R' . R2
+     *
+     * Same-axis and simultaneous move canonicalization is not implemented yet:
+     *
+     *     // Logs: R L R
+     *     import { Alg } from "cubing/alg";
+     *     import { cube3x3x3 } from "cubing/puzzles";
+     *     new Alg("R L R").experimentalSimplify({ cancel: true, puzzleLoader: cube3x3x3 }).log()
+     */
+    experimentalSimplify(options?: SimplifyOptions): Alg;
+    /** @deprecated See {@link experimentalSimplify} */
+    simplify(options?: SimplifyOptions): Alg;
+}
+//# sourceMappingURL=Alg.d.ts.map

package/dist/types/src/cubing/alg/Alg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Alg.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/Alg.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEjD,OAAO,EAAU,kBAAkB,EAAW,MAAM,aAAa,CAAC;AAElE,OAAO,EAAY,eAAe,EAAE,MAAM,YAAY,CAAC;AAGvD,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE/C,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAG5D,oBAAY,iBAAiB,GAAG,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;AAyBjE,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,iBAAiB,GAAG,GAAG,CAKjE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,GAAI,SAAQ,SAAS,CAAC,GAAG,CAAC;;gBAGzB,GAAG,CAAC,EAAE,iBAAiB;IAYnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAoBvC;;;;;;;;;OASG;IACH,MAAM,IAAI,GAAG;IAMb,kDAAkD;IACjD,kBAAkB,CACjB,OAAO,GAAE,kBAAgD,EACzD,KAAK,CAAC,EAAE,MAAM,GACb,SAAS,CAAC,OAAO,CAAC;IAOrB;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,GAAG;IASzC,kBAAkB;IACjB,qBAAqB,IAAI,SAAS,CAAC,IAAI,CAAC;IAQzC,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,GAAG;IAMrC,kBAAkB;IAClB,mBAAmB,IAAI,OAAO;IAO9B,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG;IAIjC,kBAAkB;IAClB,KAAK,IAAI,SAAS,CAAC,OAAO,CAAC;IAI1B,aAAa,IAAI,SAAS,CAAC,OAAO,CAAC;IAMpC,kBAAkB;IAClB,oBAAoB,IAAI,MAAM;IAI9B,4BAA4B,IAAI,MAAM;IAItC,kBAAkB;IAClB,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM;IAuBlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,oBAAoB,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,GAAG;IAIpD,mDAAmD;IACnD,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,GAAG;CAGzC"}

package/dist/types/src/cubing/alg/Alg.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Alg.spec.d.ts.map

package/dist/types/src/cubing/alg/Alg.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Alg.spec.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/Alg.spec.ts"],"names":[],"mappings":""}

package/dist/types/src/cubing/alg/AlgBuilder.d.ts

@@ -0,0 +1,13 @@
+import { Alg } from "./Alg";
+import type { AlgNode } from "./alg-nodes/AlgNode";
+/** @category Alg */
+export declare class AlgBuilder {
+    #private;
+    push(u: AlgNode): void;
+    /** @deprecated */
+    experimentalPushAlg(alg: Alg): void;
+    experimentalNumAlgNodes(): number;
+    toAlg(): Alg;
+    reset(): void;
+}
+//# sourceMappingURL=AlgBuilder.d.ts.map

package/dist/types/src/cubing/alg/AlgBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlgBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/AlgBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAC5B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,oBAAoB;AACpB,qBAAa,UAAU;;IAGrB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI;IAKtB,kBAAkB;IAClB,mBAAmB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAQnC,uBAAuB,IAAI,MAAM;IAKjC,KAAK,IAAI,GAAG;IAIZ,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/src/cubing/alg/Serializable.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=Serializable.d.ts.map

package/dist/types/src/cubing/alg/Serializable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serializable.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/Serializable.ts"],"names":[],"mappings":""}

package/dist/types/src/cubing/alg/alg-nodes/AlgNode.d.ts

@@ -0,0 +1,14 @@
+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";
+/** @category Alg Nodes */
+export declare type AlgLeaf = Move | LineComment | Newline | Pause;
+/** @category Alg Nodes */
+export declare type AlgBranch = Grouping | Conjugate | Commutator;
+/** @category Alg Nodes */
+export declare type AlgNode = AlgLeaf | AlgBranch;
+//# sourceMappingURL=AlgNode.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/AlgNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlgNode.d.ts","sourceRoot":"","sources":["../../../../../../src/cubing/alg/alg-nodes/AlgNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,0BAA0B;AAC1B,oBAAY,OAAO,GAAG,IAAI,GAAG,WAAW,GAAG,OAAO,GAAG,KAAK,CAAC;AAC3D,0BAA0B;AAC1B,oBAAY,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAE1D,0BAA0B;AAC1B,oBAAY,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC"}

package/dist/types/src/cubing/alg/alg-nodes/QuantumWithAmount.d.ts

@@ -0,0 +1,12 @@
+import type { Repeatable } from "../common";
+import { IterationDirection } from "../iteration";
+import type { AlgLeaf } from "./AlgNode";
+export declare class QuantumWithAmount<Q extends Repeatable> {
+    readonly quantum: Q;
+    readonly amount: number;
+    constructor(quantum: Q, amount?: number);
+    suffix(): string;
+    isIdentical(other: QuantumWithAmount<Q>): boolean;
+    experimentalExpand(iterDir: IterationDirection, depth: number): Generator<AlgLeaf>;
+}
+//# sourceMappingURL=QuantumWithAmount.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/QuantumWithAmount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuantumWithAmount.d.ts","sourceRoot":"","sources":["../../../../../../src/cubing/alg/alg-nodes/QuantumWithAmount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAmB,MAAM,cAAc,CAAC;AAEnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,qBAAa,iBAAiB,CAAC,CAAC,SAAS,UAAU;IACjD,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,OAAO,EAAE,CAAC,EAAE,MAAM,GAAE,MAAU;IAe1C,MAAM,IAAI,MAAM;IAahB,WAAW,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,OAAO;IAOhD,kBAAkB,CACjB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,MAAM,GACZ,SAAS,CAAC,OAAO,CAAC;CAOtB"}

package/dist/types/src/cubing/alg/alg-nodes/containers/Commutator.d.ts

@@ -0,0 +1,16 @@
+import { Alg, FlexibleAlgSource } from "../../Alg";
+import { AlgCommon, Comparable } from "../../common";
+import { IterationDirection } from "../../iteration";
+import type { AlgLeaf } from "../AlgNode";
+/** @category Alg Nodes */
+export declare class Commutator extends AlgCommon<Commutator> {
+    #private;
+    constructor(aSource: FlexibleAlgSource, bSource: FlexibleAlgSource);
+    get A(): Alg;
+    get B(): Alg;
+    isIdentical(other: Comparable): boolean;
+    invert(): Commutator;
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<AlgLeaf>;
+    toString(): string;
+}
+//# sourceMappingURL=Commutator.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/containers/Commutator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Commutator.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/containers/Commutator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAyB,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,0BAA0B;AAC1B,qBAAa,UAAW,SAAQ,SAAS,CAAC,UAAU,CAAC;;gBAIvC,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,iBAAiB;IAMlE,IAAI,CAAC,IAAI,GAAG,CAEX;IAED,IAAI,CAAC,IAAI,GAAG,CAEX;IAED,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAQvC,MAAM,IAAI,UAAU;IAInB,kBAAkB,CACjB,OAAO,GAAE,kBAAgD,EACzD,KAAK,CAAC,EAAE,MAAM,GACb,SAAS,CAAC,OAAO,CAAC;IA2CrB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/types/src/cubing/alg/alg-nodes/containers/Conjugate.d.ts

@@ -0,0 +1,16 @@
+import { Alg, FlexibleAlgSource } from "../../Alg";
+import { AlgCommon, Comparable } from "../../common";
+import { IterationDirection } from "../../iteration";
+import type { AlgLeaf } from "../AlgNode";
+/** @category Alg Nodes */
+export declare class Conjugate extends AlgCommon<Conjugate> {
+    #private;
+    constructor(aSource: FlexibleAlgSource, bSource: FlexibleAlgSource);
+    get A(): Alg;
+    get B(): Alg;
+    isIdentical(other: Comparable): boolean;
+    invert(): Conjugate;
+    experimentalExpand(iterDir: IterationDirection, depth?: number): Generator<AlgLeaf>;
+    toString(): string;
+}
+//# sourceMappingURL=Conjugate.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/containers/Conjugate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Conjugate.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/containers/Conjugate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAyB,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,0BAA0B;AAC1B,qBAAa,SAAU,SAAQ,SAAS,CAAC,SAAS,CAAC;;gBAIrC,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,iBAAiB;IAMlE,IAAI,CAAC,IAAI,GAAG,CAEX;IAED,IAAI,CAAC,IAAI,GAAG,CAEX;IAED,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAQvC,MAAM,IAAI,SAAS;IAIlB,kBAAkB,CACjB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,CAAC,EAAE,MAAM,GACb,SAAS,CAAC,OAAO,CAAC;IAWrB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/types/src/cubing/alg/alg-nodes/containers/Grouping.d.ts

@@ -0,0 +1,23 @@
+import { Alg, FlexibleAlgSource } from "../../Alg";
+import { AlgCommon, Comparable } from "../../common";
+import { IterationDirection } from "../../iteration";
+import { Move } from "../leaves/Move";
+import type { Pause } from "../leaves/Pause";
+import type { AlgLeaf } from "../AlgNode";
+/** @category Alg Nodes */
+export declare class Grouping extends AlgCommon<Grouping> {
+    #private;
+    experimentalNISSPlaceholder?: Pause;
+    constructor(algSource: FlexibleAlgSource, amount?: number);
+    isIdentical(other: Comparable): boolean;
+    get alg(): Alg;
+    get amount(): number;
+    /** @deprecated */
+    get experimentalRepetitionSuffix(): string;
+    invert(): Grouping;
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<AlgLeaf>;
+    static fromString(): Grouping;
+    toString(): string;
+    experimentalAsSquare1Tuple(): [moveU: Move, moveD: Move] | null;
+}
+//# sourceMappingURL=Grouping.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/containers/Grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Grouping.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/containers/Grouping.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAyB,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAe,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAwC1C,0BAA0B;AAC1B,qBAAa,QAAS,SAAQ,SAAS,CAAC,QAAQ,CAAC;;IAE/C,2BAA2B,CAAC,EAAE,KAAK,CAAC;gBAExB,SAAS,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,MAAM;IAMzD,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAQvC,IAAI,GAAG,IAAI,GAAG,CAEb;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,kBAAkB;IAClB,IAAI,4BAA4B,IAAI,MAAM,CAEzC;IAED,MAAM,IAAI,QAAQ;IAOjB,kBAAkB,CACjB,OAAO,GAAE,kBAAgD,EACzD,KAAK,CAAC,EAAE,MAAM,GACb,SAAS,CAAC,OAAO,CAAC;IASrB,MAAM,CAAC,UAAU,IAAI,QAAQ;IAI7B,QAAQ,IAAI,MAAM;IAOlB,0BAA0B,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,IAAI;CAShE"}

package/dist/types/src/cubing/alg/alg-nodes/index.d.ts

@@ -0,0 +1,12 @@
+export { Grouping } from "./containers/Grouping";
+export { LineComment } from "./leaves/LineComment";
+export { Commutator } from "./containers/Commutator";
+export { Conjugate } from "./containers/Conjugate";
+export { Move, QuantumMove } from "./leaves/Move";
+export { Newline } from "./leaves/Newline";
+export { Pause } from "./leaves/Pause";
+import type { AlgNode } from "./AlgNode";
+export { AlgNode };
+/** @deprecated */
+export declare type Unit = AlgNode;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/cubing/alg/alg-nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,OAAO,EAAE,CAAC;AACnB,kBAAkB;AAClB,oBAAY,IAAI,GAAG,OAAO,CAAC"}

package/dist/types/src/cubing/alg/alg-nodes/leaves/LineComment.d.ts

@@ -0,0 +1,14 @@
+import { AlgCommon, Comparable } from "../../common";
+import { IterationDirection } from "../../iteration";
+import type { AlgLeaf } from "../AlgNode";
+/** @category Alg Nodes */
+export declare class LineComment extends AlgCommon<LineComment> {
+    #private;
+    constructor(commentText: string);
+    get text(): string;
+    isIdentical(other: Comparable): boolean;
+    invert(): LineComment;
+    experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<AlgLeaf>;
+    toString(): string;
+}
+//# sourceMappingURL=LineComment.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/leaves/LineComment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LineComment.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/leaves/LineComment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAI1C,0BAA0B;AAC1B,qBAAa,WAAY,SAAQ,SAAS,CAAC,WAAW,CAAC;;gBAGzC,WAAW,EAAE,MAAM;IAQ/B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAKvC,MAAM,IAAI,WAAW;IAIpB,kBAAkB,CACjB,QAAQ,GAAE,kBAAgD,EAC1D,MAAM,GAAE,MAAiB,GACxB,SAAS,CAAC,OAAO,CAAC;IAIrB,QAAQ,IAAI,MAAM;CASnB"}

package/dist/types/src/cubing/alg/alg-nodes/leaves/LineComment.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LineComment.spec.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/leaves/LineComment.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LineComment.spec.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/leaves/LineComment.spec.ts"],"names":[],"mappings":""}

package/dist/types/src/cubing/alg/alg-nodes/leaves/Move.d.ts

@@ -0,0 +1,52 @@
+import { AlgCommon, Comparable } from "../../common";
+import { IterationDirection } from "../../iteration";
+import type { AlgLeaf } from "../AlgNode";
+interface QuantumMoveModifications {
+    outerLayer?: number;
+    innerLayer?: number;
+    family?: string;
+}
+export declare class QuantumMove extends Comparable {
+    #private;
+    constructor(family: string, innerLayer?: number | null, outerLayer?: number | null);
+    static fromString(s: string): QuantumMove;
+    modified(modifications: QuantumMoveModifications): QuantumMove;
+    isIdentical(other: QuantumMove): boolean;
+    /** @deprecated */
+    get family(): string;
+    /** @deprecated */
+    get outerLayer(): number | null;
+    /** @deprecated */
+    get innerLayer(): number | null;
+    experimentalExpand(): Generator<AlgLeaf>;
+    toString(): string;
+}
+export interface MoveModifications {
+    outerLayer?: number;
+    innerLayer?: number;
+    family?: string;
+    amount?: number;
+}
+/** @category Alg Nodes */
+export declare class Move extends AlgCommon<Move> {
+    #private;
+    constructor(...args: [QuantumMove] | [QuantumMove, number] | [string] | [string, number]);
+    isIdentical(other: Comparable): boolean;
+    invert(): Move;
+    experimentalExpand(iterDir?: IterationDirection): Generator<AlgLeaf>;
+    get quantum(): QuantumMove;
+    modified(modifications: MoveModifications): Move;
+    static fromString(s: string): Move;
+    get amount(): number;
+    /** @deprecated */
+    get type(): string;
+    /** @deprecated */
+    get family(): string;
+    /** @deprecated */
+    get outerLayer(): number | undefined;
+    /** @deprecated */
+    get innerLayer(): number | undefined;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=Move.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/leaves/Move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Move.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/leaves/Move.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAKrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,UAAU,wBAAwB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,WAAY,SAAQ,UAAU;;gBAMvC,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,EAC1B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IA+C5B,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW;IAKzC,QAAQ,CAAC,aAAa,EAAE,wBAAwB,GAAG,WAAW;IAQ9D,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAWxC,kBAAkB;IAClB,IAAI,MAAM,IAAI,MAAM,CAEnB;IAGD,kBAAkB;IAClB,IAAI,UAAU,IAAI,MAAM,GAAG,IAAI,CAE9B;IAGD,kBAAkB;IAClB,IAAI,UAAU,IAAI,MAAM,GAAG,IAAI,CAE9B;IAED,kBAAkB,IAAI,SAAS,CAAC,OAAO,CAAC;IAM/B,QAAQ,IAAI,MAAM;CAU5B;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,0BAA0B;AAC1B,qBAAa,IAAK,SAAQ,SAAS,CAAC,IAAI,CAAC;;gBAIrC,GAAG,IAAI,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAqB9E,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAQvC,MAAM,IAAI,IAAI;IAQb,kBAAkB,CACjB,OAAO,GAAE,kBAAgD,GACxD,SAAS,CAAC,OAAO,CAAC;IAUrB,IAAI,OAAO,IAAI,WAAW,CAEzB;IAGD,QAAQ,CAAC,aAAa,EAAE,iBAAiB,GAAG,IAAI;IAQhD,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIlC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,kBAAkB;IAClB,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED,kBAAkB;IAClB,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,kBAAkB;IAClB,IAAI,UAAU,IAAI,MAAM,GAAG,SAAS,CAEnC;IAED,kBAAkB;IAClB,IAAI,UAAU,IAAI,MAAM,GAAG,SAAS,CAEnC;IAED,QAAQ,IAAI,MAAM;CAkCnB"}

package/dist/types/src/cubing/alg/alg-nodes/leaves/Move.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Move.spec.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/leaves/Move.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Move.spec.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/leaves/Move.spec.ts"],"names":[],"mappings":""}

package/dist/types/src/cubing/alg/alg-nodes/leaves/Newline.d.ts

@@ -0,0 +1,11 @@
+import { AlgCommon, Comparable } from "../../common";
+import { IterationDirection } from "../../iteration";
+import type { AlgLeaf } from "../AlgNode";
+/** @category Alg Nodes */
+export declare class Newline extends AlgCommon<Newline> {
+    toString(): string;
+    isIdentical(other: Comparable): boolean;
+    invert(): Newline;
+    experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<AlgLeaf>;
+}
+//# sourceMappingURL=Newline.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/leaves/Newline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Newline.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/leaves/Newline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,0BAA0B;AAC1B,qBAAa,OAAQ,SAAQ,SAAS,CAAC,OAAO,CAAC;IAC7C,QAAQ,IAAI,MAAM;IAIlB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAIvC,MAAM,IAAI,OAAO;IAIhB,kBAAkB,CACjB,QAAQ,GAAE,kBAAgD,EAC1D,MAAM,GAAE,MAAiB,GACxB,SAAS,CAAC,OAAO,CAAC;CAGtB"}

package/dist/types/src/cubing/alg/alg-nodes/leaves/Pause.d.ts

@@ -0,0 +1,13 @@
+import type { Grouping } from "..";
+import { AlgCommon, Comparable } from "../../common";
+import { IterationDirection } from "../../iteration";
+import type { AlgLeaf } from "../AlgNode";
+/** @category Alg Nodes */
+export declare class Pause extends AlgCommon<Pause> {
+    experimentalNISSGrouping?: Grouping;
+    toString(): string;
+    isIdentical(other: Comparable): boolean;
+    invert(): Pause;
+    experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<AlgLeaf>;
+}
+//# sourceMappingURL=Pause.d.ts.map

package/dist/types/src/cubing/alg/alg-nodes/leaves/Pause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pause.d.ts","sourceRoot":"","sources":["../../../../../../../src/cubing/alg/alg-nodes/leaves/Pause.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,0BAA0B;AAC1B,qBAAa,KAAM,SAAQ,SAAS,CAAC,KAAK,CAAC;IACzC,wBAAwB,CAAC,EAAE,QAAQ,CAAC;IAEpC,QAAQ,IAAI,MAAM;IAIlB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAIvC,MAAM,IAAI,KAAK;IAId,kBAAkB,CACjB,QAAQ,GAAE,kBAAgD,EAC1D,MAAM,GAAE,MAAiB,GACxB,SAAS,CAAC,OAAO,CAAC;CAGtB"}

package/dist/types/src/cubing/alg/common.d.ts

@@ -0,0 +1,20 @@
+import type { Alg } from "./Alg";
+import type { IterationDirection } from "./iteration";
+import type { AlgLeaf, AlgNode } from "./alg-nodes/AlgNode";
+export declare function setAlgDebugField(debug: boolean): void;
+export declare abstract class Comparable {
+    is(c: any): boolean;
+    as<T>(c: new (...args: any) => T): T | null;
+    abstract isIdentical(other: Comparable): boolean;
+}
+export interface Repeatable extends Comparable {
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<AlgLeaf>;
+}
+export declare abstract class AlgCommon<T extends Alg | AlgNode> extends Comparable implements Repeatable {
+    constructor();
+    get log(): (message?: any) => void;
+    abstract toString(): string;
+    abstract invert(): T;
+    abstract experimentalExpand(iterDir: IterationDirection): Generator<AlgLeaf>;
+}
+//# sourceMappingURL=common.d.ts.map

package/dist/types/src/cubing/alg/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAG5D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAErD;AAED,8BAAsB,UAAU;IAC9B,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,OAAO;IAInB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI;IAI3C,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;CACjD;AAED,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C,kBAAkB,CAChB,OAAO,CAAC,EAAE,kBAAkB,EAC5B,KAAK,CAAC,EAAE,MAAM,GACb,SAAS,CAAC,OAAO,CAAC,CAAC;CACvB;AAGD,8BAAsB,SAAS,CAAC,CAAC,SAAS,GAAG,GAAG,OAAO,CACrD,SAAQ,UACR,YAAW,UAAU;;IAarB,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,CAMjC;aAEiB,QAAQ,IAAI,MAAM;IAEpC,QAAQ,CAAC,MAAM,IAAI,CAAC;IAEpB,QAAQ,CAAC,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,SAAS,CAAC,OAAO,CAAC;CAC7E"}

package/dist/types/src/cubing/alg/cubing-private/index.d.ts

@@ -0,0 +1,3 @@
+export { directedGenerator as experimentalDirectedGenerator, direct as experimentalDirect, IterationDirection as ExperimentalIterationDirection, } from "../iteration";
+export type { QuantumDirectionalCancellation } from "../simplify";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/cubing/alg/cubing-private/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/cubing/alg/cubing-private/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,IAAI,6BAA6B,EAClD,MAAM,IAAI,kBAAkB,EAC5B,kBAAkB,IAAI,8BAA8B,GACrD,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC"}

package/dist/types/src/cubing/alg/debug.d.ts

@@ -0,0 +1,11 @@
+declare type ReportingLevel = "none" | "warn" | "error";
+export declare function reportTypeMismatch(msg: string): void;
+export declare function setAlgPartTypeMismatchReportingLevel(level: ReportingLevel): void;
+export declare const algDebugGlobals: {
+    caratNISSNotationEnabled: boolean;
+};
+export declare function setAlgDebug(options: {
+    caratNISSNotationEnabled?: boolean;
+}): void;
+export {};
+//# sourceMappingURL=debug.d.ts.map

package/dist/types/src/cubing/alg/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/debug.ts"],"names":[],"mappings":"AAAA,aAAK,cAAc,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAOhD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAcpD;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,cAAc,GACpB,IAAI,CAEN;AAED,eAAO,MAAM,eAAe,EAAE;IAAE,wBAAwB,EAAE,OAAO,CAAA;CAEhE,CAAC;AAEF,wBAAgB,WAAW,CAAC,OAAO,EAAE;IACnC,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,GAAG,IAAI,CAKP"}

package/dist/types/src/cubing/alg/example.d.ts

@@ -0,0 +1,15 @@
+import { Alg } from "./Alg";
+export declare const Example: {
+    Sune: Alg;
+    AntiSune: Alg;
+    SuneCommutator: Alg;
+    Niklas: Alg;
+    EPerm: Alg;
+    FURURFCompact: Alg;
+    APermCompact: Alg;
+    FURURFMoves: Alg;
+    TPerm: Alg;
+    HeadlightSwaps: Alg;
+    TriplePause: Alg;
+};
+//# sourceMappingURL=example.d.ts.map

package/dist/types/src/cubing/alg/example.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/example.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAO5B,eAAO,MAAM,OAAO;;;;;;;;;;;;CA4InB,CAAC"}

package/dist/types/src/cubing/alg/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * For a walkthrough, see:
+ *
+ * https://js.cubing.net/cubing/alg/
+ *
+ * @packageDocumentation
+ */
+export { Alg } from "./Alg";
+export { AlgBuilder } from "./AlgBuilder";
+export { TraversalDownUp, TraversalUp, functionFromTraversal, } from "./traversal";
+export { Example } from "./example";
+export { keyToMove } from "./keyboard";
+export * from "./alg-nodes";
+export type { MoveModifications } from "./alg-nodes/leaves/Move";
+export type { AlgLeaf, AlgBranch, AlgNode } from "./alg-nodes/AlgNode";
+export { experimentalAlgCubingNetLink } from "./url";
+export type { AlgCubingNetOptions } from "./url";
+export { experimentalAppendMove } from "./simplify";
+export type { PuzzleSpecificSimplifyOptions, SimplifyOptions, AppendCancelOptions, } from "./simplify";
+export { experimentalIs } from "./is";
+export type { Parsed as ExperimentalParsed } from "./parseAlg";
+export { setAlgDebug } from "./debug";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/cubing/alg/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EACL,eAAe,EACf,WAAW,EACX,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,YAAY,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,OAAO,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAEjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,YAAY,EACV,6BAA6B,EAC7B,eAAe,EACf,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAGtC,YAAY,EAAE,MAAM,IAAI,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE/D,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/types/src/cubing/alg/is.d.ts

@@ -0,0 +1,5 @@
+import type { Alg } from "./Alg";
+import { Commutator, Conjugate, Grouping, LineComment, Move, Newline, Pause } from "./alg-nodes";
+export declare function experimentalIs(v: any, c: typeof Alg | typeof Grouping | typeof LineComment | typeof Commutator | typeof Conjugate | typeof Move | typeof Newline | typeof Pause): boolean;
+export declare function experimentalIsAlgNode(v: any): boolean;
+//# sourceMappingURL=is.d.ts.map

package/dist/types/src/cubing/alg/is.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/is.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EACL,UAAU,EACV,SAAS,EACT,QAAQ,EACR,WAAW,EACX,IAAI,EACJ,OAAO,EACP,KAAK,EACN,MAAM,aAAa,CAAC;AAErB,wBAAgB,cAAc,CAC5B,CAAC,EAAE,GAAG,EACN,CAAC,EACG,OAAO,GAAG,GACV,OAAO,QAAQ,GACf,OAAO,WAAW,GAClB,OAAO,UAAU,GACjB,OAAO,SAAS,GAChB,OAAO,IAAI,GACX,OAAO,OAAO,GACd,OAAO,KAAK,GACf,OAAO,CAET;AACD,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,GAAG,OAAO,CAUrD"}

package/dist/types/src/cubing/alg/iteration.d.ts

@@ -0,0 +1,10 @@
+export declare enum IterationDirection {
+    Forwards = 1,
+    Backwards = -1
+}
+export declare function toggleDirection(iterationDirection: IterationDirection, flip?: boolean): IterationDirection;
+export declare function direct<T>(g: Iterable<T>, iterDir: IterationDirection): Iterable<T>;
+export declare function reverse<T>(g: Iterable<T>): Iterable<T>;
+export declare function directedGenerator<T>(g: Generator<T>, direction: IterationDirection): Generator<T>;
+export declare function reverseGenerator<T>(g: Generator<T>): Generator<T>;
+//# sourceMappingURL=iteration.d.ts.map

package/dist/types/src/cubing/alg/iteration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/iteration.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,QAAQ,IAAI;IACZ,SAAS,KAAK;CACf;AAED,wBAAgB,eAAe,CAC7B,kBAAkB,EAAE,kBAAkB,EACtC,IAAI,GAAE,OAAc,GACnB,kBAAkB,CAUpB;AAED,wBAAgB,MAAM,CAAC,CAAC,EACtB,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EACd,OAAO,EAAE,kBAAkB,GAC1B,QAAQ,CAAC,CAAC,CAAC,CAEb;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEtD;AAED,wBAAiB,iBAAiB,CAAC,CAAC,EAClC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EACf,SAAS,EAAE,kBAAkB,GAC5B,SAAS,CAAC,CAAC,CAAC,CAId;AAED,wBAAiB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAIlE"}

package/dist/types/src/cubing/alg/keyboard.d.ts

@@ -0,0 +1,3 @@
+import type { AlgLeaf } from "./alg-nodes/AlgNode";
+export declare function keyToMove(e: KeyboardEvent): AlgLeaf | null;
+//# sourceMappingURL=keyboard.d.ts.map

package/dist/types/src/cubing/alg/keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/keyboard.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AA4CnD,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO,GAAG,IAAI,CAM1D"}

package/dist/types/src/cubing/alg/limits.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_INT = 2147483647;
+export declare const MAX_INT_DESCRIPTION = "2^31 - 1";
+export declare const MIN_INT = -2147483648;
+export declare const MIN_INT_DESCRIPTION = "-2^31";
+//# sourceMappingURL=limits.d.ts.map

package/dist/types/src/cubing/alg/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../../../../src/cubing/alg/limits.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,aAAa,CAAC;AAClC,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAC9C,eAAO,MAAM,OAAO,cAAc,CAAC;AACnC,eAAO,MAAM,mBAAmB,UAAU,CAAC"}