cubing 0.20.2 → 0.21.0-pre12

package/src/cubing/alg/Alg.ts

@@ -47,6 +47,29 @@ export function experimentalEnsureAlg(alg: FlexibleAlgSource): Alg {
   return new Alg(alg);
 }
 
+/**
+ * Alg is a class that encapsulated a structured alg. To create an alg from a string, use:
+ *
+ *     new Alg("R U R'"); // Convenient
+ *     Alg.fromString(dynamicString); // Recommended when handling dynamic input.
+ *
+ * Once you have an Alg, you can call methods to transform it:
+ *
+ *     new Alg("[[R: U], R U R2']").expand().simplify().invert();
+ *
+ * To convert an Alg to a string, use .toString():
+ *
+ *     new Alg("R U F").invert().toString();
+ *
+ * If you need to debug, you may also find it convenient to use .log():
+ *
+ *     if (alg.isIdentical(alg.invert())) {
+ *       alg.log("A self-inverse!")
+ *     }
+ *
+ * For more information, see: {@link https://js.cubing.net/cubing/alg/}
+ *
+ */
 export class Alg extends AlgCommon<Alg> {
   // #debugString: string;
   #units: Iterable<Unit>; // TODO: freeze?
@@ -62,6 +85,36 @@ export class Alg extends AlgCommon<Alg> {
     }
   }
 
