cubing 0.25.14 → 0.26.2

package/dist/types/bluetooth/smart-puzzle/gocube.d.ts

@@ -1,22 +0,0 @@
-/// <reference types="web-bluetooth" />
-import { Alg } from "../../alg";
-import { BluetoothConfig, BluetoothPuzzle } from "./bluetooth-puzzle";
-export declare class GoCube extends BluetoothPuzzle {
-    private server;
-    goCubeStateCharacteristic: BluetoothRemoteGATTCharacteristic;
-    static connect(server: BluetoothRemoteGATTServer): Promise<GoCube>;
-    private recorded;
-    private homeQuatInverse;
-    private lastRawQuat;
-    private currentQuat;
-    private lastTarget;
-    private alg;
-    private constructor();
-    disconnect(): void;
-    reset(): void;
-    resetAlg(alg?: Alg): void;
-    resetOrientation(): void;
-    name(): string | undefined;
-    private onCubeCharacteristicChanged;
-}
-export declare const goCubeConfig: BluetoothConfig<BluetoothPuzzle>;

package/dist/types/bluetooth/smart-robot/GanRobot.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="web-bluetooth" />
-import { Alg, Move } from "../../alg";
-import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
-export interface GanRobotStatus {
-    movesRemaining: number;
-}
-interface GanRobotOptions {
-    xAngle: boolean;
-    singleMoveFixHack: boolean;
-    bufferQueue: number;
-    postSleep: number;
-}
-export declare class GanRobot extends EventTarget {
-    private server;
-    private statusCharacteristic;
-    private moveCharacteristic;
-    experimentalDebugOnSend: ((alg: Alg) => void) | null;
-    experimentalDebugLog: typeof console.log;
-    experimentalOptions: GanRobotOptions;
-    constructor(_service: BluetoothRemoteGATTService, server: BluetoothRemoteGATTServer, device: BluetoothDevice, statusCharacteristic: BluetoothRemoteGATTCharacteristic, moveCharacteristic: BluetoothRemoteGATTCharacteristic);
-    static connect(server: BluetoothRemoteGATTServer, device: BluetoothDevice): Promise<GanRobot>;
-    name(): string | undefined;
-    disconnect(): void;
-    onDisconnect(): void;
-    private moveToNibble;
-    private writeNibbles;
-    private getStatus;
-    locked: boolean;
-    processQueue(): void;
-    private moveQueue;
-    private queueMoves;
-    applyMoves(moves: Iterable<Move>): Promise<void>;
-}
-export declare const ganTimerConfig: BluetoothConfig<GanRobot>;
-export {};

package/dist/types/bluetooth/smart-robot/index.d.ts

@@ -1,4 +0,0 @@
-import { BluetoothConnectOptions } from "../connect";
-import { GanRobot } from "./GanRobot";
-export declare type BluetoothRobot = GanRobot;
-export declare function connectSmartRobot(options?: BluetoothConnectOptions): Promise<BluetoothRobot>;

package/dist/types/bluetooth/smart-timer/GanTimer.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="web-bluetooth" />
-import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
-export declare class GanTimer extends EventTarget {
-    private server;
-    private timeCharacteristic;
-    private polling;
-    private previousDetail;
-    constructor(_service: BluetoothRemoteGATTService, server: BluetoothRemoteGATTServer, device: BluetoothDevice, timeCharacteristic: BluetoothRemoteGATTCharacteristic);
-    static connect(server: BluetoothRemoteGATTServer, device: BluetoothDevice): Promise<GanTimer>;
-    disconnect(): void;
-    poll(): Promise<void>;
-    onDisconnect(): void;
-    getTimeCharacteristic(): Promise<Uint8Array>;
-    getTime(): Promise<number>;
-    decodeTimeMs(bytes: Uint8Array): number;
-    startPolling(): void;
-    stopPolling(): void;
-}
-export declare const ganTimerConfig: BluetoothConfig<GanTimer>;

