cubing 0.21.2 → 0.23.0

package/src/cubing/search/inside/solve/puzzles/FTO.sgs

@@ -1,264 +0,0 @@
-SubgroupSizes 12 12 11 12 12 11 10 9 11 8 10 9 7 8 10 10 6 9 8 5 7 6 5 4 4 8 7 3 6 6 2 5 3 4 3
-
-Alg BB
-Alg BB'
-Alg U
-Alg U'
-Alg BB BL
-Alg BB BL'
-Alg BB' BR
-Alg BB' BR'
-Alg U R'
-Alg U' L
-Alg BB BL' D
-
-Alg R
-Alg R'
-Alg R D
-Alg R D'
-Alg R BR
-Alg R BR'
-Alg R' F
-Alg R' L
-Alg R' L'
-Alg BB L BB'
-Alg U L' U'
-
-Alg BB U BB'
-Alg BB U' BB'
-Alg BB R BB'
-Alg BB R' BB'
-Alg BB' U' BB
-Alg BB' U BB L
-Alg BB' U BB L'
-Alg BB' U' BB BL'
-Alg BB U' BB' BR
-Alg BB' R' BB F
-
-Alg BR
-Alg BR'
-Alg BR BL
-Alg BR BL'
-Alg BR' F
-Alg BR' F'
-Alg BR' D
-Alg BB BR BB'
-Alg U F U'
-Alg BR BL L
-Alg BR' D BR'
-
-Alg BB' BL BB
-Alg BB' BL' BB
-Alg BR D' BR'
-Alg BB' BL BB D'
-Alg BB' BL BB BL
-Alg BB' BL BB BL'
-Alg BB' BL L BB
-Alg BB' BL' BB F'
-Alg BB' BL' BB L'
-Alg BB' BL' BB BL'
-Alg BB' BL' L BL' BB
-
-Alg R' BR R
-Alg R' BR' R
-Alg BR BL' D BR
-Alg R' BR D R
-Alg R' BR D' R
-Alg R' BR R BL
-Alg BB' D' BL D BB
-Alg BR BB D' BB' BR'
-Alg BR BL' D BR L'
-Alg BR BL' D BL BR
-
-Alg U BR U'
-Alg U BR' U'
-Alg U' R U
-Alg U' R' U
-Alg U BR BB' U'
-Alg U BR' U' D
-Alg U BR' U' D'
-Alg U' R F' U
-Alg U' R' U L'
-
-Alg U BB U'
-Alg U BB' U'
-Alg U BB U' L
-Alg U BB U' L'
-Alg U BB' U' BL'
-Alg U BB U' L F
-Alg U BB U' L F'
-Alg U BB' U' BL' D'
-
-Alg BB BL' L BL BB'
-Alg BB BL' L' BL BB'
-Alg U BB' D BB U'
-Alg U BB' D' BB U'
-Alg U R D R' U'
-Alg U R D' R' U'
-Alg R' F L F' R
-Alg R' F L' F' R
-Alg BB L' BB F' D BB
-Alg U BB' D' BB U' D
-
-Alg F
-Alg F'
-Alg F D
-Alg F D'
-Alg F' L
-Alg F' L'
-Alg F D' BL
-
-Alg F BL F'
-Alg F BL' F'
-Alg BR' BL BR
-Alg BR' BL' BR
-Alg F BR F' BR'
-Alg F BL F' BL'
-Alg F BL' F' L
-Alg F BL' L' F'
-Alg F BR' BL BR F'
-
-Alg F' BL F
-Alg F' BL' F
-Alg U BL U'
-Alg U BL' U'
-Alg F U' F' U
-Alg F' BL F D'
-Alg F' BL F BL'
-Alg F' BL D F
-
-Alg L
-Alg L'
-Alg L BL
-Alg L BL'
-Alg F' D F
-Alg L BL D
-
-Alg L' BL L
-Alg L' BL' L
-Alg L' BL D L
-Alg L' BL D' L
-Alg L' BL L BL'
-Alg L' BL D' L BL
-Alg L' BL D' L BL'
-
-Alg L D L'
-Alg L D' L'
-Alg R' D R
-Alg R' D' R
-Alg L D L' D'
-Alg L R L' R'
-Alg L' BB' L BB
-Alg R' D R BL
-Alg L BL' L' BL L'
-
-Alg U L' D L U'
-Alg U BB D BB' U'
-Alg U L' D' L U'
-Alg U BB D' BB' U'
-Alg R' D' BL' D R
-Alg U BB D' BB' U' D
-Alg U BB' L BB L' U'
-Alg U BB D BB' U' BL'
-Alg U BB D' BB' L' D' L U'
-
-Alg F L F'
-Alg F L' F'
-Alg F L F' D
-Alg F L F' D'
-Alg F L' F' BL'
-
-Alg L BL' D BL L'
-Alg L BL' D' BL L'
-Alg F D L D' L' F'
-Alg F L D L' D' F'
-Alg F L' BB' L BB F'
-Alg F' D' R' D R F
-Alg F D L D' L' F' BL'
-Alg F' R' BB' R' BB R' F
-
-Alg BB D BB'
-Alg BB D' BB'
-Alg L' D L
-Alg L' D' L
-Alg BB D BB' D'
-Alg BB' L BB L'
-Alg BB D BB' D' BL
-
-Alg D
-Alg D'
-Alg D BL
-Alg D BL'
-
-Alg D BL' D BL D'
-Alg D BL' D' BL D'
-Alg BB D R D' R' BB'
-Alg BB R D R' D' BB'
-Alg D BL' D BL D' BL
-Alg D BL' D BL D' BL'
-
-Alg D BL D BL' D'
-Alg D BL D' BL' D'
-Alg BB' BL' BB BR D' BR'
-Alg D BL D BL' D' BL
-Alg D BL D BL' D' BL'
-
-Alg D' BL D
-Alg D' BL' D
-Alg D' BL D BL
-Alg D' BL D BL'
-
-Alg BB D' BB' BL BB D BB'
-Alg BB D' BB' BL' BB D BB'
-Alg D' BL' D BL D' BL D
-
-Alg BB R' BB' BL BB R BB'
-Alg BB R' BB' BL' BB R BB'
-Alg L R L' BL' L R' L'
-
-Alg F BL' BB' BL F' BL' BB
-Alg F' R' F BL F' R F
-Alg F' R' F BL' F' R F
-Alg BR R BR' BL' BR R' BR'
-Alg F L' BL U BL' U' L F'
-Alg F' U' F D F' U F D'
-Alg F BL F' D F BL' F' BL D'
-
-Alg F D F U' F' U D' F'
-Alg F D F' BL F BL' D' F'
-Alg F U D BL' U' BL D' F'
-Alg F U' D F U F' D' F'
-Alg F' BR L F BR' F' L' F
-Alg U R BL' F BL F' R' U'
-
-Alg BL
-Alg BL'
-
-Alg F U BL U' BL' F'
-Alg F BL U BL' U' F'
-Alg U BL BR BL' BR' U'
-Alg BR F BL F' BL' BR'
-Alg F U' F' U BL' U BL U'
-
-Alg F U' F' D F U F' D'
-Alg BB' U' F U BB U' F' U
-Alg D F U' F' D' F U F'
-Alg BR' U BR D' BR' U' BR D
-Alg D' BR BL' F BL' F' BL BR' BL D
-
-Alg U BR' U' BR BL' BR BL BR'
-
-Alg F L F' BL D F' D' F BL' L'
-Alg F' BR F BR' L BL' BR' BL BR L'
-Alg BB BR' U R BR' R' BR U' BB' BR
-Alg U BR' U' BR L' BL BR BL' BR' L
-
-Alg F BL F' BL F BL F' BL
-Alg F BL' F' BL' F BL' F' BL'
-
-Alg F' D BR F' R F R' BR' F D'
-Alg BB BL U' L U L' BL' U BB' U'
-Alg U BB U' BL L U' L' U BL' BB'
-
-Alg F BL F' BL' BB F' BR F BR' BB'
-Alg BB BR F' BR' BB' F BL F BL' F'

