cubing 0.25.14 → 0.26.2

package/dist/types/stream/process/ReorientedStream.d.ts

@@ -1,20 +0,0 @@
-import { Move } from "../../alg";
-export interface PuzzleStreamMoveEventDetail {
-    move: Move;
-}
-export interface PuzzleStreamMoveEvent {
-    type: "move";
-    detail: PuzzleStreamMoveEventDetail;
-}
-export declare type PuzzleStreamMoveEventRegisterCompatible = CustomEvent<PuzzleStreamMoveEventDetail>;
-declare class OrientationTracker {
-    state: import("../../kpuzzle").KState;
-    processMove(move: Move): Move[];
-}
-export declare class ReorientedStream extends EventTarget {
-    orientationTracker: OrientationTracker;
-    constructor(target: EventTarget);
-    dispatchMove(detail: PuzzleStreamMoveEventDetail): void;
-    onMove(event: PuzzleStreamMoveEvent): void;
-}
-export {};

package/dist/types/stream/proxy-event.d.ts

@@ -1,13 +0,0 @@
-import type { MoveEvent, OrientationEvent } from "../bluetooth";
-export interface ProxyMoveEvent {
-    event: "move";
-    data: MoveEvent;
-}
-export interface ProxyOrientationEvent {
-    event: "orientation";
-    data: OrientationEvent;
-}
-export interface ProxyResetEvent {
-    event: "reset";
-}
-export declare type ProxyEvent = ProxyMoveEvent | ProxyOrientationEvent | ProxyResetEvent;

package/dist/types/stream/twizzle/TwizzleStream.d.ts

@@ -1,18 +0,0 @@
-declare class TwizzleStream extends EventTarget {
-    socket: WebSocket;
-    constructor(url: string);
-    onMessage(msg: MessageEvent): void;
-}
-declare type StreamsField = {
-    streamID: string;
-    senders: {
-        name: string;
-        twizzleUserID: string;
-        wcaID: string | null;
-    }[];
-}[];
-export declare class TwizzleStreamServer {
-    streams(): Promise<StreamsField>;
-    connect(streamID: string): TwizzleStream;
-}
-export {};

package/dist/types/stream/twizzle/stream-types.d.ts

@@ -1,32 +0,0 @@
-export interface MoveEvent {
-    latestMove: any;
-    timeStamp: number;
-    state: any;
-}
-export interface BinaryMoveEvent {
-    latestMove: any;
-    timeStamp: number;
-    binaryState: string;
-}
-export interface OrientationEvent {
-    quaternion: {
-        x: number;
-        y: number;
-        z: number;
-        w: number;
-    };
-    timeStamp: number;
-}
-export interface ResetEvent {
-    trackingOrientation: boolean;
-}
-export declare type StreamMessageEvent = {
-    event: "move";
-    data: MoveEvent;
-} | {
-    event: "orientation";
-    data: OrientationEvent;
-} | {
-    event: "reset";
-    data: ResetEvent;
-};

package/dist/types/stream/websocket-proxy.d.ts

@@ -1,21 +0,0 @@
-import type { MoveEvent, OrientationEvent } from "../bluetooth";
-import type { ProxyEvent } from "./proxy-event";
-export declare class WebSocketProxySender {
-    protected websocket: WebSocket;
-    constructor(url: string);
-    sendMoveEvent(e: MoveEvent): void;
-    sendOrientationEvent(e: OrientationEvent): void;
-    sendResetEvent(): void;
-    protected sendProxyEvent(proxyEvent: ProxyEvent): void;
-    protected onopen(): void;
-    protected onerror(error: Error): void;
-    protected onmessage(_e: MessageEvent): void;
-}
-export declare abstract class WebSocketProxyReceiver {
-    protected websocket: WebSocket;
-    constructor(url: string, socketOrigin?: string);
-    protected onopen(): void;
-    protected onerror(error: Error): void;
-    protected onmessage(e: MessageEvent): void;
-    abstract onProxyEvent(e: ProxyEvent): void;
-}