package/dist/types/bluetooth/smart-timer/index.d.ts

@@ -1,4 +0,0 @@
-import { BluetoothConnectOptions } from "../connect";
-import { GanTimer } from "./GanTimer";
-export declare type BluetoothTimer = GanTimer;
-export declare function connectSmartTimer(options?: BluetoothConnectOptions): Promise<BluetoothTimer>;

package/dist/types/bluetooth/transformer.d.ts

@@ -1,9 +0,0 @@
-import type { MoveEvent, OrientationEvent } from "./smart-puzzle/bluetooth-puzzle";
-export interface StreamTransformer {
-    transformMove(moveEvent: MoveEvent): void;
-    transformOrientation(orientationEvent: OrientationEvent): void;
-}
-export declare class BasicRotationTransformer implements StreamTransformer {
-    transformMove(_moveEvent: MoveEvent): void;
-    transformOrientation(orientationEvent: OrientationEvent): void;
-}

package/dist/types/cubing.bundle-global.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/cubing.bundle-global.exports.d.ts

@@ -1,24 +0,0 @@
-import * as alg from "./alg";
-import * as bluetooth from "./bluetooth";
-import * as kpuzzle from "./kpuzzle";
-import * as notation from "./notation";
-import * as protocol from "./protocol";
-import * as puzzleGeometry from "./puzzle-geometry";
-import * as puzzles from "./puzzles";
-import * as scramble from "./scramble";
-import * as stream from "./stream";
-import * as search from "./search";
-import * as twisty from "./twisty";
-export declare const cubingBundleGlobalExports: {
-    alg: typeof alg;
-    bluetooth: typeof bluetooth;
-    kpuzzle: typeof kpuzzle;
-    notation: typeof notation;
-    protocol: typeof protocol;
-    puzzleGeometry: typeof puzzleGeometry;
-    puzzles: typeof puzzles;
-    scramble: typeof scramble;
-    stream: typeof stream;
-    search: typeof search;
-    twisty: typeof twisty;
-};

package/dist/types/kpuzzle/3x3x3/3x3x3.kpuzzle.json.d.ts

@@ -1,2 +0,0 @@
-import type { KPuzzleDefinition } from "../KPuzzleDefinition";
-export declare const cube3x3x3KPuzzleDefinition: KPuzzleDefinition;

package/dist/types/kpuzzle/3x3x3/3x3x3.kpuzzle.json.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/kpuzzle/3x3x3/puzzle-orientation.d.ts

@@ -1,5 +0,0 @@
-import { KState } from "../KState";
-export declare function experimentalIs3x3x3Solved(state: KState, options: {
-    ignorePuzzleOrientation: boolean;
-    ignoreCenterOrientation: boolean;
-}): boolean;

package/dist/types/kpuzzle/KPuzzle.d.ts

@@ -1,30 +0,0 @@
-import { Alg, Move } from "../alg";
-import type { PGNotation } from "../puzzle-geometry/PuzzleGeometry";
-import type { KPuzzleDefinition } from "./KPuzzleDefinition";
-import { KState } from "./KState";
-import { KTransformation } from "./KTransformation";
-export declare type KTransformationSource = Alg | Move | string | KTransformation;
-export declare class KPuzzle {
-    #private;
-    readonly definition: KPuzzleDefinition;
-    private experimentalPGNotation;
-    constructor(definition: KPuzzleDefinition, options?: {
-        experimentalPGNotation?: PGNotation;
-    });
-    name(): string;
-    identityTransformation(): KTransformation;
-    moveToTransformation(move: Move | string): KTransformation;
-    algToTransformation(alg: Alg | string): KTransformation;
-    /** @deprecated */
-    toTransformation(source: KTransformationSource): KTransformation;
-    startState(): KState;
-    canConvertStateToUniqueTransformation(): boolean;
-    /** @deprecated */
-    get state(): never;
-    /** @deprecated */
-    reset(): never;
-    /** @deprecated */
-    applyMove(_move: Move): never;
-    /** @deprecated */
-    applyAlg(_alg: Alg): never;
-}