package/src/cubing/search/inside/solve/vendor/random-uint-below/get-random-values.ts

@@ -1,38 +0,0 @@
-export type GetRandomValuesFunction = (arr: Uint32Array) => void;
-
-// This is a workaround for a `node` segfault.
-// In theory, imports are cached and safe to import multiple times: https://nodejs.org/api/esm.html#esm_urls
-// In practice, a rapid series of inline imports inside a worker causes a segfault(!) in `node`.
-// So we cach a single import reference. We avoid populating it until we first need it, so that we don't attempt to perform the import in environments that don't need or have it (e.g. browsers, `deno`).
-let cryptoPromise: Promise<typeof import("crypto")> | null = null;
-
-// We could use top-level await to define this more statically, but that has limited transpilation support.
-export async function getRandomValuesFactory(): Promise<GetRandomValuesFunction> {
-  const hasWebCrypto =
-    typeof crypto !== "undefined" &&
-    typeof crypto.getRandomValues !== "undefined";
-
-  if (hasWebCrypto) {
-    return crypto.getRandomValues.bind(crypto) as GetRandomValuesFunction;
-  } else {
-    const nodeCrypto = await (cryptoPromise ??= import("crypto"));
-    return (arr: Uint32Array) => {
-      if (!(arr instanceof Uint32Array)) {
-        throw new Error(
-          "The getRandomValues() shim only takes unsigned 32-bit int arrays",
-        );
-      }
-      const bytes = nodeCrypto.randomBytes(arr.length * 4);
-      const uint32_list = [];
-      for (let i = 0; i < arr.length; i++) {
-        uint32_list.push(
-          (bytes[i * 4 + 0] << 24) +
-            (bytes[i * 4 + 1] << 16) +
-            (bytes[i * 4 + 2] << 8) +
-            (bytes[i * 4 + 3] << 0),
-        );
-      }
-      arr.set(uint32_list);
-    };
-  }
-}