package/dist/types/twisty/controllers/AnimationTypes.d.ts

@@ -1,32 +0,0 @@
-import type { Move } from "../../alg";
-import type { KState } from "../../kpuzzle/KState";
-export declare type MillisecondTimestamp = number;
-export declare type Duration = MillisecondTimestamp;
-export declare type Timestamp = MillisecondTimestamp;
-export declare type Fraction = number;
-export declare enum Direction {
-    Forwards = 1,
-    Paused = 0,
-    Backwards = -1
-}
-export declare function directionScalar(direction: Direction): MillisecondTimestamp;
-export interface MoveInProgress {
-    move: Move;
-    direction: Direction;
-    fraction: number;
-}
-export declare type PuzzlePosition = {
-    state: KState;
-    movesInProgress: MoveInProgress[];
-};
-export declare enum BoundaryType {
-    Move = "move",
-    EntireTimeline = "entire-timeline"
-}
-export interface TimeRange {
-    start: MillisecondTimestamp;
-    end: MillisecondTimestamp;
-}
-export interface PositionListener {
-    onPositionChange(position: PuzzlePosition): void;
-}

package/dist/types/twisty/controllers/RenderScheduler.d.ts

@@ -1,12 +0,0 @@
-export declare class RenderScheduler {
-    private callback;
-    private animFrameID;
-    private animFrame;
-    constructor(callback: (timestamp: DOMHighResTimeStamp) => void);
-    requestAnimFrame(): void;
-    cancelAnimFrame(): void;
-    private animFrameWrapper;
-}
-export interface Schedulable {
-    scheduleRender(): void;
-}

package/dist/types/twisty/controllers/TwistyAnimationController.d.ts

@@ -1,36 +0,0 @@
-import { BoundaryType, MillisecondTimestamp } from "./AnimationTypes";
-import type { PlayingInfo, SimpleDirection } from "../model/props/timeline/PlayingInfoProp";
-import type { TwistyPlayerModel } from "../model/TwistyPlayerModel";
-import type { CatchUpMove } from "../model/props/puzzle/state/CatchUpMoveProp";
-export interface TwistyAnimationControllerDelegate {
-    flash(): void;
-}
-export declare class TwistyAnimationController {
-    #private;
-    private delegate;
-    private playing;
-    private direction;
-    private catchUpHelper;
-    private model;
-    private lastDatestamp;
-    private lastTimestampPromise;
-    private scheduler;
-    constructor(model: TwistyPlayerModel, delegate: TwistyAnimationControllerDelegate);
-    onPlayingProp(playingInfo: PlayingInfo): Promise<void>;
-    onCatchUpMoveProp(catchUpMove: CatchUpMove): Promise<void>;
-    jumpToStart(options?: {
-        flash: boolean;
-    }): void;
-    jumpToEnd(options?: {
-        flash: boolean;
-    }): void;
-    playPause(): void;
-    play(options?: {
-        direction?: SimpleDirection;
-        untilBoundary?: BoundaryType;
-        autoSkipToOtherEndIfStartingAtBoundary?: boolean;
-        loop?: boolean;
-    }): Promise<void>;
-    pause(): void;
-    animFrame(frameDatestamp: MillisecondTimestamp): Promise<void>;
-}

package/dist/types/twisty/controllers/TwistyPlayerController.d.ts

@@ -1,15 +0,0 @@
-import type { TwistyPlayerModel } from "../model/TwistyPlayerModel";
-import { TwistyAnimationController, TwistyAnimationControllerDelegate } from "./TwistyAnimationController";
-export declare class TwistyPlayerController {
-    private model;
-    animationController: TwistyAnimationController;
-    constructor(model: TwistyPlayerModel, delegate: TwistyAnimationControllerDelegate);
-    jumpToStart(options?: {
-        flash: boolean;
-    }): void;
-    jumpToEnd(options?: {
-        flash: boolean;
-    }): void;
-    togglePlay(play?: boolean): void;
-    visitTwizzleLink(): Promise<void>;
-}