package/dist/types/kpuzzle/KPuzzleDefinition.d.ts

@@ -1,21 +0,0 @@
-export declare type KTransformationData = Record<string, KTransformationOrbitData>;
-export interface KTransformationOrbitData {
-    permutation: number[];
-    orientation: number[];
-}
-export declare type KStateData = Record<string, KStateOrbitData>;
-export interface KStateOrbitData {
-    pieces: number[];
-    orientation: number[];
-}
-export interface KOrbitDefinition {
-    numPieces: number;
-    numOrientations: number;
-}
-export interface KPuzzleDefinition {
-    name: string;
-    orbits: Record<string, KOrbitDefinition>;
-    startStateData: KStateData;
-    moves: Record<string, KTransformationData>;
-    experimentalDerivedMoves?: Record<string, string>;
-}

package/dist/types/kpuzzle/KState.d.ts

@@ -1,23 +0,0 @@
-import type { KPuzzle } from ".";
-import type { Alg, Move } from "../alg";
-import type { KTransformationSource } from "./KPuzzle";
-import type { KStateData } from "./KPuzzleDefinition";
-import { KTransformation } from "./KTransformation";
-export declare class KState {
-    readonly kpuzzle: KPuzzle;
-    readonly stateData: KStateData;
-    constructor(kpuzzle: KPuzzle, stateData: KStateData);
-    toJSON(): any;
-    static fromTransformation(transformation: KTransformation): KState;
-    /** @deprecated */
-    apply(source: KTransformationSource): KState;
-    applyTransformation(transformation: KTransformation): KState;
-    applyMove(move: Move | string): KState;
-    applyAlg(alg: Alg | string): KState;
-    /** @deprecated */
-    experimentalToTransformation(): KTransformation | null;
-    experimentalIs3x3x3Solved(options: {
-        ignorePuzzleOrientation: boolean;
-        ignoreCenterOrientation: boolean;
-    }): boolean;
-}

package/dist/types/kpuzzle/KTransformation.d.ts

@@ -1,24 +0,0 @@
-import type { Alg, Move } from "../alg";
-import type { KPuzzle, KTransformationSource } from "./KPuzzle";
-import type { KTransformationData } from "./KPuzzleDefinition";
-import { KState } from "./KState";
-export 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;
-    toKState(): KState;
-    repetitionOrder(): number;
-    selfMultiply(amount: number): KTransformation;
-}

package/dist/types/kpuzzle/calculate.d.ts

@@ -1,16 +0,0 @@
-import type { KPuzzleDefinition } from ".";
-import { Alg } from "../alg";
-import type { KPuzzle } from "./KPuzzle";
-import type { KOrbitDefinition, KTransformationOrbitData, KTransformationData } from "./KPuzzleDefinition";
-import { KTransformation } from "./KTransformation";
-export declare function isOrbitTransformationDataIdentityUncached(numOrientations: number, orbitTransformationData: KTransformationOrbitData): boolean;
-export declare function isOrbitTransformationDataIdentical(orbitDefinition: KOrbitDefinition, orbitTransformationData1: KTransformationOrbitData, orbitTransformationData2: KTransformationOrbitData, options?: {
-    ignoreOrientation?: boolean;
-    ignorePermutation?: boolean;
-}): boolean;
-export declare function isTransformationDataIdentical(kpuzzle: KPuzzle, transformationData1: KTransformationData, transformationData2: KTransformationData): boolean;
-export declare function invertTransformation(kpuzzle: KPuzzle, transformationData: KTransformationData): KTransformationData;
-export declare function repeatTransformationUncached(kpuzzle: KPuzzle, transformationData: KTransformationData, amount: number): KTransformationData;
-export declare const algToTransformation: (alg: Alg, kpuzzle: KPuzzle) => KTransformation;
-export declare function canConvertStateToUniqueTransformationUncached(definition: KPuzzleDefinition): boolean;
-export declare function transformationRepetitionOrder(definition: KPuzzleDefinition, transformation: KTransformation): number;

