cubing 0.61.0 → 0.61.1

package/dist/lib/cubing/{KPattern-CU9Suh1T.d.ts → PuzzleLoader-CkghxdIL.d.ts}

@@ -357,10 +357,6 @@ interface NotationMapper {
     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 = [
@@ -381,7 +377,7 @@ declare class PuzzleGeometryFullOptions {
     outerBlockMoves: boolean;
     vertexMoves: boolean;
     addRotations: boolean;
-    moveList: string[] | null;
+    moveList: (string | Move)[] | null;
     fixedOrientation: boolean;
     fixedPieceType: null | "e" | "v" | "f";
     orientCenters: boolean;
@@ -414,157 +410,6 @@ declare class Perm {
     order(): number;
 }
 
-type KPatternData = Record<string, KPatternOrbitData>;
-interface KPatternOrbitData {
-    pieces: number[];
-    orientation: number[];
-    /** Each piece may have an "orientation mod" that means "the orientation of
-     * this piece is known mod [value]".
-     *
-     * Suppose `.numOrientations` for this orbit has a value of N. This is
-     * considered the default value for the orientation mod of each piece in the
-     * orbit.
-     *
-     * - Each entry must be one of the following:
-     *   - A proper divisor of N.
-     *     - For example: if N is 12, then one of: 1, 2, 3, 6
-     *   - The special value 0, indicating the default value (N).
-     *     - This indicates that the orientation of a piece is fully known, i.e.
-     *        that its "orientation mod" is the default value (N). However, such a
-     *        value is recorded as 0 instead of N, in order to make it simpler to
-     *        implement and debug pattern logic involving the default value.
-     * - If `.orientationMod[i]` is a proper divisor of N (i.e. not 0), then
-     *   `.orientation[i]` must be less than `.orientationMod[i]`. That is, the
-     *   orientation values must be individually "normalized" for each piece.
-     * - If the `orientationMod` field is not present, then every piece is
-     *   considered to have the default value for its "orientation mod".
-     *
-     * For a "real-world" example of this concept, consider a traditional analog
-     * 12-hour clock dial, like one that might hang on the wall in a school room.
-     * Although there are 24 hours in a day, A.M. and P.M. times are not
-     * distinguishable on such a clock. Since 3:00 (AM) and 15:00 are not
-     * distinguishable, we would read either of those times as 3:00 with an
-     * implicit "orientation mod" of 12.
-     *
-     * For most puzzles, however, we care about "visual" indistinguishability
-     * rather than "temporal" indistinguishability. To adapt the previous example,
-     * imagine a 24-hour clock with 24 hour marks around the dial, but where the
-     * hour hand is symmetric and points equally at the current hour as well as
-     * its diametic opposite (like a compass needle but painted all in one color).
-     * This has the same set of "valid patterns" as a normal 12-hour clock. Such a
-     * clock also has an "orientation mod" of 12, but where the multiples of the
-     * modulus have been "unfolded" to show their full symmetry instead of being
-     * implicit.
-     *
-     * For a non-trivial puzzle example, consider Eitan's FisherTwist, a shape mod
-     * of the 3x3x3 cube:
-     * https://www.hknowstore.com/locale/en-US/item.aspx?corpname=nowstore&itemid=97eb4e89-367e-4d02-b7f0-34e5e7f3cd12
-     *
-     * - The 4 equatorial centers have C₂ symmetry — it is possible to rotate any
-     *   of these centers 180° without a visible change to the state. This means
-     *   that the possible orientations "loop" after incrementing the orientation
-     *   by 2 (two turns clockwise), and therefore the "orientation mod" of a
-     *   given piece is only 2.
-     *   - If we apply a counter-clockwise rotation to one of these centers, the
-     *     transformation applies an orientation of 3. But the net orientation is
-     *     recorded as a normalized value of 1 instead, because 3 (mod 2) ≡ 1 (mod
-     *     2).
-     * - The 2 polar centers (U and D) have no distinguishable rotations. This
-     *   means that their orientation is "known mod 1" — any transformation of one
-     *   of these centers is indistinguishable from another transformation of the
-     *   same center, and all of them are mapped to a value of 0 (the only
-     *   possible value that exists mod 1).
-     *
-     * For 3x3x3:
-     *
-     * - When solving a normal 3x3x3, center orientations are conventionally
-     *   ignored. This is similar to the polar center case for Eitan's
-     *   FisherTwist, and the "orientation mod" of each piece is 1. This is also
-     *   the core motivating use case.
-     * - For a supercube
-     *   (https://experiments.cubing.net/cubing.js/twisty/supercube.html) or the
-     *   general case of a "picture cube", all four center orientations are
-     *   distinguishable for every center. This means all centers have the default
-     *   orientation mod of 4. As documented above, this can be recorded with a
-     *   `.orientationMod` of `[0, 0, 0, 0, 0, 0]`, or equivalently by omitting
-     *   the `.orientationMod` field.
-     * - When modeling a real 3x3x3 speedcube, it is common to have a logo on a
-     *   single sticker. If you want to model the exact visually distinguishable
-     *   states of such a puzzles, it is possible to use an `.orientationMod` such
-     *   as `[0, 1, 1, 1, 1, 1]`. For example, this can make it easy to find an
-     *   alg for a given case "while keeping the logo the same", without placing
-     *   more restrictions on other centers (which could make the search slower or
-     *   produce longer solutions).
-     *
-     * For those with a mathematical background, you may notice a relationship to
-     * the concept of a coset (https://en.wikipedia.org/wiki/Coset). For example,
-     * consider the group of patterns of a `KPuzzle` (without indistinguishable
-     * pieces) generated by a set of transformations. We can assign each set of
-     * piece orbits an orientation mod value (which must be identical for all
-     * constituent pieces of the same orbit). Each such choice generates a set of
-     * valid `KPattern`s that forms a subgroup, and each set of valid `.orientation`
-     * values defines one coset of this set. However, note that the set of valid
-     * `KPattern`s does *not* form a group when there are any pieces with different
-     * `.orientationMod` values that share an orbit.
-     *
-     * --------
-     *
-     * Note that the concept of "orientation mod" exclusively applies to `KPattern`,
-     * not `KTransformation`. If we tried to apply the orientation mod
-     * calculations to the *transformations* of Eitan's FisherTwist, then `SWAP =
-     * [U, M' E2 M]` would be indistinguishable from the identity. This would mean
-     * that if we calculated `SWAP` and then used this calculation for `S SWAP
-     * S'`, then we would conclude that it has no net effect. However, `S SWAP S'`
-     * does *not* have the same effect as doing nothing — it visibly rotates the L
-     * and R centers! (In mathematical terms: the set of `KTransformation`s would
-     * not form a valid set of semigroup actions, due to broken associativity.)
-     *
-     * Although there are times that we could theoretically save some time/space
-     * by ignoring some information when it's not needed for working with certain
-     * `KTransformation`s (e.g. ignoring all center orientations for 3x3x3), it is
-     * more practical for each `KTransformation` to always track the full range
-     * for each piece's `.orientation`. For example:
-     *
-     * - This is simpler, both conceptually and in code.
-     * - This allows changing the set of moves for a puzzle, without recalculating
-     *   cached transformations or certain lookup tables (useful for alg
-     *   searches).
-     * - This allows swapping out a normal 3x3x3 in a `<twisty-player>` for a
-     *   picture cube, without re-calculating the center orientations of the
-     *   current alg.
-     *
-     * These use cases may not be strictly "necessary", but the opposite behaviour
-     * might be surprising or frustrating if someone does not expect it. So we
-     * implement it this way.
-     *
-     * Informally, the `KTransformation` has the full responsibility for tracking
-     * "what really happens" — even if the effect is invisible in some cases,
-     * while the `KPattern` tracks both what "is" and what "isn't" known.
-     **/
-    orientationMod?: number[];
-}
-type KTransformationData = Record<string, KTransformationOrbitData>;
-interface KTransformationOrbitData {
-    permutation: number[];
-    orientationDelta: number[];
-}
-interface KPuzzleOrbitDefinition {
-    orbitName: string;
-    numPieces: number;
-    numOrientations: number;
-}
-interface KPuzzleDefinition {
-    name: string;
-    orbits: KPuzzleOrbitDefinition[];
-    defaultPattern: KPatternData;
-    moves: Record<string, KTransformationData>;
-    derivedMoves?: Record<string, string>;
-    experimentalIsPatternSolved?: (kpattern: KPattern, options: {
-        ignorePuzzleOrientation: boolean;
-        ignoreCenterOrientation: boolean;
-    }) => boolean;
-}
-
 declare class PGOrbitDef {
     size: number;
     mod: number;
@@ -635,10 +480,10 @@ declare class VisibleState extends PGTransformBase {
 }
 
 type PuzzleDescriptionString = string;
-declare const PGPuzzles: {
+declare const pgPuzzle: {
     [name: string]: PuzzleDescriptionString;
 };
-type PuzzleName = keyof typeof PGPuzzles;
+type PuzzleName = keyof typeof pgPuzzle;
 
 declare class Quat {
     a: number;
@@ -839,6 +684,168 @@ declare class PGNotation {
     remapKPuzzleDefinition(kpuzzleDefinition: KPuzzleDefinition): KPuzzleDefinition;
 }
 
+type KPatternData = {
+    [orbitName: string]: KPatternOrbitData;
+};
+interface KPatternOrbitData {
+    pieces: number[];
+    orientation: number[];
+    /** Each piece may have an "orientation mod" that means "the orientation of
+     * this piece is known mod [value]".
+     *
+     * Suppose `.numOrientations` for this orbit has a value of N. This is
+     * considered the default value for the orientation mod of each piece in the
+     * orbit.
+     *
+     * - Each entry must be one of the following:
+     *   - A proper divisor of N.
+     *     - For example: if N is 12, then one of: 1, 2, 3, 6
+     *   - The special value 0, indicating the default value (N).
+     *     - This indicates that the orientation of a piece is fully known, i.e.
+     *        that its "orientation mod" is the default value (N). However, such a
+     *        value is recorded as 0 instead of N, in order to make it simpler to
+     *        implement and debug pattern logic involving the default value.
+     * - If `.orientationMod[i]` is a proper divisor of N (i.e. not 0), then
+     *   `.orientation[i]` must be less than `.orientationMod[i]`. That is, the
+     *   orientation values must be individually "normalized" for each piece.
+     * - If the `orientationMod` field is not present, then every piece is
+     *   considered to have the default value for its "orientation mod".
+     *
+     * For a "real-world" example of this concept, consider a traditional analog
+     * 12-hour clock dial, like one that might hang on the wall in a school room.
+     * Although there are 24 hours in a day, A.M. and P.M. times are not
+     * distinguishable on such a clock. Since 3:00 (AM) and 15:00 are not
+     * distinguishable, we would read either of those times as 3:00 with an
+     * implicit "orientation mod" of 12.
+     *
+     * For most puzzles, however, we care about "visual" indistinguishability
+     * rather than "temporal" indistinguishability. To adapt the previous example,
+     * imagine a 24-hour clock with 24 hour marks around the dial, but where the
+     * hour hand is symmetric and points equally at the current hour as well as
+     * its diametic opposite (like a compass needle but painted all in one color).
+     * This has the same set of "valid patterns" as a normal 12-hour clock. Such a
+     * clock also has an "orientation mod" of 12, but where the multiples of the
+     * modulus have been "unfolded" to show their full symmetry instead of being
+     * implicit.
+     *
+     * For a non-trivial puzzle example, consider Eitan's FisherTwist, a shape mod
+     * of the 3x3x3 cube:
+     * https://www.hknowstore.com/locale/en-US/item.aspx?corpname=nowstore&itemid=97eb4e89-367e-4d02-b7f0-34e5e7f3cd12
+     *
+     * - The 4 equatorial centers have C₂ symmetry — it is possible to rotate any
+     *   of these centers 180° without a visible change to the state. This means
+     *   that the possible orientations "loop" after incrementing the orientation
+     *   by 2 (two turns clockwise), and therefore the "orientation mod" of a
+     *   given piece is only 2.
+     *   - If we apply a counter-clockwise rotation to one of these centers, the
+     *     transformation applies an orientation of 3. But the net orientation is
+     *     recorded as a normalized value of 1 instead, because 3 (mod 2) ≡ 1 (mod
+     *     2).
+     * - The 2 polar centers (U and D) have no distinguishable rotations. This
+     *   means that their orientation is "known mod 1" — any transformation of one
+     *   of these centers is indistinguishable from another transformation of the
+     *   same center, and all of them are mapped to a value of 0 (the only
+     *   possible value that exists mod 1).
+     *
+     * For 3x3x3:
+     *
+     * - When solving a normal 3x3x3, center orientations are conventionally
+     *   ignored. This is similar to the polar center case for Eitan's
+     *   FisherTwist, and the "orientation mod" of each piece is 1. This is also
+     *   the core motivating use case.
+     * - For a supercube
+     *   (https://experiments.cubing.net/cubing.js/twisty/supercube.html) or the
+     *   general case of a "picture cube", all four center orientations are
+     *   distinguishable for every center. This means all centers have the default
+     *   orientation mod of 4. As documented above, this can be recorded with a
+     *   `.orientationMod` of `[0, 0, 0, 0, 0, 0]`, or equivalently by omitting
+     *   the `.orientationMod` field.
+     * - When modeling a real 3x3x3 speedcube, it is common to have a logo on a
+     *   single sticker. If you want to model the exact visually distinguishable
+     *   states of such a puzzles, it is possible to use an `.orientationMod` such
+     *   as `[0, 1, 1, 1, 1, 1]`. For example, this can make it easy to find an
+     *   alg for a given case "while keeping the logo the same", without placing
+     *   more restrictions on other centers (which could make the search slower or
+     *   produce longer solutions).
+     *
+     * For those with a mathematical background, you may notice a relationship to
+     * the concept of a coset (https://en.wikipedia.org/wiki/Coset). For example,
+     * consider the group of patterns of a `KPuzzle` (without indistinguishable
+     * pieces) generated by a set of transformations. We can assign each set of
+     * piece orbits an orientation mod value (which must be identical for all
+     * constituent pieces of the same orbit). Each such choice generates a set of
+     * valid `KPattern`s that forms a subgroup, and each set of valid `.orientation`
+     * values defines one coset of this set. However, note that the set of valid
+     * `KPattern`s does *not* form a group when there are any pieces with different
+     * `.orientationMod` values that share an orbit.
+     *
+     * --------
+     *
+     * Note that the concept of "orientation mod" exclusively applies to `KPattern`,
+     * not `KTransformation`. If we tried to apply the orientation mod
+     * calculations to the *transformations* of Eitan's FisherTwist, then `SWAP =
+     * [U, M' E2 M]` would be indistinguishable from the identity. This would mean
+     * that if we calculated `SWAP` and then used this calculation for `S SWAP
+     * S'`, then we would conclude that it has no net effect. However, `S SWAP S'`
+     * does *not* have the same effect as doing nothing — it visibly rotates the L
+     * and R centers! (In mathematical terms: the set of `KTransformation`s would
+     * not form a valid set of semigroup actions, due to broken associativity.)
+     *
+     * Although there are times that we could theoretically save some time/space
+     * by ignoring some information when it's not needed for working with certain
+     * `KTransformation`s (e.g. ignoring all center orientations for 3x3x3), it is
+     * more practical for each `KTransformation` to always track the full range
+     * for each piece's `.orientation`. For example:
+     *
+     * - This is simpler, both conceptually and in code.
+     * - This allows changing the set of moves for a puzzle, without recalculating
+     *   cached transformations or certain lookup tables (useful for alg
+     *   searches).
+     * - This allows swapping out a normal 3x3x3 in a `<twisty-player>` for a
+     *   picture cube, without re-calculating the center orientations of the
+     *   current alg.
+     *
+     * These use cases may not be strictly "necessary", but the opposite behaviour
+     * might be surprising or frustrating if someone does not expect it. So we
+     * implement it this way.
+     *
+     * Informally, the `KTransformation` has the full responsibility for tracking
+     * "what really happens" — even if the effect is invisible in some cases,
+     * while the `KPattern` tracks both what "is" and what "isn't" known.
+     **/
+    orientationMod?: number[];
+}
+type KTransformationData = {
+    [orbitName: string]: KTransformationOrbitData;
+};
+interface KTransformationOrbitData {
+    permutation: number[];
+    orientationDelta: number[];
+}
+interface KPuzzleOrbitDefinition {
+    orbitName: string;
+    numPieces: number;
+    numOrientations: number;
+}
+interface KPuzzleDefinitionJSON {
+    name: string;
+    orbits: KPuzzleOrbitDefinition[];
+    defaultPattern: KPatternData;
+    moves: {
+        [orbitName: string]: KTransformationData;
+    };
+    derivedMoves?: {
+        [derivedMove: string]: string;
+    };
+}
+
+interface KPuzzleDefinition extends KPuzzleDefinitionJSON {
+    experimentalIsPatternSolved?: (kpattern: KPattern, options: {
+        ignorePuzzleOrientation: boolean;
+        ignoreCenterOrientation: boolean;
+    }) => boolean;
+}
+
 declare class KTransformation {
     #private;
     readonly kpuzzle: KPuzzle;
@@ -879,6 +886,26 @@ declare class KPuzzle {
     canConvertDefaultPatternToUniqueTransformation(): boolean;
 }
 
+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 MillisecondTimestamp = Tagged<DOMHighResTimeStamp, "MillisecondTimestamp">;
 type MillisecondDuration = Tagged<number, "MillisecondDuration">;
 declare enum Direction {
@@ -2322,24 +2349,4 @@ interface PuzzleLoader {
     algTransformData?: AlgTransformData;
 }
 
-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 { Newline as $, type AlgLeaf as A, type MillisecondTimestamp as B, type LeafIndex as C, KTransformation as D, type ExperimentalStickering as E, type MillisecondDuration as F, type BackViewLayout as G, backViewLayouts as H, TwistyAlgViewer as I, type TwistyPlayerConfig as J, KPattern as K, type LeafCount as L, Move as M, NO_VALUE as N, TwistyPlayer as O, Perm as P, Quat as Q, TwizzleLink as R, type StickerDat as S, TwistyAlgEditor as T, type AlgNode as U, type VisualizationFormat as V, type AppendOptions as W, Grouping as X, LineComment as Y, Commutator as Z, Conjugate as _, type PuzzleGeometryOptions as a, Pause as a0, type KeyMapping as a1, type AlgBranch as a2, type GroupingModifications as a3, type MoveModifications as a4, type Parsed as a5, type ExperimentalNotationType as a6, type ExperimentalSerializationOptions as a7, type AppendCancelOptions as a8, type SimplifyOptions as a9, QuantumMove as aa, type KPatternData as ab, type KPatternOrbitData as ac, type KPuzzleDefinition as ad, type KTransformationData as ae, type KTransformationOrbitData as af, type StickerDatAxis as b, type StickerDatFace as c, type StickerDatSticker as d, getPuzzleDescriptionString as e, getPuzzleGeometryByDesc as f, getPG3DNamedPuzzles as g, getPuzzleGeometryByName as h, PGNotation as i, PUZZLE_BASE_SHAPES as j, PUZZLE_CUT_TYPES as k, type PuzzleBaseShape as l, type PuzzleCutDescription as m, type PuzzleCutType as n, type PuzzleDescription as o, parseOptions as p, PuzzleGeometry as q, parsePuzzleDescription 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 AlgTransformData as y, type AlgIndexer as z };
+export { Pause as $, type AlgLeaf as A, type LeafIndex as B, KTransformation as C, type MillisecondDuration as D, type ExperimentalStickering as E, type BackViewLayout as F, backViewLayouts as G, TwistyAlgViewer as H, type TwistyPlayerConfig as I, TwistyPlayer as J, KPattern as K, type LeafCount as L, Move as M, NO_VALUE as N, TwizzleLink as O, Perm as P, Quat as Q, type AlgNode as R, type StickerDat as S, TwistyAlgEditor as T, type AppendOptions as U, type VisualizationFormat as V, Grouping as W, LineComment as X, Commutator as Y, Conjugate as Z, Newline as _, type PuzzleGeometryOptions as a, type KeyMapping as a0, type AlgBranch as a1, type GroupingModifications as a2, type MoveModifications as a3, type Parsed as a4, type ExperimentalNotationType as a5, type ExperimentalSerializationOptions as a6, type AppendCancelOptions as a7, type SimplifyOptions as a8, QuantumMove as a9, type KPuzzleDefinition as aa, type KPatternData as ab, type KPatternOrbitData as ac, type KPuzzleOrbitDefinition as ad, type KTransformationData as ae, type KTransformationOrbitData as af, type StickerDatAxis as b, type StickerDatFace as c, type StickerDatSticker as d, getPuzzleDescriptionString as e, getPuzzleGeometryByDesc as f, getPG3DNamedPuzzles as g, getPuzzleGeometryByName as h, PGNotation as i, PUZZLE_BASE_SHAPES as j, PUZZLE_CUT_TYPES as k, type PuzzleBaseShape as l, type PuzzleCutDescription as m, type PuzzleCutType as n, type PuzzleDescription as o, PuzzleGeometry as p, parsePuzzleDescription as q, Alg as r, type PuzzleLoader as s, type PuzzleID as t, KPuzzle as u, type StickeringMask as v, type PuzzleSpecificSimplifyOptions as w, type AlgTransformData as x, type AlgIndexer as y, type MillisecondTimestamp as z };

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

@@ -1,5 +1,5 @@
-import { U as AlgNode, s as Alg, M as Move, W as AppendOptions, X as Grouping, Y as LineComment, Z as Commutator, _ as Conjugate, $ as Newline, a0 as Pause, a1 as KeyMapping, A as AlgLeaf } from '../KPattern-CU9Suh1T.js';
-export { a2 as AlgBranch, a8 as AppendCancelOptions, a6 as ExperimentalNotationType, a5 as ExperimentalParsed, a7 as ExperimentalSerializationOptions, a3 as GroupingModifications, a4 as MoveModifications, x as PuzzleSpecificSimplifyOptions, aa as QuantumMove, a9 as SimplifyOptions } from '../KPattern-CU9Suh1T.js';
+import { R as AlgNode, r as Alg, M as Move, U as AppendOptions, W as Grouping, X as LineComment, Y as Commutator, Z as Conjugate, _ as Newline, $ as Pause, a0 as KeyMapping, A as AlgLeaf } from '../PuzzleLoader-CkghxdIL.js';
+export { a1 as AlgBranch, a7 as AppendCancelOptions, a5 as ExperimentalNotationType, a4 as ExperimentalParsed, a6 as ExperimentalSerializationOptions, a2 as GroupingModifications, a3 as MoveModifications, w as PuzzleSpecificSimplifyOptions, a9 as QuantumMove, a8 as SimplifyOptions } from '../PuzzleLoader-CkghxdIL.js';
 import 'type-fest';
 import 'three/src/Three.js';
 

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

@@ -1,6 +1,6 @@
-import { u as PuzzleID, t as PuzzleLoader, a1 as KeyMapping, K as KPattern, s as Alg, M as Move, B as MillisecondTimestamp } from '../KPattern-CU9Suh1T.js';
-import { B as BluetoothPuzzle } from '../bluetooth-puzzle-gTRbIRyj.js';
-export { A as MoveEvent, O as OrientationEvent } from '../bluetooth-puzzle-gTRbIRyj.js';
+import { t as PuzzleID, s as PuzzleLoader, a0 as KeyMapping, K as KPattern, r as Alg, M as Move, z as MillisecondTimestamp } from '../PuzzleLoader-CkghxdIL.js';
+import { B as BluetoothPuzzle } from '../bluetooth-puzzle-c-_IBAdu.js';
+export { A as MoveEvent, O as OrientationEvent } from '../bluetooth-puzzle-c-_IBAdu.js';
 import 'type-fest';
 import 'three/src/Three.js';
 

package/dist/lib/cubing/bluetooth/index.js

@@ -1,17 +1,17 @@
 import {
   binaryComponentsToReid3x3x3,
   twizzleBinaryToBinaryComponents
-} from "../chunks/chunk-ABQAUY7H.js";
+} from "../chunks/chunk-557DMXD6.js";
 import {
   puzzles
-} from "../chunks/chunk-WIZJQ7QS.js";
+} from "../chunks/chunk-UZ7SWKN6.js";
 import {
   cube3x3x3,
   experimental3x3x3KPuzzle
-} from "../chunks/chunk-RUSWM2KK.js";
+} from "../chunks/chunk-ST4K23C3.js";
 import {
   KPattern
-} from "../chunks/chunk-PSQEELP4.js";
+} from "../chunks/chunk-WAYEJXCG.js";
 import {
   Alg,
   Move,

package/dist/lib/cubing/{bluetooth-puzzle-gTRbIRyj.d.ts → bluetooth-puzzle-c-_IBAdu.d.ts}

@@ -1,4 +1,4 @@
-import { A as AlgLeaf, K as KPattern } from './KPattern-CU9Suh1T.js';
+import { A as AlgLeaf, K as KPattern } from './PuzzleLoader-CkghxdIL.js';
 
 interface StreamTransformer {
     transformAlgLeaf(algLeafEvent: AlgLeafEvent): void;

package/dist/lib/cubing/chunks/{chunk-ABQAUY7H.js → chunk-557DMXD6.js}

@@ -3,10 +3,10 @@ import {
   normalize3x3x3Orientation,
   puzzleOrientation3x3x3Cache,
   puzzleOrientation3x3x3Idx
-} from "./chunk-RUSWM2KK.js";
+} from "./chunk-ST4K23C3.js";
 import {
   KPattern
-} from "./chunk-PSQEELP4.js";
+} from "./chunk-WAYEJXCG.js";
 
 // src/cubing/protocol/binary/orbit-indexing.ts
 function identityPermutation(numElems) {
@@ -262,4 +262,4 @@ export {
   bufferToSpacedHex,
   spacedHexToBuffer
 };
-//# sourceMappingURL=chunk-ABQAUY7H.js.map
+//# sourceMappingURL=chunk-557DMXD6.js.map

package/dist/lib/cubing/chunks/{chunk-RKTO4CAU.js → chunk-7DT3G3FA.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7GUL3OBQ.js";
 import {
   node_adapter_default
-} from "./chunk-NX2Q6B7Y.js";
+} from "./chunk-ZKJKRQKY.js";
 import {
   Alg
 } from "./chunk-7D7ZUWUK.js";
@@ -348,4 +348,4 @@ export {
   solveTwips,
   setSearchDebug
 };
-//# sourceMappingURL=chunk-RKTO4CAU.js.map
+//# sourceMappingURL=chunk-7DT3G3FA.js.map

package/dist/lib/cubing/chunks/{chunk-BUZPONAW.js → chunk-I5QO52OG.js}

@@ -1,6 +1,6 @@
 import {
   cube3x3x3KPuzzleDefinition
-} from "./chunk-RUSWM2KK.js";
+} from "./chunk-ST4K23C3.js";
 import {
   TraversalUp,
   functionFromTraversal
@@ -270,4 +270,4 @@ export {
   countLeavesInExpansionForSimultaneousMoveIndexer,
   countMetricMoves
 };
-//# sourceMappingURL=chunk-BUZPONAW.js.map
+//# sourceMappingURL=chunk-I5QO52OG.js.map

package/dist/lib/cubing/chunks/{chunk-PVOSBZRD.js → chunk-KZGAQEPN.js}

@@ -1,6 +1,6 @@
 import {
   from
-} from "./chunk-RUSWM2KK.js";
+} from "./chunk-ST4K23C3.js";
 
 // src/cubing/twisty/debug.ts
 var twistyDebugGlobals = {
@@ -527,7 +527,7 @@ var StatsPanel = class {
 // src/cubing/twisty/heavy-code-imports/3d.ts
 var cachedConstructorProxy = null;
 async function bulk3DCode() {
-  return cachedConstructorProxy ??= import("./twisty-dynamic-3d-LPZQIDD2.js");
+  return cachedConstructorProxy ??= import("./twisty-dynamic-3d-OCL53BVF.js");
 }
 
 // src/cubing/twisty/views/canvas.ts
@@ -1171,4 +1171,4 @@ export {
   Twisty3DVantage,
   bulk3DCode
 };
-//# sourceMappingURL=chunk-PVOSBZRD.js.map
+//# sourceMappingURL=chunk-KZGAQEPN.js.map

package/dist/lib/cubing/chunks/{chunk-RUSWM2KK.js → chunk-ST4K23C3.js}

@@ -1,7 +1,7 @@
 import {
   KPattern,
   KPuzzle
-} from "./chunk-PSQEELP4.js";
+} from "./chunk-WAYEJXCG.js";
 import {
   Alg,
   Commutator,
@@ -1762,4 +1762,4 @@ export {
   PGPuzzleLoader,
   CubePGPuzzleLoader
 };
-//# sourceMappingURL=chunk-RUSWM2KK.js.map
+//# sourceMappingURL=chunk-ST4K23C3.js.map