package/dist/types/twisty/controllers/easing.d.ts

@@ -1 +0,0 @@
-export declare function smootherStep(x: number): number;

package/dist/types/twisty/controllers/indexer/AlgDuration.d.ts

@@ -1,17 +0,0 @@
-import { Alg, Grouping, LineComment, Commutator, Conjugate, Move, Newline, Pause, TraversalUp } from "../../../alg";
-import type { Duration } from "../AnimationTypes";
-export declare function constantDurationForAmount(_amount: number): Duration;
-export declare function defaultDurationForAmount(amount: number): Duration;
-export declare function ExperimentalScaledDefaultDurationForAmount(scale: number, amount: number): Duration;
-export declare class AlgDuration extends TraversalUp<Duration> {
-    durationForAmount: (amount: number) => Duration;
-    constructor(durationForAmount?: (amount: number) => Duration);
-    traverseAlg(alg: Alg): Duration;
-    traverseGrouping(grouping: Grouping): Duration;
-    traverseMove(move: Move): Duration;
-    traverseCommutator(commutator: Commutator): Duration;
-    traverseConjugate(conjugate: Conjugate): Duration;
-    traversePause(_pause: Pause): Duration;
-    traverseNewline(_newline: Newline): Duration;
-    traverseLineComment(_comment: LineComment): Duration;
-}

package/dist/types/twisty/controllers/indexer/AlgIndexer.d.ts

@@ -1,36 +0,0 @@
-import type { Move } from "../../../alg/units";
-import type { KTransformation } from "../../../kpuzzle";
-import type { KState } from "../../../kpuzzle/KState";
-import type { Direction, Duration, MillisecondTimestamp, PuzzlePosition, Timestamp } from "../AnimationTypes";
-import type { AnimatedLeafUnit } from "./simultaneous-moves/simul-moves";
-export interface CurrentMove {
-    move: Move;
-    direction: Direction;
-    fraction: number;
-    startTimestamp: MillisecondTimestamp;
-    endTimestamp: MillisecondTimestamp;
-}
-export declare function currentMoveEquals(cm1: CurrentMove, cm2: CurrentMove): boolean;
-export declare function currentMoveArrayEquals(cma1: CurrentMove[], cma2: CurrentMove[]): boolean;
-export interface CurrentMoveInfo {
-    stateIndex: number;
-    currentMoves: CurrentMove[];
-    movesFinishing: CurrentMove[];
-    movesFinished: CurrentMove[];
-    movesStarting: CurrentMove[];
-    latestStart: number;
-    earliestEnd: number;
-}
-export declare function currentMoveInfoEquals(c1: CurrentMoveInfo, c2: CurrentMoveInfo): boolean;
-export interface AlgIndexer {
-    getAnimLeaf(index: number): AnimatedLeafUnit | null;
-    indexToMoveStartTimestamp(index: number): Timestamp;
-    stateAtIndex(index: number, startSTate?: KState): KState;
-    transformationAtIndex(index: number): KTransformation;
-    numAnimatedLeaves(): number;
-    timestampToIndex(timestamp: Timestamp): number;
-    algDuration(): Duration;
-    moveDuration(index: number): number;
-    timestampToPosition?: (timestamp: Timestamp, startState?: KState) => PuzzlePosition;
-    currentMoveInfo?: (timestamp: Timestamp) => CurrentMoveInfo;
-}

package/dist/types/twisty/controllers/indexer/SimpleAlgIndexer.d.ts