package/dist/types/kpuzzle/combine.d.ts

@@ -1,3 +0,0 @@
-import type { KPuzzleDefinition, KStateData, KTransformationData } from "./KPuzzleDefinition";
-export declare function combineTransformationData(definition: KPuzzleDefinition, transformationData1: KTransformationData, transformationData2: KTransformationData): KTransformationData;
-export declare function applyTransformationDataToStateData(definition: KPuzzleDefinition, stateData: KStateData, transformationData: KTransformationData): KStateData;

package/dist/types/kpuzzle/construct.d.ts

@@ -1,5 +0,0 @@
-import type { Move } from "../alg";
-import type { KPuzzle } from "./KPuzzle";
-import type { KPuzzleDefinition, KTransformationData } from "./KPuzzleDefinition";
-export declare function constructIdentityTransformationDataUncached(definition: KPuzzleDefinition): KTransformationData;
-export declare function moveToTransformationUncached(kpuzzle: KPuzzle, move: Move): KTransformationData;

package/dist/types/notation/CountAnimatedLeaves.d.ts

@@ -1,2 +0,0 @@
-import { Alg } from "../alg";
-export declare const countAnimatedLeaves: (alg: Alg) => number;

package/dist/types/notation/CountMoves.d.ts

@@ -1,3 +0,0 @@
-import { Alg } from "../alg";
-export declare const countMoves: (alg: Alg) => number;
-export declare const countQuantumMoves: (alg: Alg) => number;

package/dist/types/protocol/binary/binary3x3x3.d.ts

@@ -1,19 +0,0 @@
-import { KState } from "../../kpuzzle";
-declare type Binary3x3x3State = ArrayBuffer;
-export interface Binary3x3x3Components {
-    epLex: number;
-    eoMask: number;
-    cpLex: number;
-    coMask: number;
-    poIdxU: number;
-    poIdxL: number;
-    moSupport: number;
-    moMask: number;
-}
-export declare function reid3x3x3ToBinaryComponents(state: KState): Binary3x3x3Components;
-export declare function binaryComponentsToTwizzleBinary(components: Binary3x3x3Components): Binary3x3x3State;
-export declare function reid3x3x3ToTwizzleBinary(state: KState): Binary3x3x3State;
-export declare function twizzleBinaryToBinaryComponents(buffer: ArrayBuffer): Binary3x3x3Components;
-export declare function binaryComponentsToReid3x3x3(components: Binary3x3x3Components): KState;
-export declare function twizzleBinaryToReid3x3x3(buffy: ArrayBuffer): KState;
-export {};

package/dist/types/protocol/binary/binary3x3x3.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/protocol/binary/hex.d.ts

@@ -1,2 +0,0 @@
-export declare function bufferToSpacedHex(buffer: ArrayBuffer): string;
-export declare function spacedHexToBuffer(hex: string): Uint8Array;

package/dist/types/protocol/binary/hex.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/protocol/binary/orbit-indexing.d.ts

@@ -1,5 +0,0 @@
-export declare function identityPermutation(numElems: number): number[];
-export declare function orientationsToMask(radix: number, orientations: number[]): number;
-export declare function maskToOrientations(radix: number, numElems: number, mask: number): number[];
-export declare function permutationToLex(permutation: number[]): number;
-export declare function lexToPermutation(numPieces: number, lexicographicIdx: number): number[];

package/dist/types/protocol/binary/orbit-indexing.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/protocol/binary/puzzle-orientation.d.ts

