cubing 0.56.0 → 0.57.0

package/dist/lib/cubing/puzzle-geometry/index.js

@@ -1,7 +1,7 @@
 import {
   Move,
   QuantumMove
-} from "../chunks/chunk-2SBMIHZV.js";
+} from "../chunks/chunk-SWKNZGJF.js";
 
 // src/cubing/puzzle-geometry/colors.ts
 function defaultPlatonicColorSchemes() {
@@ -183,7 +183,7 @@ var FaceNameSwizzler = class {
         }
       }
       return true;
-    } catch (e) {
+    } catch {
       return false;
     }
   }
@@ -213,49 +213,6 @@ var FaceNameSwizzler = class {
   }
 };
 
-// src/cubing/puzzle-geometry/notation-mapping/NullMapper.ts
-var NullMapper = class {
-  notationToInternal(move) {
-    return move;
-  }
-  notationToExternal(move) {
-    return move;
-  }
-};
-
-// src/cubing/puzzle-geometry/notation-mapping/FTONotationMapper.ts
-var FTONotationMapper = class {
-  constructor(child, sw) {
-    this.child = child;
-    this.sw = sw;
-  }
-  notationToInternal(move) {
-    if (move.family === "T" && move.innerLayer === void 0 && move.outerLayer === void 0) {
-      return new Move(
-        new QuantumMove("FLRv", move.innerLayer, move.outerLayer),
-        move.amount
-      );
-    } else {
-      const r = this.child.notationToInternal(move);
-      return r;
-    }
-  }
-  // we never rewrite click moves to these moves.
-  notationToExternal(move) {
-    let fam = move.family;
-    if (fam.length > 0 && fam[fam.length - 1] === "v") {
-      fam = fam.substring(0, fam.length - 1);
-    }
-    if (this.sw.spinmatch(fam, "FLUR")) {
-      return new Move(
-        new QuantumMove("T", move.innerLayer, move.outerLayer),
-        move.amount
-      );
-    }
-    return this.child.notationToExternal(move);
-  }
-};
-
 // src/cubing/puzzle-geometry/notation-mapping/FaceRenamingMapper.ts
 var FaceRenamingMapper = class {
   constructor(internalNames, externalNames) {
@@ -302,6 +259,39 @@ var FaceRenamingMapper = class {
   }
 };
 
+// src/cubing/puzzle-geometry/notation-mapping/FTONotationMapper.ts
+var FTONotationMapper = class {
+  constructor(child, sw) {
+    this.child = child;
+    this.sw = sw;
+  }
+  notationToInternal(move) {
+    if (move.family === "T" && move.innerLayer === void 0 && move.outerLayer === void 0) {
+      return new Move(
+        new QuantumMove("FLRv", move.innerLayer, move.outerLayer),
+        move.amount
+      );
+    } else {
+      const r = this.child.notationToInternal(move);
+      return r;
+    }
+  }
+  // we never rewrite click moves to these moves.
+  notationToExternal(move) {
+    let fam = move.family;
+    if (fam.length > 0 && fam[fam.length - 1] === "v") {
+      fam = fam.substring(0, fam.length - 1);
+    }
+    if (this.sw.spinmatch(fam, "FLUR")) {
+      return new Move(
+        new QuantumMove("T", move.innerLayer, move.outerLayer),
+        move.amount
+      );
+    }
+    return this.child.notationToExternal(move);
+  }
+};
+
 // src/cubing/puzzle-geometry/notation-mapping/MegaminxScramblingNotationMapper.ts
 var MegaminxScramblingNotationMapper = class {
   constructor(child) {
@@ -361,6 +351,16 @@ var MegaminxScramblingNotationMapper = class {
   }
 };
 
+// src/cubing/puzzle-geometry/notation-mapping/NullMapper.ts
+var NullMapper = class {
+  notationToInternal(move) {
+    return move;
+  }
+  notationToExternal(move) {
+    return move;
+  }
+};
+
 // src/cubing/puzzle-geometry/notation-mapping/NxNxNCubeMapper.ts
 var NxNxNCubeMapper = class {
   constructor(slices) {
@@ -667,104 +667,6 @@ function remapKPuzzleDefinition(internalDefinition, notationMapper) {
   return externalDefinition;
 }
 
-// src/cubing/puzzle-geometry/Options.ts
-function parseOptions(argv) {
-  let argp = 0;
-  const options = {};
-  while (argp < argv.length && argv[argp][0] === "-") {
-    const option = argv[argp++];
-    if (option === "--rotations") {
-      options.addRotations = true;
-    } else if (option === "--allmoves") {
-      options.allMoves = true;
-    } else if (option === "--outerblockmoves") {
-      options.outerBlockMoves = true;
-    } else if (option === "--vertexmoves") {
-      options.vertexMoves = true;
-    } else if (option === "--nocorners") {
-      options.includeCornerOrbits = false;
-    } else if (option === "--noedges") {
-      options.includeEdgeOrbits = false;
-    } else if (option === "--noorientation") {
-      options.fixedOrientation = true;
-    } else if (option === "--nocenters") {
-      options.includeCenterOrbits = false;
-    } else if (option === "--omit") {
-      options.excludeOrbits = argv[argp].split(",");
-      argp++;
-    } else if (option === "--moves") {
-      options.moveList = argv[argp].split(",");
-      argp++;
-    } else if (option === "--optimize") {
-      options.optimizeOrbits = true;
-    } else if (option === "--scramble") {
-      options.scrambleAmount = 100;
-    } else if (option === "--fixcorner") {
-      options.fixedPieceType = "v";
-    } else if (option === "--fixedge") {
-      options.fixedPieceType = "e";
-    } else if (option === "--fixcenter") {
-      options.fixedPieceType = "f";
-    } else if (option === "--orientcenters") {
-      options.orientCenters = true;
-    } else if (option === "--puzzleorientation") {
-      options.puzzleOrientation = JSON.parse(argv[argp]);
-      argp++;
-    } else {
-      throw new Error(`Bad option: ${option}`);
-    }
-  }
-  const puzzleDescription = parsePuzzleDescription(argv.slice(argp).join(" "));
-  return { puzzleDescription, options };
-}
-var PuzzleGeometryFullOptions = class {
-  verbosity = 0;
-  // verbosity (console.log)
-  allMoves = false;
-  // generate all slice moves in ksolve
-  outerBlockMoves;
-  // generate outer block moves
-  vertexMoves = false;
-  // generate vertex moves
-  addRotations = false;
-  // add symmetry information to ksolve output
-  moveList = null;
-  // move list to generate
-  fixedOrientation = false;
-  // eliminate any orientations
-  fixedPieceType = null;
-  // fix a piece?
-  orientCenters = false;
-  // orient centers?
-  // TODO: Group these into a single object?
-  includeCornerOrbits = true;
-  // include corner orbits
-  includeCenterOrbits = true;
-  // include center orbits
-  includeEdgeOrbits = true;
-  // include edge orbits
-  // Overrides the previous options.
-  excludeOrbits = [];
-  // exclude these orbits
-  optimizeOrbits = false;
-  // optimize PermOri
-  grayCorners = false;
-  // make corner sets gray
-  grayCenters = false;
-  // make center sets gray
-  grayEdges = false;
-  // make edge sets gray
-  puzzleOrientation = null;
-  // single puzzle orientation from options
-  puzzleOrientations = null;
-  // puzzle orientation override object from options // TODO: is this needed?
-  scrambleAmount = 0;
-  // scramble?
-  constructor(options = {}) {
-    Object.assign(this, options);
-  }
-};
-
 // src/cubing/puzzle-geometry/Perm.ts
 var zeroCache = [];
 var iotaCache = [];
@@ -857,13 +759,13 @@ var Perm = class _Perm {
     return 0;
   }
   toGap() {
-    const cyc = new Array();
+    const cyc = [];
     const seen = new Array(this.n);
     for (let i = 0; i < this.p.length; i++) {
       if (seen[i] || this.p[i] === i) {
         continue;
       }
-      const incyc = new Array();
+      const incyc = [];
       for (let j = this.p[i]; !seen[j]; j = this.p[j]) {
         incyc.push(1 + j);
         seen[j] = true;
@@ -873,13 +775,13 @@ var Perm = class _Perm {
     return cyc.join("");
   }
   toMathematica() {
-    const cyc = new Array();
+    const cyc = [];
     const seen = new Array(this.n);
     for (let i = 0; i < this.p.length; i++) {
       if (seen[i] || this.p[i] === i) {
         continue;
       }
-      const incyc = new Array();
+      const incyc = [];
       for (let j = this.p[i]; !seen[j]; j = this.p[j]) {
         incyc.push(1 + j);
         seen[j] = true;
@@ -1442,7 +1344,7 @@ var PGTransformBase = class {
     return this;
   }
   toPerm() {
-    const perms = new Array();
+    const perms = [];
     let n = 0;
     for (const orbit of this.orbits) {
       const p = orbit.toPerm();
@@ -2630,98 +2532,9 @@ var PuzzleGeometry = class {
     if (this.options.verbosity > 0) {
       console.log(this.header("# "));
     }
-    this.create(puzzleDescription);
-    tend(t1);
-  }
-  rotations;
-  // all members of the rotation group
-  baseplanerot;
-  // unique rotations of the baseplane
-  baseplanes;
-  // planes, corresponding to faces
-  facenames;
-  // face names
-  faceplanes;
-  // face planes
-  edgenames;
-  // edge names
-  vertexnames;
-  // vertexnames
-  geonormals;
-  // all geometric directions, with names and types
-  moveplanes;
-  // the planes that split moves
-  moveplanes2;
-  // the planes that split moves, filtered
-  moveplanesets;
-  // the move planes, in parallel sets
-  moveplanenormals;
-  // one move plane
-  movesetorders;
-  // the order of rotations for each move set
-  movesetgeos;
-  // geometric feature information for move sets
-  basefaces;
-  // polytope faces before cuts
-  faces;
-  // all the stickers
-  facecentermass;
-  // center of mass of all faces
-  baseFaceCount;
-  // number of base faces
-  stickersperface;
-  // number of stickers per face
-  shortedge;
-  // number of stickers per face
-  markedface;
-  // given a bitmap of faces, identify the marked one
-  cubies;
-  // the cubies
-  vertexdistance;
-  // vertex distance
-  edgedistance;
-  // edge distance
-  facetocubie;
-  // map a face to a cubie index
-  facetoord;
-  // map a face to a cubie ord
-  moverotations;
-  // move rotations
-  facelisthash;
-  // face list by key
-  cubiesetnames;
-  // cubie set names
-  cubieords;
-  // the size of each orbit
-  cubiesetnums;
-  cubieordnums;
-  orbitoris;
-  // the orientation size of each orbit
-  cubievaluemap;
-  // the map for identical cubies
-  cubiesetcubies;
-  // cubies in each cubie set
-  cmovesbyslice = [];
-  // cmoves as perms by slice
-  parsedmovelist;
-  // parsed move list
-  duplicatedFaces = [];
-  // which faces are duplicated
-  duplicatedCubies = [];
-  // which cubies are duplicated
-  fixedCubie = -1;
-  // fixed cubie, if any
-  net = [];
-  colors = [];
-  swizzler;
-  notationMapper = new NullMapper();
-  addNotationMapper = "";
-  setReidOrSpeffzOrder = false;
-  options;
-  create(puzzleDescription) {
     const { shape, cuts } = puzzleDescription;
-    this.moveplanes = [];
-    this.moveplanes2 = [];
+    this.movePlanes = [];
+    this.movePlanesFiltered = [];
     this.faces = [];
     this.cubies = [];
     let g = null;
@@ -2754,9 +2567,11 @@ var PuzzleGeometry = class {
       console.log(`# Rotations: ${this.rotations.length}`);
     }
     const baseplane = g[0];
-    this.baseplanerot = uniqueplanes(baseplane, this.rotations);
-    const baseplanes = this.baseplanerot.map((_) => baseplane.rotateplane(_));
-    this.baseplanes = baseplanes;
+    this.basePlaneRotations = uniqueplanes(baseplane, this.rotations);
+    const baseplanes = this.basePlaneRotations.map(
+      (_) => baseplane.rotateplane(_)
+    );
+    this.basePlanes = baseplanes;
     this.baseFaceCount = baseplanes.length;
     const net = defaultnets()[baseplanes.length];
     this.net = net;
@@ -2779,8 +2594,8 @@ var PuzzleGeometry = class {
     const planerot = uniqueplanes(boundary, this.rotations);
     const planes = planerot.map((_) => boundary.rotateplane(_));
     const firstface = getface(planes);
-    this.edgedistance = firstface[0].sum(firstface[1]).smul(0.5).dist(zero);
-    this.vertexdistance = firstface[0].dist(zero);
+    this.edgeDistance = firstface[0].sum(firstface[1]).smul(0.5).dist(zero);
+    this.vertexDistance = firstface[0].dist(zero);
     const cutplanes = [];
     const intersects = [];
     let sawface = false;
@@ -2798,13 +2613,13 @@ var PuzzleGeometry = class {
         }
         case "v": {
           normal = vertexnormal;
-          distance = this.vertexdistance;
+          distance = this.vertexDistance;
           sawvertex = true;
           break;
         }
         case "e": {
           normal = edgenormal;
-          distance = this.edgedistance;
+          distance = this.edgeDistance;
           sawedge = true;
           break;
         }
@@ -2825,10 +2640,10 @@ var PuzzleGeometry = class {
         cutplanes.push(edgenormal.makecut(10));
       }
     }
-    this.basefaces = [];
-    for (const baseplanerot of this.baseplanerot) {
+    this.baseFaces = [];
+    for (const baseplanerot of this.basePlaneRotations) {
       const face = baseplanerot.rotateface(firstface);
-      this.basefaces.push(new Face(face));
+      this.baseFaces.push(new Face(face));
     }
     const facenames = [];
     const faceplanes = [];
@@ -2844,8 +2659,8 @@ var PuzzleGeometry = class {
       }
       a.push([p, name]);
     }
-    for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(firstface);
+    for (let i = 0; i < this.basePlaneRotations.length; i++) {
+      const face = this.basePlaneRotations[i].rotateface(firstface);
       for (let j = 0; j < face.length; j++) {
         const jj = (j + 1) % face.length;
         const midpoint = face[j].sum(face[jj]).smul(0.5);
@@ -2853,8 +2668,8 @@ var PuzzleGeometry = class {
       }
     }
     const otherfaces = [];
-    for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(firstface);
+    for (let i = 0; i < this.basePlaneRotations.length; i++) {
+      const face = this.basePlaneRotations[i].rotateface(firstface);
       const facelist = [];
       for (let j = 0; j < face.length; j++) {
         const jj = (j + 1) % face.length;
@@ -2906,15 +2721,15 @@ var PuzzleGeometry = class {
         facenametoindex[neti[j]] = of;
       }
     }
-    for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(firstface);
-      const faceplane = boundary.rotateplane(this.baseplanerot[i]);
+    for (let i = 0; i < this.basePlaneRotations.length; i++) {
+      const face = this.basePlaneRotations[i].rotateface(firstface);
+      const faceplane = boundary.rotateplane(this.basePlaneRotations[i]);
       const facename = faceindextoname[i];
       facenames.push([face, facename]);
       faceplanes.push([faceplane, facename]);
     }
-    for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(firstface);
+    for (let i = 0; i < this.basePlaneRotations.length; i++) {
+      const face = this.basePlaneRotations[i].rotateface(firstface);
       const facename = faceindextoname[i];
       for (let j = 0; j < face.length; j++) {
         const jj = (j + 1) % face.length;
@@ -3015,7 +2830,7 @@ var PuzzleGeometry = class {
       }
       vertexnames[i] = [vertexnames[i][0], r];
     }
-    this.markedface = markedface;
+    this.markedFaceLookup = markedface;
     if (this.options.verbosity > 1) {
       console.log(`# Face names: ${facenames.map((_) => _[1]).join(" ")}`);
       console.log(`# Edge names: ${edgenames.map((_) => _[1]).join(" ")}`);
@@ -3031,38 +2846,38 @@ var PuzzleGeometry = class {
     for (const vertexname of vertexnames) {
       geonormals.push([vertexname[0].makenormal(), vertexname[1], "v"]);
     }
-    this.facenames = facenames;
-    this.faceplanes = faceplanes;
-    this.edgenames = edgenames;
-    this.vertexnames = vertexnames;
-    this.geonormals = geonormals;
+    this.faceNames = facenames;
+    this.facePlanes = faceplanes;
+    this.edgeNames = edgenames;
+    this.vertexNames = vertexnames;
+    this.geometryNormals = geonormals;
     const geonormalnames = geonormals.map((_) => _[1]);
     this.swizzler.setGripNames(geonormalnames);
     if (this.options.verbosity > 0) {
       console.log(
-        `# Distances: face ${1} edge ${this.edgedistance} vertex ${this.vertexdistance}`
+        `# Distances: face ${1} edge ${this.edgeDistance} vertex ${this.vertexDistance}`
       );
     }
     for (let c = 0; c < cutplanes.length; c++) {
       for (const rotation of this.rotations) {
         const q = cutplanes[c].rotateplane(rotation);
         let wasseen = false;
-        for (const moveplane of this.moveplanes) {
+        for (const moveplane of this.movePlanes) {
           if (q.sameplane(moveplane)) {
             wasseen = true;
             break;
           }
         }
         if (!wasseen) {
-          this.moveplanes.push(q);
+          this.movePlanes.push(q);
           if (intersects[c]) {
-            this.moveplanes2.push(q);
+            this.movePlanesFiltered.push(q);
           }
         }
       }
     }
     let ft = new FaceTree(firstface);
-    const tar = this.moveplanes2.slice();
+    const tar = this.movePlanesFiltered.slice();
     let rval = 31;
     for (let i = 0; i < tar.length; i++) {
       const j = i + Math.floor((tar.length - i) * (rval / 65536));
@@ -3075,7 +2890,7 @@ var PuzzleGeometry = class {
     if (this.options.verbosity > 0) {
       console.log(`# Faces is now ${faces.length}`);
     }
-    this.stickersperface = faces.length;
+    this.stickersPerFace = faces.length;
     const simplerot = [];
     const cm = centermassface(firstface);
     for (const rotation of this.rotations) {
@@ -3112,18 +2927,18 @@ var PuzzleGeometry = class {
         }
       }
     }
-    this.shortedge = 1e99;
+    this.shortestEdge = 1e99;
     for (const face of faces) {
       for (let j = 0; j < face.length; j++) {
         const k = (j + 1) % face.length;
         const t = face.get(j).dist(face.get(k));
-        if (t < this.shortedge) {
-          this.shortedge = t;
+        if (t < this.shortestEdge) {
+          this.shortestEdge = t;
         }
       }
     }
     if (this.options.verbosity > 0) {
-      console.log(`# Short edge is ${this.shortedge}`);
+      console.log(`# Short edge is ${this.shortestEdge}`);
     }
     if (shape === "c" && sawface && !sawedge && !sawvertex) {
       this.addNotationMapper = "NxNxNCubeMapper";
@@ -3164,14 +2979,99 @@ var PuzzleGeometry = class {
         ])
       );
     }
+    tend(t1);
   }
+  rotations;
+  // all members of the rotation group
+  basePlaneRotations;
+  // unique rotations of the baseplane
+  basePlanes;
+  // planes, corresponding to faces
+  faceNames;
+  // face names
+  facePlanes;
+  // face planes
+  edgeNames;
+  // edge names
+  vertexNames;
+  // vertexnames
+  geometryNormals;
+  // all geometric directions, with names and types
+  movePlanes;
+  // the planes that split moves
+  movePlanesFiltered;
+  // the planes that split moves, filtered
+  movePlaneSets;
+  // the move planes, in parallel sets
+  movePlaneNormals;
+  // one move plane
+  movesetorders;
+  // the order of rotations for each move set
+  movesetgeos;
+  // geometric feature information for move sets
+  baseFaces;
+  // polytope faces before cuts
+  faces;
+  // all the stickers
+  faceCenterMass;
+  // center of mass of all faces
+  baseFaceCount;
+  // number of base faces
+  stickersPerFace;
+  // number of stickers per face
+  shortestEdge;
+  markedFaceLookup;
+  // given a bitmap of faces, identify the marked one
+  cubies;
+  // the cubies
+  vertexDistance;
+  // vertex distance
+  edgeDistance;
+  // edge distance
+  faceToCubie;
+  // map a face to a cubie index
+  faceToCubieOrd;
+  // map a face to a cubie ord
+  moveRotations;
+  // move rotations
+  faceListHash;
+  // face list by key
+  cubieSetNames;
+  // cubie set names
+  cubieOrbitSizes;
+  // the size of each orbit
+  cubieSetNums;
+  cubieOrdNums;
+  orbitOrientations;
+  // the orientation size of each orbit
+  cubieValueMap;
+  // the map for identical cubies
+  cubieSetCubies;
+  // cubies in each cubie set
+  cmovesBySlice = [];
+  // cmoves as perms by slice
+  parsedMoveList;
+  // parsed move list
+  duplicatedFaces = [];
+  // which faces are duplicated
+  duplicatedCubies = [];
+  // which cubies are duplicated
+  fixedCubie = -1;
+  // fixed cubie, if any
+  net = [];
+  colors = [];
+  swizzler;
+  notationMapper = new NullMapper();
+  addNotationMapper = "";
+  setReidOrSpeffzOrder = false;
+  options;
   keyface(face) {
     return this.keyface2(face.centermass());
   }
   keyface2(cm) {
     let s = "";
     const sfcc = String.fromCharCode;
-    for (const moveplaneset of this.moveplanesets) {
+    for (const moveplaneset of this.movePlaneSets) {
       if (moveplaneset.length > 0) {
         const dv = cm.dot(moveplaneset[0]);
         let t = 0;
@@ -3202,7 +3102,7 @@ var PuzzleGeometry = class {
   keyface3(face) {
     const cm = face.centermass();
     const r = [];
-    for (const moveplaneset of this.moveplanesets) {
+    for (const moveplaneset of this.movePlaneSets) {
       if (moveplaneset.length > 0) {
         const dv = cm.dot(moveplaneset[0]);
         let t = 0;
@@ -3222,22 +3122,22 @@ var PuzzleGeometry = class {
   }
   findface(cm) {
     const key = this.keyface2(cm);
-    const arr = this.facelisthash.get(key);
+    const arr = this.faceListHash.get(key);
     if (arr.length === 1) {
       return arr[0];
     }
     for (let i = 0; i + 1 < arr.length; i++) {
-      const face2 = this.facelisthash.get(key)[i];
-      if (Math.abs(cm.dist(this.facecentermass[face2])) < eps3) {
+      const face2 = this.faceListHash.get(key)[i];
+      if (Math.abs(cm.dist(this.faceCenterMass[face2])) < eps3) {
         return face2;
       }
     }
     return arr[arr.length - 1];
   }
   project2d(facen, edgen, targvec) {
-    const face = this.facenames[facen][0];
+    const face = this.faceNames[facen][0];
     const edgen2 = (edgen + 1) % face.length;
-    const plane = this.baseplanes[facen];
+    const plane = this.basePlanes[facen];
     let x0 = face[edgen2].sub(face[edgen]);
     const olen = x0.len();
     x0 = x0.normalize();
@@ -3269,17 +3169,17 @@ var PuzzleGeometry = class {
   }
   allstickers() {
     const t1 = tstart("allstickers");
-    this.faces = expandfaces(this.baseplanerot, this.faces);
+    this.faces = expandfaces(this.basePlaneRotations, this.faces);
     if (this.options.verbosity > 0) {
       console.log(`# Total stickers is now ${this.faces.length}`);
     }
-    this.facecentermass = new Array(this.faces.length);
+    this.faceCenterMass = new Array(this.faces.length);
     for (let i = 0; i < this.faces.length; i++) {
-      this.facecentermass[i] = this.faces[i].centermass();
+      this.faceCenterMass[i] = this.faces[i].centermass();
     }
     const moveplanesets = [];
     const moveplanenormals = [];
-    for (const q of this.moveplanes) {
+    for (const q of this.movePlanes) {
       const qnormal = q.makenormal();
       let wasseen = false;
       for (const moveplanenormal of moveplanenormals) {
@@ -3292,7 +3192,7 @@ var PuzzleGeometry = class {
         moveplanesets.push([]);
       }
     }
-    for (const q of this.moveplanes2) {
+    for (const q of this.movePlanesFiltered) {
       const qnormal = q.makenormal();
       for (let j = 0; j < moveplanenormals.length; j++) {
         if (qnormal.sameplane(moveplanenormals[j])) {
@@ -3312,8 +3212,8 @@ var PuzzleGeometry = class {
       q.sort((a, b) => a.a - b.a);
       moveplanesets[i] = q;
     }
-    this.moveplanesets = moveplanesets;
-    this.moveplanenormals = moveplanenormals;
+    this.movePlaneSets = moveplanesets;
+    this.movePlaneNormals = moveplanenormals;
     const sizes = moveplanesets.map((_) => _.length);
     if (this.options.verbosity > 0) {
       console.log(`# Move plane sets: ${sizes}`);
@@ -3334,7 +3234,7 @@ var PuzzleGeometry = class {
         }
       }
     }
-    this.moverotations = moverotations;
+    this.moveRotations = moverotations;
     for (let i = 0; i < moverotations.length; i++) {
       const r = moverotations[i];
       const goodnormal = r[0].makenormal();
@@ -3356,7 +3256,7 @@ var PuzzleGeometry = class {
       const p0 = moveplanenormals[i];
       let neg = null;
       let pos = null;
-      for (const geonormal of this.geonormals) {
+      for (const geonormal of this.geometryNormals) {
         const d = p0.dot(geonormal[0]);
         if (Math.abs(d - 1) < eps3) {
           pos = [geonormal[1], geonormal[2]];
@@ -3433,7 +3333,7 @@ var PuzzleGeometry = class {
         }
       }
     }
-    this.facelisthash = facelisthash;
+    this.faceListHash = facelisthash;
     if (this.options.verbosity > 0) {
       console.log(`# Cubies: ${facelisthash.size}`);
     }
@@ -3470,12 +3370,12 @@ var PuzzleGeometry = class {
         }
         let bits = 0;
         for (const f of facelist) {
-          bits |= 1 << Math.floor(f / this.stickersperface);
+          bits |= 1 << Math.floor(f / this.stickersPerFace);
         }
-        const markedface = this.markedface[bits];
+        const markedface = this.markedFaceLookup[bits];
         let mini = -1;
         for (let i = 0; i < facelist.length; i++) {
-          if (Math.floor(facelist[i] / this.stickersperface) === markedface) {
+          if (Math.floor(facelist[i] / this.stickersPerFace) === markedface) {
             mini = i;
           }
         }
@@ -3497,8 +3397,8 @@ var PuzzleGeometry = class {
       cubies.push(facelist);
     }
     this.cubies = cubies;
-    this.facetocubie = facetocubie;
-    this.facetoord = facetoord;
+    this.faceToCubie = facetocubie;
+    this.faceToCubieOrd = facetoord;
     const typenames = ["?", "CENTERS", "EDGES", "CORNERS", "C4RNER", "C5RNER"];
     const cubiesetnames = [];
     const cubietypecounts = [0, 0, 0, 0, 0, 0];
@@ -3548,9 +3448,9 @@ var PuzzleGeometry = class {
         cubiesetcubies[cubiesetnum].push(cind);
         cubieordnums[cind] = cubieords[cubiesetnum]++;
         if (queue.length < this.rotations.length) {
-          const cm = this.facecentermass[cubies[cind][0]];
+          const cm = this.faceCenterMass[cubies[cind][0]];
           for (const moverotation of moverotations) {
-            const tq = this.facetocubie[this.findface(cm.rotatepoint(moverotation[0]))];
+            const tq = this.faceToCubie[this.findface(cm.rotatepoint(moverotation[0]))];
             if (!seen[tq]) {
               queue.push(tq);
               seen[tq] = true;
@@ -3560,7 +3460,7 @@ var PuzzleGeometry = class {
       }
       cubiesetnum++;
     }
-    if (this.setReidOrSpeffzOrder && 4 <= this.stickersperface) {
+    if (this.setReidOrSpeffzOrder && 4 <= this.stickersPerFace) {
       const reidorder = [
         [
           "UF",
@@ -3633,8 +3533,8 @@ var PuzzleGeometry = class {
         -1,
         -1
       ];
-      if (this.stickersperface > 9) {
-        for (const vertex of this.vertexnames) {
+      if (this.stickersPerFace > 9) {
+        for (const vertex of this.vertexNames) {
           cornerloc[this.upperStringToBitSet(vertex[1])] = vertex[0];
         }
         for (let i = 0; i < 6; i++) {
@@ -3646,10 +3546,10 @@ var PuzzleGeometry = class {
       }
       for (const cubieset of cubiesetcubies) {
         for (const cubienum of cubieset) {
-          if (cubies[cubienum].length === 3 || this.stickersperface <= 9) {
+          if (cubies[cubienum].length === 3 || this.stickersPerFace <= 9) {
             let mask = 0;
             for (const cubie of cubies[cubienum]) {
-              mask |= 1 << this.facenames[this.getfaceindex(cubie)][1].charCodeAt(0) - 65;
+              mask |= 1 << this.faceNames[this.getfaceindex(cubie)][1].charCodeAt(0) - 65;
             }
             cubieordnums[cubienum] = reidmap[mask];
           } else {
@@ -3657,7 +3557,7 @@ var PuzzleGeometry = class {
               const ordset = [];
               for (let k = 0; k < cubies[cubienum].length; k++) {
                 const sticker = cubies[cubienum][k];
-                const facekey = spefffacelookup[this.facenames[this.getfaceindex(sticker)][1]];
+                const facekey = spefffacelookup[this.faceNames[this.getfaceindex(sticker)][1]];
                 let bestdist = 1e20;
                 const cubieloc = this.faces[sticker].centermass();
                 let bestmask = 0;
@@ -3706,13 +3606,13 @@ var PuzzleGeometry = class {
         }
       }
     }
-    this.cubiesetnums = cubiesetnums;
-    this.cubieordnums = cubieordnums;
-    this.cubiesetnames = cubiesetnames;
-    this.cubieords = cubieords;
-    this.orbitoris = orbitoris;
-    this.cubievaluemap = cubievaluemap;
-    this.cubiesetcubies = cubiesetcubies;
+    this.cubieSetNums = cubiesetnums;
+    this.cubieOrdNums = cubieordnums;
+    this.cubieSetNames = cubiesetnames;
+    this.cubieOrbitSizes = cubieords;
+    this.orbitOrientations = orbitoris;
+    this.cubieValueMap = cubievaluemap;
+    this.cubieSetCubies = cubiesetcubies;
     if (this.options.fixedPieceType !== null) {
       for (let i = 0; i < cubies.length; i++) {
         if (this.options.fixedPieceType === "v" && cubies[i].length > 2 || this.options.fixedPieceType === "e" && cubies[i].length === 2 || this.options.fixedPieceType === "f" && cubies[i].length === 1) {
@@ -3747,8 +3647,8 @@ var PuzzleGeometry = class {
       throw Error(`Bad move passed ${mv}`);
     }
     const grip = p[4];
-    let loslice = void 0;
-    let hislice = void 0;
+    let loslice;
+    let hislice;
     if (p[2] !== void 0) {
       if (p[3] === void 0) {
         throw Error("Missing second number in range");
@@ -3829,16 +3729,17 @@ var PuzzleGeometry = class {
     }
     loslice--;
     hislice--;
+    const movePlaneSets = this.movePlaneSets;
     if (fullrotation) {
       loslice = 0;
-      hislice = this.moveplanesets[msi].length;
+      hislice = movePlaneSets[msi].length;
     }
-    if (loslice < 0 || loslice > this.moveplanesets[msi].length || hislice < 0 || hislice > this.moveplanesets[msi].length) {
+    if (loslice < 0 || loslice > movePlaneSets[msi].length || hislice < 0 || hislice > movePlaneSets[msi].length) {
       throw Error(
-        `Bad slice spec ${loslice} ${hislice} vs ${this.moveplanesets[msi].length}`
+        `Bad slice spec ${loslice} ${hislice} vs ${movePlaneSets[msi].length}`
       );
     }
-    if (!permissivieMoveParsing && loslice === 0 && hislice === this.moveplanesets[msi].length && !fullrotation) {
+    if (!permissivieMoveParsing && loslice === 0 && hislice === movePlaneSets[msi].length && !fullrotation) {
       throw Error("! full puzzle rotations must be specified with v suffix.");
     }
     return [void 0, msi, loslice, hislice, firstgrip, move.amount];
@@ -3850,7 +3751,7 @@ var PuzzleGeometry = class {
   }
   genperms() {
     const t1 = tstart("genperms");
-    if (this.cmovesbyslice.length > 0) {
+    if (this.cmovesBySlice.length > 0) {
       return;
     }
     const cmovesbyslice = [];
@@ -3859,11 +3760,11 @@ var PuzzleGeometry = class {
         if (this.cubies[k].length === 1) {
           const kk = this.cubies[k][0];
           const i = this.getfaceindex(kk);
-          const center = this.basefaces[i].centermass();
-          if (center.dist(this.facecentermass[kk]) < eps3) {
+          const center = this.baseFaces[i].centermass();
+          if (center.dist(this.faceCenterMass[kk]) < eps3) {
             const bits = 1 << i | 1 << this.baseFaceCount;
-            const towards = this.markedface[bits];
-            const normal = this.baseplanes[towards].makenormal();
+            const towards = this.markedFaceLookup[bits];
+            const normal = this.basePlanes[towards].makenormal();
             let hiv = -1;
             let hii = -1;
             for (let ii = 0; ii < this.faces[kk].length; ii++) {
@@ -3885,19 +3786,19 @@ var PuzzleGeometry = class {
               }
               this.faces[kk] = new Face(qs);
             }
-            const o = this.basefaces[i].length;
+            const o = this.baseFaces[i].length;
             for (let m = 1; m < o; m++) {
               this.cubies[k].push(this.cubies[k][m - 1]);
             }
             this.duplicatedFaces[kk] = o;
             this.duplicatedCubies[k] = o;
-            this.orbitoris[this.cubiesetnums[k]] = o;
+            this.orbitOrientations[this.cubieSetNums[k]] = o;
           }
         }
       }
     }
-    for (let k = 0; k < this.moveplanesets.length; k++) {
-      const moveplaneset = this.moveplanesets[k];
+    for (let k = 0; k < this.movePlaneSets.length; k++) {
+      const moveplaneset = this.movePlaneSets[k];
       const slicenum = [];
       const slicecnts = [moveplaneset.length + 1, 0];
       let bhi = 1;
@@ -3907,7 +3808,7 @@ var PuzzleGeometry = class {
       for (let i = 0; i < this.faces.length; i++) {
         let t = 0;
         if (moveplaneset.length > 0) {
-          const dv = this.facecentermass[i].dot(moveplaneset[0]);
+          const dv = this.faceCenterMass[i].dot(moveplaneset[0]);
           for (let b = bhi; b > 0; b >>= 1) {
             if (t + b <= moveplaneset.length && dv > moveplaneset[t + b - 1].a) {
               t += b;
@@ -3930,25 +3831,28 @@ var PuzzleGeometry = class {
         if (slicenum[i] < 0) {
           continue;
         }
-        const b = [this.facetocubie[i], this.facetoord[i]];
-        let cm = this.facecentermass[i];
+        const b = [this.faceToCubie[i], this.faceToCubieOrd[i]];
+        let cm = this.faceCenterMass[i];
         const ocm = cm;
         let fi2 = i;
         const sc = slicenum[fi2];
         for (; ; ) {
           slicenum[fi2] = -1;
-          const cm2 = cm.rotatepoint(this.moverotations[k][0]);
+          const cm2 = cm.rotatepoint(this.moveRotations[k][0]);
           if (cm2.dist(ocm) < eps3) {
             break;
           }
           fi2 = this.findface(cm2);
-          b.push(this.facetocubie[fi2], this.facetoord[fi2]);
+          b.push(this.faceToCubie[fi2], this.faceToCubieOrd[fi2]);
           cm = cm2;
         }
         if (b.length > 2 && this.options.orientCenters && (this.cubies[b[0]].length === 1 || this.duplicatedCubies[b[0]] > 1)) {
-          if (this.facecentermass[i].dist(
-            this.basefaces[this.getfaceindex(i)].centermass()
-          ) < eps3) {
+          if (
+            // TODO: refactor to avoid non-null-assertion
+            this.faceCenterMass[i].dist(
+              this.baseFaces[this.getfaceindex(i)].centermass()
+            ) < eps3
+          ) {
             let face1 = this.faces[this.cubies[b[0]][0]];
             for (let ii = 0; ii < b.length; ii += 2) {
               const face0 = this.faces[this.cubies[b[ii]][0]];
@@ -3965,13 +3869,13 @@ var PuzzleGeometry = class {
                 );
               } else {
                 b[ii + 1] = o;
-                face1 = face1.rotate(this.moverotations[k][0]);
+                face1 = face1.rotate(this.moveRotations[k][0]);
               }
             }
           }
         }
         if (b.length === 2 && this.options.orientCenters) {
-          const dir = this.facecentermass[i].dot(this.moveplanenormals[k]);
+          const dir = this.faceCenterMass[i].dot(this.movePlaneNormals[k]);
           for (let ii = 1; ii < this.movesetorders[k]; ii++) {
             if (dir > 0) {
               b.push(b[0], ii);
@@ -3979,6 +3883,7 @@ var PuzzleGeometry = class {
               b.push(
                 b[0],
                 (this.movesetorders[k] - ii) % this.movesetorders[k]
+                // TODO: refactor to avoid non-null-assertion
               );
             }
           }
@@ -4000,33 +3905,33 @@ var PuzzleGeometry = class {
       }
       cmovesbyslice.push(axiscmoves);
     }
-    this.cmovesbyslice = cmovesbyslice;
+    this.cmovesBySlice = cmovesbyslice;
     if (this.options.moveList) {
       const parsedmovelist = [];
       for (const moveString of this.options.moveList) {
         parsedmovelist.push(this.parsemove(moveString));
       }
-      this.parsedmovelist = parsedmovelist;
+      this.parsedMoveList = parsedmovelist;
     }
-    this.facelisthash.clear();
-    this.facecentermass = [];
+    this.faceListHash.clear();
+    this.faceCenterMass = [];
     tend(t1);
   }
   getboundarygeometry() {
     return {
-      baseplanes: this.baseplanes,
-      facenames: this.facenames,
-      faceplanes: this.faceplanes,
-      vertexnames: this.vertexnames,
-      edgenames: this.edgenames,
-      geonormals: this.geonormals
+      baseplanes: this.basePlanes,
+      facenames: this.faceNames,
+      faceplanes: this.facePlanes,
+      vertexnames: this.vertexNames,
+      edgenames: this.edgeNames,
+      geonormals: this.geometryNormals
     };
   }
   getmovesets(k) {
-    const slices = this.moveplanesets[k].length;
+    const slices = this.movePlaneSets[k].length;
     let r = [];
-    if (this.parsedmovelist !== void 0) {
-      for (const parsedmove of this.parsedmovelist) {
+    if (this.parsedMoveList !== void 0) {
+      for (const parsedmove of this.parsedMoveList) {
         if (parsedmove[1] !== k) {
           continue;
         }
@@ -4199,7 +4104,7 @@ ${comment}
     const moveorbits = [];
     const perms = [];
     const oris = [];
-    for (const len of this.cubieords) {
+    for (const len of this.cubieOrbitSizes) {
       perms.push(iota(len));
       oris.push(zeros(len));
     }
@@ -4207,9 +4112,9 @@ ${comment}
       const slicecmoves = axiscmoves[m];
       for (let j = 0; j < slicecmoves.length; j += 2 * movesetorder) {
         const mperm = slicecmoves.slice(j, j + 2 * movesetorder);
-        const setnum = this.cubiesetnums[mperm[0]];
+        const setnum = this.cubieSetNums[mperm[0]];
         for (let ii = 0; ii < mperm.length; ii += 2) {
-          mperm[ii] = this.cubieordnums[mperm[ii]];
+          mperm[ii] = this.cubieOrdNums[mperm[ii]];
         }
         let inc = 2;
         let oinc = 3;
@@ -4217,26 +4122,29 @@ ${comment}
           inc = mperm.length - 2;
           oinc = mperm.length - 1;
         }
-        if (perms[setnum] === iota(this.cubieords[setnum])) {
+        if (perms[setnum] === iota(this.cubieOrbitSizes[setnum])) {
           perms[setnum] = perms[setnum].slice();
-          if (this.orbitoris[setnum] > 1 && !this.options.fixedOrientation) {
+          if (this.orbitOrientations[setnum] > 1 && // TODO: refactor to avoid non-null-assertion
+          !this.options.fixedOrientation) {
             oris[setnum] = oris[setnum].slice();
           }
         }
         for (let ii = 0; ii < mperm.length; ii += 2) {
           perms[setnum][mperm[(ii + inc) % mperm.length]] = mperm[ii];
-          if (this.orbitoris[setnum] > 1 && !this.options.fixedOrientation) {
-            oris[setnum][mperm[ii]] = (mperm[(ii + oinc) % mperm.length] - mperm[(ii + 1) % mperm.length] + 2 * this.orbitoris[setnum]) % this.orbitoris[setnum];
+          if (this.orbitOrientations[setnum] > 1 && // TODO: refactor to avoid non-null-assertion
+          !this.options.fixedOrientation) {
+            oris[setnum][mperm[ii]] = (mperm[(ii + oinc) % mperm.length] - mperm[(ii + 1) % mperm.length] + 2 * this.orbitOrientations[setnum]) % // TODO: refactor to avoid non-null-assertion
+            this.orbitOrientations[setnum];
           }
         }
       }
     }
     let lastId = new PGOrbit(iota(24), zeros(24), 1);
-    for (let ii = 0; ii < this.cubiesetnames.length; ii++) {
+    for (let ii = 0; ii < this.cubieSetNames.length; ii++) {
       if (setmoves && !setmoves[ii]) {
         continue;
       }
-      if (this.orbitoris[ii] === 1 || this.options.fixedOrientation) {
+      if (this.orbitOrientations[ii] === 1 || this.options.fixedOrientation) {
         if (perms[ii] === iota(lastId.perm.length)) {
           if (perms[ii] !== lastId.perm) {
             lastId = new PGOrbit(perms[ii], oris[ii], 1);
@@ -4250,7 +4158,9 @@ ${comment}
         for (let jj = 0; jj < perms[ii].length; jj++) {
           no[jj] = oris[ii][perms[ii][jj]];
         }
-        moveorbits.push(new PGOrbit(perms[ii], no, this.orbitoris[ii]));
+        moveorbits.push(
+          new PGOrbit(perms[ii], no, this.orbitOrientations[ii])
+        );
       }
     }
     let mv = new PGTransform(moveorbits);
@@ -4291,7 +4201,7 @@ ${comment}
   getOrbitsDef(fortwisty, includemoves = true) {
     const setmoves = [];
     if (fortwisty) {
-      for (let i = 0; i < this.cubiesetnames.length; i++) {
+      for (let i = 0; i < this.cubieSetNames.length; i++) {
         setmoves.push(1);
       }
     }
@@ -4299,7 +4209,7 @@ ${comment}
     const setdefs = [];
     const mps = [];
     const addrot = [];
-    for (let k = 0; k < this.moveplanesets.length; k++) {
+    for (let k = 0; k < this.movePlaneSets.length; k++) {
       const moveset = this.getmovesets(k);
       mps.push(moveset);
       if (this.options.addRotations) {
@@ -4309,8 +4219,8 @@ ${comment}
       }
     }
     const hasrotation = [];
-    for (let k = 0; k < this.moveplanesets.length; k++) {
-      const slices = this.moveplanesets[k].length;
+    for (let k = 0; k < this.movePlaneSets.length; k++) {
+      const slices = this.movePlaneSets[k].length;
       let sawone = false;
       const moveset = mps[k];
       for (let i = 0; i < moveset.length; i += 2) {
@@ -4321,28 +4231,28 @@ ${comment}
       hasrotation[k] = sawone;
     }
     if (this.options.addRotations && (this.options.moveList || this.options.fixedPieceType !== null)) {
-      for (let i = 0; i < this.moverotations.length; i++) {
+      for (let i = 0; i < this.moveRotations.length; i++) {
         addrot[i] = 0;
       }
-      for (let k = 0; k < this.moveplanesets.length; k++) {
+      for (let k = 0; k < this.movePlaneSets.length; k++) {
         if (hasrotation[k]) {
           addrot[k] = 3;
           continue;
         }
-        for (let i = 0; i < this.moverotations.length; i++) {
-          let nn = this.moveplanenormals[k];
+        for (let i = 0; i < this.moveRotations.length; i++) {
+          let nn = this.movePlaneNormals[k];
           for (let ii = 1; ii * 2 <= this.movesetorders[i]; ii++) {
-            nn = nn.rotatepoint(this.moverotations[i][0]);
+            nn = nn.rotatepoint(this.moveRotations[i][0]);
             if (addrot[i] & ii) {
               continue;
             }
             let found = -1;
             let neg = false;
-            for (let j = 0; j < this.moveplanenormals.length; j++) {
-              if (nn.dist(this.moveplanenormals[j]) < eps3) {
+            for (let j = 0; j < this.movePlaneNormals.length; j++) {
+              if (nn.dist(this.movePlaneNormals[j]) < eps3) {
                 found = j;
                 break;
-              } else if (nn.dist(this.moveplanenormals[j].smul(-1)) < eps3) {
+              } else if (nn.dist(this.movePlaneNormals[j].smul(-1)) < eps3) {
                 found = j;
                 neg = true;
                 break;
@@ -4352,10 +4262,13 @@ ${comment}
               throw Error("Could not find rotation");
             }
             const cmp = mps[found];
-            if (cmp.length !== mps[k].length || this.moveplanesets[k].length !== this.moveplanesets[found].length || this.diffmvsets(
+            if (cmp.length !== mps[k].length || this.movePlaneSets[k].length !== // TODO
+            this.movePlaneSets[found].length || // TODO
+            this.diffmvsets(
               cmp,
               mps[k],
-              this.moveplanesets[found].length,
+              this.movePlaneSets[found].length,
+              // TODO
               neg
             )) {
               addrot[i] |= ii;
@@ -4363,7 +4276,7 @@ ${comment}
           }
         }
       }
-      for (let i = 0; i < this.moverotations.length; i++) {
+      for (let i = 0; i < this.moveRotations.length; i++) {
         if (addrot[i] === 0) {
           addrot[i] = 1;
         } else if (addrot[i] === 1) {
@@ -4379,13 +4292,13 @@ ${comment}
         }
       }
     }
-    for (let k = 0; k < this.moveplanesets.length; k++) {
+    for (let k = 0; k < this.movePlaneSets.length; k++) {
       if (addrot[k] !== 0 && !hasrotation[k]) {
-        mps[k].push([0, this.moveplanesets[k].length]);
+        mps[k].push([0, this.movePlaneSets[k].length]);
         mps[k].push(addrot[k]);
       }
     }
-    for (let k = 0; k < this.moveplanesets.length; k++) {
+    for (let k = 0; k < this.movePlaneSets.length; k++) {
       const moveset = mps[k];
       const movesetorder = this.movesetorders[k];
       for (let i = 0; i < moveset.length; i += 2) {
@@ -4401,7 +4314,7 @@ ${comment}
           allbits[j] = 1;
         }
       }
-      const axiscmoves = this.cmovesbyslice[k];
+      const axiscmoves = this.cmovesBySlice[k];
       for (let i = 0; i < axiscmoves.length; i++) {
         if (allbits[i] !== 1) {
           continue;
@@ -4411,43 +4324,45 @@ ${comment}
           if (this.skipcubie(slicecmoves[j])) {
             continue;
           }
-          const ind = this.cubiesetnums[slicecmoves[j]];
+          const ind = this.cubieSetNums[slicecmoves[j]];
           setmoves[ind] = 1;
         }
       }
     }
-    for (let i = 0; i < this.cubiesetnames.length; i++) {
+    for (let i = 0; i < this.cubieSetNames.length; i++) {
       if (!setmoves[i]) {
         continue;
       }
-      if (this.omitSet(this.cubiesetnames[i])) {
+      if (this.omitSet(this.cubieSetNames[i])) {
         setmoves[i] = 0;
         continue;
       }
-      setnames.push(this.cubiesetnames[i]);
+      setnames.push(this.cubieSetNames[i]);
       setdefs.push(
         new PGOrbitDef(
-          this.cubieords[i],
-          this.options.fixedOrientation ? 1 : this.orbitoris[i]
+          this.cubieOrbitSizes[i],
+          // TODO: refactor to avoid non-null-assertion
+          this.options.fixedOrientation ? 1 : this.orbitOrientations[i]
+          // TODO: refactor to avoid non-null-assertion
         )
       );
     }
     const solved = [];
-    for (let i = 0; i < this.cubiesetnames.length; i++) {
+    for (let i = 0; i < this.cubieSetNames.length; i++) {
       if (!setmoves[i]) {
         continue;
       }
-      if (this.omitSet(this.cubiesetnames[i])) {
+      if (this.omitSet(this.cubieSetNames[i])) {
         continue;
       }
-      const p = [];
+      const p = Array(this.cubieOrbitSizes[i]).fill(-1);
       const o = [];
-      for (let j = 0; j < this.cubieords[i]; j++) {
+      for (let j = 0; j < this.cubieOrbitSizes[i]; j++) {
         if (fortwisty) {
-          p.push(j);
+          p[j] = j;
         } else {
-          const cubie = this.cubiesetcubies[i][j];
-          p.push(this.cubievaluemap[cubie]);
+          const cubie = this.cubieSetCubies[i][j];
+          p[this.cubieOrdNums[cubie]] = this.cubieValueMap[cubie];
         }
         o.push(0);
       }
@@ -4455,7 +4370,8 @@ ${comment}
         new PGOrbit(
           p,
           o,
-          this.options.fixedOrientation ? 1 : this.orbitoris[i]
+          this.options.fixedOrientation ? 1 : this.orbitOrientations[i]
+          // TODO: refactor to avoid non-null-assertion
         )
       );
     }
@@ -4464,8 +4380,8 @@ ${comment}
     const moves = [];
     const isrots = [];
     if (includemoves) {
-      for (let k = 0; k < this.moveplanesets.length; k++) {
-        const moveplaneset = this.moveplanesets[k];
+      for (let k = 0; k < this.movePlaneSets.length; k++) {
+        const moveplaneset = this.movePlaneSets[k];
         const slices = moveplaneset.length;
         const moveset = mps[k];
         const movesetgeo = this.movesetgeos[k];
@@ -4473,8 +4389,8 @@ ${comment}
           const movebits = moveset[i];
           let nameoverride;
           let inverted = false;
-          if (this.parsedmovelist !== void 0) {
-            for (const parsedmove of this.parsedmovelist) {
+          if (this.parsedMoveList !== void 0) {
+            for (const parsedmove of this.parsedMoveList) {
               if (parsedmove[1] !== k) {
                 continue;
               }
@@ -4509,9 +4425,10 @@ ${comment}
             movebits,
             moveset[i + 1],
             inverted,
-            this.cmovesbyslice[k],
+            this.cmovesBySlice[k],
             setmoves,
             this.movesetorders[k]
+            // TODO: refactor to avoid non-null-assertion
           );
           moves.push(mv);
         }
@@ -4547,7 +4464,7 @@ ${comment}
   getsolved() {
     const r = [];
     for (let i = 0; i < this.baseFaceCount; i++) {
-      for (let j = 0; j < this.stickersperface; j++) {
+      for (let j = 0; j < this.stickersPerFace; j++) {
         r.push(i);
       }
     }
@@ -4566,7 +4483,7 @@ ${comment}
     let feature2 = null;
     const feature1geoname = this.swizzler.unswizzle(feature1name);
     const feature2geoname = this.swizzler.unswizzle(feature2name);
-    for (const gn of this.geonormals) {
+    for (const gn of this.geometryNormals) {
       if (feature1geoname === gn[1]) {
         feature1 = gn[0];
       }
@@ -4670,7 +4587,7 @@ ${comment}
     ];
     edges2[net[0][0]] = initv;
     extendedges(edges2[net[0][0]], polyn);
-    geos[this.facenames[0][1]] = this.project2d(0, 0, [
+    geos[this.faceNames[0][1]] = this.project2d(0, 0, [
       new Quat(0, initv[0][0], initv[0][1], 0),
       new Quat(0, initv[1][0], initv[1][1], 0)
     ]);
@@ -4706,7 +4623,7 @@ ${comment}
         const mp = thisface[(caf0 + j) % polyn].sum(thisface[(caf0 + j + polyn - 1) % polyn]).smul(0.5);
         const epi = findelement(bg.edgenames, mp);
         const edgename = bg.edgenames[epi][1];
-        const el = splitByFaceNames(edgename, this.facenames);
+        const el = splitByFaceNames(edgename, this.faceNames);
         const gf1 = el[f0 === el[0] ? 1 : 0];
         let gf1i = -1;
         for (let k = 0; k < bg.facenames.length; k++) {
@@ -4751,13 +4668,13 @@ ${comment}
       if (threed) {
         q = q.rotatepoint(rot);
         const xoff2 = 0.5 * trim + 0.25 * w;
-        const xmul = this.baseplanes[fn].rotateplane(rot).d < 0 ? 1 : -1;
+        const xmul = this.basePlanes[fn].rotateplane(rot).d < 0 ? 1 : -1;
         return [
           trim + w * 0.5 + xmul * (xoff2 - q.b * sc2),
           trim + h * 0.5 + q.c * sc2
         ];
       } else {
-        const g = geos[this.facenames[fn][1]];
+        const g = geos[this.faceNames[fn][1]];
         return [
           trim + twodshrink * q.dot(g[0]) + g[2].b,
           trim + h - twodshrink * q.dot(g[1]) - g[2].c
@@ -4776,11 +4693,11 @@ ${comment}
     const colormap = [];
     const facegeo = [];
     for (let i = 0; i < this.baseFaceCount; i++) {
-      colormap[i] = this.colors[this.facenames[i][1]];
+      colormap[i] = this.colors[this.faceNames[i][1]];
     }
     for (let i = 0; i < this.faces.length; i++) {
       const face = this.faces[i];
-      const facenum = Math.floor(i / this.stickersperface);
+      const facenum = Math.floor(i / this.stickersPerFace);
       const fg = [];
       for (let j = 0; j < face.length; j++) {
         fg.push(mappt2d(facenum, face.get(j)));
@@ -4790,20 +4707,20 @@ ${comment}
     const svg = [];
     for (let j = 0; j < this.baseFaceCount; j++) {
       svg.push("<g>");
-      svg.push(`<title>${this.facenames[j][1]}</title>
+      svg.push(`<title>${this.faceNames[j][1]}</title>
 `);
-      for (let ii = 0; ii < this.stickersperface; ii++) {
-        const i = j * this.stickersperface + ii;
-        const cubie = this.facetocubie[i];
-        const cubieori = this.facetoord[i];
-        const cubiesetnum = this.cubiesetnums[cubie];
-        const cubieord = this.cubieordnums[cubie];
+      for (let ii = 0; ii < this.stickersPerFace; ii++) {
+        const i = j * this.stickersPerFace + ii;
+        const cubie = this.faceToCubie[i];
+        const cubieori = this.faceToCubieOrd[i];
+        const cubiesetnum = this.cubieSetNums[cubie];
+        const cubieord = this.cubieOrdNums[cubie];
         const color = this.graybyori(cubie) ? "#808080" : colormap[pos.p[i]];
-        let id = `${this.cubiesetnames[cubiesetnum]}-l${cubieord}-o${cubieori}`;
+        let id = `${this.cubieSetNames[cubiesetnum]}-l${cubieord}-o${cubieori}`;
         svg.push(drawedges(id, facegeo[i], color));
         if (this.duplicatedFaces[i]) {
           for (let jj = 1; jj < this.duplicatedFaces[i]; jj++) {
-            id = `${this.cubiesetnames[cubiesetnum]}-l${cubieord}-o${jj}`;
+            id = `${this.cubieSetNames[cubiesetnum]}-l${cubieord}-o${jj}`;
             svg.push(drawedges(id, facegeo[i], color));
           }
         }
@@ -4825,19 +4742,19 @@ ${svg.join(
     const stickers = [];
     const rot = this.getInitial3DRotation();
     const faces = [];
-    const maxdist = 0.52 * this.basefaces[0].get(0).len();
-    for (let i = 0; i < this.basefaces.length; i++) {
-      const coords = this.basefaces[i].rotate(rot);
-      const name = this.facenames[i][1];
+    const maxdist = 0.52 * this.baseFaces[0].get(0).len();
+    for (let i = 0; i < this.baseFaces.length; i++) {
+      const coords = this.baseFaces[i].rotate(rot);
+      const name = this.faceNames[i][1];
       faces.push({ coords: toFaceCoords(coords, maxdist), name });
     }
     for (let i = 0; i < this.faces.length; i++) {
-      const facenum = Math.floor(i / this.stickersperface);
-      const cubie = this.facetocubie[i];
-      const cubieori = this.facetoord[i];
-      const cubiesetnum = this.cubiesetnums[cubie];
-      const cubieord = this.cubieordnums[cubie];
-      let color = this.graybyori(cubie) ? options?.darkIgnoredOrbits ? "#222222" : "#808080" : this.colors[this.facenames[facenum][1]];
+      const facenum = Math.floor(i / this.stickersPerFace);
+      const cubie = this.faceToCubie[i];
+      const cubieori = this.faceToCubieOrd[i];
+      const cubiesetnum = this.cubieSetNums[cubie];
+      const cubieord = this.cubieOrdNums[cubie];
+      let color = this.graybyori(cubie) ? options?.darkIgnoredOrbits ? "#222222" : "#808080" : this.colors[this.faceNames[facenum][1]];
       if (options?.stickerColors) {
         color = options.stickerColors[i];
       }
@@ -4845,7 +4762,8 @@ ${svg.join(
       stickers.push({
         coords: toFaceCoords(coords, maxdist),
         color,
-        orbit: this.cubiesetnames[cubiesetnum],
+        orbit: this.cubieSetNames[cubiesetnum],
+        // TODO: refactor to avoid non-null-assertion
         ord: cubieord,
         ori: cubieori,
         face: facenum
@@ -4860,7 +4778,8 @@ ${svg.join(
           stickers.push({
             coords: toFaceCoords(fcoords, maxdist),
             color,
-            orbit: this.cubiesetnames[cubiesetnum],
+            orbit: this.cubieSetNames[cubiesetnum],
+            // TODO: refactor to avoid non-null-assertion
             ord: cubieord,
             ori: jj,
             face: facenum,
@@ -4873,7 +4792,7 @@ ${svg.join(
     for (let i = 0; i < this.movesetgeos.length; i++) {
       const msg = this.movesetgeos[i];
       const order = this.movesetorders[i];
-      for (const gn of this.geonormals) {
+      for (const gn of this.geometryNormals) {
         if (msg[0] === gn[1] && msg[1] === gn[2]) {
           grips.push({
             coordinates: toCoords(gn[0].rotatepoint(rot), 1),
@@ -4922,7 +4841,7 @@ ${svg.join(
   getGeoNormal(geoname) {
     const rot = this.getInitial3DRotation();
     const grip = this.swizzler.unswizzle(geoname);
-    for (const gn of this.geonormals) {
+    for (const gn of this.geometryNormals) {
       if (grip === gn[1]) {
         const r = toCoords(gn[0].rotatepoint(rot), 1);
         if (Math.abs(r[0]) < eps3 && Math.abs(r[2]) < eps3) {
@@ -4935,16 +4854,16 @@ ${svg.join(
     return void 0;
   }
   getfaceindex(facenum) {
-    const divid = this.stickersperface;
+    const divid = this.stickersPerFace;
     return Math.floor(facenum / divid);
   }
   textForTwizzleExplorer() {
-    return `Faces ${this.baseplanerot.length}
-Stickers per face ${this.stickersperface}
-Short edge ${this.shortedge}
+    return `Faces ${this.basePlaneRotations.length}
+Stickers per face ${this.stickersPerFace}
+Short edge ${this.shortestEdge}
 Cubies ${this.cubies.length}
-Edge distance ${this.edgedistance}
-Vertex distance ${this.vertexdistance}`;
+Edge distance ${this.edgeDistance}
+Vertex distance ${this.vertexDistance}`;
   }
   writeSchreierSims(tw) {
     const os = this.getOrbitsDef(false);
@@ -4963,9 +4882,9 @@ var PGNotation = class {
   orbitNames;
   lookupMove(move) {
     const mv = this.pg.parseMove(move);
-    if (this.pg.parsedmovelist) {
+    if (this.pg.parsedMoveList) {
       let found = false;
-      for (const parsedmove of this.pg.parsedmovelist) {
+      for (const parsedmove of this.pg.parsedMoveList) {
         if (parsedmove[1] === mv[1] && parsedmove[2] === mv[2] && parsedmove[3] === mv[3] && parsedmove[4] === mv[4]) {
           found = true;
         }
@@ -4976,16 +4895,17 @@ var PGNotation = class {
     }
     let bits = [mv[2], mv[3]];
     if (!mv[4]) {
-      const slices = this.pg.moveplanesets[mv[1]].length;
+      const slices = this.pg.movePlaneSets[mv[1]].length;
       bits = [slices - mv[3], slices - mv[2]];
     }
     const pgmv = this.pg.getMoveFromBits(
       bits,
       mv[5],
       !mv[4],
-      this.pg.cmovesbyslice[mv[1]],
+      this.pg.cmovesBySlice[mv[1]],
       void 0,
       this.pg.movesetorders[mv[1]]
+      // TODO: refactor to avoid non-null-assertion
     );
     const r = PGOrbitsDef.transformToKTransformationData(this.orbitNames, pgmv);
     return r;
@@ -4994,6 +4914,104 @@ var PGNotation = class {
     return remapKPuzzleDefinition(kpuzzleDefinition, this.pg.notationMapper);
   }
 };
+
+// src/cubing/puzzle-geometry/Options.ts
+function parseOptions(argv) {
+  let argp = 0;
+  const options = {};
+  while (argp < argv.length && argv[argp][0] === "-") {
+    const option = argv[argp++];
+    if (option === "--rotations") {
+      options.addRotations = true;
+    } else if (option === "--allmoves") {
+      options.allMoves = true;
+    } else if (option === "--outerblockmoves") {
+      options.outerBlockMoves = true;
+    } else if (option === "--vertexmoves") {
+      options.vertexMoves = true;
+    } else if (option === "--nocorners") {
+      options.includeCornerOrbits = false;
+    } else if (option === "--noedges") {
+      options.includeEdgeOrbits = false;
+    } else if (option === "--noorientation") {
+      options.fixedOrientation = true;
+    } else if (option === "--nocenters") {
+      options.includeCenterOrbits = false;
+    } else if (option === "--omit") {
+      options.excludeOrbits = argv[argp].split(",");
+      argp++;
+    } else if (option === "--moves") {
+      options.moveList = argv[argp].split(",");
+      argp++;
+    } else if (option === "--optimize") {
+      options.optimizeOrbits = true;
+    } else if (option === "--scramble") {
+      options.scrambleAmount = 100;
+    } else if (option === "--fixcorner") {
+      options.fixedPieceType = "v";
+    } else if (option === "--fixedge") {
+      options.fixedPieceType = "e";
+    } else if (option === "--fixcenter") {
+      options.fixedPieceType = "f";
+    } else if (option === "--orientcenters") {
+      options.orientCenters = true;
+    } else if (option === "--puzzleorientation") {
+      options.puzzleOrientation = JSON.parse(argv[argp]);
+      argp++;
+    } else {
+      throw new Error(`Bad option: ${option}`);
+    }
+  }
+  const puzzleDescription = parsePuzzleDescription(argv.slice(argp).join(" "));
+  return { puzzleDescription, options };
+}
+var PuzzleGeometryFullOptions = class {
+  verbosity = 0;
+  // verbosity (console.log)
+  allMoves = false;
+  // generate all slice moves in ksolve
+  outerBlockMoves = false;
+  // generate outer block moves
+  vertexMoves = false;
+  // generate vertex moves
+  addRotations = false;
+  // add symmetry information to ksolve output
+  moveList = null;
+  // move list to generate
+  fixedOrientation = false;
+  // eliminate any orientations
+  fixedPieceType = null;
+  // fix a piece?
+  orientCenters = false;
+  // orient centers?
+  // TODO: Group these into a single object?
+  includeCornerOrbits = true;
+  // include corner orbits
+  includeCenterOrbits = true;
+  // include center orbits
+  includeEdgeOrbits = true;
+  // include edge orbits
+  // Overrides the previous options.
+  excludeOrbits = [];
+  // exclude these orbits
+  optimizeOrbits = false;
+  // optimize PermOri
+  grayCorners = false;
+  // make corner sets gray
+  grayCenters = false;
+  // make center sets gray
+  grayEdges = false;
+  // make edge sets gray
+  puzzleOrientation = null;
+  // single puzzle orientation from options
+  puzzleOrientations = null;
+  // puzzle orientation override object from options // TODO: is this needed?
+  scrambleAmount = 0;
+  // scramble?
+  constructor(options = {}) {
+    Object.assign(this, options);
+  }
+};
 export {
   PUZZLE_BASE_SHAPES as EXPERIMENTAL_PUZZLE_BASE_SHAPES,
   PUZZLE_CUT_TYPES as EXPERIMENTAL_PUZZLE_CUT_TYPES,