@@ -1,19 +0,0 @@
-import { Alg, Move } from "../../../alg";
-import type { KPuzzle, KTransformation } from "../../../kpuzzle";
-import type { KState } from "../../../kpuzzle/KState";
-import type { Duration, Timestamp } from "../AnimationTypes";
-import type { AlgIndexer } from "./AlgIndexer";
-export declare class SimpleAlgIndexer implements AlgIndexer {
-    private kpuzzle;
-    private moves;
-    private durationFn;
-    constructor(kpuzzle: KPuzzle, alg: Alg);
-    getAnimLeaf(index: number): Move;
-    indexToMoveStartTimestamp(index: number): Timestamp;
-    timestampToIndex(timestamp: Timestamp): number;
-    stateAtIndex(index: number): KState;
-    transformationAtIndex(index: number): KTransformation;
-    algDuration(): Duration;
-    numAnimatedLeaves(): number;
-    moveDuration(index: number): number;
-}

package/dist/types/twisty/controllers/indexer/simultaneous-moves/SimultaneousMoveIndexer.d.ts

@@ -1,22 +0,0 @@
-import { Alg } from "../../../../alg";
-import type { KPuzzle, KTransformation } from "../../../../kpuzzle";
-import type { KState } from "../../../../kpuzzle/KState";
-import { Duration, PuzzlePosition, Timestamp } from "../../AnimationTypes";
-import type { CurrentMoveInfo } from "../AlgIndexer";
-import { AnimatedLeafUnit } from "./simul-moves";
-export declare class SimultaneousMoveIndexer {
-    private kpuzzle;
-    private animLeaves;
-    constructor(kpuzzle: KPuzzle, alg: Alg);
-    getAnimLeaf(index: number): AnimatedLeafUnit | null;
-    private getAnimLeafWithRange;
-    indexToMoveStartTimestamp(index: number): Timestamp;
-    timestampToIndex(timestamp: Timestamp): number;
-    timestampToPosition(timestamp: Timestamp, startState?: KState): PuzzlePosition;
-    currentMoveInfo(timestamp: Timestamp): CurrentMoveInfo;
-    stateAtIndex(index: number, startState?: KState): KState;
-    transformationAtIndex(index: number): KTransformation;
-    algDuration(): Duration;
-    numAnimatedLeaves(): number;
-    moveDuration(index: number): number;
-}

package/dist/types/twisty/controllers/indexer/simultaneous-moves/simul-moves.d.ts

@@ -1,25 +0,0 @@
-import { LineComment, Commutator, Conjugate, Pause, TraversalUp, Move, Alg, Grouping, Newline } from "../../../../alg";
-import type { MillisecondTimestamp } from "../../AnimationTypes";
-export declare type AnimatedLeafUnit = Move | Pause;
-export interface LocalAnimLeavesWithRange {
-    animLeafUnit: AnimatedLeafUnit;
-    msUntilNext: MillisecondTimestamp;
-    duration: MillisecondTimestamp;
-}
-export interface AnimLeafWithRange {
-    animLeaf: AnimatedLeafUnit;
-    start: MillisecondTimestamp;
-    end: MillisecondTimestamp;
-}
-export declare class LocalSimulMoves extends TraversalUp<LocalAnimLeavesWithRange[]> {
-    traverseAlg(alg: Alg): LocalAnimLeavesWithRange[];
-    traverseGroupingOnce(alg: Alg): LocalAnimLeavesWithRange[];
-    traverseGrouping(grouping: Grouping): LocalAnimLeavesWithRange[];
-    traverseMove(move: Move): LocalAnimLeavesWithRange[];
-    traverseCommutator(commutator: Commutator): LocalAnimLeavesWithRange[];
-    traverseConjugate(conjugate: Conjugate): LocalAnimLeavesWithRange[];
-    traversePause(pause: Pause): LocalAnimLeavesWithRange[];
-    traverseNewline(_newline: Newline): LocalAnimLeavesWithRange[];
-    traverseLineComment(_comment: LineComment): LocalAnimLeavesWithRange[];
-}
-export declare function simulMoves(a: Alg): AnimLeafWithRange[];