@@ -1,4 +0,0 @@
-import type { KState } from "../../kpuzzle/KState";
-export declare function puzzleOrientationIdx(state: KState): [number, number];
-export declare function normalizePuzzleOrientation(state: KState): KState;
-export declare function reorientPuzzle(state: KState, idxU: number, idxL: number): KState;

package/dist/types/puzzle-geometry/FaceNameSwizzler.d.ts

@@ -1,12 +0,0 @@
-export declare class FaceNameSwizzler {
-    facenames: string[];
-    prefixFree: boolean;
-    gripnames: string[];
-    constructor(facenames: string[], gripnames_arg?: string[]);
-    setGripNames(names: string[]): void;
-    splitByFaceNames(s: string): number[];
-    joinByFaceIndices(list: number[]): string;
-    spinmatch(userinput: string, longname: string): boolean;
-    spinmatchv(userinput: string, longname: string): boolean;
-    unswizzle(s: string): string;
-}

package/dist/types/puzzle-geometry/Options.d.ts

@@ -1,45 +0,0 @@
-import { PuzzleDescription } from "./PuzzleGeometry";
-export declare function parseOptions(argv: string[]): {
-    puzzleDescription: PuzzleDescription | null;
-    options: PuzzleGeometryOptions;
-};
-declare type FaceName = string;
-declare type OrientationDirection = [number, number, number];
-export declare type FaceBasedOrientationDescription = [
-    [
-        FaceName,
-        OrientationDirection
-    ],
-    [
-        FaceName,
-        OrientationDirection
-    ]
-];
-export declare type BaseFaceCount = 4 | 6 | 8 | 12 | 20;
-export declare type FaceBasedOrientationDescriptionLookup = Record<BaseFaceCount, FaceBasedOrientationDescription>;
-export declare class PuzzleGeometryFullOptions {
-    verbosity: number;
-    allMoves: boolean;
-    outerBlockMoves: boolean;
-    vertexMoves: boolean;
-    addRotations: boolean;
-    moveList: string[] | null;
-    fixedOrientation: boolean;
-    fixedPieceType: null | "e" | "v" | "f";
-    orientCenters: boolean;
-    includeCornerOrbits: boolean;
-    includeCenterOrbits: boolean;
-    includeEdgeOrbits: boolean;
-    excludeOrbits: string[];
-    optimizeOrbits: boolean;
-    grayCorners: boolean;
-    grayCenters: boolean;
-    grayEdges: boolean;
-    puzzleOrientation: FaceBasedOrientationDescription | null;
-    puzzleOrientations: FaceBasedOrientationDescriptionLookup | null;
-    scrambleAmount: number;
-    constructor(options?: PuzzleGeometryOptions);
-}
-export declare type PuzzleGeometryOptions = Partial<PuzzleGeometryFullOptions>;
-export declare function parsePGOptionList(optionlist?: any[]): PuzzleGeometryOptions;
-export {};

package/dist/types/puzzle-geometry/PGPuzzles.d.ts

@@ -1,5 +0,0 @@
-export declare type PuzzleDescriptionString = string;
-export declare const PGPuzzles: {
-    [name: string]: PuzzleDescriptionString;
-};
-export declare type PuzzleName = keyof typeof PGPuzzles;

package/dist/types/puzzle-geometry/PGPuzzles.spec.d.ts

@@ -1,4 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-export {};

package/dist/types/puzzle-geometry/Perm.d.ts

@@ -1,18 +0,0 @@
-export declare function zeros(n: number): number[];
-export declare function iota(n: number): number[];
-export declare function identity(n: number): Perm;
-export declare function random(n: number): Perm;
-export declare function factorial(a: number): number;
-export declare function lcm(a: number, b: number): number;
-export declare class Perm {
-    n: number;
-    p: number[];
-    constructor(a: number[]);
-    toString(): string;
-    mul(p2: Perm): Perm;
-    rmul(p2: Perm): Perm;
-    inv(): Perm;
-    compareTo(p2: Perm): number;
-    toGap(): string;
-    order(): number;
-}

