cubing 0.54.5 → 0.55.1

package/dist/lib/cubing/{PuzzleLoader-Ft_XlaHS.d.ts → KPattern-BXlfgC6b.d.ts}

@@ -1,356 +1,10 @@
 import { Texture, Object3D, Raycaster, PerspectiveCamera, Scene, WebGLRenderer } from 'three';
 
-type ExperimentalNotationType$1 = "auto" | "LGN";
-interface ExperimentalSerializationOptions$1 {
-    notation?: ExperimentalNotationType$1;
-}
-
-declare enum IterationDirection$1 {
-    Forwards = 1,
-    Backwards = -1
-}
-
 type ExperimentalNotationType = "auto" | "LGN";
 interface ExperimentalSerializationOptions {
     notation?: ExperimentalNotationType;
 }
 
-declare abstract class Comparable$1 {
-    is(c: any): boolean;
-    as<T>(c: new (...args: any) => T): T | null;
-    abstract isIdentical(other: Comparable$1): boolean;
-}
-interface Repeatable$1 extends Comparable$1 {
-    experimentalExpand(iterDir?: IterationDirection$1, depth?: number): Generator<AlgLeaf$1>;
-}
-declare abstract class AlgCommon$1<T extends Alg$1 | AlgNode$1> extends Comparable$1 implements Repeatable$1 {
-    constructor();
-    get log(): (message?: any) => void;
-    abstract toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
-    abstract invert(): T;
-    abstract experimentalExpand(iterDir: IterationDirection$1): Generator<AlgLeaf$1>;
-}
-
-interface QuantumMoveModifications$1 {
-    outerLayer?: number;
-    innerLayer?: number;
-    family?: string;
-}
-declare class QuantumMove$1 extends Comparable$1 {
-    #private;
-    constructor(family: string, innerLayer?: number | null, outerLayer?: number | null);
-    static fromString(s: string): QuantumMove$1;
-    modified(modifications: QuantumMoveModifications$1): QuantumMove$1;
-    isIdentical(other: QuantumMove$1): boolean;
-    /** @deprecated */
-    get family(): string;
-    /** @deprecated */
-    get outerLayer(): number | null;
-    /** @deprecated */
-    get innerLayer(): number | null;
-    experimentalExpand(): Generator<AlgLeaf$1>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-}
-interface MoveModifications$1 {
-    outerLayer?: number;
-    innerLayer?: number;
-    family?: string;
-    amount?: number;
-}
-/** @category Alg Nodes */
-declare class Move$1 extends AlgCommon$1<Move$1> {
-    #private;
-    constructor(...args: [QuantumMove$1] | [QuantumMove$1, number] | [string] | [string, number]);
-    isIdentical(other: Comparable$1): boolean;
-    invert(): Move$1;
-    experimentalExpand(iterDir?: IterationDirection$1): Generator<AlgLeaf$1>;
-    get quantum(): QuantumMove$1;
-    modified(modifications: MoveModifications$1): Move$1;
-    static fromString(s: string): Move$1;
-    get amount(): number;
-    /** @deprecated */
-    get type(): string;
-    /** @deprecated */
-    get family(): string;
-    /** @deprecated */
-    get outerLayer(): number | undefined;
-    /** @deprecated */
-    get innerLayer(): number | undefined;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-}
-
-/** @category Alg Nodes */
-declare class Pause$1 extends AlgCommon$1<Pause$1> {
-    experimentalNISSGrouping?: Grouping$1;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-    isIdentical(other: Comparable$1): boolean;
-    invert(): Pause$1;
-    experimentalExpand(_iterDir?: IterationDirection$1, _depth?: number): Generator<AlgLeaf$1>;
-}
-
-/** @category Alg Nodes */
-declare class Grouping$1 extends AlgCommon$1<Grouping$1> {
-    #private;
-    experimentalNISSPlaceholder?: Pause$1;
-    constructor(algSource: FlexibleAlgSource$1, amount?: number);
-    isIdentical(other: Comparable$1): boolean;
-    get alg(): Alg$1;
-    get amount(): number;
-    /** @deprecated */
-    get experimentalRepetitionSuffix(): string;
-    invert(): Grouping$1;
-    experimentalExpand(iterDir?: IterationDirection$1, depth?: number): Generator<AlgLeaf$1>;
-    static fromString(): Grouping$1;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-    experimentalAsSquare1Tuple(): [moveU: Move$1, moveD: Move$1] | null;
-}
-
-/** @category Alg Nodes */
-declare class LineComment$1 extends AlgCommon$1<LineComment$1> {
-    #private;
-    constructor(commentText: string);
-    get text(): string;
-    isIdentical(other: Comparable$1): boolean;
-    invert(): LineComment$1;
-    experimentalExpand(_iterDir?: IterationDirection$1, _depth?: number): Generator<AlgLeaf$1>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-}
-
-/** @category Alg Nodes */
-declare class Commutator$1 extends AlgCommon$1<Commutator$1> {
-    #private;
-    constructor(aSource: FlexibleAlgSource$1, bSource: FlexibleAlgSource$1);
-    get A(): Alg$1;
-    get B(): Alg$1;
-    isIdentical(other: Comparable$1): boolean;
-    invert(): Commutator$1;
-    experimentalExpand(iterDir?: IterationDirection$1, depth?: number): Generator<AlgLeaf$1>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-}
-
-/** @category Alg Nodes */
-declare class Conjugate$1 extends AlgCommon$1<Conjugate$1> {
-    #private;
-    constructor(aSource: FlexibleAlgSource$1, bSource: FlexibleAlgSource$1);
-    get A(): Alg$1;
-    get B(): Alg$1;
-    isIdentical(other: Comparable$1): boolean;
-    invert(): Conjugate$1;
-    experimentalExpand(iterDir: IterationDirection$1, depth?: number): Generator<AlgLeaf$1>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-}
-
-/** @category Alg Nodes */
-declare class Newline$1 extends AlgCommon$1<Newline$1> {
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
-    isIdentical(other: Comparable$1): boolean;
-    invert(): Newline$1;
-    experimentalExpand(_iterDir?: IterationDirection$1, _depth?: number): Generator<AlgLeaf$1>;
-}
-
-/** @category Alg Nodes */
-type AlgLeaf$1 = Move$1 | LineComment$1 | Newline$1 | Pause$1;
-/** @category Alg Nodes */
-type AlgBranch$1 = Grouping$1 | Conjugate$1 | Commutator$1;
-/** @category Alg Nodes */
-type AlgNode$1 = AlgLeaf$1 | AlgBranch$1;
-
-declare const DEFAULT_DIRECTIONAL$1 = "any-direction";
-type QuantumDirectionalCancellation$1 = typeof DEFAULT_DIRECTIONAL$1 | "same-direction" | "none";
-type ModWrap$1 = "none" | "gravity" | "canonical-centered" | "canonical-positive" | "preserve-sign";
-interface AppendCancelOptions$1 {
-    directional?: QuantumDirectionalCancellation$1;
-    puzzleSpecificModWrap?: ModWrap$1;
-}
-interface AppendOptions$1 {
-    cancel?: boolean | AppendCancelOptions$1;
-    puzzleLoader?: {
-        puzzleSpecificSimplifyOptions?: PuzzleSpecificSimplifyOptions$1;
-    };
-    puzzleSpecificSimplifyOptions?: PuzzleSpecificSimplifyOptions$1;
-}
-interface SimplifyOptions$1 extends AppendOptions$1 {
-    depth?: number | null;
-}
-interface PuzzleSpecificAxisSimplifyInfo$1 {
-    areQuantumMovesSameAxis: (quantumMove1: QuantumMove$1, quantumMove2: QuantumMove$1) => boolean;
-    simplifySameAxisMoves: (moves: Move$1[], quantumMod: boolean) => Move$1[];
-}
-interface PuzzleSpecificSimplifyOptions$1 {
-    quantumMoveOrder?: (quantumMove: QuantumMove$1) => number;
-    axis?: PuzzleSpecificAxisSimplifyInfo$1;
-}
-
-type FlexibleAlgSource$1 = string | Iterable<AlgNode$1> | Alg$1;
-/**
- * `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
- */
-declare class Alg$1 extends AlgCommon$1<Alg$1> {
-    #private;
-    constructor(alg?: FlexibleAlgSource$1);
-    /**
-     * 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$1): 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$1;
-    /** @deprecated Use {@link Alg.expand} instead. */
-    experimentalExpand(iterDir?: IterationDirection$1, depth?: number): Generator<AlgLeaf$1>;
-    /**
-     * 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$1;
-    /** @deprecated */
-    experimentalLeafMoves(): Generator<Move$1>;
-    concat(input: FlexibleAlgSource$1): Alg$1;
-    /** @deprecated */
-    experimentalIsEmpty(): boolean;
-    static fromString(s: string): Alg$1;
-    /** @deprecated */
-    units(): Generator<AlgNode$1>;
-    childAlgNodes(): Generator<AlgNode$1>;
-    /** @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(experimentalSerializationOptions?: ExperimentalSerializationOptions): 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$1): Alg$1;
-    /** @deprecated See {@link experimentalSimplify} */
-    simplify(options?: SimplifyOptions$1): Alg$1;
-}
-
 declare enum IterationDirection {
     Forwards = 1,
     Backwards = -1
@@ -367,7 +21,7 @@ interface Repeatable extends Comparable {
 declare abstract class AlgCommon<T extends Alg | AlgNode> extends Comparable implements Repeatable {
     constructor();
     get log(): (message?: any) => void;
-    abstract toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    abstract toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
     abstract invert(): T;
     abstract experimentalExpand(iterDir: IterationDirection): Generator<AlgLeaf>;
 }
@@ -390,7 +44,7 @@ declare class QuantumMove extends Comparable {
     /** @deprecated */
     get innerLayer(): number | null;
     experimentalExpand(): Generator<AlgLeaf>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
 }
 interface MoveModifications {
     outerLayer?: number;
@@ -417,13 +71,13 @@ declare class Move extends AlgCommon<Move> {
     get outerLayer(): number | undefined;
     /** @deprecated */
     get innerLayer(): number | undefined;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
 }
 
 /** @category Alg Nodes */
 declare class Pause extends AlgCommon<Pause> {
     experimentalNISSGrouping?: Grouping;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
     isIdentical(other: Comparable): boolean;
     invert(): Pause;
     experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<AlgLeaf>;
@@ -442,7 +96,7 @@ declare class Grouping extends AlgCommon<Grouping> {
     invert(): Grouping;
     experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<AlgLeaf>;
     static fromString(): Grouping;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
     experimentalAsSquare1Tuple(): [moveU: Move, moveD: Move] | null;
 }
 
@@ -454,7 +108,7 @@ declare class LineComment extends AlgCommon<LineComment> {
     isIdentical(other: Comparable): boolean;
     invert(): LineComment;
     experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<AlgLeaf>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
 }
 
 /** @category Alg Nodes */
@@ -466,7 +120,7 @@ declare class Commutator extends AlgCommon<Commutator> {
     isIdentical(other: Comparable): boolean;
     invert(): Commutator;
     experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<AlgLeaf>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
 }
 
 /** @category Alg Nodes */
@@ -478,12 +132,12 @@ declare class Conjugate extends AlgCommon<Conjugate> {
     isIdentical(other: Comparable): boolean;
     invert(): Conjugate;
     experimentalExpand(iterDir: IterationDirection, depth?: number): Generator<AlgLeaf>;
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
 }
 
 /** @category Alg Nodes */
 declare class Newline extends AlgCommon<Newline> {
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
     isIdentical(other: Comparable): boolean;
     invert(): Newline;
     experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<AlgLeaf>;
@@ -636,7 +290,7 @@ declare class Alg extends AlgCommon<Alg> {
      *     // R U2 L
      *     console.log(alg.toString())
      */
-    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions$1): string;
+    toString(experimentalSerializationOptions?: ExperimentalSerializationOptions): string;
     /**
      * `experimentalSimplify` can perform several mostly-syntactic simplifications on an alg:
      *
@@ -692,19 +346,15 @@ declare class Alg extends AlgCommon<Alg> {
     simplify(options?: SimplifyOptions): Alg;
 }
 
-declare const startCharIndexKey: unique symbol;
-declare const endCharIndexKey: unique symbol;
-interface ParserIndexed {
-    [startCharIndexKey]: number;
-    [endCharIndexKey]: number;
-}
-type Parsed<T extends Alg | AlgNode> = T & ParserIndexed;
-
 interface NotationMapper {
     notationToInternal(move: Move): Move | null;
     notationToExternal(move: Move): Move | null;
 }
 
+declare function parseOptions(argv: string[]): {
+    puzzleDescription: PuzzleDescription | null;
+    options: PuzzleGeometryOptions;
+};
 type FaceName = string;
 type OrientationDirection = [number, number, number];
 type FaceBasedOrientationDescription = [
@@ -758,47 +408,6 @@ declare class Perm {
     order(): number;
 }
 
-declare class KTransformation {
-    #private;
-    readonly kpuzzle: KPuzzle;
-    readonly transformationData: KTransformationData;
-    constructor(kpuzzle: KPuzzle, transformationData: KTransformationData);
-    toJSON(): any;
-    invert(): KTransformation;
-    isIdentityTransformation(): boolean;
-    /** @deprecated */
-    static experimentalConstructIdentity(kpuzzle: KPuzzle): KTransformation;
-    isIdentical(t2: KTransformation): boolean;
-    /** @deprecated */
-    apply(source: KTransformationSource): KTransformation;
-    applyTransformation(t2: KTransformation): KTransformation;
-    applyMove(move: Move | string): KTransformation;
-    applyAlg(alg: Alg | string): KTransformation;
-    toKPattern(): KPattern;
-    repetitionOrder(): number;
-    selfMultiply(amount: number): KTransformation;
-}
-
-declare class KPattern {
-    readonly kpuzzle: KPuzzle;
-    readonly patternData: KPatternData;
-    constructor(kpuzzle: KPuzzle, patternData: KPatternData);
-    toJSON(): any;
-    static fromTransformation(transformation: KTransformation): KPattern;
-    /** @deprecated */
-    apply(source: KTransformationSource): KPattern;
-    applyTransformation(transformation: KTransformation): KPattern;
-    applyMove(move: Move | string): KPattern;
-    applyAlg(alg: Alg | string): KPattern;
-    isIdentical(other: KPattern): boolean;
-    /** @deprecated */
-    experimentalToTransformation(): KTransformation | null;
-    experimentalIsSolved(options: {
-        ignorePuzzleOrientation: boolean;
-        ignoreCenterOrientation: boolean;
-    }): boolean;
-}
-
 type KPatternData = Record<string, KPatternOrbitData>;
 interface KPatternOrbitData {
     pieces: number[];
@@ -1020,6 +629,10 @@ declare class VisibleState extends PGTransformBase {
 }
 
 type PuzzleDescriptionString = string;
+declare const PGPuzzles: {
+    [name: string]: PuzzleDescriptionString;
+};
+type PuzzleName = keyof typeof PGPuzzles;
 
 declare class Quat {
     a: number;
@@ -1091,6 +704,10 @@ interface StickerDat {
     notationMapper: NotationMapper;
     textureMapper: TextureMapper;
 }
+declare function getPG3DNamedPuzzles(): {
+    [s: string]: PuzzleDescriptionString;
+};
+declare function getPuzzleDescriptionString(puzzleName: PuzzleName): PuzzleDescriptionString;
 declare const PUZZLE_BASE_SHAPES: readonly ["c", "t", "o", "d", "i"];
 type PuzzleBaseShape = (typeof PUZZLE_BASE_SHAPES)[number];
 declare const PUZZLE_CUT_TYPES: readonly ["f", "v", "e"];
@@ -1103,6 +720,9 @@ type PuzzleDescription = {
     shape: PuzzleBaseShape;
     cuts: PuzzleCutDescription[];
 };
+declare function parsePuzzleDescription(s: PuzzleDescriptionString): PuzzleDescription | null;
+declare function getPuzzleGeometryByDesc(desc: string, options?: PuzzleGeometryOptions): PuzzleGeometry;
+declare function getPuzzleGeometryByName(puzzleName: PuzzleName, options?: PuzzleGeometryOptions): PuzzleGeometry;
 type MoveSetGeo = [string, string, string, string, number];
 /** @category PuzzleGeometry */
 declare class PuzzleGeometry {
@@ -1213,6 +833,27 @@ declare class PGNotation {
     remapKPuzzleDefinition(kpuzzleDefinition: KPuzzleDefinition): KPuzzleDefinition;
 }
 
+declare class KTransformation {
+    #private;
+    readonly kpuzzle: KPuzzle;
+    readonly transformationData: KTransformationData;
+    constructor(kpuzzle: KPuzzle, transformationData: KTransformationData);
+    toJSON(): any;
+    invert(): KTransformation;
+    isIdentityTransformation(): boolean;
+    /** @deprecated */
+    static experimentalConstructIdentity(kpuzzle: KPuzzle): KTransformation;
+    isIdentical(t2: KTransformation): boolean;
+    /** @deprecated */
+    apply(source: KTransformationSource): KTransformation;
+    applyTransformation(t2: KTransformation): KTransformation;
+    applyMove(move: Move | string): KTransformation;
+    applyAlg(alg: Alg | string): KTransformation;
+    toKPattern(): KPattern;
+    repetitionOrder(): number;
+    selfMultiply(amount: number): KTransformation;
+}
+
 type KTransformationSource = Alg | Move | string | KTransformation;
 declare class KPuzzle {
     #private;
@@ -2418,6 +2059,14 @@ declare global {
     }
 }
 
+declare const startCharIndexKey: unique symbol;
+declare const endCharIndexKey: unique symbol;
+interface ParserIndexed {
+    [startCharIndexKey]: number;
+    [endCharIndexKey]: number;
+}
+type Parsed<T extends Alg | AlgNode> = T & ParserIndexed;
+
 declare class DataDown {
     earliestMoveIndex: number;
     twistyAlgViewer: TwistyAlgViewer;
@@ -2615,4 +2264,24 @@ interface PuzzleLoader {
     keyMapping?: () => Promise<KeyMapping>;
 }
 
-export { Alg$1 as A, Commutator$1 as C, type ExperimentalNotationType as E, Grouping$1 as G, IterationDirection$1 as I, type KeyMapping as K, LineComment$1 as L, Move$1 as M, Newline$1 as N, type PuzzleSpecificSimplifyOptions$1 as P, QuantumMove$1 as Q, type SimplifyOptions$1 as S, type AlgNode$1 as a, type AlgLeaf$1 as b, type AppendOptions$1 as c, Conjugate$1 as d, Pause$1 as e, type MoveModifications$1 as f, type AlgBranch$1 as g, type AppendCancelOptions$1 as h, type ExperimentalSerializationOptions as i, type AlgLeaf as j };
+declare class KPattern {
+    readonly kpuzzle: KPuzzle;
+    readonly patternData: KPatternData;
+    constructor(kpuzzle: KPuzzle, patternData: KPatternData);
+    toJSON(): any;
+    static fromTransformation(transformation: KTransformation): KPattern;
+    /** @deprecated */
+    apply(source: KTransformationSource): KPattern;
+    applyTransformation(transformation: KTransformation): KPattern;
+    applyMove(move: Move | string): KPattern;
+    applyAlg(alg: Alg | string): KPattern;
+    isIdentical(other: KPattern): boolean;
+    /** @deprecated */
+    experimentalToTransformation(): KTransformation | null;
+    experimentalIsSolved(options: {
+        ignorePuzzleOrientation: boolean;
+        ignoreCenterOrientation: boolean;
+    }): boolean;
+}
+
+export { LineComment as $, type AlgLeaf as A, TwistyPlayer as B, TwistyAlgViewer as C, type Duration as D, type ExperimentalStickering as E, TwistyAlgEditor as F, type TwistyPlayerConfig as G, type BackViewLayout as H, backViewLayouts as I, TwizzleLink as J, KPattern as K, type MillisecondTimestamp as L, Move as M, NO_VALUE as N, type AlgNode as O, Perm as P, Quat as Q, type AppendOptions as R, type StickerDat as S, type Timestamp as T, type KeyMapping as U, type VisualizationFormat as V, Grouping as W, Commutator as X, Conjugate as Y, Pause as Z, Newline as _, getPuzzleGeometryByDesc as a, type MoveModifications as a0, type AlgBranch as a1, type AppendCancelOptions as a2, type SimplifyOptions as a3, type Parsed as a4, type ExperimentalNotationType as a5, type ExperimentalSerializationOptions as a6, QuantumMove as a7, type KPuzzleDefinition as a8, type KPatternData as a9, type KPatternOrbitData as aa, type KTransformationData as ab, type KTransformationOrbitData as ac, getPuzzleGeometryByName as b, getPG3DNamedPuzzles as c, PuzzleGeometry as d, type StickerDatAxis as e, type StickerDatFace as f, getPuzzleDescriptionString as g, type StickerDatSticker as h, parseOptions as i, type PuzzleGeometryOptions as j, PGNotation as k, type PuzzleCutDescription as l, type PuzzleDescription as m, PUZZLE_CUT_TYPES as n, type PuzzleCutType as o, parsePuzzleDescription as p, PUZZLE_BASE_SHAPES as q, type PuzzleBaseShape as r, Alg as s, type PuzzleLoader as t, type PuzzleID as u, KPuzzle as v, type StickeringMask as w, type PuzzleSpecificSimplifyOptions as x, type AlgIndexer as y, KTransformation as z };

package/dist/lib/cubing/alg/index.d.ts

@@ -1,6 +1,5 @@
-import { a as AlgNode, A as Alg, M as Move, c as AppendOptions, K as KeyMapping, b as AlgLeaf, G as Grouping, C as Commutator, d as Conjugate, e as Pause, N as Newline, L as LineComment } from '../PuzzleLoader-Ft_XlaHS.js';
-export { g as AlgBranch, h as AppendCancelOptions, E as ExperimentalNotationType, i as ExperimentalSerializationOptions, f as MoveModifications, P as PuzzleSpecificSimplifyOptions, Q as QuantumMove, S as SimplifyOptions } from '../PuzzleLoader-Ft_XlaHS.js';
-export { P as ExperimentalParsed } from '../parseAlg.d-DgyP8Jpl.js';
+import { O as AlgNode, s as Alg, M as Move, R as AppendOptions, U as KeyMapping, A as AlgLeaf, W as Grouping, X as Commutator, Y as Conjugate, Z as Pause, _ as Newline, $ as LineComment } from '../KPattern-BXlfgC6b.js';
+export { a1 as AlgBranch, a2 as AppendCancelOptions, a5 as ExperimentalNotationType, a4 as ExperimentalParsed, a6 as ExperimentalSerializationOptions, a0 as MoveModifications, x as PuzzleSpecificSimplifyOptions, a7 as QuantumMove, a3 as SimplifyOptions } from '../KPattern-BXlfgC6b.js';
 import 'three';
 
 /** @deprecated */

package/dist/lib/cubing/bluetooth/index.d.ts

@@ -1,10 +1,7 @@
-import { K as KPattern } from '../KPattern.d-tlN4iAuY.js';
-import { a as PuzzleID, P as PuzzleLoader } from '../TwizzleLink.d-DdZRboJ4.js';
-import { A as Alg, M as Move } from '../PuzzleLoader-Ft_XlaHS.js';
-import { B as BluetoothPuzzle } from '../bluetooth-puzzle.d-kb8nnIde.js';
-export { A as MoveEvent, O as OrientationEvent } from '../bluetooth-puzzle.d-kb8nnIde.js';
+import { u as PuzzleID, t as PuzzleLoader, K as KPattern, s as Alg, M as Move } from '../KPattern-BXlfgC6b.js';
+import { B as BluetoothPuzzle } from '../bluetooth-puzzle-CkZw4jC6.js';
+export { A as MoveEvent, O as OrientationEvent } from '../bluetooth-puzzle-CkZw4jC6.js';
 import 'three';
-import '../parseAlg.d-DgyP8Jpl.js';
 
 declare function enableDebugLogging(enable: boolean): void;
 

package/dist/lib/cubing/{bluetooth-puzzle.d-kb8nnIde.d.ts → bluetooth-puzzle-CkZw4jC6.d.ts}

@@ -1,5 +1,4 @@
-import { b as AlgLeaf } from './PuzzleLoader-Ft_XlaHS.js';
-import { K as KPattern } from './KPattern.d-tlN4iAuY.js';
+import { A as AlgLeaf, K as KPattern } from './KPattern-BXlfgC6b.js';
 
 interface StreamTransformer {
     transformAlgLeaf(algLeafEvent: AlgLeafEvent): void;

package/dist/lib/cubing/chunks/{chunk-YUHH4EXE.js → chunk-6WYRN27C.js}

@@ -1,13 +1,14 @@
 import {
-  getBuiltinModule,
   node_adapter_default
-} from "./chunk-GOT3GVLG.js";
+} from "./chunk-RDSQRW3G.js";
 
 // src/cubing/vendor/apache/comlink-everywhere/inside/index.ts
 import { expose as comlinkExpose } from "comlink";
 var useNodeWorkarounds = typeof globalThis.Worker === "undefined" && typeof globalThis.WorkerNavigator === "undefined";
 async function nodeEndpointPort() {
-  const { parentPort } = await getBuiltinModule("node:worker_threads");
+  const { parentPort } = globalThis.process.getBuiltinModule(
+    "node:worker_threads"
+  );
   return node_adapter_default(
     parentPort
   );
@@ -26,4 +27,4 @@ export {
   nodeEndpointPort,
   expose
 };
-//# sourceMappingURL=chunk-YUHH4EXE.js.map
+//# sourceMappingURL=chunk-6WYRN27C.js.map

package/dist/lib/cubing/chunks/chunk-6WYRN27C.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cubing/vendor/apache/comlink-everywhere/inside/index.ts"],
+  "sourcesContent": ["import { expose as comlinkExpose } from \"comlink\";\nimport nodeEndpoint from \"../node-adapter\";\n\nconst useNodeWorkarounds =\n  typeof globalThis.Worker === \"undefined\" &&\n  typeof (globalThis as any).WorkerNavigator === \"undefined\";\n\nexport async function nodeEndpointPort(): Promise<\n  Worker & {\n    nodeWorker?: import(\"node:worker_threads\").Worker;\n  }\n> {\n  const { parentPort } = globalThis.process.getBuiltinModule(\n    \"node:worker_threads\",\n  );\n  return nodeEndpoint(\n    parentPort as unknown as import(\"node:worker_threads\").Worker,\n  );\n}\n\nexport function expose(api: any) {\n  if (useNodeWorkarounds) {\n    (async () => {\n      comlinkExpose(api, await nodeEndpointPort());\n    })();\n  } else {\n    comlinkExpose(api);\n  }\n}\n"],
+  "mappings": ";;;;;AAAA,SAAS,UAAU,qBAAqB;AAGxC,IAAM,qBACJ,OAAO,WAAW,WAAW,eAC7B,OAAQ,WAAmB,oBAAoB;AAEjD,eAAsB,mBAIpB;AACA,QAAM,EAAE,WAAW,IAAI,WAAW,QAAQ;AAAA,IACxC;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,EACF;AACF;AAEO,SAAS,OAAO,KAAU;AAC/B,MAAI,oBAAoB;AACtB,KAAC,YAAY;AACX,oBAAc,KAAK,MAAM,iBAAiB,CAAC;AAAA,IAC7C,GAAG;AAAA,EACL,OAAO;AACL,kBAAc,GAAG;AAAA,EACnB;AACF;",
+  "names": []
+}