package/dist/types/twisty/controllers/indexer/tree/AlgWalker.d.ts

@@ -1,63 +0,0 @@
-import { Alg, Commutator, Conjugate, Grouping, LineComment, Move, Newline, Pause, TraversalDownUp, TraversalUp, Unit } from "../../../../alg";
-import type { KPuzzle, KTransformation } from "../../../../kpuzzle";
-export declare class AlgPartDecoration {
-    moveCount: number;
-    duration: number;
-    forward: KTransformation;
-    backward: KTransformation;
-    children: Array<AlgPartDecoration>;
-    constructor(moveCount: number, duration: number, forward: KTransformation, backward: KTransformation, children?: Array<AlgPartDecoration>);
-}
-export declare class DecoratorConstructor extends TraversalUp<AlgPartDecoration> {
-    private kpuzzle;
-    private identity;
-    private dummyLeaf;
-    private durationFn;
-    private cache;
-    constructor(kpuzzle: KPuzzle);
-    traverseAlg(alg: Alg): AlgPartDecoration;
-    traverseGrouping(grouping: Grouping): AlgPartDecoration;
-    traverseMove(move: Move): AlgPartDecoration;
-    traverseCommutator(commutator: Commutator): AlgPartDecoration;
-    traverseConjugate(conjugate: Conjugate): AlgPartDecoration;
-    traversePause(pause: Pause): AlgPartDecoration;
-    traverseNewline(_newline: Newline): AlgPartDecoration;
-    traverseLineComment(_comment: LineComment): AlgPartDecoration;
-    private mult;
-}
-declare class WalkerDown {
-    apd: AlgPartDecoration;
-    back: boolean;
-    constructor(apd: AlgPartDecoration, back: boolean);
-}
-export declare class AlgWalker extends TraversalDownUp<WalkerDown, boolean> {
-    kpuzzle: KPuzzle;
-    algOrUnit: Alg | Unit;
-    apd: AlgPartDecoration;
-    move?: Unit;
-    moveDuration: number;
-    back: boolean;
-    st: KTransformation;
-    root: WalkerDown;
-    i: number;
-    dur: number;
-    private goali;
-    private goaldur;
-    constructor(kpuzzle: KPuzzle, algOrUnit: Alg | Unit, // TODO: can we keep these separate?
-    apd: AlgPartDecoration);
-    moveByIndex(loc: number): boolean;
-    moveByDuration(dur: number): boolean;
-    dosearch(loc: number, dur: number): boolean;
-    traverseAlg(alg: Alg, wd: WalkerDown): boolean;
-    traverseGrouping(grouping: Grouping, wd: WalkerDown): boolean;
-    traverseMove(move: Move, wd: WalkerDown): boolean;
-    traverseCommutator(commutator: Commutator, wd: WalkerDown): boolean;
-    traverseConjugate(conjugate: Conjugate, wd: WalkerDown): boolean;
-    traversePause(pause: Pause, wd: WalkerDown): boolean;
-    traverseNewline(_newline: Newline, _wd: WalkerDown): boolean;
-    traverseLineComment(_lineComment: LineComment, _wd: WalkerDown): boolean;
-    private firstcheck;
-    private domult;
-    private keepgoing;
-}
-export {};

package/dist/types/twisty/controllers/indexer/tree/TreeAlgIndexer.d.ts