package/dist/types/puzzle-geometry/PermOriSet.d.ts

@@ -1,71 +0,0 @@
-import type { KPuzzleDefinition, KTransformationData } from "../kpuzzle";
-import type { NotationMapper } from "./notation-mapping/NotationMapper";
-import { Perm } from "./Perm";
-export declare class PGOrbitDef {
-    size: number;
-    mod: number;
-    constructor(size: number, mod: number);
-    reassemblySize(): number;
-}
-export declare function externalName(mapper: NotationMapper, moveString: string): string;
-export declare class PGOrbitsDef {
-    orbitnames: string[];
-    private orbitdefs;
-    solved: VisibleState;
-    movenames: string[];
-    moveops: PGTransform[];
-    constructor(orbitnames: string[], orbitdefs: PGOrbitDef[], solved: VisibleState, movenames: string[], moveops: PGTransform[]);
-    transformToKTransformationData(t: PGTransform): KTransformationData;
-    static transformToKTransformationData(orbitnames: string[], t: PGTransform): KTransformationData;
-    toKsolve(name: string, mapper?: NotationMapper): string[];
-    toKPuzzleDefinition(includemoves: boolean): KPuzzleDefinition;
-    optimize(): PGOrbitsDef;
-    scramble(n: number): void;
-    getScrambleTransformation(n: number): PGTransform;
-    reassemblySize(): number;
-}
-export declare class PGOrbit {
-    perm: number[];
-    ori: number[];
-    orimod: number;
-    private static kcache;
-    static e(n: number, mod: number): PGOrbit;
-    constructor(perm: number[], ori: number[], orimod: number);
-    mul(b: PGOrbit): PGOrbit;
-    inv(): PGOrbit;
-    equal(b: PGOrbit): boolean;
-    killOri(): this;
-    toPerm(): Perm;
-    identicalPieces(): number[][];
-    order(): number;
-    isIdentity(): boolean;
-    private zeroOris;
-    remap(no: number[], on: number[], nv: number): PGOrbit;
-    remapVS(no: number[], nv: number): PGOrbit;
-    appendDefinition(result: string[], name: string, useVS: boolean, concise?: boolean): void;
-    toKPuzzle(): Record<string, number[]>;
-}
-export declare class PGTransformBase {
-    orbits: PGOrbit[];
-    constructor(orbits: PGOrbit[]);
-    internalMul(b: PGTransformBase): PGOrbit[];
-    protected internalInv(): PGOrbit[];
-    equal(b: PGTransformBase): boolean;
-    protected killOri(): this;
-    toPerm(): Perm;
-    identicalPieces(): number[][];
-    order(): number;
-}
-export declare class PGTransform extends PGTransformBase {
-    constructor(orbits: PGOrbit[]);
-    mul(b: PGTransform): PGTransform;
-    mulScalar(n: number): PGTransform;
-    inv(): PGTransform;
-    e(): PGTransform;
-}
-export declare class VisibleState extends PGTransformBase {
-    constructor(orbits: PGOrbit[]);
-    mul(b: PGTransform): VisibleState;
-}
-export declare function showcanon(g: PGOrbitsDef, disp: (s: string) => void): void;
-export declare function showcanon0(g: PGOrbitsDef, disp: (s: string) => void): void;

package/dist/types/puzzle-geometry/PlatonicGenerator.d.ts

@@ -1,10 +0,0 @@
- 
-import { Quat } from "./Quat";
-export declare function cube(): Quat[];
-export declare function tetrahedron(): Quat[];
-export declare function dodecahedron(): Quat[];
-export declare function icosahedron(): Quat[];
-export declare function octahedron(): Quat[];
-export declare function closure(g: Quat[]): Quat[];
-export declare function uniqueplanes(p: Quat, g: Quat[]): Quat[];
-export declare function getface(planes: Quat[]): Quat[];