cubing 0.25.13 → 0.26.1

package/dist/types/PuzzleLoader-a7faf593.d.ts

@@ -0,0 +1,172 @@
+import { a as KPuzzle } from './KState-ba36d9a3';
+import { h as PuzzleGeometry } from './KPuzzleDefinition-8531b592';
+
+interface UserVisibleError {
+    errors: string[];
+}
+declare class UserVisibleErrorTracker extends SimpleTwistyPropSource<UserVisibleError> {
+    getDefaultValue(): UserVisibleError;
+    reset(): void;
+    canReuseValue(_v1: UserVisibleError, _v2: UserVisibleError): boolean;
+}
+
+declare type InputRecord = {};
+declare type InputProps<T extends InputRecord> = {
+    [s in keyof T]: TwistyPropParent<T[s]>;
+};
+interface SourceEventDetail<OutputType> {
+    sourceProp: TwistyPropSource<OutputType, any>;
+    value: Promise<OutputType>;
+    generation: number;
+}
+declare type SourceEvent<T> = CustomEvent<SourceEventDetail<T>>;
+declare type PromiseOrValue<T> = T | Promise<T>;
+declare abstract class TwistyPropParent<T> {
+    #private;
+    abstract get(): Promise<T>;
+    canReuse(v1: T, v2: T): boolean;
+    canReuseValue(_v1: T, _v2: T): boolean;
+    debugGetChildren(): Array<TwistyPropDerived<any, any>>;
+    protected addChild(child: TwistyPropDerived<any, any>): void;
+    protected removeChild(child: TwistyPropDerived<any, any>): void;
+    protected lastSourceGeneration: number;
+    protected markStale(sourceEvent: SourceEvent<any>): void;
+    /** @deprecated */
+    addRawListener(listener: () => void, options?: {
+        initial: boolean;
+    }): void;
+    /** @deprecated */
+    removeRawListener(listener: () => void): void;
+    addFreshListener(listener: (value: T) => void): void;
+    removeFreshListener(listener: (value: T) => void): void;
+}
+declare abstract class TwistyPropSource<OutputType, InputType = OutputType> extends TwistyPropParent<OutputType> {
+    #private;
+    abstract getDefaultValue(): PromiseOrValue<OutputType>;
+    constructor(initialValue?: PromiseOrValue<InputType>);
+    set(input: PromiseOrValue<InputType>): void;
+    get(): Promise<OutputType>;
+    deriveFromPromiseOrValue(input: PromiseOrValue<InputType>, oldValuePromise: Promise<OutputType>): Promise<OutputType>;
+    protected abstract derive(input: InputType, oldValuePromise: Promise<OutputType>): PromiseOrValue<OutputType>;
+}
+declare abstract class SimpleTwistyPropSource<SimpleType> extends TwistyPropSource<SimpleType> {
+    derive(input: SimpleType): PromiseOrValue<SimpleType>;
+}
+declare const NO_VALUE: unique symbol;
+declare type NoValueType = typeof NO_VALUE;
+declare abstract class TwistyPropDerived<InputTypes extends InputRecord, OutputType> extends TwistyPropParent<OutputType> {
+    #private;
+    protected userVisibleErrorTracker?: UserVisibleErrorTracker | undefined;
+    constructor(parents: InputProps<InputTypes>, userVisibleErrorTracker?: UserVisibleErrorTracker | undefined);
+    get(): Promise<OutputType>;
+    protected abstract derive(input: InputTypes): PromiseOrValue<OutputType>;
+}
+
+declare const puzzleIDs: {
+    "3x3x3": boolean;
+    custom: boolean;
+    "2x2x2": boolean;
+    "4x4x4": boolean;
+    "5x5x5": boolean;
+    "6x6x6": boolean;
+    "7x7x7": boolean;
+    "40x40x40": boolean;
+    megaminx: boolean;
+    pyraminx: boolean;
+    square1: boolean;
+    clock: boolean;
+    skewb: boolean;
+    fto: boolean;
+    gigaminx: boolean;
+    master_tetraminx: boolean;
+    kilominx: boolean;
+    redi_cube: boolean;
+};
+declare type PuzzleID = keyof typeof puzzleIDs;
+declare class PuzzleIDRequestProp extends SimpleTwistyPropSource<PuzzleID | NoValueType> {
+    getDefaultValue(): PuzzleID | NoValueType;
+}
+
+declare const experimentalStickerings: {
+    full: boolean;
+    "centers-only": boolean;
+    PLL: boolean;
+    CLS: boolean;
+    OLL: boolean;
+    COLL: boolean;
+    OCLL: boolean;
+    CLL: boolean;
+    ELL: boolean;
+    ELS: boolean;
+    LL: boolean;
+    F2L: boolean;
+    ZBLL: boolean;
+    ZBLS: boolean;
+    WVLS: boolean;
+    VLS: boolean;
+    LS: boolean;
+    EO: boolean;
+    EOline: boolean;
+    EOcross: boolean;
+    CMLL: boolean;
+    L6E: boolean;
+    L6EO: boolean;
+    Daisy: boolean;
+    Cross: boolean;
+    "2x2x2": boolean;
+    "2x2x3": boolean;
+    "Void Cube": boolean;
+    invisible: boolean;
+    picture: boolean;
+    "experimental-centers-U": boolean;
+    "experimental-centers-U-D": boolean;
+    "experimental-centers-U-L-D": boolean;
+    "experimental-centers-U-L-B-D": boolean;
+    "experimental-centers": boolean;
+    "experimental-fto-fc": boolean;
+    "experimental-fto-f2t": boolean;
+    "experimental-fto-sc": boolean;
+    "experimental-fto-l2c": boolean;
+    "experimental-fto-lbt": boolean;
+    "experimental-fto-l3t": boolean;
+    "experimental-global-custom-1": boolean;
+    "experimental-global-custom-2": boolean;
+};
+declare type ExperimentalStickering = keyof typeof experimentalStickerings;
+declare class StickeringProp extends SimpleTwistyPropSource<ExperimentalStickering> {
+    getDefaultValue(): ExperimentalStickering;
+}
+
+declare type FaceletMeshAppearance = "regular" | "dim" | "oriented" | "ignored" | "invisible";
+declare type FaceletAppearance = {
+    appearance: FaceletMeshAppearance;
+    hintAppearance?: FaceletMeshAppearance;
+};
+declare type PieceAppearance = {
+    facelets: (FaceletMeshAppearance | FaceletAppearance | null)[];
+};
+declare type OrbitAppearance = {
+    pieces: (PieceAppearance | null)[];
+};
+declare type PuzzleAppearance = {
+    name?: string;
+    orbits: Record<string, OrbitAppearance>;
+};
+declare function getFaceletAppearance(appearance: PuzzleAppearance, orbitName: string, pieceIdx: number, faceletIdx: number, hint: boolean): FaceletMeshAppearance;
+
+interface PuzzleLoader {
+    id: string;
+    fullName: string;
+    inventedBy?: string[];
+    inventionYear?: number;
+    /** @deprecated */
+    def?: never;
+    kpuzzle: () => Promise<KPuzzle>;
+    svg: () => Promise<string>;
+    llSVG?: () => Promise<string>;
+    pg?: () => Promise<PuzzleGeometry>;
+    appearance?: (stickering: ExperimentalStickering) => Promise<PuzzleAppearance>;
+    stickerings?: () => Promise<ExperimentalStickering[]>;
+}
+
+export { ExperimentalStickering as E, FaceletMeshAppearance as F, NoValueType as N, PuzzleLoader as P, SimpleTwistyPropSource as S, TwistyPropSource as T, UserVisibleErrorTracker as U, PuzzleID as a, PuzzleAppearance as b, TwistyPropDerived as c, StickeringProp as d, PuzzleIDRequestProp as e, NO_VALUE as f, getFaceletAppearance as g };

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