@@ -1,20 +0,0 @@
-import type { Alg, Move } from "../../../../alg";
-import type { KPuzzle, KTransformation } from "../../../../kpuzzle";
-import type { KState } from "../../../../kpuzzle/KState";
-import type { Duration, Timestamp } from "../../AnimationTypes";
-import type { AlgIndexer } from "../AlgIndexer";
-export declare class TreeAlgIndexer implements AlgIndexer {
-    private kpuzzle;
-    private decoration;
-    private walker;
-    constructor(kpuzzle: KPuzzle, alg: Alg);
-    getAnimLeaf(index: number): Move | null;
-    indexToMoveStartTimestamp(index: number): Timestamp;
-    indexToMovesInProgress(index: number): Timestamp;
-    stateAtIndex(index: number, startState?: KState): KState;
-    transformationAtIndex(index: number): KTransformation;
-    numAnimatedLeaves(): number;
-    timestampToIndex(timestamp: Timestamp): number;
-    algDuration(): Duration;
-    moveDuration(index: number): number;
-}

package/dist/types/twisty/controllers/indexer/tree/chunkAlgs.d.ts

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

package/dist/types/twisty/controllers/stream/timeline-move-calculation-draft.d.ts

@@ -1,15 +0,0 @@
-import { Move } from "../../../alg";
-import type { Duration, Timestamp } from "../AnimationTypes";
-interface Event {
-    timeStamp: Timestamp;
-    move: Move;
-}
-export interface TimelineEntry {
-    event: Event;
-    start: Timestamp;
-    end: Timestamp;
-}
-declare type Timeline = TimelineEntry[];
-export declare function toAxes(events: Event[], diameterMs: Duration): TimelineEntry[][];
-export declare function toTimeline(events: Event[], diameterMs?: number): Timeline;
-export {};

package/dist/types/twisty/heavy-code-imports/3d.d.ts

@@ -1,2 +0,0 @@
-export declare function proxy3D(): Promise<typeof import("./dynamic-entries/3d-dynamic")>;
-export declare const THREEJS: Promise<typeof import("three")>;

package/dist/types/twisty/heavy-code-imports/dynamic-entries/3d-dynamic.d.ts

@@ -1,10 +0,0 @@
-import { PuzzleLoader } from "../../../puzzles";
-import type { HintFaceletStyle } from "../../model/props/puzzle/display/HintFaceletProp";
-import { Cube3D, Cube3DOptions } from "../../views/3D/puzzles/Cube3D";
-import { PG3D } from "../../views/3D/puzzles/PG3D";
-export * as T3I from "three";
-export { Cube3D } from "../../views/3D/puzzles/Cube3D";
-export { PG3D } from "../../views/3D/puzzles/PG3D";
-export { Twisty3DScene } from "../../views/3D/Twisty3DScene";
-export declare function cube3DShim(options?: Cube3DOptions): Promise<Cube3D>;
-export declare function pg3dShim(puzzleLoader: PuzzleLoader, hintFacelets: HintFaceletStyle): Promise<PG3D>;

package/dist/types/twisty/model/PromiseFreshener.d.ts

@@ -1,13 +0,0 @@
-export declare class PromiseFreshener<T> {
-    #private;
-    queue(p: Promise<T>): Promise<{
-        fresh: false;
-    } | {
-        fresh: true;
-        result: T;
-    }>;
-}
-export declare class StaleDropper<T> {
-    #private;
-    queue(p: Promise<T>): Promise<T>;
-}

package/dist/types/twisty/model/TwistyPlayerModel.d.ts