package/src/cubing/twisty/old/animation/Timeline.ts

@@ -1,378 +0,0 @@
-import { RenderScheduler } from "./RenderScheduler";
-import type { AlgCursor, TimeRange } from "./cursor/AlgCursor";
-import {
-  BoundaryType,
-  Direction,
-  directionScalar,
-  MillisecondTimestamp,
-} from "./cursor/CursorTypes";
-
-// YouTube keeps playing on jump, but it also stays frozen while the cursor is
-// down. So I think it would be good for this to be false, but only if we
-// implement a "start jumping" event that pauses until "finish jumping" while
-// the scrubber is active.
-const PAUSE_ON_JUMP = true;
-
-// TODO: We use symbols to avoid exposing `number` values. Is this performant enough? Should/can we use symbols?
-export enum TimelineAction {
-  StartingToPlay = "StartingToPlay", // TODO playing backwards.
-  Pausing = "Pausing",
-  Jumping = "Jumping",
-}
-
-// TODO: We use symbols to avoid exposing `number` values. Is this performant enough? Should/can we use symbols?
-export enum TimestampLocationType {
-  StartOfTimeline = "Start",
-  EndOfTimeline = "End",
-  StartOfMove = "StartOfMove",
-  EndOfMove = "EndOfMove",
-  MiddleOfMove = "MiddleOfMove",
-  BetweenMoves = "BetweenMoves",
-}
-
-export interface TimelineActionEvent {
-  action: TimelineAction;
-  locationType: TimestampLocationType;
-}
-
-// This should be used by classes that (directly or indirectly) update puzzle
-// state based on a timestamp. It fires every time the timestamp is changed for
-// a new render (e.g. 60 times a second during animation), and only fires if the
-// timestamp has changed since the last call. This means you can use it as a
-// reliable callback telling you when to schedule a new render.
-export interface TimelineTimestampListener {
-  onTimelineTimestampChange(timestamp: MillisecondTimestamp): void;
-  onTimeRangeChange(timeRange: TimeRange): void;
-}
-
-// This should be used by classes that (directly or indirectly) update UI (e.g.
-// pause/play buttons).
-//
-// Note: the action events of a `Timeline` are not necessarily coordinated with
-// the timestamp events, since timestamp events are tied to animation frames.
-// For example, if you receive a "pausing" event, the final frame may already
-// have been drawn, or may be drawn in the near future.
-export interface TimelineActionListener {
-  onTimelineAction(actionEvent: TimelineActionEvent): void;
-}
-
-export interface TimelineTimestampDispatcher {
-  addTimestampListener(timestampListener: TimelineTimestampListener): void;
-}
-
-export interface TimelineActionDispatcher {
-  addActionListener(actionListener: TimelineActionListener): void;
-}
-
-// `performance.now()` is rounded for security concerns, so it's usually not
-// accurate to the millisecond. So we round it, which lets us work with whole ms
-// everywhere.
-function getNow(): MillisecondTimestamp {
-  return Math.round(performance.now());
-}
-
-export class Timeline
-  implements TimelineTimestampDispatcher, TimelineActionDispatcher
-{
-  animating: boolean = false;
-  tempoScale: number = 1;
-  private cursors: Set<AlgCursor> = new Set();
-  private timestampListeners: Set<TimelineTimestampListener> = new Set();
-  private actionListeners: Set<TimelineActionListener> = new Set();
-  timestamp: number = 0;
-  lastAnimFrameNow: DOMHighResTimeStamp = 0;
-  lastAnimFrameTimestamp: MillisecondTimestamp;
-  private scheduler: RenderScheduler;
-
-  direction: Direction.Backwards | Direction.Forwards = Direction.Forwards; // TODO: handle pausing here?
-
-  boundaryType: BoundaryType = BoundaryType.EntireTimeline;
-  cachedNextBoundary: MillisecondTimestamp;
-
-  constructor() {
-    const animFrame = (_now: MillisecondTimestamp): void => {
-      if (this.animating) {
-        const now = getNow(); // TODO: See if we can use the rAF value without monotonicity issues.;
-        this.timestamp =
-          this.timestamp +
-          this.tempoScale *
-            directionScalar(this.direction) *
-            (now - this.lastAnimFrameNow);
-        this.lastAnimFrameNow = now;
-
-        const atOrPastBoundary =
-          this.direction === Direction.Backwards
-            ? this.timestamp <= this.cachedNextBoundary
-            : this.timestamp >= this.cachedNextBoundary;
-        if (atOrPastBoundary) {
-          this.timestamp = this.cachedNextBoundary;
-          if (this.animating) {
-            this.animating = false;
-            this.dispatchAction(TimelineAction.Pausing);
-          }
-        }
-      }
-
-      if (this.timestamp !== this.lastAnimFrameTimestamp) {
-        this.dispatchTimestamp();
-        this.lastAnimFrameTimestamp = this.timestamp;
-      }
-
-      if (this.animating) {
-        this.scheduler.requestAnimFrame();
-      }
-    };
-    this.scheduler = new RenderScheduler(animFrame);
-  }
-
-  public addCursor(cursor: AlgCursor): void {
-    this.cursors.add(cursor);
-    this.dispatchTimeRange();
-  }
-
-  removeCursor(cursor: AlgCursor): void {
-    this.cursors.delete(cursor);
-    this.clampTimestampToRange();
-    this.dispatchTimeRange();
-  }
-
-  // TODO: test
-  private clampTimestampToRange(): void {
-    const timeRange = this.timeRange();
-    if (this.timestamp < timeRange.start) {
-      this.setTimestamp(timeRange.start);
-    }
-    if (this.timestamp > timeRange.end) {
-      this.setTimestamp(timeRange.end);
-    }
-  }
-
-  // In the future, this might do some calculations or caching.
-  public onCursorChange(_cursor: AlgCursor): void {
-    if (this.timestamp > this.maxTimestamp()) {
-      this.timestamp = this.maxTimestamp();
-    }
-    this.dispatchTimeRange();
-  }
-
-  timeRange(): TimeRange {
-    let start = 0;
-    let end = 0;
-    for (const cursor of this.cursors) {
-      const cursorTimeRange = cursor.timeRange();
-      start = Math.min(start, cursorTimeRange.start);
-      end = Math.max(end, cursorTimeRange.end);
-    }
-
-    return { start, end };
-  }
-
-  minTimestamp(): number {
-    // TODO: Calculate and cache this value every time there's a new cursor.
-    return this.timeRange().start;
-  }
-
-  maxTimestamp(): number {
-    // TODO: Calculate and cache this value every time there's a new cursor.
-    return this.timeRange().end;
-  }
-
-  private dispatchTimeRange(): void {
-    const timeRange = this.timeRange();
-    for (const listener of this.cursors) {
-      // TODO: dedup in case the timestamp hasn't changed sine last time.
-      listener.onTimeRangeChange(timeRange);
-    }
-    // TODO: Combine loops without extra memory?
-    for (const listener of this.timestampListeners) {
-      // TODO: dedup in case the timestamp hasn't changed sine last time.
-      listener.onTimeRangeChange(timeRange);
-    }
-  }
-
-  private dispatchTimestamp(): void {
-    for (const listener of this.cursors) {
-      // TODO: dedup in case the timestamp hasn't changed sine last time.
-      listener.onTimelineTimestampChange(this.timestamp);
-    }
-    // TODO: Combine loops without extra memory?
-    for (const listener of this.timestampListeners) {
-      // TODO: dedup in case the timestamp hasn't changed sine last time.
-      listener.onTimelineTimestampChange(this.timestamp);
-    }
-  }
-
-  addTimestampListener(timestampListener: TimelineTimestampListener): void {
-    this.timestampListeners.add(timestampListener);
-  }
-
-  removeTimestampListener(timestampListener: TimelineTimestampListener): void {
-    this.timestampListeners.delete(timestampListener);
-  }
-
-  addActionListener(actionListener: TimelineActionListener): void {
-    this.actionListeners.add(actionListener);
-  }
-
-  removeActionListener(actionListener: TimelineActionListener): void {
-    this.actionListeners.delete(actionListener);
-  }
-
-  play(): void {
-    this.experimentalPlay(Direction.Forwards, BoundaryType.EntireTimeline);
-  }
-
-  experimentalPlay(
-    direction: Direction.Backwards | Direction.Forwards,
-    boundaryType: BoundaryType = BoundaryType.EntireTimeline,
-  ): void {
-    this.direction = direction;
-    this.boundaryType = boundaryType;
-    const nextBoundary = this.nextBoundary(
-      this.timestamp,
-      direction,
-      this.boundaryType,
-    );
-    if (nextBoundary === null) {
-      return; // Nowhere to end, so we don't animate.
-    }
-    this.cachedNextBoundary = nextBoundary;
-    if (!this.animating) {
-      this.animating = true;
-      this.lastAnimFrameNow = getNow();
-      this.dispatchAction(TimelineAction.StartingToPlay);
-      this.scheduler.requestAnimFrame();
-    }
-  }
-
-  // Non-inclusive
-  private nextBoundary(
-    timestamp: MillisecondTimestamp,
-    direction: Direction.Backwards | Direction.Forwards,
-    boundaryType: BoundaryType = BoundaryType.EntireTimeline,
-  ): MillisecondTimestamp | null {
-    switch (boundaryType) {
-      case BoundaryType.EntireTimeline: {
-        switch (direction) {
-          case Direction.Backwards:
-            return timestamp <= this.minTimestamp()
-              ? null
-              : this.minTimestamp();
-          case Direction.Forwards:
-            return timestamp >= this.maxTimestamp()
-              ? null
-              : this.maxTimestamp();
-          default:
-            throw new Error("invalid direction");
-        }
-      }
-      case BoundaryType.Move: {
-        let result: null | MillisecondTimestamp = null;
-        for (const cursor of this.cursors) {
-          const boundaryTimestamp = cursor.moveBoundary(timestamp, direction);
-          if (boundaryTimestamp !== null) {
-            switch (direction) {
-              case Direction.Backwards: {
-                result = Math.min(
-                  result ?? boundaryTimestamp,
-                  boundaryTimestamp,
-                );
-                break;
-              }
-              case Direction.Forwards: {
-                result = Math.max(
-                  result ?? boundaryTimestamp,
-                  boundaryTimestamp,
-                );
-                break;
-              }
-              default:
-                throw new Error("invalid direction");
-            }
-          }
-        }
-        return result;
-      }
-      default:
-        throw new Error("invalid boundary type");
-    }
-  }
-
-  // One more render may be dispatched after this.
-  pause(): void {
-    // TODO: error if already paused?
-    if (this.animating) {
-      this.animating = false;
-      this.dispatchAction(TimelineAction.Pausing);
-      this.scheduler.requestAnimFrame();
-    }
-  }
-
-  playPause(): void {
-    if (this.animating) {
-      this.pause();
-    } else {
-      if (this.timestamp >= this.maxTimestamp()) {
-        this.timestamp = 0;
-      }
-      this.experimentalPlay(Direction.Forwards, BoundaryType.EntireTimeline);
-    }
-  }
-
-  setTimestamp(timestamp: MillisecondTimestamp): void {
-    const oldTimestamp = this.timestamp;
-    this.timestamp = timestamp;
-    this.lastAnimFrameNow = getNow();
-
-    if (oldTimestamp !== timestamp) {
-      this.dispatchAction(TimelineAction.Jumping);
-      this.scheduler.requestAnimFrame();
-    }
-
-    if (PAUSE_ON_JUMP) {
-      this.animating = false;
-      this.dispatchAction(TimelineAction.Pausing);
-    }
-  }
-
-  jumpToStart(): void {
-    this.setTimestamp(this.minTimestamp());
-  }
-
-  jumpToEnd(): void {
-    this.setTimestamp(this.maxTimestamp());
-  }
-
-  /** @deprecated */
-  experimentalJumpToLastMove(): void {
-    let max: MillisecondTimestamp = 0;
-    for (const cursor of this.cursors) {
-      max = Math.max(
-        max,
-        cursor.experimentalTimestampForStartOfLastMove() ?? 0,
-      );
-    }
-    this.setTimestamp(max);
-  }
-
-  private dispatchAction(event: TimelineAction): void {
-    let locationType = TimestampLocationType.MiddleOfMove; // TODO
-    switch (this.timestamp) {
-      // TODO
-      case this.minTimestamp():
-        locationType = TimestampLocationType.StartOfTimeline;
-        break;
-      case this.maxTimestamp():
-        locationType = TimestampLocationType.EndOfTimeline;
-        break;
-    }
-
-    const actionEvent: TimelineActionEvent = {
-      action: event,
-      locationType,
-    };
-    for (const listener of this.actionListeners) {
-      listener.onTimelineAction(actionEvent);
-    }
-  }
-}