+  /**
+   * Checks whether this Alg is structurally identical to another Alg. This
+   * essentially means that they are written identically apart from whitespace.
+   *
+   *     const alg1 = new Alg("R U L'");
+   *     const alg2 = new Alg("L U' R'").invert();
+   *     // true
+   *     alg1.isIdentical(alg2);
+   *
+   *     // false
+   *     new Alg("[R, U]").isIdentical(new Alg("R U R' U'"));
+   *     // true
+   *     new Alg("[R, U]").expand().isIdentical(new Alg("R U R' U'"));
+   *
+   * Note that .isIdentical() efficiently compares algorithms, but mainly exists
+   * to help optimize code when the structure of an algorithm hasn't changed.
+   * There are many ways to write the "same" alg on most puzzles, but is
+   * *highly* recommended to avoid expanding two Alg instances to compare them,
+   * since that can easily slow your program to a crawl if someone inputs an alg
+   * containing a large repetition. In general, you should use `cubing/kpuzzle`
+   * to compare if two algs have the same effect on a puzzle.
+   *
+   * Also note that parser annotations are not take into account while comparing
+   * algs:
+   *
+   *     const alg = new Alg([new Move("R"), new Move("U2")]);
+   *     // true, even though one of the algs has parser annotations
+   *     alg.isIdentical(new Alg("R U2"))
+   *
+   */
   isIdentical(other: Comparable): boolean {
     const otherAsAlg = other as Alg;
     if (!other.is(Alg)) {
@@ -82,6 +135,16 @@ export class Alg extends AlgCommon<Alg> {
     return true;
   }
 
+  /**
+   * Returns the inverse of the given alg.
+   *
+   * Note that that this does not make any assumptions about what puzzle the alg
+   * is for. For example, U2 is its own inverse on a cube, but U2' has the same
+   * effect U3 (and not U2) on Megaminx:
+   *
+   *     // Outputs: R U2' L'
+   *     new Alg("L U2 R'").invert().log();
+   */
   invert(): Alg {
     // TODO: Handle newLines and comments correctly
     // TODO: Make more efficient.
@@ -99,6 +162,24 @@ export class Alg extends AlgCommon<Alg> {
     }
   }
 
+  /**
+   * Expands all Grouping, Commutator, and Conjugate parts nested inside the
+   * alg.
+   *
+   *     // F R U R' U' F'
+   *     new Alg("[F: [R, U]]").expand().log();
+   *
+   *     // F [R, U] F'
+   *     new Alg("[F: [R, U]]").expand(({ depth: 1 }).log();
+   *
+   * Avoid calling this on a user-provided alg unless the user explicitly asks
+   * to see the expanded alg. Otherwise, it's easy to make your program freeze
+   * when someone passes in an alg like: (R U)10000000
+   *
+   * Generally, if you want to perform an operation on an entire alg, you'll
+   * want to use something based on the `Traversal` mechanism, like countMoves()
+   * from `cubing/notation`.
+   */
   expand(options?: { depth?: number }): Alg {
     return new Alg(
       this.experimentalExpand(
@@ -125,6 +206,7 @@ export class Alg extends AlgCommon<Alg> {
 
   /** @deprecated */
   experimentalIsEmpty(): boolean {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     for (const _ of this.#units) {
       return false;
     }
@@ -158,6 +240,13 @@ export class Alg extends AlgCommon<Alg> {
   //   };
   // }
 
+  /**
+   * Converts the Alg to a string:
+   *
+   *     const alg = new Alg([new Move("R"), new Move("U2"), new Move("L")])
+   *     // R U2 L
+   *     console.log(alg.toString())
+   */
   toString(): string {
     let output = "";
     let previousUnit: Unit | null = null;

package/src/cubing/alg/common.ts

@@ -36,7 +36,7 @@ export abstract class AlgCommon<T extends Alg | Unit>
     super();
     if (writeAlgDebugField) {
       Object.defineProperty(this, "_debugStr", {
-        get: function () {
+        get: () => {
           return this.toString();
         },
       });
@@ -46,7 +46,9 @@ export abstract class AlgCommon<T extends Alg | Unit>
   get log(): (message?: any) => void {
     // By returning a (bound) version of `console.log`, we ensure that DevTools
     // logs the call site instead of this function.
-    return console.log.bind(console, this, this.toString());
+    return console.log.bind(console, this, this.toString()) as (
+      message?: any,
+    ) => void;
   }
 
   abstract toString(): string;

package/src/cubing/alg/iteration.ts

@@ -33,7 +33,7 @@ export function* directedGenerator<T>(
   g: Generator<T>,
   direction: IterationDirection,
 ): Generator<T> {
-  return direction === IterationDirection.Backwards
+  direction === IterationDirection.Backwards
     ? yield* reverseGenerator(g)
     : yield* g;
 }

package/src/cubing/alg/parse.ts

@@ -266,6 +266,8 @@ class AlgParser {
     }
 
     let quantumMove = this.parseQuantumMoveImpl();
+    // Only `hadEmptyAbsAmount` is `const`.
+    // eslint-disable-next-line prefer-const
     let [amount, hadEmptyAbsAmount] = this.parseAmountAndTrackEmptyAbsAmount();
     const suffix = this.parseMoveSuffix();
 

package/src/cubing/alg/test/alg-comparison.ts

@@ -12,6 +12,7 @@ expect.extend({
 declare global {
   // eslint-disable-next-line @typescript-eslint/no-namespace
   namespace jest {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     interface Matchers<R, T> {
       toBeIdentical(observed: Alg): CustomMatcherResult;
     }

package/src/cubing/alg/units/Unit.ts

@@ -9,6 +9,3 @@ import type { Pause } from "./leaves/Pause";
 export type LeafUnit = Move | LineComment | Newline | Pause;
 
 export type Unit = LeafUnit | Grouping | Conjugate | Commutator;
-
-// @ts-ignore https://github.com/snowpackjs/snowpack/discussions/1589#discussioncomment-130176
-const _SNOWPACK_HACK = true;

package/src/cubing/alg/units/containers/Commutator.ts

@@ -80,6 +80,6 @@ export class Commutator extends AlgCommon<Commutator> {
   }
 
   toString(): string {
-    return `[${this.#A}, ${this.#B}]`;
+    return `[${this.#A.toString()}, ${this.#B.toString()}]`;
   }
 }

package/src/cubing/alg/units/leaves/Move.ts

@@ -31,8 +31,8 @@ export class QuantumMove extends Comparable {
     if (
       this.#innerLayer !== null &&
       (!Number.isInteger(this.#innerLayer) ||
-        this.#innerLayer! < 1 ||
-        this.#innerLayer! > MAX_INT)
+        this.#innerLayer < 1 ||
+        this.#innerLayer > MAX_INT)
     ) {
       throw new Error(
         `QuantumMove inner layer must be a positive integer below ${MAX_INT_DESCRIPTION}.`,
@@ -53,7 +53,7 @@ export class QuantumMove extends Comparable {
     if (
       this.#outerLayer !== null &&
       this.#innerLayer !== null &&
-      this.#innerLayer! <= this.#outerLayer!
+      this.#innerLayer <= this.#outerLayer
     ) {
       throw new Error(
         "QuantumMove outer layer must be smaller than inner layer.",
@@ -81,7 +81,7 @@ export class QuantumMove extends Comparable {
   }
 
   isIdentical(other: QuantumMove): boolean {
-    const otherAsQuantumMove = other as QuantumMove;
+    const otherAsQuantumMove = other;
     return (
       other.is(QuantumMove) &&
       this.#family === otherAsQuantumMove.#family &&

package/src/cubing/bluetooth/connect/index.ts

@@ -13,7 +13,7 @@ function requestOptions<T>(
         optionalServices: [] as BluetoothServiceUUID[],
       }
     : {
-        filters: [] as BluetoothRequestDeviceFilter[],
+        filters: [] as BluetoothLEScanFilter[],
         optionalServices: [] as BluetoothServiceUUID[],
       };
   for (const config of configs) {

package/src/cubing/bluetooth/smart-puzzle/Heykube.ts

@@ -158,7 +158,7 @@ export class HeykubeCube extends BluetoothPuzzle {
 
 // // TODO: Move this into a factory?
 export const heykubeConfig: BluetoothConfig<BluetoothPuzzle> = {
-  connect: HeykubeCube.connect,
+  connect: HeykubeCube.connect.bind(HeykubeCube),
   prefixes: ["HEYKUBE"],
   filters: [{ namePrefix: "HEYKUBE" }],
   optionalServices: [UUIDs.heykubeService],

package/src/cubing/bluetooth/smart-puzzle/bluetooth-puzzle.ts

@@ -36,7 +36,7 @@ export interface BluetoothConfig<T> {
   ) => Promise<T>;
   // TODO: Can we reuse `filters`?
   prefixes: string[]; // `[""]` for GiiKER
-  filters: BluetoothRequestDeviceFilter[];
+  filters: BluetoothLEScanFilter[];
   optionalServices: BluetoothServiceUUID[];
 }
 

package/src/cubing/bluetooth/smart-puzzle/gan.ts

@@ -163,11 +163,11 @@ const commands: { [cmd: string]: BufferSource } = {
 
 function buf2hex(buffer: ArrayBuffer): string {
   // buffer is an ArrayBuffer
-  return Array.prototype.map
-    .call(new Uint8Array(buffer), (x: number) =>
+  return (
+    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>
       ("00" + x.toString(16)).slice(-2),
-    )
-    .join(" ");
+    ) as string[]
+  ).join(" ");
 }
 
 const reidEdgeOrder = "UF UR UB UL DF DR DB DL FR FL BR BL".split(" ");
@@ -474,7 +474,7 @@ export class GanCube extends BluetoothPuzzle {
 
 // // TODO: Move this into a factory?
 export const ganConfig: BluetoothConfig<BluetoothPuzzle> = {
-  connect: GanCube.connect,
+  connect: GanCube.connect.bind(GanCube),
   prefixes: ["GAN"],
   filters: [{ namePrefix: "GAN" }],
   optionalServices: [UUIDs.ganCubeService, UUIDs.infoService],

package/src/cubing/bluetooth/smart-puzzle/giiker.ts

@@ -106,7 +106,7 @@ async function decodeState(data: Uint8Array): Promise<Uint8Array> {
   if (!probablyEncrypted(data)) {
     return data;
   }
-  return await decryptState(data);
+  return decryptState(data);
   // TODO: Check that the decrypted state is a valid staet.
 }
 
@@ -257,7 +257,7 @@ export class GiiKERCube extends BluetoothPuzzle {
 
 // TODO: Move this into a factory?
 export const giiKERConfig: BluetoothConfig<BluetoothPuzzle> = {
-  connect: GiiKERCube.connect,
+  connect: GiiKERCube.connect.bind(GiiKERCube),
   prefixes: ["Gi", ""], // Hack
   filters: [
     // Known prefixes: GiC, GiS (3x3x3), Gi2 (2x2x2)

package/src/cubing/bluetooth/smart-puzzle/gocube.ts

@@ -11,11 +11,11 @@ const UUIDs = {
 // https://stackoverflow.com/a/40031979
 function buf2hex(buffer: ArrayBuffer): string {
   // buffer is an ArrayBuffer
-  return Array.prototype.map
-    .call(new Uint8Array(buffer), (x: number) =>
+  return (
+    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>
       ("00" + x.toString(16)).slice(-2),
-    )
-    .join(" ");
+    ) as string[]
+  ).join(" ");
 }
 
 function bufferToString(buffer: ArrayBuffer): string {
@@ -160,7 +160,7 @@ const rotateTowardsRate = 0.5;
 
 // TODO: Move this into a factory?
 export const goCubeConfig: BluetoothConfig<BluetoothPuzzle> = {
-  connect: GoCube.connect,
+  connect: GoCube.connect.bind(GoCube),
   prefixes: ["GoCube", "Rubik"],
   filters: [{ namePrefix: "GoCube" }, { namePrefix: "Rubik" }],
   optionalServices: [UUIDs.goCubeService],

package/src/cubing/bluetooth/smart-robot/GanRobot.ts

@@ -4,11 +4,11 @@ import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
 // TODO: Remove this. It's only used for debugging.
 function buf2hex(buffer: ArrayBuffer): string {
   // buffer is an ArrayBuffer
-  return Array.prototype.map
-    .call(new Uint8Array(buffer), (x: number) =>
+  return (
+    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>
       ("00" + x.toString(16)).slice(-2),
-    )
-    .join(" ");
+    ) as string[]
+  ).join(" ");
 }
 
 const MAX_NIBBLES_PER_WRITE = 18 * 2;
@@ -304,7 +304,7 @@ export class GanRobot extends EventTarget {
 
 // // TODO: Move this into a factory?
 export const ganTimerConfig: BluetoothConfig<GanRobot> = {
-  connect: GanRobot.connect,
+  connect: GanRobot.connect.bind(GanRobot),
   prefixes: ["GAN"],
   filters: [{ namePrefix: "GAN" }],
   optionalServices: [UUIDs.ganRobotService],

package/src/cubing/bluetooth/smart-timer/GanTimer.ts

@@ -1,4 +1,4 @@
-import type { MillisecondTimestamp } from "../../twisty/animation/cursor/CursorTypes";
+import type { MillisecondTimestamp } from "../../twisty/old/animation/cursor/CursorTypes";
 import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
 
 // TODO: Short IDs
@@ -134,7 +134,7 @@ export class GanTimer extends EventTarget {
 
 // // TODO: Move this into a factory?
 export const ganTimerConfig: BluetoothConfig<GanTimer> = {
-  connect: GanTimer.connect,
+  connect: GanTimer.connect.bind(GanTimer),
   prefixes: ["GAN"],
   filters: [{ namePrefix: "GAN" }],
   optionalServices: [UUIDs.ganTimerService],

package/src/cubing/kpuzzle/3x3x3/3x3x3.kpuzzle.json.spec.ts

@@ -0,0 +1,40 @@
+import { Alg } from "../../alg";
+import { KPuzzle } from "../kpuzzle";
+import { cube3x3x3KPuzzle } from "./3x3x3.kpuzzle.json";
+
+function transformationForAlg(alg: string | Alg) {
+  const kpuzzle = new KPuzzle(cube3x3x3KPuzzle);
+  kpuzzle.applyAlg(new Alg(alg));
+  return kpuzzle.state;
+}
+
+describe("3x3x3 definition", () => {
+  it("should have consistent moves", () => {
+    expect(transformationForAlg("r")).not.toEqual(transformationForAlg("R M"));
+
+    expect(transformationForAlg("u")).toEqual(transformationForAlg("U E'"));
+    expect(transformationForAlg("l")).toEqual(transformationForAlg("L M"));
+    expect(transformationForAlg("f")).toEqual(transformationForAlg("F S"));
+    expect(transformationForAlg("r")).toEqual(transformationForAlg("R M'"));
+    expect(transformationForAlg("b")).toEqual(transformationForAlg("B S'"));
+    expect(transformationForAlg("d")).toEqual(transformationForAlg("D E"));
+
+    expect(transformationForAlg("u")).toEqual(transformationForAlg("Uw"));
+    expect(transformationForAlg("l")).toEqual(transformationForAlg("Lw"));
+    expect(transformationForAlg("f")).toEqual(transformationForAlg("Fw"));
+    expect(transformationForAlg("r")).toEqual(transformationForAlg("Rw"));
+    expect(transformationForAlg("b")).toEqual(transformationForAlg("Bw"));
+    expect(transformationForAlg("d")).toEqual(transformationForAlg("Dw"));
+
+    expect(transformationForAlg("x")).toEqual(transformationForAlg("R M' L'"));
+    expect(transformationForAlg("y")).toEqual(transformationForAlg("U E' D'"));
+    expect(transformationForAlg("z")).toEqual(transformationForAlg("F S B'"));
+
+    expect(transformationForAlg("Uv")).toEqual(transformationForAlg("y"));
+    expect(transformationForAlg("Lv")).toEqual(transformationForAlg("x'"));
+    expect(transformationForAlg("Fv")).toEqual(transformationForAlg("z"));
+    expect(transformationForAlg("Rv")).toEqual(transformationForAlg("x"));
+    expect(transformationForAlg("Bv")).toEqual(transformationForAlg("z'"));
+    expect(transformationForAlg("Dv")).toEqual(transformationForAlg("y'"));
+  });
+});

package/src/cubing/{puzzles/implementations/3x3x3/3x3x3.kpuzzle.json_.ts → kpuzzle/3x3x3/3x3x3.kpuzzle.json.ts}

@@ -1,6 +1,11 @@
+// TODO: This file is here to avoid dependency loops, but it should eventually
+// move back into `cubing/puzzles`. We currently have a few functions that are
+// hardcoded to require synchronous access to this definition, and we need to
+// find a better way to do that.
+
 // TODO: this would be a raw `.json` file, but Parcel runs into an error from
 
-import type { KPuzzleDefinition } from "../../../kpuzzle";
+import type { KPuzzleDefinition } from "..";
 
 // using that as both a sync and async import. Probably https://github.com/parcel-bundler/parcel/issues/2546
 export const cube3x3x3KPuzzle: KPuzzleDefinition = {
@@ -251,16 +256,16 @@ export const cube3x3x3KPuzzle: KPuzzleDefinition = {
     },
     b: {
       EDGES: {
-        permutation: [8, 5, 2, 1, 9, 7, 6, 3, 4, 0, 10, 11],
-        orientation: [1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0],
+        permutation: [0, 5, 10, 1, 4, 7, 11, 3, 8, 9, 6, 2],
+        orientation: [0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1],
       },
       CORNERS: {
-        permutation: [4, 1, 2, 0, 5, 3, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0],
+        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
+        orientation: [0, 2, 1, 0, 0, 0, 2, 1],
       },
       CENTERS: {
         permutation: [3, 0, 2, 5, 4, 1],
-        orientation: [3, 3, 3, 3, 0, 3],
+        orientation: [3, 3, 0, 3, 1, 3],
       },
     },
     d: {

package/src/cubing/kpuzzle/canon.spec.ts

@@ -1,16 +1,12 @@
 import { getPuzzleGeometryByName } from "../puzzle-geometry";
-import {
-  KPuzzleDefinition,
-  areStatesEquivalent,
-  combineTransformations,
-} from ".";
+import { areStatesEquivalent, combineTransformations } from ".";
 import { Canonicalizer, CanonicalSequenceIterator } from "./canonicalize";
 import { Alg } from "../alg";
+
 describe("CanonSequences", () => {
   it("should merge sequences (megaminx test)", () => {
-    const options: string[] = [];
-    const pg = getPuzzleGeometryByName("megaminx", options);
-    const def = pg.writekpuzzle(false) as KPuzzleDefinition;
+    const pg = getPuzzleGeometryByName("megaminx", {});
+    const def = pg.writekpuzzle(false);
     const canon = new Canonicalizer(def);
     const a1 = "U F2 BL R3 L3";
     const a2 = "L2 BL2 F' U2";
@@ -32,9 +28,8 @@ describe("CanonSequences", () => {
     ).toBeTruthy();
   });
   it("should generate canonical sequences (3x3x3 test)", () => {
-    const options: string[] = ["allmoves", "false"];
-    const pg = getPuzzleGeometryByName("3x3x3", options);
-    const def = pg.writekpuzzle(false) as KPuzzleDefinition;
+    const pg = getPuzzleGeometryByName("3x3x3", { allMoves: false });
+    const def = pg.writekpuzzle(false);
     const canon = new Canonicalizer(def);
     const cnts = [0, 0, 0, 0];
     const csi = new CanonicalSequenceIterator(canon);

package/src/cubing/kpuzzle/canonicalize.ts

@@ -103,7 +103,7 @@ export class Canonicalizer {
   ): SearchSequence {
     const ss = new SearchSequence(this, tr);
     for (const move of alg.experimentalLeafMoves()) {
-      ss.appendOneMove(this.blockMoveToInternalMove(move as Move));
+      ss.appendOneMove(this.blockMoveToInternalMove(move));
     }
     return ss;
   }

package/src/cubing/kpuzzle/definition_types.ts

@@ -21,6 +21,3 @@ export interface KPuzzleDefinition {
   svg?: string;
   moveNotation?: MoveNotation;
 }
-
-// @ts-ignore https://github.com/snowpackjs/snowpack/discussions/1589#discussioncomment-130176
-const _SNOWPACK_HACK = true;

package/src/cubing/kpuzzle/index.ts

@@ -27,6 +27,7 @@ export { parseKPuzzleDefinition } from "./parser";
 
 export { KPuzzleSVGWrapper } from "./svg";
 
+export { cube3x3x3KPuzzle as experimentalCube3x3x3KPuzzle } from "./3x3x3/3x3x3.kpuzzle.json";
 export { experimentalIs3x3x3Solved } from "./puzzle-orientation";
 
 export { transformationForQuantumMove as experimentalTransformationForQuantumMove } from "./kpuzzle";

package/src/cubing/kpuzzle/prunetable.spec.ts

@@ -1,13 +1,11 @@
 import { getPuzzleGeometryByName } from "../puzzle-geometry";
-import type { KPuzzleDefinition } from ".";
 import { Canonicalizer } from "./canonicalize";
 import { PruningTable } from "./pruningtable";
 import { Alg } from "../alg";
 describe("PruneTable", () => {
   it("solve 2x2x2", () => {
-    const options: string[] = [];
-    const pg = getPuzzleGeometryByName("2x2x2", options);
-    const def = pg.writekpuzzle(false) as KPuzzleDefinition;
+    const pg = getPuzzleGeometryByName("2x2x2", {});
+    const def = pg.writekpuzzle(false);
     const canon = new Canonicalizer(def);
     const a1 = "L' D L2 D' L2 F R' F R' L' F D L2 F2 R' F U B'";
     const ss1 = canon.sequenceToSearchSequence(

package/src/cubing/kpuzzle/puzzle-orientation.ts

@@ -1,6 +1,6 @@
 import { experimentalNormalizePuzzleOrientation as normalize3x3x3Orientation } from "../protocol";
 import type { Transformation } from "./definition_types";
-import { experimentalCube3x3x3KPuzzle as def } from "../puzzles";
+import { cube3x3x3KPuzzle as def } from "./3x3x3/3x3x3.kpuzzle.json";
 import {
   areOrbitTransformationsEquivalent,
   areTransformationsEquivalent,

package/src/cubing/kpuzzle/svg.ts

@@ -87,10 +87,7 @@ export class KPuzzleSVGWrapper {
     }
     svgElem.style.maxWidth = "100%";
     svgElem.style.maxHeight = "100%";
-    this.gradientDefs = document.createElementNS(
-      xmlns,
-      "defs",
-    ) as SVGDefsElement;
+    this.gradientDefs = document.createElementNS(xmlns, "defs");
     svgElem.insertBefore(this.gradientDefs, svgElem.firstChild);
 
     for (const orbitName in kPuzzleDefinition.orbits) {
@@ -135,7 +132,7 @@ export class KPuzzleSVGWrapper {
               }
             })();
           } else {
-            originalColor = elem.style.fill as string;
+            originalColor = elem.style.fill;
           }
           this.originalColors[id] = originalColor;
           this.gradients[id] = this.newGradient(id, originalColor);
@@ -165,9 +162,7 @@ export class KPuzzleSVGWrapper {
       const orbitDefinition = definition.orbits[orbitName];
 
       const curOrbitState = state[orbitName];
-      const nextOrbitState = nextState
-        ? (nextState as Transformation)[orbitName]
-        : null;
+      const nextOrbitState = nextState ? nextState[orbitName] : null;
       for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
         for (
           let orientation = 0;
@@ -271,7 +266,7 @@ export class KPuzzleSVGWrapper {
       { offset: 100, color: originalColor },
     ];
     for (const stopDef of stopDefs) {
-      const stop = document.createElementNS(xmlns, "stop") as SVGStopElement;
+      const stop = document.createElementNS(xmlns, "stop");
       stop.setAttribute("offset", `${stopDef.offset}%`);
       stop.setAttribute("stop-color", stopDef.color);
       stop.setAttribute("stop-opacity", "1");

package/src/cubing/kpuzzle/transformations.ts

@@ -147,7 +147,7 @@ export function invertTransformation(
       const newPerm = new Array(oDef.numPieces);
       const newOri = new Array(oDef.numPieces);
       for (let idx = 0; idx < oDef.numPieces; idx++) {
-        const fromIdx = o.permutation[idx] as number;
+        const fromIdx = o.permutation[idx];
         newPerm[fromIdx] = idx;
         newOri[fromIdx] =
           (oDef.orientations - o.orientation[idx] + oDef.orientations) %

package/src/cubing/protocol/binary/binary3x3x3.spec.ts

@@ -1,6 +1,9 @@
 import { Alg } from "../../alg";
-import { KPuzzle, Transformation } from "../../kpuzzle";
-import { cube3x3x3KPuzzle as def } from "../../puzzles/implementations/3x3x3/3x3x3.kpuzzle.json_";
+import {
+  KPuzzle,
+  Transformation,
+  experimentalCube3x3x3KPuzzle as def,
+} from "../../kpuzzle";
 import {
   reid3x3x3ToTwizzleBinary,
   twizzleBinaryToReid3x3x3,

package/src/cubing/protocol/binary/hex.ts

@@ -1,10 +1,10 @@
 export function bufferToSpacedHex(buffer: ArrayBuffer): string {
   // buffer is an ArrayBuffer
-  return Array.prototype.map
-    .call(new Uint8Array(buffer), (x: number) =>
+  return (
+    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>
       ("00" + x.toString(16)).slice(-2),
-    )
-    .join(" ");
+    ) as string[]
+  ).join(" ");
 }
 
 export function spacedHexToBuffer(hex: string): Uint8Array {

package/src/cubing/protocol/binary/orbit-indexing.ts

@@ -1,5 +1,5 @@
 export function identityPermutation(numElems: number): number[] {
-  const arr = new Array(numElems);
+  const arr = new Array<number>(numElems);
   for (let i = 0; i < numElems; i++) {
     arr[i] = i;
   }
@@ -30,7 +30,7 @@ export function maskToOrientations(
     arr.push(mask % radix);
     mask = Math.floor(mask / radix);
   }
-  return new Array(numElems - arr.length).fill(0).concat(arr.reverse());
+  return new Array<number>(numElems - arr.length).fill(0).concat(arr.reverse());
 }
 
 // From https://www.jaapsch.net/puzzles/compindx.htm#perm

package/src/cubing/protocol/binary/puzzle-orientation.ts

@@ -6,7 +6,7 @@ import {
   Transformation,
 } from "../../kpuzzle";
 // TODO: Should we expose this directly in the `puzzles` package for sync uses?
-import { experimentalCube3x3x3KPuzzle as def } from "../../puzzles";
+import { experimentalCube3x3x3KPuzzle as def } from "../../kpuzzle";
 
 export function puzzleOrientationIdx(state: Transformation): [number, number] {
   const idxU = state["CENTERS"].permutation[0];
@@ -25,7 +25,7 @@ export function puzzleOrientationIdx(state: Transformation): [number, number] {
 const puzzleOrientationCache: Transformation[][] = new Array(6)
   .fill(0)
   .map(() => {
-    return new Array(6);
+    return new Array<Transformation>(6);
   });
 
 // We use a new block to avoid keeping a reference to temporary vars.