@@ -1,85 +0,0 @@
-import { Move } from "../../alg";
-import { ArbitraryStringProp } from "./props/general/ArbitraryStringProp";
-import { URLProp } from "./props/general/URLProp";
-import { AlgProp } from "./props/puzzle/state/AlgProp";
-import { AlgTransformationProp } from "./props/puzzle/state/AlgTransformationProp";
-import { AnchorTransformationProp } from "./props/puzzle/state/AnchorTransformationProp";
-import { CatchUpMoveProp } from "./props/puzzle/state/CatchUpMoveProp";
-import { CurrentLeavesSimplifiedProp } from "./props/puzzle/state/CurrentLeavesSimplified";
-import { CurrentMoveInfoProp } from "./props/puzzle/state/CurrentMoveInfoProp";
-import { CurrentStateProp as CurrentStateProp } from "./props/puzzle/state/CurrentStateProp";
-import { IndexerConstructorProp } from "./props/puzzle/state/IndexerConstructorProp";
-import { IndexerConstructorRequestProp } from "./props/puzzle/state/IndexerConstructorRequestProp";
-import { IndexerProp } from "./props/puzzle/state/IndexerProp";
-import { LegacyPositionProp } from "./props/puzzle/state/LegacyPositionProp";
-import { NaiveMoveCountProp } from "./props/puzzle/state/NaiveMoveCountProp";
-import { PuzzleAlgProp } from "./props/puzzle/state/PuzzleAlgProp";
-import { SetupAnchorProp } from "./props/puzzle/state/SetupAnchorProp";
-import { SetupTransformationProp } from "./props/puzzle/state/SetupTransformationProp";
-import { KPuzzleProp } from "./props/puzzle/structure/KPuzzleProp";
-import { PGPuzzleDescriptionStringProp } from "./props/puzzle/structure/PuzzleDescriptionProp";
-import { PuzzleIDProp } from "./props/puzzle/structure/PuzzleIDProp";
-import { PuzzleIDRequestProp } from "./props/puzzle/structure/PuzzleIDRequestProp";
-import { PuzzleLoaderProp } from "./props/puzzle/structure/PuzzleLoaderProp";
-import { CoarseTimelineInfoProp } from "./props/timeline/CoarseTimelineInfoProp";
-import { DetailedTimelineInfoProp } from "./props/timeline/DetailedTimelineInfoProp";
-import { PlayingInfoProp } from "./props/timeline/PlayingInfoProp";
-import { TempoScaleProp } from "./props/timeline/TempoScaleProp";
-import { TimestampRequestProp } from "./props/timeline/TimestampRequestProp";
-import { BackViewProp } from "./props/viewer/BackViewProp";
-import { ButtonAppearanceProp } from "./props/viewer/ButtonAppearanceProp";
-import { ControlPanelProp } from "./props/viewer/ControlPanelProp";
-import { TimeRangeProp } from "./props/viewer/TimeRangeProp";
-import { ViewerLinkProp } from "./props/viewer/ViewerLinkProp";
-import { VisualizationFormatProp } from "./props/viewer/VisualizationProp";
-import { VisualizationStrategyProp } from "./props/viewer/VisualizationStrategyProp";
-import { TwistySceneModel } from "./TwistySceneModel";
-import { UserVisibleErrorTracker } from "./UserVisibleErrorTracker";
-export declare class TwistyPlayerModel {
-    userVisibleErrorTracker: UserVisibleErrorTracker;
-    alg: AlgProp;
-    backView: BackViewProp;
-    controlPanel: ControlPanelProp;
-    catchUpMove: CatchUpMoveProp;
-    indexerConstructorRequest: IndexerConstructorRequestProp;
-    playingInfo: PlayingInfoProp;
-    puzzleDescriptionRequest: PGPuzzleDescriptionStringProp;
-    puzzleIDRequest: PuzzleIDRequestProp;
-    setupAnchor: SetupAnchorProp;
-    setupAlg: AlgProp;
-    setupTransformation: SetupTransformationProp;
-    tempoScale: TempoScaleProp;
-    timestampRequest: TimestampRequestProp;
-    viewerLink: ViewerLinkProp;
-    visualizationFormat: VisualizationFormatProp;
-    title: ArbitraryStringProp;
-    videoURL: URLProp;
-    competitionID: ArbitraryStringProp;
-    puzzleLoader: PuzzleLoaderProp;
-    kpuzzle: KPuzzleProp;
-    puzzleID: PuzzleIDProp;
-    puzzleAlg: PuzzleAlgProp;
-    puzzleSetupAlg: PuzzleAlgProp;
-    visualizationStrategy: VisualizationStrategyProp;
-    indexerConstructor: IndexerConstructorProp;
-    moveCount: NaiveMoveCountProp;
-    setupAlgTransformation: AlgTransformationProp;
-    indexer: IndexerProp;
-    anchorTransformation: AnchorTransformationProp;
-    timeRange: TimeRangeProp;
-    detailedTimelineInfo: DetailedTimelineInfoProp;
-    coarseTimelineInfo: CoarseTimelineInfoProp;
-    currentMoveInfo: CurrentMoveInfoProp;
-    buttonAppearance: ButtonAppearanceProp;
-    currentLeavesSimplified: CurrentLeavesSimplifiedProp;
-    currentState: CurrentStateProp;
-    legacyPosition: LegacyPositionProp;
-    twistySceneModel: TwistySceneModel;
-    twizzleLink(): Promise<string>;
-    experimentalAddMove(flexibleMove: Move | string, options?: {
-        coalesce?: boolean;
-        mod?: number;
-    }): void;
-    /** @deprecated */
-    get playingInfoProp(): PlayingInfoProp;
-}