@@ -1,13 +1,49 @@
-export { Alg } from "./Alg";
-export { AlgBuilder } from "./AlgBuilder";
-export { TraversalDownUp, TraversalUp } from "./traversal";
-export { Example } from "./example";
-export { keyToMove } from "./keyboard";
-export * from "./units";
-export { MoveModifications } from "./units/leaves/Move";
-export { algCubingNetLink } from "./url";
-export type { AlgCubingNetOptions } from "./url";
-export { experimentalAppendMove } from "./operation";
-export { experimentalIs } from "./is";
-export { directedGenerator as experimentalDirectedGenerator, direct as experimentalDirect, IterationDirection as ExperimentalIterationDirection, } from "./iteration";
-export type { Parsed as ExperimentalParsed } from "./parse";
+import { U as Unit, A as Alg, M as Move, G as Grouping, L as LineComment, C as Commutator, a as Conjugate, N as Newline, P as Pause } from '../Alg-6f3dc52c';
+export { A as Alg, C as Commutator, a as Conjugate, I as ExperimentalIterationDirection, G as Grouping, L as LineComment, M as Move, c as MoveModifications, N as Newline, P as Pause, Q as QuantumMove, T as TraversalDownUp, b as TraversalUp, U as Unit, e as experimentalDirect, d as experimentalDirectedGenerator } from '../Alg-6f3dc52c';
+export { P as ExperimentalParsed } from '../parse-6d363160';
+
+declare class AlgBuilder {
+    #private;
+    push(u: Unit): void;
+    /** @deprecated */
+    experimentalPushAlg(alg: Alg): void;
+    experimentalNumUnits(): number;
+    toAlg(): Alg;
+    reset(): void;
+}
+
+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;
+};
+
+declare function keyToMove(e: KeyboardEvent): Move | null;
+
+interface AlgCubingNetOptions {
+    alg?: Alg;
+    setup?: Alg;
+    title?: string;
+    puzzle?: "1x1x1" | "2x2x2" | "3x3x3" | "4x4x4" | "5x5x5" | "6x6x6" | "7x7x7" | "8x8x8" | "9x9x9" | "10x10x10" | "11x11x11" | "12x12x12" | "13x13x13" | "14x14x14" | "16x16x16" | "17x17x17";
+    stage?: "full" | "cross" | "F2L" | "LL" | "OLL" | "PLL" | "CLS" | "ELS" | "L6E" | "CMLL" | "WV" | "ZBLL" | "void";
+    view?: "editor" | "playback" | "fullscreen";
+    type?: "moves" | "reconstruction" | "alg" | "reconstruction-end-with-setup";
+}
+declare function algCubingNetLink(options: AlgCubingNetOptions): string;
+
+declare function experimentalAppendMove(alg: Alg, newMove: Move, options?: {
+    coalesce?: boolean;
+    mod?: number;
+}): Alg;
+
+declare function experimentalIs(v: any, c: typeof Alg | typeof Grouping | typeof LineComment | typeof Commutator | typeof Conjugate | typeof Move | typeof Newline | typeof Pause): boolean;
+
+export { AlgBuilder, AlgCubingNetOptions, Example, algCubingNetLink, experimentalAppendMove, experimentalIs, keyToMove };

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

@@ -1,11 +1,147 @@
-export { enableDebugLogging } from "./debug";
-export { debugKeyboardConnect, KeyboardPuzzle } from "./keyboard";
-export type { BluetoothConfig, BluetoothPuzzle, MoveEvent, OrientationEvent, } from "./smart-puzzle/bluetooth-puzzle";
-export { connectSmartPuzzle } from "./smart-puzzle/connect";
-export { GanCube } from "./smart-puzzle/gan";
-export { GiiKERCube, giikerMoveToAlgMoveForTesting, } from "./smart-puzzle/giiker";
-export { GoCube } from "./smart-puzzle/gocube";
-export type { BluetoothRobot } from "./smart-robot";
-export { connectSmartRobot } from "./smart-robot";
-export type { BluetoothTimer } from "./smart-timer";
-export { connectSmartTimer } from "./smart-timer";
+import { K as KState } from '../KState-ba36d9a3';
+import { B as BluetoothPuzzle } from '../bluetooth-puzzle-bc1a5264';
+export { a as BluetoothConfig, B as BluetoothPuzzle, M as MoveEvent, O as OrientationEvent } from '../bluetooth-puzzle-bc1a5264';
+import { M as Move, A as Alg } from '../Alg-6f3dc52c';
+import '../KPuzzleDefinition-8531b592';
+
+declare function enableDebugLogging(enable: boolean): void;
+
+declare class KeyboardPuzzle extends BluetoothPuzzle {
+    private target;
+    private puzzle;
+    private state;
+    listener: (e: KeyboardEvent) => Promise<void>;
+    constructor(target: Element);
+    name(): string | undefined;
+    disconnect(): void;
+    getState(): Promise<KState>;
+    private onKeyDown;
+}
+declare function debugKeyboardConnect(target?: any): Promise<KeyboardPuzzle>;
+
+/******** connect() ********/
+interface BluetoothConnectOptions {
+    acceptAllDevices?: boolean;
+}
+
+declare function connectSmartPuzzle(options?: BluetoothConnectOptions): Promise<BluetoothPuzzle>;
+
+declare class GanCube extends BluetoothPuzzle {
+    private kpuzzle;
+    private service;
+    private server;
+    private physicalStateCharacteristic;
+    private lastMoveCounter;
+    private aesKey;
+    static connect(server: BluetoothRemoteGATTServer): Promise<GanCube>;
+    INTERVAL_MS: number;
+    private intervalHandle;
+    private state;
+    private cachedFaceletStatus1Characteristic;
+    private cachedFaceletStatus2Characteristic;
+    private cachedActualAngleAndBatteryCharacteristic;
+    private constructor();
+    name(): string | undefined;
+    disconnect(): void;
+    startTrackingMoves(): void;
+    stopTrackingMoves(): void;
+    intervalHandler(): Promise<void>;
+    getBattery(): Promise<number>;
+    getState(): Promise<KState>;
+    faceletStatus1Characteristic(): Promise<BluetoothRemoteGATTCharacteristic>;
+    faceletStatus2Characteristic(): Promise<BluetoothRemoteGATTCharacteristic>;
+    actualAngleAndBatteryCharacteristic(): Promise<BluetoothRemoteGATTCharacteristic>;
+    reset(): Promise<void>;
+    readFaceletStatus1Characteristic(): Promise<ArrayBuffer>;
+    readFaceletStatus2Characteristic(): Promise<string>;
+    readActualAngleAndBatteryCharacteristic(): Promise<ArrayBuffer>;
+}
+
+declare function giikerMoveToAlgMove(face: number, amount: number): Move;
+
+declare class GiiKERCube extends BluetoothPuzzle {
+    private server;
+    private cubeCharacteristic;
+    private originalValue?;
+    static connect(server: BluetoothRemoteGATTServer): Promise<GiiKERCube>;
+    private constructor();
+    name(): string | undefined;
+    disconnect(): void;
+    getState(): Promise<KState>;
+    private getBit;
+    private toReid333;
+    private onCubeCharacteristicChanged;
+    private isRepeatedInitialValue;
+}
+
+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;
+}
+
+interface GanRobotOptions {
+    xAngle: boolean;
+    singleMoveFixHack: boolean;
+    bufferQueue: number;
+    postSleep: number;
+}
+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>;
+}
+
+declare type BluetoothRobot = GanRobot;
+declare function connectSmartRobot(options?: BluetoothConnectOptions): Promise<BluetoothRobot>;
+
+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;
+}
+
+declare type BluetoothTimer = GanTimer;
+declare function connectSmartTimer(options?: BluetoothConnectOptions): Promise<BluetoothTimer>;
+
+export { BluetoothRobot, BluetoothTimer, GanCube, GiiKERCube, GoCube, KeyboardPuzzle, connectSmartPuzzle, connectSmartRobot, connectSmartTimer, debugKeyboardConnect, enableDebugLogging, giikerMoveToAlgMove as giikerMoveToAlgMoveForTesting };