package/dist/types/twisty/model/TwistySceneModel.d.ts

@@ -1,27 +0,0 @@
-import { URLProp } from "./props/general/URLProp";
-import { FoundationDisplayProp } from "./props/puzzle/display/FoundationDisplayProp";
-import { HintFaceletProp } from "./props/puzzle/display/HintFaceletProp";
-import { SpriteProp } from "./props/puzzle/display/SpriteProp";
-import { StickeringProp } from "./props/puzzle/display/StickeringProp";
-import { MovePressInputProp } from "./props/puzzle/state/MovePressInputProp";
-import { BackgroundProp } from "./props/viewer/BackgroundProp";
-import { LatitudeLimitProp } from "./props/viewer/LatitudeLimit";
-import { OrbitCoordinatesProp } from "./props/viewer/OrbitCoordinatesProp";
-import { OrbitCoordinatesRequestProp } from "./props/viewer/OrbitCoordinatesRequestProp";
-import type { TwistyPlayerModel } from "./TwistyPlayerModel";
-export declare class TwistySceneModel {
-    twistyPlayerModel: TwistyPlayerModel;
-    background: BackgroundProp;
-    foundationDisplay: FoundationDisplayProp;
-    foundationStickerSpriteURL: URLProp;
-    hintFacelet: HintFaceletProp;
-    hintStickerSpriteURL: URLProp;
-    latitudeLimit: LatitudeLimitProp;
-    movePressInput: MovePressInputProp;
-    orbitCoordinatesRequest: OrbitCoordinatesRequestProp;
-    stickering: StickeringProp;
-    foundationStickerSprite: SpriteProp;
-    hintStickerSprite: SpriteProp;
-    orbitCoordinates: OrbitCoordinatesProp;
-    constructor(twistyPlayerModel: TwistyPlayerModel);
-}

package/dist/types/twisty/model/UserVisibleErrorTracker.d.ts

@@ -1,10 +0,0 @@
-import { SimpleTwistyPropSource } from "./props/TwistyProp";
-interface UserVisibleError {
-    errors: string[];
-}
-export declare class UserVisibleErrorTracker extends SimpleTwistyPropSource<UserVisibleError> {
-    getDefaultValue(): UserVisibleError;
-    reset(): void;
-    canReuseValue(_v1: UserVisibleError, _v2: UserVisibleError): boolean;
-}
-export {};

package/dist/types/twisty/model/helpers.d.ts

@@ -1,4 +0,0 @@
-export declare function arrayEquals<T>(a: readonly T[], b: readonly T[]): boolean;
-export declare function arrayEqualsCompare<T>(a: readonly T[], b: readonly T[], compare: (a: T, b: T) => boolean): boolean;
-export declare function mod(v: number, m: number, offset?: number): number;
-export declare function modIntoRange(v: number, rangeMin: number, rangeMax: number): number;