package/dist/types/{bluetooth/smart-puzzle/bluetooth-puzzle.d.ts → bluetooth-puzzle-bc1a5264.d.ts}

@@ -1,16 +1,20 @@
-/// <reference types="web-bluetooth" />
-import type { Move } from "../../alg";
-import type { KState } from "../../kpuzzle/KState";
-import { StreamTransformer } from "../transformer";
+import { M as Move } from './Alg-6f3dc52c';
+import { K as KState } from './KState-ba36d9a3';
+
+interface StreamTransformer {
+    transformMove(moveEvent: MoveEvent): void;
+    transformOrientation(orientationEvent: OrientationEvent): void;
+}
+
 /******** BluetoothPuzzle ********/
-export interface MoveEvent {
+interface MoveEvent {
     latestMove: Move;
     timeStamp: number;
     debug?: Record<string, unknown>;
     state?: KState;
     quaternion?: any;
 }
-export interface OrientationEvent {
+interface OrientationEvent {
     quaternion: {
         x: number;
         y: number;
@@ -20,13 +24,13 @@ export interface OrientationEvent {
     timeStamp: number;
     debug?: Record<string, unknown>;
 }
-export interface BluetoothConfig<T> {
+interface BluetoothConfig<T> {
     connect: (server: BluetoothRemoteGATTServer, device?: BluetoothDevice) => Promise<T>;
     prefixes: string[];
     filters: BluetoothLEScanFilter[];
     optionalServices: BluetoothServiceUUID[];
 }
-export declare abstract class BluetoothPuzzle extends EventTarget {
+declare abstract class BluetoothPuzzle extends EventTarget {
     transformers: StreamTransformer[];
     protected listeners: Array<(e: MoveEvent) => void>;
     protected orientationListeners: Array<(e: OrientationEvent) => void>;
@@ -39,3 +43,5 @@ export declare abstract class BluetoothPuzzle extends EventTarget {
     protected dispatchMove(moveEvent: MoveEvent): void;
     protected dispatchOrientation(orientationEvent: OrientationEvent): void;
 }
+
+export { BluetoothPuzzle as B, MoveEvent as M, OrientationEvent as O, BluetoothConfig as a };

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

@@ -1,6 +1,8 @@
-export { KPuzzle } from "./KPuzzle";
-export type { KPuzzleDefinition, KStateData, KTransformationData, } from "./KPuzzleDefinition";
-export { KState } from "./KState";
-export { KTransformation } from "./KTransformation";
-import { KPuzzle } from "./KPuzzle";
-export declare const experimental3x3x3KPuzzle: KPuzzle;
+import { a as KPuzzle } from '../KState-ba36d9a3';
+export { a as KPuzzle, K as KState, b as KTransformation } from '../KState-ba36d9a3';
+export { a as KPuzzleDefinition, b as KStateData, K as KTransformationData } from '../KPuzzleDefinition-8531b592';
+import '../Alg-6f3dc52c';
+
+declare const experimental3x3x3KPuzzle: KPuzzle;
+
+export { experimental3x3x3KPuzzle };

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

@@ -1,2 +1,8 @@
-export { countMoves as experimentalCountMoves, countQuantumMoves as experimentalCountQuantumMoves, } from "./CountMoves";
-export { countAnimatedLeaves as experimentalCountAnimatedLeaves } from "./CountAnimatedLeaves";
+import { A as Alg } from '../Alg-6f3dc52c';
+
+declare const countMoves: (alg: Alg) => number;
+declare const countQuantumMoves: (alg: Alg) => number;
+
+declare const countAnimatedLeaves: (alg: Alg) => number;
+
+export { countAnimatedLeaves as experimentalCountAnimatedLeaves, countMoves as experimentalCountMoves, countQuantumMoves as experimentalCountQuantumMoves };

package/dist/types/outside-d6602f71.d.ts

@@ -0,0 +1,22 @@
+import { A as Alg } from './Alg-6f3dc52c';
+import { K as KState } from './KState-ba36d9a3';
+
+declare enum PrefetchLevel {
+    Auto = "auto",
+    None = "none",
+    Immediate = "immediate"
+}
+
+declare function randomScrambleForEvent(eventID: string): Promise<Alg>;
+declare function experimentalSolve3x3x3IgnoringCenters(state: KState): Promise<Alg>;
+declare function experimentalSolve2x2x2(state: KState): Promise<Alg>;
+declare function solveSkewb(state: KState): Promise<Alg>;
+declare function solvePyraminx(state: KState): Promise<Alg>;
+declare function solveMegaminx(state: KState): Promise<Alg>;
+declare function setDebug(options: {
+    logPerf?: boolean;
+    scramblePrefetchLevel?: `${PrefetchLevel}`;
+    forceStringWorker?: boolean;
+}): void;
+
+export { experimentalSolve2x2x2 as a, solvePyraminx as b, solveMegaminx as c, setDebug as d, experimentalSolve3x3x3IgnoringCenters as e, randomScrambleForEvent as r, solveSkewb as s };

package/dist/types/parse-6d363160.d.ts

@@ -0,0 +1,9 @@
+import { A as Alg, U as Unit } from './Alg-6f3dc52c';
+
+interface ParserIndexed {
+    startCharIndex: number;
+    endCharIndex: number;
+}
+declare type Parsed<T extends Alg | Unit> = T & ParserIndexed;
+
+export { Parsed as P };

package/dist/types/protocol/index.d.ts

@@ -1,4 +1,26 @@
-export { reid3x3x3ToTwizzleBinary, twizzleBinaryToReid3x3x3, } from "./binary/binary3x3x3";
-export { bufferToSpacedHex, spacedHexToBuffer } from "./binary/hex";
-export { normalizePuzzleOrientation as experimentalNormalizePuzzleOrientation } from "./binary/puzzle-orientation";
-export { binaryComponentsToReid3x3x3 as experimentalBinaryComponentsToReid3x3x3, twizzleBinaryToBinaryComponents as experimentalTwizzleBinaryToBinaryComponents, } from "./binary/binary3x3x3";
+import { K as KState } from '../KState-ba36d9a3';
+import '../Alg-6f3dc52c';
+import '../KPuzzleDefinition-8531b592';
+
+declare type Binary3x3x3State = ArrayBuffer;
+interface Binary3x3x3Components {
+    epLex: number;
+    eoMask: number;
+    cpLex: number;
+    coMask: number;
+    poIdxU: number;
+    poIdxL: number;
+    moSupport: number;
+    moMask: number;
+}
+declare function reid3x3x3ToTwizzleBinary(state: KState): Binary3x3x3State;
+declare function twizzleBinaryToBinaryComponents(buffer: ArrayBuffer): Binary3x3x3Components;
+declare function binaryComponentsToReid3x3x3(components: Binary3x3x3Components): KState;
+declare function twizzleBinaryToReid3x3x3(buffy: ArrayBuffer): KState;
+
+declare function bufferToSpacedHex(buffer: ArrayBuffer): string;
+declare function spacedHexToBuffer(hex: string): Uint8Array;
+
+declare function normalizePuzzleOrientation(state: KState): KState;
+
+export { bufferToSpacedHex, binaryComponentsToReid3x3x3 as experimentalBinaryComponentsToReid3x3x3, normalizePuzzleOrientation as experimentalNormalizePuzzleOrientation, twizzleBinaryToBinaryComponents as experimentalTwizzleBinaryToBinaryComponents, reid3x3x3ToTwizzleBinary, spacedHexToBuffer, twizzleBinaryToReid3x3x3 };

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

@@ -1,6 +1,7 @@
-export { getPuzzleDescriptionString, getPuzzleGeometryByDesc, getPuzzleGeometryByName, getPG3DNamedPuzzles, parsePuzzleDescription, PuzzleGeometry, } from "./PuzzleGeometry";
-export type { StickerDat, StickerDatAxis, StickerDatFace, StickerDatSticker, } from "./PuzzleGeometry";
-export { parseOptions } from "./Options";
-export { Quat } from "./Quat";
-export { schreierSims } from "./SchreierSims";
-export { PGNotation as ExperimentalPGNotation } from "./PuzzleGeometry";
+import { c as Perm } from '../KPuzzleDefinition-8531b592';
+export { P as ExperimentalPGNotation, h as PuzzleGeometry, Q as Quat, S as StickerDat, i as StickerDatAxis, j as StickerDatFace, k as StickerDatSticker, f as getPG3DNamedPuzzles, g as getPuzzleDescriptionString, d as getPuzzleGeometryByDesc, e as getPuzzleGeometryByName, l as parseOptions, p as parsePuzzleDescription } from '../KPuzzleDefinition-8531b592';
+import '../Alg-6f3dc52c';
+
+declare function schreierSims(g: Perm[], disp: (s: string) => void): number;
+
+export { schreierSims };

package/dist/types/puzzles/index.d.ts

@@ -1,12 +1,29 @@
-export { experimental3x3x3KPuzzle } from "../kpuzzle";
-export { customPGPuzzleLoader as experimentalCustomPGPuzzleLoader } from "./customPGPuzzleLoader";
-export { eventInfo, wcaEventInfo } from "./events";
-export { getFaceletAppearance as experimentalGetFaceletAppearance } from "./stickerings/appearance";
-export type { FaceletMeshAppearance as ExperimentalFaceletMeshAppearance, PuzzleAppearance as ExperimentalPuzzleAppearance, } from "./stickerings/appearance";
-export { cubeAppearance as experimentalCubeAppearance } from "./stickerings/cube-stickerings";
-export type { PuzzleLoader };
-export { cube2x2x2, cube3x3x3 };
-import { cube2x2x2 } from "./implementations/2x2x2";
-import { cube3x3x3 } from "./implementations/3x3x3";
-import type { PuzzleLoader } from "./PuzzleLoader";
-export declare const puzzles: Record<string, PuzzleLoader>;
+export { experimental3x3x3KPuzzle } from '../kpuzzle/index';
+import { m as PuzzleDescriptionString } from '../KPuzzleDefinition-8531b592';
+import { P as PuzzleLoader, a as PuzzleID, E as ExperimentalStickering, b as PuzzleAppearance } from '../PuzzleLoader-a7faf593';
+export { F as ExperimentalFaceletMeshAppearance, b as ExperimentalPuzzleAppearance, P as PuzzleLoader, g as experimentalGetFaceletAppearance } from '../PuzzleLoader-a7faf593';
+import '../KState-ba36d9a3';
+import '../Alg-6f3dc52c';
+
+declare function customPGPuzzleLoader(desc: PuzzleDescriptionString, info?: {
+    fullName?: string;
+    inventedBy?: string[];
+    inventionYear?: number;
+}): PuzzleLoader;
+
+interface EventInfo {
+    puzzleID: PuzzleID;
+    eventName: string;
+}
+declare function wcaEventInfo(event: string): EventInfo | null;
+declare function eventInfo(event: string): EventInfo | null;
+
+declare function cubeAppearance(puzzleLoader: PuzzleLoader, stickering: ExperimentalStickering): Promise<PuzzleAppearance>;
+
+declare const cube2x2x2: PuzzleLoader;
+
+declare const cube3x3x3: PuzzleLoader;
+
+declare const puzzles: Record<string, PuzzleLoader>;
+
+export { cube2x2x2, cube3x3x3, eventInfo, cubeAppearance as experimentalCubeAppearance, customPGPuzzleLoader as experimentalCustomPGPuzzleLoader, puzzles, wcaEventInfo };

package/dist/types/scramble/index.d.ts

@@ -1 +1,4 @@
-export { experimentalRandomScrambleForEvent as randomScrambleForEvent } from "../search";
+export { r as randomScrambleForEvent } from '../outside-d6602f71';
+import '../Alg-6f3dc52c';
+import '../KState-ba36d9a3';
+import '../KPuzzleDefinition-8531b592';

package/dist/types/search/index.d.ts

@@ -1,2 +1,8 @@
-export { randomScrambleForEvent as experimentalRandomScrambleForEvent, experimentalSolve3x3x3IgnoringCenters, experimentalSolve2x2x2, solveSkewb, solvePyraminx, solveMegaminx, setDebug, } from "./outside";
-export { random333State } from "./inside/solve/puzzles/3x3x3";
+export { r as experimentalRandomScrambleForEvent, a as experimentalSolve2x2x2, e as experimentalSolve3x3x3IgnoringCenters, d as setDebug, c as solveMegaminx, b as solvePyraminx, s as solveSkewb } from '../outside-d6602f71';
+import { K as KState } from '../KState-ba36d9a3';
+import '../Alg-6f3dc52c';
+import '../KPuzzleDefinition-8531b592';
+
+declare function random333State(): Promise<KState>;
+
+export { random333State };