cubing 0.20.1 → 0.21.0-pre11

package/dist/esm/puzzle-geometry/index.js

@@ -1,127 +1,107 @@
 import {
   Move,
   QuantumMove
-} from "../chunk-YNB7QLBF.js";
-import "../chunk-WJ7AVUI7.js";
+} from "../chunk-BU5PUJK3.js";
+import "../chunk-WO2AXYFE.js";
 
-// src/cubing/puzzle-geometry/Perm.ts
-var zeroCache = [];
-var iotaCache = [];
-function zeros(n) {
-  if (!zeroCache[n]) {
-    const c = Array(n);
-    for (let i = 0; i < n; i++) {
-      c[i] = 0;
-    }
-    zeroCache[n] = c;
-  }
-  return zeroCache[n];
-}
-function iota(n) {
-  if (!iotaCache[n]) {
-    const c = Array(n);
-    for (let i = 0; i < n; i++) {
-      c[i] = i;
+// src/cubing/puzzle-geometry/FaceNameSwizzler.ts
+var FaceNameSwizzler = class {
+  constructor(facenames, gripnames_arg) {
+    this.facenames = facenames;
+    this.prefixFree = true;
+    this.gripnames = [];
+    if (gripnames_arg) {
+      this.gripnames = gripnames_arg;
     }
-    iotaCache[n] = c;
-  }
-  return iotaCache[n];
-}
-function identity(n) {
-  return new Perm(iota(n));
-}
-function factorial(a) {
-  let r = 1;
-  while (a > 1) {
-    r *= a;
-    a--;
-  }
-  return r;
-}
-function gcd(a, b) {
-  if (a > b) {
-    const t = a;
-    a = b;
-    b = t;
-  }
-  while (a > 0) {
-    const m = b % a;
-    b = a;
-    a = m;
-  }
-  return b;
-}
-function lcm(a, b) {
-  return a / gcd(a, b) * b;
-}
-var Perm = class {
-  constructor(a) {
-    this.n = a.length;
-    this.p = a;
-  }
-  toString() {
-    return "Perm[" + this.p.join(" ") + "]";
-  }
-  mul(p2) {
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[i] = p2.p[this.p[i]];
+    for (let i = 0; this.prefixFree && i < facenames.length; i++) {
+      for (let j = 0; this.prefixFree && j < facenames.length; j++) {
+        if (i !== j && facenames[i].startsWith(facenames[j])) {
+          this.prefixFree = false;
+        }
+      }
     }
-    return new Perm(c);
   }
-  rmul(p2) {
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[i] = this.p[p2.p[i]];
-    }
-    return new Perm(c);
+  setGripNames(names) {
+    this.gripnames = names;
   }
-  inv() {
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[this.p[i]] = i;
+  splitByFaceNames(s) {
+    const r = [];
+    let at = 0;
+    while (at < s.length) {
+      if (at > 0 && at < s.length && s[at] === "_") {
+        at++;
+      }
+      let currentMatch = -1;
+      for (let i = 0; i < this.facenames.length; i++) {
+        if (s.substr(at).startsWith(this.facenames[i]) && (currentMatch < 0 || this.facenames[i].length > this.facenames[currentMatch].length)) {
+          currentMatch = i;
+        }
+      }
+      if (currentMatch >= 0) {
+        r.push(currentMatch);
+        at += this.facenames[currentMatch].length;
+      } else {
+        throw new Error("Could not split " + s + " into face names.");
+      }
     }
-    return new Perm(c);
+    return r;
   }
-  compareTo(p2) {
-    for (let i = 0; i < this.n; i++) {
-      if (this.p[i] !== p2.p[i]) {
-        return this.p[i] - p2.p[i];
+  joinByFaceIndices(list) {
+    let sep = "";
+    const r = [];
+    for (let i = 0; i < list.length; i++) {
+      r.push(sep);
+      r.push(this.facenames[list[i]]);
+      if (!this.prefixFree) {
+        sep = "_";
       }
     }
-    return 0;
+    return r.join("");
   }
-  toGap() {
-    const cyc = new Array();
-    const seen = new Array(this.n);
-    for (let i = 0; i < this.p.length; i++) {
-      if (seen[i] || this.p[i] === i) {
-        continue;
+  spinmatch(userinput, longname) {
+    if (userinput === longname) {
+      return true;
+    }
+    try {
+      const e1 = this.splitByFaceNames(userinput);
+      const e2 = this.splitByFaceNames(longname);
+      if (e1.length !== e2.length && e1.length < 3) {
+        return false;
       }
-      const incyc = new Array();
-      for (let j = i; !seen[j]; j = this.p[j]) {
-        incyc.push(1 + j);
-        seen[j] = true;
+      for (let i = 0; i < e1.length; i++) {
+        for (let j = 0; j < i; j++) {
+          if (e1[i] === e1[j]) {
+            return false;
+          }
+        }
+        let found = false;
+        for (let j = 0; j < e2.length; j++) {
+          if (e1[i] === e2[j]) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          return false;
+        }
       }
-      cyc.push("(" + incyc.join(",") + ")");
+      return true;
+    } catch (e) {
+      return false;
     }
-    return cyc.join("");
   }
-  order() {
-    let r = 1;
-    const seen = new Array(this.n);
-    for (let i = 0; i < this.p.length; i++) {
-      if (seen[i] || this.p[i] === i) {
-        continue;
-      }
-      let cs = 0;
-      for (let j = i; !seen[j]; j = this.p[j]) {
-        cs++;
-        seen[j] = true;
+  unswizzle(s) {
+    if ((s.endsWith("v") || s.endsWith("w")) && s[0] <= "Z") {
+      s = s.slice(0, s.length - 1);
+    }
+    const upperCaseGrip = s.toUpperCase();
+    for (let i = 0; i < this.gripnames.length; i++) {
+      const g = this.gripnames[i];
+      if (this.spinmatch(upperCaseGrip, g)) {
+        return g;
       }
-      r = lcm(r, cs);
     }
-    return r;
+    return s;
   }
 };
 
@@ -465,8 +445,204 @@ var SkewbNotationMapper = class {
   }
 };
 
+// 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 {
+  constructor(options = {}) {
+    this.verbosity = 0;
+    this.allMoves = false;
+    this.vertexMoves = false;
+    this.addRotations = false;
+    this.moveList = null;
+    this.fixedOrientation = false;
+    this.fixedPieceType = null;
+    this.orientCenters = false;
+    this.includeCornerOrbits = true;
+    this.includeCenterOrbits = true;
+    this.includeEdgeOrbits = true;
+    this.excludeOrbits = [];
+    this.optimizeOrbits = false;
+    this.grayCorners = false;
+    this.grayCenters = false;
+    this.grayEdges = false;
+    this.puzzleOrientation = null;
+    this.puzzleOrientations = null;
+    this.scrambleAmount = 0;
+    Object.assign(this, options);
+  }
+};
+
+// src/cubing/puzzle-geometry/Perm.ts
+var zeroCache = [];
+var iotaCache = [];
+function zeros(n) {
+  if (!zeroCache[n]) {
+    const c = Array(n);
+    for (let i = 0; i < n; i++) {
+      c[i] = 0;
+    }
+    zeroCache[n] = c;
+  }
+  return zeroCache[n];
+}
+function iota(n) {
+  if (!iotaCache[n]) {
+    const c = Array(n);
+    for (let i = 0; i < n; i++) {
+      c[i] = i;
+    }
+    iotaCache[n] = c;
+  }
+  return iotaCache[n];
+}
+function identity(n) {
+  return new Perm(iota(n));
+}
+function factorial(a) {
+  let r = 1;
+  while (a > 1) {
+    r *= a;
+    a--;
+  }
+  return r;
+}
+function gcd(a, b) {
+  if (a > b) {
+    const t = a;
+    a = b;
+    b = t;
+  }
+  while (a > 0) {
+    const m = b % a;
+    b = a;
+    a = m;
+  }
+  return b;
+}
+function lcm(a, b) {
+  return a / gcd(a, b) * b;
+}
+var Perm = class {
+  constructor(a) {
+    this.n = a.length;
+    this.p = a;
+  }
+  toString() {
+    return "Perm[" + this.p.join(" ") + "]";
+  }
+  mul(p2) {
+    const c = Array(this.n);
+    for (let i = 0; i < this.n; i++) {
+      c[i] = p2.p[this.p[i]];
+    }
+    return new Perm(c);
+  }
+  rmul(p2) {
+    const c = Array(this.n);
+    for (let i = 0; i < this.n; i++) {
+      c[i] = this.p[p2.p[i]];
+    }
+    return new Perm(c);
+  }
+  inv() {
+    const c = Array(this.n);
+    for (let i = 0; i < this.n; i++) {
+      c[this.p[i]] = i;
+    }
+    return new Perm(c);
+  }
+  compareTo(p2) {
+    for (let i = 0; i < this.n; i++) {
+      if (this.p[i] !== p2.p[i]) {
+        return this.p[i] - p2.p[i];
+      }
+    }
+    return 0;
+  }
+  toGap() {
+    const cyc = new Array();
+    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();
+      for (let j = i; !seen[j]; j = this.p[j]) {
+        incyc.push(1 + j);
+        seen[j] = true;
+      }
+      cyc.push("(" + incyc.join(",") + ")");
+    }
+    return cyc.join("");
+  }
+  order() {
+    let r = 1;
+    const seen = new Array(this.n);
+    for (let i = 0; i < this.p.length; i++) {
+      if (seen[i] || this.p[i] === i) {
+        continue;
+      }
+      let cs = 0;
+      for (let j = i; !seen[j]; j = this.p[j]) {
+        cs++;
+        seen[j] = true;
+      }
+      r = lcm(r, cs);
+    }
+    return r;
+  }
+};
+
 // src/cubing/puzzle-geometry/PermOriSet.ts
-var OrbitDef = class {
+var PGOrbitDef = class {
   constructor(size, mod) {
     this.size = size;
     this.mod = mod;
@@ -483,7 +659,7 @@ function externalName(mapper, moveString) {
   }
   return mv2.toString();
 }
-var OrbitsDef = class {
+var PGOrbitsDef = class {
   constructor(orbitnames, orbitdefs, solved, movenames, moveops) {
     this.orbitnames = orbitnames;
     this.orbitdefs = orbitdefs;
@@ -494,14 +670,14 @@ var OrbitsDef = class {
   transformToKPuzzle(t) {
     const mp = {};
     for (let j = 0; j < this.orbitnames.length; j++) {
-      mp[this.orbitnames[j]] = t.orbits[j].toKpuzzle();
+      mp[this.orbitnames[j]] = t.orbits[j].toKPuzzle();
     }
     return mp;
   }
   static transformToKPuzzle(orbitnames, t) {
     const mp = {};
     for (let j = 0; j < orbitnames.length; j++) {
-      mp[orbitnames[j]] = t.orbits[j].toKpuzzle();
+      mp[orbitnames[j]] = t.orbits[j].toKPuzzle();
     }
     return mp;
   }
@@ -510,12 +686,12 @@ var OrbitsDef = class {
     result.push("Name " + name);
     result.push("");
     for (let i = 0; i < this.orbitnames.length; i++) {
-      result.push("Set " + this.orbitnames[i] + " " + this.orbitdefs[i].size + " " + this.orbitdefs[i].mod);
+      result.push(`Set ${this.orbitnames[i]} ${this.orbitdefs[i].size} ${this.orbitdefs[i].mod}`);
     }
     result.push("");
     result.push("Solved");
     for (let i = 0; i < this.orbitnames.length; i++) {
-      this.solved.orbits[i].appendConciseDefinition(result, this.orbitnames[i], false);
+      this.solved.orbits[i].appendDefinition(result, this.orbitnames[i], false, false);
     }
     result.push("End");
     for (let i = 0; i < this.movenames.length; i++) {
@@ -529,16 +705,16 @@ var OrbitsDef = class {
       result.push("Move " + name2);
       for (let j = 0; j < this.orbitnames.length; j++) {
         if (doinv) {
-          this.moveops[i].orbits[j].inv().appendConciseDefinition(result, this.orbitnames[j], true);
+          this.moveops[i].orbits[j].inv().appendDefinition(result, this.orbitnames[j], true);
         } else {
-          this.moveops[i].orbits[j].appendConciseDefinition(result, this.orbitnames[j], true);
+          this.moveops[i].orbits[j].appendDefinition(result, this.orbitnames[j], true);
         }
       }
       result.push("End");
     }
     return result;
   }
-  toKpuzzle() {
+  toKPuzzle(includemoves) {
     const orbits = {};
     const start = {};
     for (let i = 0; i < this.orbitnames.length; i++) {
@@ -546,11 +722,13 @@ var OrbitsDef = class {
         numPieces: this.orbitdefs[i].size,
         orientations: this.orbitdefs[i].mod
       };
-      start[this.orbitnames[i]] = this.solved.orbits[i].toKpuzzle();
+      start[this.orbitnames[i]] = this.solved.orbits[i].toKPuzzle();
     }
     const moves = {};
-    for (let i = 0; i < this.movenames.length; i++) {
-      moves[this.movenames[i]] = this.transformToKPuzzle(this.moveops[i]);
+    if (includemoves) {
+      for (let i = 0; i < this.movenames.length; i++) {
+        moves[this.movenames[i]] = this.transformToKPuzzle(this.moveops[i]);
+      }
     }
     return { name: "PG3D", orbits, startPieces: start, moves };
   }
@@ -637,18 +815,18 @@ var OrbitsDef = class {
           }
         }
         if (multiple) {
-          neworbitnames.push(this.orbitnames[i] + "_p" + j);
+          neworbitnames.push(`${this.orbitnames[i]}_p${j}`);
         } else {
           neworbitnames.push(this.orbitnames[i]);
         }
         if (keepori) {
-          neworbitdefs.push(new OrbitDef(nv, this.orbitdefs[i].mod));
+          neworbitdefs.push(new PGOrbitDef(nv, this.orbitdefs[i].mod));
           newsolved.push(this.solved.orbits[i].remapVS(no, nv));
           for (let k = 0; k < this.moveops.length; k++) {
             newmoveops[k].push(this.moveops[k].orbits[i].remap(no, on, nv));
           }
         } else {
-          neworbitdefs.push(new OrbitDef(nv, 1));
+          neworbitdefs.push(new PGOrbitDef(nv, 1));
           newsolved.push(this.solved.orbits[i].remapVS(no, nv).killOri());
           for (let k = 0; k < this.moveops.length; k++) {
             newmoveops[k].push(this.moveops[k].orbits[i].remap(no, on, nv).killOri());
@@ -656,7 +834,7 @@ var OrbitsDef = class {
         }
       }
     }
-    return new OrbitsDef(neworbitnames, neworbitdefs, new VisibleState(newsolved), this.movenames, newmoveops.map((_) => new Transformation(_)));
+    return new PGOrbitsDef(neworbitnames, neworbitdefs, new VisibleState(newsolved), this.movenames, newmoveops.map((_) => new PGTransform(_)));
   }
   scramble(n) {
     const pool = [];
@@ -695,14 +873,14 @@ var OrbitsDef = class {
     return n;
   }
 };
-var _Orbit = class {
+var _PGOrbit = class {
   constructor(perm, ori, orimod) {
     this.perm = perm;
     this.ori = ori;
     this.orimod = orimod;
   }
   static e(n, mod) {
-    return new _Orbit(iota(n), zeros(n), mod);
+    return new _PGOrbit(iota(n), zeros(n), mod);
   }
   mul(b) {
     const n = this.perm.length;
@@ -711,14 +889,14 @@ var _Orbit = class {
       for (let i = 0; i < n; i++) {
         newPerm[i] = this.perm[b.perm[i]];
       }
-      return new _Orbit(newPerm, this.ori, this.orimod);
+      return new _PGOrbit(newPerm, this.ori, this.orimod);
     } else {
       const newOri = new Array(n);
       for (let i = 0; i < n; i++) {
         newPerm[i] = this.perm[b.perm[i]];
         newOri[i] = (this.ori[b.perm[i]] + b.ori[i]) % this.orimod;
       }
-      return new _Orbit(newPerm, newOri, this.orimod);
+      return new _PGOrbit(newPerm, newOri, this.orimod);
     }
   }
   inv() {
@@ -729,7 +907,7 @@ var _Orbit = class {
       newPerm[this.perm[i]] = i;
       newOri[this.perm[i]] = (this.orimod - this.ori[i]) % this.orimod;
     }
-    return new _Orbit(newPerm, newOri, this.orimod);
+    return new _PGOrbit(newPerm, newOri, this.orimod);
   }
   equal(b) {
     const n = this.perm.length;
@@ -815,7 +993,7 @@ var _Orbit = class {
       newPerm[i] = on[this.perm[no[i]]];
       newOri[i] = this.ori[no[i]];
     }
-    return new _Orbit(newPerm, newOri, this.orimod);
+    return new _PGOrbit(newPerm, newOri, this.orimod);
   }
   remapVS(no, nv) {
     const newPerm = new Array(nv);
@@ -830,10 +1008,10 @@ var _Orbit = class {
       newPerm[i] = reassign[ov];
       newOri[i] = this.ori[no[i]];
     }
-    return new _Orbit(newPerm, newOri, this.orimod);
+    return new _PGOrbit(newPerm, newOri, this.orimod);
   }
-  appendConciseDefinition(result, name, useVS) {
-    if (this.isIdentity()) {
+  appendDefinition(result, name, useVS, concise = true) {
+    if (concise && this.isIdentity()) {
       return;
     }
     result.push(name);
@@ -850,21 +1028,21 @@ var _Orbit = class {
       }
     }
   }
-  toKpuzzle() {
+  toKPuzzle() {
     const n = this.perm.length;
     if (this.isIdentity()) {
-      if (!_Orbit.kcache[n]) {
-        _Orbit.kcache[n] = { permutation: iota(n), orientation: zeros(n) };
+      if (!_PGOrbit.kcache[n]) {
+        _PGOrbit.kcache[n] = { permutation: iota(n), orientation: zeros(n) };
       }
-      return _Orbit.kcache[n];
+      return _PGOrbit.kcache[n];
     } else {
       return { permutation: this.perm, orientation: this.ori };
     }
   }
 };
-var Orbit = _Orbit;
-Orbit.kcache = [];
-var TransformationBase = class {
+var PGOrbit = _PGOrbit;
+PGOrbit.kcache = [];
+var PGTransformBase = class {
   constructor(orbits) {
     this.orbits = orbits;
   }
@@ -877,8 +1055,8 @@ var TransformationBase = class {
   }
   internalInv() {
     const newOrbits = [];
-    for (let i = 0; i < this.orbits.length; i++) {
-      newOrbits.push(this.orbits[i].inv());
+    for (const orbit of this.orbits) {
+      newOrbits.push(orbit.inv());
     }
     return newOrbits;
   }
@@ -891,23 +1069,22 @@ var TransformationBase = class {
     return true;
   }
   killOri() {
-    for (let i = 0; i < this.orbits.length; i++) {
-      this.orbits[i].killOri();
+    for (const orbit of this.orbits) {
+      orbit.killOri();
     }
     return this;
   }
   toPerm() {
     const perms = new Array();
     let n = 0;
-    for (let i = 0; i < this.orbits.length; i++) {
-      const p = this.orbits[i].toPerm();
+    for (const orbit of this.orbits) {
+      const p = orbit.toPerm();
       perms.push(p);
       n += p.n;
     }
     const newPerm = new Array(n);
     n = 0;
-    for (let i = 0; i < this.orbits.length; i++) {
-      const p = perms[i];
+    for (const p of perms) {
       for (let j = 0; j < p.n; j++) {
         newPerm[n + j] = n + p.p[j];
       }
@@ -918,30 +1095,30 @@ var TransformationBase = class {
   identicalPieces() {
     const r = [];
     let n = 0;
-    for (let i = 0; i < this.orbits.length; i++) {
-      const o = this.orbits[i].orimod;
-      const s = this.orbits[i].identicalPieces();
+    for (const orbit of this.orbits) {
+      const o = orbit.orimod;
+      const s = orbit.identicalPieces();
       for (let j = 0; j < s.length; j++) {
         r.push(s[j].map((_) => _ * o + n));
       }
-      n += o * this.orbits[i].perm.length;
+      n += o * orbit.perm.length;
     }
     return r;
   }
   order() {
     let r = 1;
-    for (let i = 0; i < this.orbits.length; i++) {
-      r = lcm(r, this.orbits[i].order());
+    for (const orbit of this.orbits) {
+      r = lcm(r, orbit.order());
     }
     return r;
   }
 };
-var Transformation = class extends TransformationBase {
+var PGTransform = class extends PGTransformBase {
   constructor(orbits) {
     super(orbits);
   }
   mul(b) {
-    return new Transformation(this.internalMul(b));
+    return new PGTransform(this.internalMul(b));
   }
   mulScalar(n) {
     if (n === 0) {
@@ -973,13 +1150,13 @@ var Transformation = class extends TransformationBase {
     return r;
   }
   inv() {
-    return new Transformation(this.internalInv());
+    return new PGTransform(this.internalInv());
   }
   e() {
-    return new Transformation(this.orbits.map((_) => Orbit.e(_.perm.length, _.orimod)));
+    return new PGTransform(this.orbits.map((_) => PGOrbit.e(_.perm.length, _.orimod)));
   }
 };
-var VisibleState = class extends TransformationBase {
+var VisibleState = class extends PGTransformBase {
   constructor(orbits) {
     super(orbits);
   }
@@ -1057,112 +1234,11 @@ function showcanon(g, disp) {
         }
       }
     }
-    disp("" + d + ": canonseq " + sum + " states " + uniq);
+    disp(`${d}: canonseq ${sum} states ${uniq}`);
     curlev = nextlev;
   }
 }
 
-// src/cubing/puzzle-geometry/FaceNameSwizzler.ts
-var FaceNameSwizzler = class {
-  constructor(facenames, gripnames_arg) {
-    this.facenames = facenames;
-    this.prefixFree = true;
-    this.gripnames = [];
-    if (gripnames_arg) {
-      this.gripnames = gripnames_arg;
-    }
-    for (let i = 0; this.prefixFree && i < facenames.length; i++) {
-      for (let j = 0; this.prefixFree && j < facenames.length; j++) {
-        if (i !== j && facenames[i].startsWith(facenames[j])) {
-          this.prefixFree = false;
-        }
-      }
-    }
-  }
-  setGripNames(names) {
-    this.gripnames = names;
-  }
-  splitByFaceNames(s) {
-    const r = [];
-    let at = 0;
-    while (at < s.length) {
-      if (at > 0 && at < s.length && s[at] === "_") {
-        at++;
-      }
-      let currentMatch = -1;
-      for (let i = 0; i < this.facenames.length; i++) {
-        if (s.substr(at).startsWith(this.facenames[i]) && (currentMatch < 0 || this.facenames[i].length > this.facenames[currentMatch].length)) {
-          currentMatch = i;
-        }
-      }
-      if (currentMatch >= 0) {
-        r.push(currentMatch);
-        at += this.facenames[currentMatch].length;
-      } else {
-        throw new Error("Could not split " + s + " into face names.");
-      }
-    }
-    return r;
-  }
-  joinByFaceIndices(list) {
-    let sep = "";
-    const r = [];
-    for (let i = 0; i < list.length; i++) {
-      r.push(sep);
-      r.push(this.facenames[list[i]]);
-      if (!this.prefixFree) {
-        sep = "_";
-      }
-    }
-    return r.join("");
-  }
-  spinmatch(userinput, longname) {
-    if (userinput === longname) {
-      return true;
-    }
-    try {
-      const e1 = this.splitByFaceNames(userinput);
-      const e2 = this.splitByFaceNames(longname);
-      if (e1.length !== e2.length && e1.length < 3) {
-        return false;
-      }
-      for (let i = 0; i < e1.length; i++) {
-        for (let j = 0; j < i; j++) {
-          if (e1[i] === e1[j]) {
-            return false;
-          }
-        }
-        let found = false;
-        for (let j = 0; j < e2.length; j++) {
-          if (e1[i] === e2[j]) {
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          return false;
-        }
-      }
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  unswizzle(s) {
-    if ((s.endsWith("v") || s.endsWith("w")) && s[0] <= "Z") {
-      s = s.slice(0, s.length - 1);
-    }
-    const upperCaseGrip = s.toUpperCase();
-    for (let i = 0; i < this.gripnames.length; i++) {
-      const g = this.gripnames[i];
-      if (this.spinmatch(upperCaseGrip, g)) {
-        return g;
-      }
-    }
-    return s;
-  }
-};
-
 // src/cubing/puzzle-geometry/PGPuzzles.ts
 var PGPuzzles = {
   "2x2x2": "c f 0",
@@ -1236,20 +1312,6 @@ var PGPuzzles = {
 
 // src/cubing/puzzle-geometry/Quat.ts
 var eps = 1e-9;
-function expandfaces(rots, faces) {
-  const nfaces = [];
-  for (let i = 0; i < rots.length; i++) {
-    for (let k = 0; k < faces.length; k++) {
-      const face = faces[k];
-      const nface = [];
-      for (let j = 0; j < face.length; j++) {
-        nface.push(face[j].rotateplane(rots[i]));
-      }
-      nfaces.push(nface);
-    }
-  }
-  return nfaces;
-}
 function centermassface(face) {
   let s = new Quat(0, 0, 0, 0);
   for (let i = 0; i < face.length; i++) {
@@ -1272,38 +1334,6 @@ function solvethreeplanes(p1, p2, p3, planes) {
   }
   return p;
 }
-var FaceTree = class {
-  constructor(face, left, right) {
-    this.face = face;
-    this.left = left;
-    this.right = right;
-  }
-  split(q) {
-    const t = q.cutface(this.face);
-    if (t !== null) {
-      if (this.left === void 0) {
-        this.left = new FaceTree(t[0]);
-        this.right = new FaceTree(t[1]);
-      } else {
-        this.left = this.left?.split(q);
-        this.right = this.right?.split(q);
-      }
-    }
-    return this;
-  }
-  collect(arr, leftfirst) {
-    if (this.left === void 0) {
-      arr.push(this.face);
-    } else if (leftfirst) {
-      this.left?.collect(arr, false);
-      this.right?.collect(arr, true);
-    } else {
-      this.right?.collect(arr, false);
-      this.left?.collect(arr, true);
-    }
-    return arr;
-  }
-};
 var Quat = class {
   constructor(a, b, c, d) {
     this.a = a;
@@ -1315,7 +1345,7 @@ var Quat = class {
     return new Quat(this.a * q.a - this.b * q.b - this.c * q.c - this.d * q.d, this.a * q.b + this.b * q.a + this.c * q.d - this.d * q.c, this.a * q.c - this.b * q.d + this.c * q.a + this.d * q.b, this.a * q.d + this.b * q.c - this.c * q.b + this.d * q.a);
   }
   toString() {
-    return "Q[" + this.a + "," + this.b + "," + this.c + "," + this.d + "]";
+    return `Q[${this.a},${this.b},${this.c},${this.d}]`;
   }
   dist(q) {
     return Math.hypot(this.a - q.a, this.b - q.b, this.c - q.c, this.d - q.d);
@@ -1400,9 +1430,6 @@ var Quat = class {
   rotateface(face) {
     return face.map((_) => _.rotatepoint(this));
   }
-  rotatecubie(cubie) {
-    return cubie.map((_) => this.rotateface(_));
-  }
   intersect3(p2, p3) {
     const det = this.det3x3(this.b, this.c, this.d, p2.b, p2.c, p2.d, p3.b, p3.c, p3.d);
     if (Math.abs(det) < eps) {
@@ -1533,74 +1560,293 @@ function closure(g) {
           break;
         }
       }
-      if (!wasseen) {
-        q.push(ns);
+      if (!wasseen) {
+        q.push(ns);
+      }
+    }
+  }
+  return q;
+}
+function uniqueplanes(p, g) {
+  const planes = [];
+  const planerot = [];
+  for (let i = 0; i < g.length; i++) {
+    const p2 = p.rotateplane(g[i]);
+    let wasseen = false;
+    for (let j = 0; j < planes.length; j++) {
+      if (p2.dist(planes[j]) < eps2) {
+        wasseen = true;
+        break;
+      }
+    }
+    if (!wasseen) {
+      planes.push(p2);
+      planerot.push(g[i]);
+    }
+  }
+  return planerot;
+}
+function getface(planes) {
+  const face = [];
+  for (let i = 1; i < planes.length; i++) {
+    for (let j = i + 1; j < planes.length; j++) {
+      const p = solvethreeplanes(0, i, j, planes);
+      if (p) {
+        let wasseen = false;
+        for (let k = 0; k < face.length; k++) {
+          if (p.dist(face[k]) < eps2) {
+            wasseen = true;
+            break;
+          }
+        }
+        if (!wasseen) {
+          face.push(p);
+        }
+      }
+    }
+  }
+  for (; ; ) {
+    let changed = false;
+    for (let i = 0; i < face.length; i++) {
+      const j = (i + 1) % face.length;
+      if (planes[0].dot(face[i].cross(face[j])) < 0) {
+        const t = face[i];
+        face[i] = face[j];
+        face[j] = t;
+        changed = true;
+      }
+    }
+    if (!changed) {
+      break;
+    }
+  }
+  return face;
+}
+
+// src/cubing/puzzle-geometry/SchreierSims.ts
+var FactoredNumber = class {
+  constructor() {
+    this.mult = [];
+  }
+  multiply(n) {
+    for (let f = 2; f * f <= n; f++) {
+      while (n % f === 0) {
+        if (this.mult[f] !== void 0) {
+          this.mult[f]++;
+        } else {
+          this.mult[f] = 1;
+        }
+        n /= f;
+      }
+    }
+    if (n > 1) {
+      if (this.mult[n] !== void 0) {
+        this.mult[n]++;
+      } else {
+        this.mult[n] = 1;
+      }
+    }
+  }
+  toString() {
+    let r = "";
+    for (let i = 0; i < this.mult.length; i++) {
+      if (this.mult[i] !== void 0) {
+        if (r !== "") {
+          r += "*";
+        }
+        r += i;
+        if (this.mult[i] > 1) {
+          r += `^${this.mult[i]}`;
+        }
+      }
+    }
+    return r;
+  }
+};
+function schreierSims(g, disp) {
+  const n = g[0].p.length;
+  const e = identity(n);
+  let sgs = [];
+  let sgsi = [];
+  let sgslen = [];
+  let Tk = [];
+  let Tklen = [];
+  function resolve(p) {
+    for (let i = p.p.length - 1; i >= 0; i--) {
+      const j = p.p[i];
+      if (j !== i) {
+        if (!sgs[i][j]) {
+          return false;
+        }
+        p = p.mul(sgsi[i][j]);
+      }
+    }
+    return true;
+  }
+  function knutha(k, p, len) {
+    Tk[k].push(p);
+    Tklen[k].push(len);
+    for (let i = 0; i < sgs[k].length; i++) {
+      if (sgs[k][i]) {
+        knuthb(k, sgs[k][i].mul(p), len + sgslen[k][i]);
       }
     }
   }
-  return q;
-}
-function uniqueplanes(p, g) {
-  const planes = [];
-  const planerot = [];
-  for (let i = 0; i < g.length; i++) {
-    const p2 = p.rotateplane(g[i]);
-    let wasseen = false;
-    for (let j = 0; j < planes.length; j++) {
-      if (p2.dist(planes[j]) < eps2) {
-        wasseen = true;
-        break;
+  function knuthb(k, p, len) {
+    const j = p.p[k];
+    if (!sgs[k][j]) {
+      sgs[k][j] = p;
+      sgsi[k][j] = p.inv();
+      sgslen[k][j] = len;
+      for (let i = 0; i < Tk[k].length; i++) {
+        knuthb(k, p.mul(Tk[k][i]), len + Tklen[k][i]);
       }
+      return;
     }
-    if (!wasseen) {
-      planes.push(p2);
-      planerot.push(g[i]);
+    const p2 = p.mul(sgsi[k][j]);
+    if (!resolve(p2)) {
+      knutha(k - 1, p2, len + sgslen[k][j]);
     }
   }
-  return planerot;
-}
-function getface(planes) {
-  const face = [];
-  for (let i = 1; i < planes.length; i++) {
-    for (let j = i + 1; j < planes.length; j++) {
-      const p = solvethreeplanes(0, i, j, planes);
-      if (p) {
-        let wasseen = false;
-        for (let k = 0; k < face.length; k++) {
-          if (p.dist(face[k]) < eps2) {
-            wasseen = true;
-            break;
+  function getsgs() {
+    sgs = [];
+    sgsi = [];
+    Tk = [];
+    sgslen = [];
+    Tklen = [];
+    for (let i = 0; i < n; i++) {
+      sgs.push([]);
+      sgsi.push([]);
+      sgslen.push([]);
+      Tk.push([]);
+      Tklen.push([]);
+      sgs[i][i] = e;
+      sgsi[i][i] = e;
+      sgslen[i][i] = 0;
+    }
+    let none = 0;
+    let sz = 1;
+    for (let i = 0; i < g.length; i++) {
+      knutha(n - 1, g[i], 1);
+      sz = 1;
+      let tks = 0;
+      let sollen = 0;
+      const avgs = [];
+      const mults = new FactoredNumber();
+      for (let j = 0; j < n; j++) {
+        let cnt = 0;
+        let lensum = 0;
+        for (let k = 0; k < n; k++) {
+          if (sgs[j][k]) {
+            cnt++;
+            lensum += sgslen[j][k];
+            if (j !== k) {
+              none++;
+            }
           }
         }
-        if (!wasseen) {
-          face.push(p);
+        tks += Tk[j].length;
+        sz *= cnt;
+        if (cnt > 1) {
+          mults.multiply(cnt);
         }
+        const avg = lensum / cnt;
+        avgs.push(avg);
+        sollen += avg;
       }
+      disp(`${i}: sz ${sz} T ${tks} sol ${sollen} none ${none} mults ${mults.toString()}`);
     }
+    return sz;
   }
-  for (; ; ) {
-    let changed = false;
-    for (let i = 0; i < face.length; i++) {
-      const j = (i + 1) % face.length;
-      if (planes[0].dot(face[i].cross(face[j])) < 0) {
-        const t = face[i];
-        face[i] = face[j];
-        face[j] = t;
-        changed = true;
+  return getsgs();
+}
+
+// src/cubing/puzzle-geometry/PuzzleGeometry.ts
+function tstart(s) {
+  return s;
+}
+function tend(_) {
+}
+var Face = class {
+  constructor(q) {
+    this.coords = new Array(q.length * 3);
+    for (let i = 0; i < q.length; i++) {
+      this.coords[3 * i] = q[i].b;
+      this.coords[3 * i + 1] = q[i].c;
+      this.coords[3 * i + 2] = q[i].d;
+    }
+    this.length = q.length;
+  }
+  get(off) {
+    return new Quat(0, this.coords[3 * off], this.coords[3 * off + 1], this.coords[3 * off + 2]);
+  }
+  centermass() {
+    let sx = 0;
+    let sy = 0;
+    let sz = 0;
+    for (let i = 0; i < this.length; i++) {
+      sx += this.coords[3 * i];
+      sy += this.coords[3 * i + 1];
+      sz += this.coords[3 * i + 2];
+    }
+    return new Quat(0, sx / this.length, sy / this.length, sz / this.length);
+  }
+  rotate(q) {
+    const a = [];
+    for (let i = 0; i < this.length; i++) {
+      a.push(this.get(i).rotatepoint(q));
+    }
+    return new Face(a);
+  }
+  rotateforward() {
+    const a = [];
+    for (let i = 1; i < this.length; i++) {
+      a.push(this.get(i));
+    }
+    a.push(this.get(0));
+    return new Face(a);
+  }
+};
+var FaceTree = class {
+  constructor(face, left, right) {
+    this.face = face;
+    this.left = left;
+    this.right = right;
+  }
+  split(q) {
+    const t = q.cutface(this.face);
+    if (t !== null) {
+      if (this.left === void 0) {
+        this.left = new FaceTree(t[0]);
+        this.right = new FaceTree(t[1]);
+      } else {
+        this.left = this.left?.split(q);
+        this.right = this.right?.split(q);
       }
     }
-    if (!changed) {
-      break;
+    return this;
+  }
+  collect(arr, leftfirst) {
+    if (this.left === void 0) {
+      arr.push(new Face(this.face));
+    } else if (leftfirst) {
+      this.left?.collect(arr, false);
+      this.right?.collect(arr, true);
+    } else {
+      this.right?.collect(arr, false);
+      this.left?.collect(arr, true);
     }
+    return arr;
   }
-  return face;
-}
-
-// src/cubing/puzzle-geometry/PuzzleGeometry.ts
-var DEFAULT_COLOR_FRACTION = 0.77;
-var NEW_FACE_NAMES = true;
-function useNewFaceNames(use) {
-  NEW_FACE_NAMES = use;
+};
+function expandfaces(rots, faces) {
+  const nfaces = [];
+  for (const rot of rots) {
+    for (const face of faces) {
+      nfaces.push(face.rotate(rot));
+    }
+  }
+  return nfaces;
 }
 var eps3 = 1e-9;
 var copyright = "PuzzleGeometry 0.1 Copyright 2018 Tomas Rokicki.";
@@ -1730,11 +1976,26 @@ function defaultfaceorders() {
 }
 function defaultOrientations() {
   return {
-    4: ["FLR", [0, 1, 0], "F", [0, 0, 1]],
-    6: ["U", [0, 1, 0], "F", [0, 0, 1]],
-    8: ["U", [0, 1, 0], "F", [0, 0, 1]],
-    12: ["U", [0, 1, 0], "F", [0, 0, 1]],
-    20: ["GUQMJ", [0, 1, 0], "F", [0, 0, 1]]
+    4: [
+      ["FLR", [0, 1, 0]],
+      ["F", [0, 0, 1]]
+    ],
+    6: [
+      ["U", [0, 1, 0]],
+      ["F", [0, 0, 1]]
+    ],
+    8: [
+      ["U", [0, 1, 0]],
+      ["F", [0, 0, 1]]
+    ],
+    12: [
+      ["U", [0, 1, 0]],
+      ["F", [0, 0, 1]]
+    ],
+    20: [
+      ["GUQMJ", [0, 1, 0]],
+      ["F", [0, 0, 1]]
+    ]
   };
 }
 function findelement(a, p) {
@@ -1751,31 +2012,35 @@ function getpuzzles() {
 function getpuzzle(puzzleName) {
   return PGPuzzles[puzzleName];
 }
-function parsedesc(s) {
+function parsePuzzleDescription(s) {
   const a = s.split(/ /).filter(Boolean);
   if (a.length % 2 === 0) {
-    return false;
+    return null;
   }
-  if (a[0] !== "o" && a[0] !== "c" && a[0] !== "i" && a[0] !== "d" && a[0] !== "t") {
-    return false;
+  const shape = a[0];
+  if (shape !== "o" && shape !== "c" && shape !== "i" && shape !== "d" && shape !== "t") {
+    return null;
   }
-  const r = [];
+  const cuts = [];
   for (let i = 1; i < a.length; i += 2) {
     if (a[i] !== "f" && a[i] !== "v" && a[i] !== "e") {
-      return false;
+      return null;
     }
-    r.push([a[i], a[i + 1]]);
+    cuts.push({ cutType: a[i], distance: parseFloat(a[i + 1]) });
   }
-  return [a[0], r];
+  return { shape, cuts };
 }
-function getPuzzleGeometryByDesc(desc, options = []) {
-  const [shape, cuts] = parsedesc(desc);
-  const pg = new PuzzleGeometry(shape, cuts, ["allmoves", "true"].concat(options));
+function getPuzzleGeometryByDesc(desc, options = {}) {
+  const parsed = parsePuzzleDescription(desc);
+  if (parsed === null) {
+    throw new Error("Could not parse the puzzle description");
+  }
+  const pg = new PuzzleGeometry(parsed, Object.assign({}, { allMoves: true }, options));
   pg.allstickers();
   pg.genperms();
   return pg;
 }
-function getPuzzleGeometryByName(puzzleName, options = []) {
+function getPuzzleGeometryByName(puzzleName, options) {
   return getPuzzleGeometryByDesc(PGPuzzles[puzzleName], options);
 }
 function getmovename(geo, bits, slices) {
@@ -1799,7 +2064,7 @@ function getmovename(geo, bits, slices) {
       movenamePrefix = String(bits[1] + 1);
     }
   } else {
-    throw "We only support slice and outer block moves right now. " + bits;
+    throw `We only support slice and outer block moves right now. ${bits}`;
   }
   return [movenamePrefix + movenameFamily, inverted];
 }
@@ -1811,9 +2076,9 @@ function splitByFaceNames(s, facenames) {
       at++;
     }
     let currentMatch = "";
-    for (let i = 0; i < facenames.length; i++) {
-      if (s.substr(at).startsWith(facenames[i][1]) && facenames[i][1].length > currentMatch.length) {
-        currentMatch = facenames[i][1];
+    for (const facename of facenames) {
+      if (s.substr(at).startsWith(facename[1]) && facename[1].length > currentMatch.length) {
+        currentMatch = facename[1];
       }
     }
     if (currentMatch !== "") {
@@ -1832,55 +2097,16 @@ function toFaceCoords(q, maxdist) {
   const r = [];
   const n = q.length;
   for (let i = 0; i < n; i++) {
-    r[n - i - 1] = toCoords(q[i], maxdist);
+    const pt = toCoords(q.get(n - i - 1), maxdist);
+    r[3 * i] = pt[0];
+    r[3 * i + 1] = pt[1];
+    r[3 * i + 2] = pt[2];
   }
   return r;
 }
-function trimEdges(face, tr) {
-  const r = [];
-  for (let iter = 1; iter < 10; iter++) {
-    for (let i = 0; i < face.length; i++) {
-      const pi = (i + face.length - 1) % face.length;
-      const ni = (i + 1) % face.length;
-      const A = face[pi].sub(face[i]).normalize();
-      const B = face[ni].sub(face[i]).normalize();
-      const d = A.dot(B);
-      const m = tr / Math.sqrt(1 - d * d);
-      r[i] = face[i].sum(A.sum(B).smul(m));
-    }
-    let good = true;
-    for (let i = 0; good && i < r.length; i++) {
-      const pi = (i + face.length - 1) % face.length;
-      const ni = (i + 1) % face.length;
-      if (r[pi].sub(r[i]).cross(r[ni].sub(r[i])).dot(r[i]) >= 0) {
-        good = false;
-      }
-    }
-    if (good) {
-      return r;
-    }
-    tr /= 2;
-  }
-  return face;
-}
 var PuzzleGeometry = class {
-  constructor(shape, cuts, optionlist) {
-    this.args = "";
+  constructor(puzzleDescription, options) {
     this.cmovesbyslice = [];
-    this.verbose = 0;
-    this.allmoves = false;
-    this.cornersets = true;
-    this.centersets = true;
-    this.edgesets = true;
-    this.omitsets = [];
-    this.graycorners = false;
-    this.graycenters = false;
-    this.grayedges = false;
-    this.killorientation = false;
-    this.optimize = false;
-    this.scramble = 0;
-    this.fixPiece = "";
-    this.orientCenters = false;
     this.duplicatedFaces = [];
     this.duplicatedCubies = [];
     this.fixedCubie = -1;
@@ -1891,84 +2117,16 @@ var PuzzleGeometry = class {
     this.notationMapper = new NullMapper();
     this.addNotationMapper = "";
     this.setReidOrder = false;
-    function asstructured(v) {
-      if (typeof v === "string") {
-        return JSON.parse(v);
-      }
-      return v;
-    }
-    function asboolean(v) {
-      if (typeof v === "string") {
-        if (v === "false") {
-          return false;
-        }
-        return true;
-      } else {
-        return v ? true : false;
-      }
-    }
-    if (optionlist !== void 0) {
-      if (optionlist.length % 2 !== 0) {
-        throw new Error("Odd length in option list?");
-      }
-      for (let i = 0; i < optionlist.length; i += 2) {
-        if (optionlist[i] === "verbose") {
-          this.verbose++;
-        } else if (optionlist[i] === "quiet") {
-          this.verbose = 0;
-        } else if (optionlist[i] === "allmoves") {
-          this.allmoves = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "outerblockmoves") {
-          this.outerblockmoves = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "vertexmoves") {
-          this.vertexmoves = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "rotations") {
-          this.addrotations = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "cornersets") {
-          this.cornersets = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "centersets") {
-          this.centersets = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "edgesets") {
-          this.edgesets = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "omit") {
-          this.omitsets = optionlist[i + 1];
-        } else if (optionlist[i] === "graycorners") {
-          this.graycorners = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "graycenters") {
-          this.graycenters = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "grayedges") {
-          this.grayedges = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "movelist") {
-          this.movelist = asstructured(optionlist[i + 1]);
-        } else if (optionlist[i] === "killorientation") {
-          this.killorientation = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "optimize") {
-          this.optimize = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "scramble") {
-          this.scramble = optionlist[i + 1];
-        } else if (optionlist[i] === "fix") {
-          this.fixPiece = optionlist[i + 1];
-        } else if (optionlist[i] === "orientcenters") {
-          this.orientCenters = asboolean(optionlist[i + 1]);
-        } else if (optionlist[i] === "puzzleorientation") {
-          this.puzzleOrientation = asstructured(optionlist[i + 1]);
-        } else if (optionlist[i] === "puzzleorientations") {
-          this.puzzleOrientations = asstructured(optionlist[i + 1]);
-        } else {
-          throw new Error("Bad option while processing option list " + optionlist[i]);
-        }
-      }
-    }
-    this.args = shape + " " + cuts.map((_) => _.join(" ")).join(" ");
-    if (optionlist) {
-      this.args += " " + optionlist.join(" ");
-    }
-    if (this.verbose > 0) {
+    const t1 = tstart("genperms");
+    this.options = new PuzzleGeometryFullOptions(options);
+    if (this.options.verbosity > 0) {
       console.log(this.header("# "));
     }
-    this.create(shape, cuts);
+    this.create(puzzleDescription);
+    tend(t1);
   }
-  create(shape, cuts) {
+  create(puzzleDescription) {
+    const { shape, cuts } = puzzleDescription;
     this.moveplanes = [];
     this.moveplanes2 = [];
     this.faces = [];
@@ -1994,47 +2152,47 @@ var PuzzleGeometry = class {
         throw new Error("Bad shape argument: " + shape);
     }
     this.rotations = closure(g);
-    if (this.verbose) {
+    if (this.options.verbosity) {
       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.basefacecount = baseplanes.length;
+    this.baseFaceCount = baseplanes.length;
     const net = defaultnets()[baseplanes.length];
     this.net = net;
     this.colors = defaultcolors()[baseplanes.length];
     this.faceorder = defaultfaceorders()[baseplanes.length];
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Base planes: " + baseplanes.length);
     }
     const baseface = getface(baseplanes);
     const zero = new Quat(0, 0, 0, 0);
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Face vertices: " + baseface.length);
     }
     const facenormal = baseplanes[0].makenormal();
     const edgenormal = baseface[0].sum(baseface[1]).makenormal();
     const vertexnormal = baseface[0].makenormal();
     const boundary = new Quat(1, facenormal.b, facenormal.c, facenormal.d);
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Boundary is " + boundary);
     }
     const planerot = uniqueplanes(boundary, this.rotations);
     const planes = planerot.map((_) => boundary.rotateplane(_));
-    let faces = [getface(planes)];
-    this.edgedistance = faces[0][0].sum(faces[0][1]).smul(0.5).dist(zero);
-    this.vertexdistance = faces[0][0].dist(zero);
+    const firstface = getface(planes);
+    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;
     let sawedge = false;
     let sawvertex = false;
-    for (let i = 0; i < cuts.length; i++) {
+    for (const cut of cuts) {
       let normal = null;
       let distance = 0;
-      switch (cuts[i][0]) {
+      switch (cut.cutType) {
         case "f":
           normal = facenormal;
           distance = 1;
@@ -2051,12 +2209,12 @@ var PuzzleGeometry = class {
           sawedge = true;
           break;
         default:
-          throw new Error("Bad cut argument: " + cuts[i][0]);
+          throw new Error("Bad cut argument: " + cut.cutType);
       }
-      cutplanes.push(normal.makecut(Number(cuts[i][1])));
-      intersects.push(cuts[i][1] < distance);
+      cutplanes.push(normal.makecut(cut.distance));
+      intersects.push(cut.distance < distance);
     }
-    if (this.addrotations) {
+    if (this.options.addRotations) {
       if (!sawface) {
         cutplanes.push(facenormal.makecut(10));
       }
@@ -2068,26 +2226,26 @@ var PuzzleGeometry = class {
       }
     }
     this.basefaces = [];
-    for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(faces[0]);
-      this.basefaces.push(face);
+    for (const baseplanerot of this.baseplanerot) {
+      const face = baseplanerot.rotateface(firstface);
+      this.basefaces.push(new Face(face));
     }
     const facenames = [];
     const faceplanes = [];
     const vertexnames = [];
     const edgenames = [];
-    const edgesperface = faces[0].length;
+    const edgesperface = firstface.length;
     function searchaddelement(a, p, name) {
-      for (let i = 0; i < a.length; i++) {
-        if (a[i][0].dist(p) < eps3) {
-          a[i].push(name);
+      for (const el of a) {
+        if (el[0].dist(p) < eps3) {
+          el.push(name);
           return;
         }
       }
       a.push([p, name]);
     }
     for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(faces[0]);
+      const face = this.baseplanerot[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);
@@ -2096,7 +2254,7 @@ var PuzzleGeometry = class {
     }
     const otherfaces = [];
     for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(faces[0]);
+      const face = this.baseplanerot[i].rotateface(firstface);
       const facelist = [];
       for (let j = 0; j < face.length; j++) {
         const jj = (j + 1) % face.length;
@@ -2118,8 +2276,8 @@ var PuzzleGeometry = class {
     facenametoindex[net[0][0]] = 0;
     faceindextoname[otherfaces[0][0]] = net[0][1];
     facenametoindex[net[0][1]] = otherfaces[0][0];
-    for (let i = 0; i < net.length; i++) {
-      const f0 = net[i][0];
+    for (const neti of net) {
+      const f0 = neti[0];
       const fi = facenametoindex[f0];
       if (fi === void 0) {
         throw new Error("Bad edge description; first edge not connected");
@@ -2127,7 +2285,7 @@ var PuzzleGeometry = class {
       let ii = -1;
       for (let j = 0; j < otherfaces[fi].length; j++) {
         const fn2 = faceindextoname[otherfaces[fi][j]];
-        if (fn2 !== void 0 && fn2 === net[i][1]) {
+        if (fn2 !== void 0 && fn2 === neti[1]) {
           ii = j;
           break;
         }
@@ -2135,17 +2293,17 @@ var PuzzleGeometry = class {
       if (ii < 0) {
         throw new Error("First element of a net not known");
       }
-      for (let j = 2; j < net[i].length; j++) {
-        if (net[i][j] === "") {
+      for (let j = 2; j < neti.length; j++) {
+        if (neti[j] === "") {
           continue;
         }
         const of = otherfaces[fi][(j + ii - 1) % edgesperface];
         const fn2 = faceindextoname[of];
-        if (fn2 !== void 0 && fn2 !== net[i][j]) {
+        if (fn2 !== void 0 && fn2 !== neti[j]) {
           throw new Error("Face mismatch in net");
         }
-        faceindextoname[of] = net[i][j];
-        facenametoindex[net[i][j]] = of;
+        faceindextoname[of] = neti[j];
+        facenametoindex[neti[j]] = of;
       }
     }
     for (let i = 0; i < faceindextoname.length; i++) {
@@ -2162,14 +2320,14 @@ var PuzzleGeometry = class {
       }
     }
     for (let i = 0; i < this.baseplanerot.length; i++) {
-      const face = this.baseplanerot[i].rotateface(faces[0]);
+      const face = this.baseplanerot[i].rotateface(firstface);
       const faceplane = boundary.rotateplane(this.baseplanerot[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(faces[0]);
+      const face = this.baseplanerot[i].rotateface(firstface);
       const facename = faceindextoname[i];
       for (let j = 0; j < face.length; j++) {
         const jj = (j + 1) % face.length;
@@ -2196,7 +2354,6 @@ var PuzzleGeometry = class {
       }
       edgenames[i] = [edgenames[i][0], c1];
     }
-    this.cornerfaces = vertexnames[0].length - 1;
     for (let i = 0; i < vertexnames.length; i++) {
       if (vertexnames[i].length < 4) {
         throw new Error("Bad length in vertex names");
@@ -2223,21 +2380,21 @@ var PuzzleGeometry = class {
       }
       vertexnames[i] = [vertexnames[i][0], r];
     }
-    if (this.verbose > 1) {
+    if (this.options.verbosity > 1) {
       console.log("# Face precedence list: " + this.faceorder.join(" "));
       console.log("# Face names: " + facenames.map((_) => _[1]).join(" "));
       console.log("# Edge names: " + edgenames.map((_) => _[1]).join(" "));
       console.log("# Vertex names: " + vertexnames.map((_) => _[1]).join(" "));
     }
     const geonormals = [];
-    for (let i = 0; i < faceplanes.length; i++) {
-      geonormals.push([faceplanes[i][0].makenormal(), faceplanes[i][1], "f"]);
+    for (const faceplane of faceplanes) {
+      geonormals.push([faceplane[0].makenormal(), faceplane[1], "f"]);
     }
-    for (let i = 0; i < edgenames.length; i++) {
-      geonormals.push([edgenames[i][0].makenormal(), edgenames[i][1], "e"]);
+    for (const edgename of edgenames) {
+      geonormals.push([edgename[0].makenormal(), edgename[1], "e"]);
     }
-    for (let i = 0; i < vertexnames.length; i++) {
-      geonormals.push([vertexnames[i][0].makenormal(), vertexnames[i][1], "v"]);
+    for (const vertexname of vertexnames) {
+      geonormals.push([vertexname[0].makenormal(), vertexname[1], "v"]);
     }
     this.facenames = facenames;
     this.faceplanes = faceplanes;
@@ -2246,15 +2403,15 @@ var PuzzleGeometry = class {
     this.geonormals = geonormals;
     const geonormalnames = geonormals.map((_) => _[1]);
     this.swizzler.setGripNames(geonormalnames);
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Distances: face " + 1 + " edge " + this.edgedistance + " vertex " + this.vertexdistance);
     }
     for (let c = 0; c < cutplanes.length; c++) {
-      for (let i = 0; i < this.rotations.length; i++) {
-        const q = cutplanes[c].rotateplane(this.rotations[i]);
+      for (const rotation of this.rotations) {
+        const q = cutplanes[c].rotateplane(rotation);
         let wasseen = false;
-        for (let j = 0; j < this.moveplanes.length; j++) {
-          if (q.sameplane(this.moveplanes[j])) {
+        for (const moveplane of this.moveplanes) {
+          if (q.sameplane(moveplane)) {
             wasseen = true;
             break;
           }
@@ -2267,7 +2424,7 @@ var PuzzleGeometry = class {
         }
       }
     }
-    let ft = new FaceTree(faces[0]);
+    let ft = new FaceTree(firstface);
     const tar = this.moveplanes2.slice();
     let rval = 31;
     for (let i = 0; i < tar.length; i++) {
@@ -2276,25 +2433,60 @@ var PuzzleGeometry = class {
       tar[j] = tar[i];
       rval = (rval * 1657 + 101) % 65536;
     }
-    faces = ft.collect([], true);
+    const faces = ft.collect([], true);
     this.faces = faces;
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Faces is now " + faces.length);
     }
     this.stickersperface = faces.length;
-    let shortedge = 1e99;
+    const simplerot = [];
+    const cm = centermassface(firstface);
+    for (const rotation of this.rotations) {
+      const f = rotation.rotateface(firstface);
+      if (cm.dist(centermassface(f)) < eps3) {
+        simplerot.push(rotation);
+      }
+    }
+    const finished = new Array(faces.length);
+    const sortme = [];
     for (let i = 0; i < faces.length; i++) {
-      for (let j = 0; j < faces[i].length; j++) {
-        const k = (j + 1) % faces[i].length;
-        const t = faces[i][j].dist(faces[i][k]);
-        if (t < shortedge) {
-          shortedge = t;
+      const cm2 = faces[i].centermass();
+      sortme.push([cm.dist(cm2), cm2, i]);
+    }
+    sortme.sort((a, b) => a[0] - b[0]);
+    for (let ii = 0; ii < faces.length; ii++) {
+      const i = sortme[ii][2];
+      if (!finished[i]) {
+        finished[i] = true;
+        for (const rot of simplerot) {
+          const f2 = faces[i].rotate(rot);
+          const cm2 = f2.centermass();
+          for (let kk = ii + 1; kk < faces.length; kk++) {
+            if (sortme[kk][0] - sortme[ii][0] > eps3) {
+              break;
+            }
+            const k = sortme[kk][2];
+            if (!finished[k] && cm2.dist(sortme[kk][1]) < eps3) {
+              finished[k] = true;
+              faces[k] = f2;
+              break;
+            }
+          }
         }
       }
     }
-    this.shortedge = shortedge;
-    if (this.verbose) {
-      console.log("# Short edge is " + shortedge);
+    this.shortedge = 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 (this.options.verbosity > 0) {
+      console.log("# Short edge is " + this.shortedge);
     }
     if (shape === "c" && sawface && !sawedge && !sawvertex) {
       this.addNotationMapper = "NxNxNCubeMapper";
@@ -2306,13 +2498,13 @@ var PuzzleGeometry = class {
     if (shape === "t" && (sawvertex || sawface) && !sawedge) {
       this.addNotationMapper = "PyraminxOrTetraminxMapper";
     }
-    if (shape === "o" && sawface && NEW_FACE_NAMES) {
+    if (shape === "o" && sawface) {
       this.notationMapper = new FaceRenamingMapper(this.swizzler, new FaceNameSwizzler(["F", "D", "L", "BL", "R", "U", "BR", "B"]));
       if (!sawedge && !sawvertex) {
         this.addNotationMapper = "FTOMapper";
       }
     }
-    if (shape === "d" && sawface && NEW_FACE_NAMES) {
+    if (shape === "d" && sawface) {
       this.addNotationMapper = "MegaminxMapper";
       this.notationMapper = new FaceRenamingMapper(this.swizzler, new FaceNameSwizzler([
         "U",
@@ -2331,55 +2523,66 @@ var PuzzleGeometry = class {
     }
   }
   keyface(face) {
-    return this.keyface2(centermassface(face));
+    return this.keyface2(face.centermass());
   }
   keyface2(cm) {
     let s = "";
-    for (let i = 0; i < this.moveplanesets.length; i++) {
-      if (this.moveplanesets[i].length > 0) {
-        const dv = cm.dot(this.moveplanesets[i][0]);
+    const sfcc = String.fromCharCode;
+    for (const moveplaneset of this.moveplanesets) {
+      if (moveplaneset.length > 0) {
+        const dv = cm.dot(moveplaneset[0]);
         let t = 0;
         let b = 1;
-        while (b * 2 <= this.moveplanesets[i].length) {
+        while (b * 2 <= moveplaneset.length) {
           b *= 2;
         }
         for (; b > 0; b >>= 1) {
-          if (t + b <= this.moveplanesets[i].length && dv > this.moveplanesets[i][t + b - 1].a) {
+          if (t + b <= moveplaneset.length && dv > moveplaneset[t + b - 1].a) {
             t += b;
           }
         }
-        if (t <= 90) {
-          s = s + String.fromCharCode(34 + t);
+        if (t < 47) {
+          s = s + sfcc(33 + t);
+        } else if (t < 47 + 47 * 47) {
+          s = s + sfcc(33 + 47 + Math.floor(t / 47) - 1) + sfcc(33 + t % 47);
+        } else if (t < 47 + 47 * 47 + 47 * 47 * 47) {
+          s = s + sfcc(33 + 47 + Math.floor((t - 47) / (47 * 47) - 1)) + sfcc(33 + 47 + Math.floor((t - 47) / 47) % 47) + sfcc(33 + t % 47);
         } else {
-          s = s + "!" + String.fromCharCode(34 + Math.floor(t / 90)) + String.fromCharCode(34 + t % 90);
+          throw Error("Too many slices for cubie encoding");
         }
       }
     }
     return s;
   }
-  findface(face) {
-    const cm = centermassface(face);
-    const key = this.keyface2(cm);
-    const arr = this.facelisthash[key];
-    if (arr.length === 1) {
-      return arr[0];
-    }
-    for (let i = 0; i + 1 < arr.length; i++) {
-      const face2 = this.facelisthash[key][i];
-      if (Math.abs(cm.dist(this.facecentermass[face2])) < eps3) {
-        return face2;
+  keyface3(face) {
+    const cm = face.centermass();
+    const r = [];
+    for (const moveplaneset of this.moveplanesets) {
+      if (moveplaneset.length > 0) {
+        const dv = cm.dot(moveplaneset[0]);
+        let t = 0;
+        let b = 1;
+        while (b * 2 <= moveplaneset.length) {
+          b *= 2;
+        }
+        for (; b > 0; b >>= 1) {
+          if (t + b <= moveplaneset.length && dv > moveplaneset[t + b - 1].a) {
+            t += b;
+          }
+        }
+        r.push(t);
       }
     }
-    return arr[arr.length - 1];
+    return r;
   }
-  findface2(cm) {
+  findface(cm) {
     const key = this.keyface2(cm);
-    const arr = this.facelisthash[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[key][i];
+      const face2 = this.facelisthash.get(key)[i];
       if (Math.abs(cm.dist(this.facecentermass[face2])) < eps3) {
         return face2;
       }
@@ -2405,22 +2608,22 @@ var PuzzleGeometry = class {
     return [x1, y1, off];
   }
   allstickers() {
+    const t1 = tstart("allstickers");
     this.faces = expandfaces(this.baseplanerot, this.faces);
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Total stickers is now " + this.faces.length);
     }
     this.facecentermass = new Array(this.faces.length);
     for (let i = 0; i < this.faces.length; i++) {
-      this.facecentermass[i] = centermassface(this.faces[i]);
+      this.facecentermass[i] = this.faces[i].centermass();
     }
     const moveplanesets = [];
     const moveplanenormals = [];
-    for (let i = 0; i < this.moveplanes.length; i++) {
-      const q = this.moveplanes[i];
+    for (const q of this.moveplanes) {
       const qnormal = q.makenormal();
       let wasseen = false;
-      for (let j = 0; j < moveplanenormals.length; j++) {
-        if (qnormal.sameplane(moveplanenormals[j].makenormal())) {
+      for (const moveplanenormal of moveplanenormals) {
+        if (qnormal.sameplane(moveplanenormal.makenormal())) {
           wasseen = true;
         }
       }
@@ -2429,8 +2632,7 @@ var PuzzleGeometry = class {
         moveplanesets.push([]);
       }
     }
-    for (let i = 0; i < this.moveplanes2.length; i++) {
-      const q = this.moveplanes2[i];
+    for (const q of this.moveplanes2) {
       const qnormal = q.makenormal();
       for (let j = 0; j < moveplanenormals.length; j++) {
         if (qnormal.sameplane(moveplanenormals[j])) {
@@ -2453,15 +2655,14 @@ var PuzzleGeometry = class {
     this.moveplanesets = moveplanesets;
     this.moveplanenormals = moveplanenormals;
     const sizes = moveplanesets.map((_) => _.length);
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Move plane sets: " + sizes);
     }
     const moverotations = [];
     for (let i = 0; i < moveplanesets.length; i++) {
       moverotations.push([]);
     }
-    for (let i = 0; i < this.rotations.length; i++) {
-      const q = this.rotations[i];
+    for (const q of this.rotations) {
       if (Math.abs(Math.abs(q.a) - 1) < eps3) {
         continue;
       }
@@ -2495,14 +2696,14 @@ var PuzzleGeometry = class {
       const p0 = moveplanenormals[i];
       let neg = null;
       let pos = null;
-      for (let j = 0; j < this.geonormals.length; j++) {
-        const d = p0.dot(this.geonormals[j][0]);
+      for (const geonormal of this.geonormals) {
+        const d = p0.dot(geonormal[0]);
         if (Math.abs(d - 1) < eps3) {
-          pos = [this.geonormals[j][1], this.geonormals[j][2]];
-          gtype = this.geonormals[j][2];
+          pos = [geonormal[1], geonormal[2]];
+          gtype = geonormal[2];
         } else if (Math.abs(d + 1) < eps3) {
-          neg = [this.geonormals[j][1], this.geonormals[j][2]];
-          gtype = this.geonormals[j][2];
+          neg = [geonormal[1], geonormal[2]];
+          gtype = geonormal[2];
         }
       }
       if (pos === null || neg === null) {
@@ -2546,112 +2747,88 @@ var PuzzleGeometry = class {
       }
     }
     this.movesetgeos = movesetgeos;
-    const cubiehash = {};
-    const facelisthash = {};
-    const cubiekey = {};
-    const cubiekeys = [];
-    const cubies = [];
+    const facelisthash = new Map();
     const faces = this.faces;
     for (let i = 0; i < faces.length; i++) {
       const face = faces[i];
       const s = this.keyface(face);
-      if (!cubiehash[s]) {
-        cubiekey[s] = cubies.length;
-        cubiekeys.push(s);
-        cubiehash[s] = [];
-        facelisthash[s] = [];
-        cubies.push(cubiehash[s]);
-      }
-      facelisthash[s].push(i);
-      cubiehash[s].push(face);
-      if (facelisthash[s].length === this.basefacecount) {
-        if (this.verbose) {
-          console.log("# Splitting core.");
-        }
-        for (let suff = 0; suff < this.basefacecount; suff++) {
-          const s2 = s + " " + suff;
-          facelisthash[s2] = [facelisthash[s][suff]];
-          cubiehash[s2] = [cubiehash[s][suff]];
-          cubiekeys.push(s2);
-          cubiekey[s2] = cubies.length;
-          cubies.push(cubiehash[s2]);
+      if (!facelisthash.get(s)) {
+        facelisthash.set(s, [i]);
+      } else {
+        const arr = facelisthash.get(s);
+        arr.push(i);
+        if (arr.length === this.baseFaceCount) {
+          if (this.options.verbosity > 0) {
+            console.log("# Splitting core.");
+          }
+          for (let suff = 0; suff < arr.length; suff++) {
+            const s2 = s + " " + suff;
+            facelisthash.set(s2, [arr[suff]]);
+          }
         }
-        cubiehash[s] = [];
-        cubies[cubiekey[s]] = [];
       }
     }
-    this.cubiekey = cubiekey;
     this.facelisthash = facelisthash;
-    this.cubiekeys = cubiekeys;
-    if (this.verbose) {
-      console.log("# Cubies: " + Object.keys(cubiehash).length);
+    if (this.options.verbosity > 0) {
+      console.log("# Cubies: " + facelisthash.size);
     }
-    this.cubies = cubies;
-    for (let k = 0; k < cubies.length; k++) {
-      const cubie = cubies[k];
-      if (cubie.length < 2) {
-        continue;
-      }
-      if (cubie.length === this.basefacecount) {
+    const cubies = [];
+    const facetocubie = [];
+    const facetoord = [];
+    for (const facelist of facelisthash.values()) {
+      if (facelist.length === this.baseFaceCount) {
         continue;
       }
-      if (cubie.length > 5) {
-        throw new Error("Bad math; too many faces on this cubie " + cubie.length);
-      }
-      const cm = cubie.map((_) => centermassface(_));
-      const s = this.keyface2(cm[0]);
-      const facelist = facelisthash[s];
-      const cmall = centermassface(cm);
-      for (let looplimit = 0; cubie.length > 2; looplimit++) {
-        let changed = false;
-        for (let i = 0; i < cubie.length; i++) {
-          const j = (i + 1) % cubie.length;
-          if (cmall.dot(cm[i].cross(cm[j])) < 0) {
-            const t = cubie[i];
-            cubie[i] = cubie[j];
-            cubie[j] = t;
-            const u = cm[i];
-            cm[i] = cm[j];
-            cm[j] = u;
-            const v = facelist[i];
-            facelist[i] = facelist[j];
-            facelist[j] = v;
-            changed = true;
+      if (facelist.length > 1) {
+        const cm = facelist.map((_) => faces[_].centermass());
+        const cmall = centermassface(cm);
+        for (let looplimit = 0; facelist.length > 2; looplimit++) {
+          let changed = false;
+          for (let i = 0; i < facelist.length; i++) {
+            const j = (i + 1) % facelist.length;
+            if (cmall.dot(cm[i].cross(cm[j])) < 0) {
+              const u = cm[i];
+              cm[i] = cm[j];
+              cm[j] = u;
+              const v = facelist[i];
+              facelist[i] = facelist[j];
+              facelist[j] = v;
+              changed = true;
+            }
+          }
+          if (!changed) {
+            break;
+          }
+          if (looplimit > 1e3) {
+            throw new Error("Bad epsilon math; too close to border");
           }
         }
-        if (!changed) {
-          break;
-        }
-        if (looplimit > 1e3) {
-          throw new Error("Bad epsilon math; too close to border");
-        }
-      }
-      let mini = 0;
-      let minf = this.findface(cubie[mini]);
-      for (let i = 1; i < cubie.length; i++) {
-        const temp = this.findface(cubie[i]);
-        if (this.faceprecedence[this.getfaceindex(temp)] < this.faceprecedence[this.getfaceindex(minf)]) {
-          mini = i;
-          minf = temp;
+        let mini = 0;
+        let minf = facelist[mini];
+        for (let i = 1; i < facelist.length; i++) {
+          const temp = facelist[i];
+          if (this.faceprecedence[this.getfaceindex(temp)] < this.faceprecedence[this.getfaceindex(minf)]) {
+            mini = i;
+            minf = temp;
+          }
         }
-      }
-      if (mini !== 0) {
-        const ocubie = cubie.slice();
-        const ofacelist = facelist.slice();
-        for (let i = 0; i < cubie.length; i++) {
-          cubie[i] = ocubie[(mini + i) % cubie.length];
-          facelist[i] = ofacelist[(mini + i) % cubie.length];
+        if (mini !== 0) {
+          const ofacelist = facelist.slice();
+          for (let i = 0; i < facelist.length; i++) {
+            facelist[i] = ofacelist[(mini + i) % facelist.length];
+          }
         }
       }
-    }
-    const facetocubies = [];
-    for (let i = 0; i < cubies.length; i++) {
-      const facelist = facelisthash[cubiekeys[i]];
       for (let j = 0; j < facelist.length; j++) {
-        facetocubies[facelist[j]] = [i, j];
+        const k = facelist[j];
+        facetocubie[k] = cubies.length;
+        facetoord[k] = j;
       }
+      cubies.push(facelist);
     }
-    this.facetocubies = facetocubies;
+    this.cubies = cubies;
+    this.facetocubie = facetocubie;
+    this.facetoord = facetoord;
     const typenames = ["?", "CENTERS", "EDGES", "CORNERS", "C4RNER", "C5RNER"];
     const cubiesetnames = [];
     const cubietypecounts = [0, 0, 0, 0, 0, 0];
@@ -2663,7 +2840,7 @@ var PuzzleGeometry = class {
     const cubieords = [];
     const cubievaluemap = [];
     const getcolorkey = (cubienum) => {
-      return cubies[cubienum].map((_) => this.getfaceindex(this.findface(_))).join(" ");
+      return cubies[cubienum].map((_) => this.getfaceindex(_)).join(" ");
     };
     const cubiesetcubies = [];
     for (let i = 0; i < cubies.length; i++) {
@@ -2681,7 +2858,7 @@ var PuzzleGeometry = class {
       const facecnt = cubie.length;
       const typectr = cubietypecounts[facecnt]++;
       let typename = typenames[facecnt];
-      if (typename === void 0 || facecnt === this.basefacecount) {
+      if (typename === void 0 || facecnt === this.baseFaceCount) {
         typename = "CORE";
       }
       typename = typename + (typectr === 0 ? "" : typectr + 1);
@@ -2701,9 +2878,9 @@ var PuzzleGeometry = class {
         cubiesetcubies[cubiesetnum].push(cind);
         cubieordnums[cind] = cubieords[cubiesetnum]++;
         if (queue.length < this.rotations.length) {
-          const cm = centermassface(cubies[cind][0]);
-          for (let j = 0; j < moverotations.length; j++) {
-            const tq = this.facetocubies[this.findface2(cm.rotatepoint(moverotations[j][0]))][0];
+          const cm = this.facecentermass[cubies[cind][0]];
+          for (const moverotation of moverotations) {
+            const tq = this.facetocubie[this.findface(cm.rotatepoint(moverotation[0]))];
             if (!seen[tq]) {
               queue.push(tq);
               seen[tq] = true;
@@ -2711,21 +2888,6 @@ var PuzzleGeometry = class {
           }
         }
       }
-      const that = this;
-      queue.sort(function(a, b) {
-        if (that.cubiekeys[a] < that.cubiekeys[b]) {
-          return 1;
-        } else if (that.cubiekeys[a] > that.cubiekeys[b]) {
-          return -1;
-        } else {
-          return 0;
-        }
-      });
-      for (let i2 = 0; i2 < queue.length; i2++) {
-        if (i2 > 1e6) {
-          cubieordnums[queue[i2]] = i2;
-        }
-      }
       cubiesetnum++;
     }
     if (this.setReidOrder && 4 <= this.stickersperface && this.stickersperface <= 9) {
@@ -2748,27 +2910,25 @@ var PuzzleGeometry = class {
         ["U", "L", "F", "R", "B", "D"]
       ];
       const reidmap = {};
-      for (let i = 0; i < reidorder.length; i++) {
-        for (let j = 0; j < reidorder[i].length; j++) {
+      for (const cubie of reidorder) {
+        for (let j = 0; j < cubie.length; j++) {
           let mask = 0;
-          for (let k = 0; k < reidorder[i][j].length; k++) {
-            mask |= 1 << reidorder[i][j].charCodeAt(k) - 65;
+          for (let k = 0; k < cubie[j].length; k++) {
+            mask |= 1 << cubie[j].charCodeAt(k) - 65;
           }
           reidmap[mask] = j;
         }
       }
-      for (let i = 0; i < cubiesetnum; i++) {
-        for (let j = 0; j < cubiesetcubies[i].length; j++) {
-          const cubienum = cubiesetcubies[i][j];
+      for (const cubieset of cubiesetcubies) {
+        for (const cubienum of cubieset) {
           let mask = 0;
-          for (let k = 0; k < cubies[cubienum].length; k++) {
-            mask |= 1 << this.facenames[this.getfaceindex(this.findface(cubies[cubienum][k]))][1].charCodeAt(0) - 65;
+          for (const cubie of cubies[cubienum]) {
+            mask |= 1 << this.facenames[this.getfaceindex(cubie)][1].charCodeAt(0) - 65;
           }
           cubieordnums[cubienum] = reidmap[mask];
         }
       }
     }
-    this.orbits = cubieords.length;
     this.cubiesetnums = cubiesetnums;
     this.cubieordnums = cubieordnums;
     this.cubiesetnames = cubiesetnames;
@@ -2776,20 +2936,21 @@ var PuzzleGeometry = class {
     this.orbitoris = orbitoris;
     this.cubievaluemap = cubievaluemap;
     this.cubiesetcubies = cubiesetcubies;
-    if (this.fixPiece !== "") {
+    if (this.options.fixedPieceType !== null) {
       for (let i = 0; i < cubies.length; i++) {
-        if (this.fixPiece === "v" && cubies[i].length > 2 || this.fixPiece === "e" && cubies[i].length === 2 || this.fixPiece === "f" && cubies[i].length === 1) {
+        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) {
           this.fixedCubie = i;
           break;
         }
       }
       if (this.fixedCubie < 0) {
-        throw new Error("Could not find a cubie of type " + this.fixPiece + " to fix.");
+        throw new Error("Could not find a cubie of type " + this.options.fixedPieceType + " to fix.");
       }
     }
-    if (this.verbose) {
+    if (this.options.verbosity > 0) {
       console.log("# Cubie orbit sizes " + cubieords);
     }
+    tend(t1);
   }
   unswizzle(mv) {
     const newmv = this.notationMapper.notationToInternal(mv);
@@ -2897,8 +3058,7 @@ var PuzzleGeometry = class {
     if (!permissivieMoveParsing && loslice === 0 && hislice === this.moveplanesets[msi].length && !fullrotation) {
       throw new Error("! full puzzle rotations must be specified with v suffix.");
     }
-    const r = [void 0, msi, loslice, hislice, firstgrip, move.amount];
-    return r;
+    return [void 0, msi, loslice, hislice, firstgrip, move.amount];
   }
   parsemove(mv) {
     const r = this.parseMove(this.stringToBlockMove(mv));
@@ -2906,19 +3066,20 @@ var PuzzleGeometry = class {
     return r;
   }
   genperms() {
+    const t1 = tstart("genperms");
     if (this.cmovesbyslice.length > 0) {
       return;
     }
     const cmovesbyslice = [];
-    if (this.orientCenters) {
+    if (this.options.orientCenters) {
       for (let k = 0; k < this.cubies.length; k++) {
         if (this.cubies[k].length === 1) {
-          const kk = this.findface(this.cubies[k][0]);
+          const kk = this.cubies[k][0];
           const i = this.getfaceindex(kk);
-          if (centermassface(this.basefaces[i]).dist(this.facecentermass[kk]) < eps3) {
+          if (this.basefaces[i].centermass().dist(this.facecentermass[kk]) < eps3) {
             const o = this.basefaces[i].length;
-            for (let m = 0; m < o; m++) {
-              this.cubies[k].push(this.cubies[k][0]);
+            for (let m = 1; m < o; m++) {
+              this.cubies[k].push(this.cubies[k][m - 1]);
             }
             this.duplicatedFaces[kk] = o;
             this.duplicatedCubies[k] = o;
@@ -2961,7 +3122,7 @@ var PuzzleGeometry = class {
         if (slicenum[i] < 0) {
           continue;
         }
-        const b = this.facetocubies[i].slice();
+        const b = [this.facetocubie[i], this.facetoord[i]];
         let cm = this.facecentermass[i];
         const ocm = cm;
         let fi2 = i;
@@ -2972,19 +3133,18 @@ var PuzzleGeometry = class {
           if (cm2.dist(ocm) < eps3) {
             break;
           }
-          fi2 = this.findface2(cm2);
-          const c = this.facetocubies[fi2];
-          b.push(c[0], c[1]);
+          fi2 = this.findface(cm2);
+          b.push(this.facetocubie[fi2], this.facetoord[fi2]);
           cm = cm2;
         }
-        if (b.length > 2 && this.orientCenters && (this.cubies[b[0]].length === 1 || this.cubies[b[0]][0] === this.cubies[b[0]][1])) {
-          if (this.facecentermass[i].dist(centermassface(this.basefaces[this.getfaceindex(i)])) < eps3) {
-            let face1 = this.cubies[b[0]][0];
+        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) {
+            let face1 = this.faces[this.cubies[b[0]][0]];
             for (let ii = 0; ii < b.length; ii += 2) {
-              const face0 = this.cubies[b[ii]][0];
+              const face0 = this.faces[this.cubies[b[ii]][0]];
               let o = -1;
               for (let jj = 0; jj < face1.length; jj++) {
-                if (face0[jj].dist(face1[0]) < eps3) {
+                if (face0.get(jj).dist(face1.get(0)) < eps3) {
                   o = jj;
                   break;
                 }
@@ -2993,12 +3153,12 @@ var PuzzleGeometry = class {
                 throw new Error("Couldn't find rotation of center faces; ignoring for now.");
               } else {
                 b[ii + 1] = o;
-                face1 = this.moverotations[k][0].rotateface(face1);
+                face1 = face1.rotate(this.moverotations[k][0]);
               }
             }
           }
         }
-        if (b.length === 2 && this.orientCenters) {
+        if (b.length === 2 && this.options.orientCenters) {
           for (let ii = 1; ii < this.movesetorders[k]; ii++) {
             if (sc === 0) {
               b.push(b[0], ii);
@@ -3011,32 +3171,30 @@ var PuzzleGeometry = class {
           if (b.length !== 2 * this.movesetorders[k]) {
             throw new Error("Bad length in perm gen");
           }
-          for (let j = 0; j < b.length; j++) {
-            axiscmoves[sc].push(b[j]);
+          for (const v of b) {
+            axiscmoves[sc].push(v);
           }
         }
         for (let j = 0; j < b.length; j += 2) {
           cubiedone[b[j]] = true;
         }
       }
+      for (let kk = 0; kk < axiscmoves.length; kk++) {
+        axiscmoves[kk] = axiscmoves[kk].slice();
+      }
       cmovesbyslice.push(axiscmoves);
     }
     this.cmovesbyslice = cmovesbyslice;
-    if (this.movelist !== void 0) {
+    if (this.options.moveList) {
       const parsedmovelist = [];
-      for (let i = 0; i < this.movelist.length; i++) {
-        parsedmovelist.push(this.parsemove(this.movelist[i]));
+      for (const moveString of this.options.moveList) {
+        parsedmovelist.push(this.parsemove(moveString));
       }
       this.parsedmovelist = parsedmovelist;
     }
-    this.facelisthash = null;
+    this.facelisthash.clear();
     this.facecentermass = [];
-    this.cubiekey = [];
-  }
-  getfaces() {
-    return this.faces.map((_) => {
-      return _.map((__) => [__.b, __.c, __.d]);
-    });
+    tend(t1);
   }
   getboundarygeometry() {
     return {
@@ -3052,8 +3210,7 @@ var PuzzleGeometry = class {
     const slices = this.moveplanesets[k].length;
     let r = [];
     if (this.parsedmovelist !== void 0) {
-      for (let i = 0; i < this.parsedmovelist.length; i++) {
-        const parsedmove = this.parsedmovelist[i];
+      for (const parsedmove of this.parsedmovelist) {
         if (parsedmove[1] !== k) {
           continue;
         }
@@ -3064,19 +3221,19 @@ var PuzzleGeometry = class {
         }
         r.push(parsedmove[5]);
       }
-    } else if (this.vertexmoves && !this.allmoves) {
+    } else if (this.options.vertexMoves && !this.options.allMoves) {
       const msg = this.movesetgeos[k];
       if (msg[1] !== msg[3]) {
         for (let i = 0; i < slices; i++) {
           if (msg[1] !== "v") {
-            if (this.outerblockmoves) {
+            if (this.options.outerBlockMoves) {
               r.push([i + 1, slices]);
             } else {
               r.push([i + 1]);
             }
             r.push(1);
           } else {
-            if (this.outerblockmoves) {
+            if (this.options.outerBlockMoves) {
               r.push([0, i]);
             } else {
               r.push([i, i]);
@@ -3087,10 +3244,10 @@ var PuzzleGeometry = class {
       }
     } else {
       for (let i = 0; i <= slices; i++) {
-        if (!this.allmoves && i + i === slices) {
+        if (!this.options.allMoves && i + i === slices) {
           continue;
         }
-        if (this.outerblockmoves) {
+        if (this.options.outerBlockMoves) {
           if (i + i > slices) {
             r.push([i, slices]);
           } else {
@@ -3103,7 +3260,7 @@ var PuzzleGeometry = class {
       }
     }
     if (this.fixedCubie >= 0) {
-      const dep = +this.cubiekeys[this.fixedCubie].trim().split(" ")[k];
+      const dep = this.keyface3(this.faces[this.cubies[this.fixedCubie][0]])[k];
       const newr = [];
       for (let i = 0; i < r.length; i += 2) {
         let o = r[i];
@@ -3137,27 +3294,20 @@ var PuzzleGeometry = class {
     if (this.duplicatedCubies[cubie]) {
       ori = 1;
     }
-    return ori === 1 && (this.graycenters || !this.centersets) || ori === 2 && (this.grayedges || !this.edgesets) || ori > 2 && (this.graycorners || !this.cornersets);
+    return ori === 1 && (this.options.grayCenters || !this.options.includeCenterOrbits) || ori === 2 && (this.options.grayEdges || !this.options.includeEdgeOrbits) || ori > 2 && (this.options.grayCorners || !this.options.includeCornerOrbits);
   }
   skipbyori(cubie) {
     let ori = this.cubies[cubie].length;
     if (this.duplicatedCubies[cubie]) {
       ori = 1;
     }
-    return ori === 1 && !this.centersets || ori === 2 && !this.edgesets || ori > 2 && !this.cornersets;
+    return ori === 1 && !this.options.includeCenterOrbits || ori === 2 && !this.options.includeEdgeOrbits || ori > 2 && !this.options.includeCornerOrbits;
   }
   skipcubie(fi) {
     return this.skipbyori(fi);
   }
-  skipset(set) {
-    if (set.length === 0) {
-      return true;
-    }
-    const fi = set[0];
-    return this.skipbyori(this.facetocubies[fi][0]);
-  }
   header(comment) {
-    return comment + copyright + "\n" + comment + this.args + "\n";
+    return comment + copyright + "\n" + comment + "\n";
   }
   writegap() {
     const os = this.getOrbitsDef(false);
@@ -3182,6 +3332,8 @@ var PuzzleGeometry = class {
     r.push("];");
     const ip = os.solved.identicalPieces();
     r.push("ip:=[" + ip.map((_) => "[" + _.map((__) => __ + 1).join(",") + "]").join(",") + "];");
+    r.push("# Size(Group(Gen));");
+    r.push("# Size(Stabilizer(Group(Gen), ip, OnTuplesSets));");
     r.push("");
     return this.header("# ") + r.join("\n");
   }
@@ -3189,9 +3341,12 @@ var PuzzleGeometry = class {
     const od = this.getOrbitsDef(false);
     return this.header("# ") + od.toKsolve(name, this.notationMapper).join("\n");
   }
-  writekpuzzle(fortwisty = true) {
-    const od = this.getOrbitsDef(fortwisty);
-    const r = od.toKpuzzle();
+  writekpuzzle(fortwisty = true, includemoves = true) {
+    const od = this.getOrbitsDef(fortwisty, includemoves);
+    const r = od.toKPuzzle(includemoves);
+    if (!r) {
+      throw new Error("Missing definition!");
+    }
     r.moveNotation = new PGNotation(this, od);
     return r;
   }
@@ -3199,9 +3354,9 @@ var PuzzleGeometry = class {
     const moveorbits = [];
     const perms = [];
     const oris = [];
-    for (let ii = 0; ii < this.cubiesetnames.length; ii++) {
-      perms.push(iota(this.cubieords[ii]));
-      oris.push(zeros(this.cubieords[ii]));
+    for (const len of this.cubieords) {
+      perms.push(iota(len));
+      oris.push(zeros(len));
     }
     for (let m = moverange[0]; m <= moverange[1]; m++) {
       const slicecmoves = axiscmoves[m];
@@ -3219,49 +3374,49 @@ var PuzzleGeometry = class {
         }
         if (perms[setnum] === iota(this.cubieords[setnum])) {
           perms[setnum] = perms[setnum].slice();
-          if (this.orbitoris[setnum] > 1 && !this.killorientation) {
+          if (this.orbitoris[setnum] > 1 && !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.killorientation) {
+          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];
           }
         }
       }
     }
-    let lastId = new Orbit(iota(24), zeros(24), 1);
+    let lastId = new PGOrbit(iota(24), zeros(24), 1);
     for (let ii = 0; ii < this.cubiesetnames.length; ii++) {
       if (setmoves && !setmoves[ii]) {
         continue;
       }
-      if (this.orbitoris[ii] === 1 || this.killorientation) {
+      if (this.orbitoris[ii] === 1 || this.options.fixedOrientation) {
         if (perms[ii] === iota(lastId.perm.length)) {
           if (perms[ii] !== lastId.perm) {
-            lastId = new Orbit(perms[ii], oris[ii], 1);
+            lastId = new PGOrbit(perms[ii], oris[ii], 1);
           }
           moveorbits.push(lastId);
         } else {
-          moveorbits.push(new Orbit(perms[ii], oris[ii], 1));
+          moveorbits.push(new PGOrbit(perms[ii], oris[ii], 1));
         }
       } else {
         const no = new Array(oris[ii].length);
         for (let jj = 0; jj < perms[ii].length; jj++) {
           no[jj] = oris[ii][perms[ii][jj]];
         }
-        moveorbits.push(new Orbit(perms[ii], no, this.orbitoris[ii]));
+        moveorbits.push(new PGOrbit(perms[ii], no, this.orbitoris[ii]));
       }
     }
-    let mv = new Transformation(moveorbits);
+    let mv = new PGTransform(moveorbits);
     if (amount !== 1) {
       mv = mv.mulScalar(amount);
     }
     return mv;
   }
   omitSet(name) {
-    for (let k = 0; k < this.omitsets.length; k++) {
-      if (this.omitsets[k] === name) {
+    for (const excludedSet of this.options.excludeOrbits) {
+      if (excludedSet === name) {
         return true;
       }
     }
@@ -3287,7 +3442,7 @@ var PuzzleGeometry = class {
     }
     return false;
   }
-  getOrbitsDef(fortwisty) {
+  getOrbitsDef(fortwisty, includemoves = true) {
     const setmoves = [];
     if (fortwisty) {
       for (let i = 0; i < this.cubiesetnames.length; i++) {
@@ -3301,13 +3456,13 @@ var PuzzleGeometry = class {
     for (let k = 0; k < this.moveplanesets.length; k++) {
       const moveset = this.getmovesets(k);
       mps.push(moveset);
-      if (this.addrotations) {
+      if (this.options.addRotations) {
         addrot.push(1);
       } else {
         addrot.push(0);
       }
     }
-    if (this.movelist && this.addrotations) {
+    if (this.options.moveList && this.options.addRotations) {
       for (let i = 0; i < this.moverotations.length; i++) {
         addrot[i] = 0;
       }
@@ -3321,18 +3476,20 @@ var PuzzleGeometry = class {
             }
             let found = -1;
             let neg = false;
-            for (let j = 0; found < 0 && j < this.moveplanenormals.length; j++) {
+            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) {
                 found = j;
                 neg = true;
+                break;
               }
             }
             if (found < 0) {
               throw new Error("Could not find rotation");
             }
-            let cmp = mps[found];
+            const cmp = mps[found];
             if (cmp.length !== mps[k].length || this.moveplanesets[k].length !== this.moveplanesets[found].length || this.diffmvsets(cmp, mps[k], this.moveplanesets[found].length, neg)) {
               addrot[i] |= ii;
             }
@@ -3401,7 +3558,7 @@ var PuzzleGeometry = class {
         continue;
       }
       setnames.push(this.cubiesetnames[i]);
-      setdefs.push(new OrbitDef(this.cubieords[i], this.killorientation ? 1 : this.orbitoris[i]));
+      setdefs.push(new PGOrbitDef(this.cubieords[i], this.options.fixedOrientation ? 1 : this.orbitoris[i]));
     }
     const solved = [];
     for (let i = 0; i < this.cubiesetnames.length; i++) {
@@ -3422,36 +3579,37 @@ var PuzzleGeometry = class {
         }
         o.push(0);
       }
-      solved.push(new Orbit(p, o, this.killorientation ? 1 : this.orbitoris[i]));
+      solved.push(new PGOrbit(p, o, this.options.fixedOrientation ? 1 : this.orbitoris[i]));
     }
     const movenames = [];
     const moves = [];
-    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];
-      for (let i = 0; i < moveset.length; i += 2) {
-        const movebits = moveset[i];
-        const mna = getmovename(movesetgeo, movebits, slices);
-        const movename = mna[0];
-        const inverted = mna[1];
-        if (moveset[i + 1] === 1) {
-          movenames.push(movename);
-        } else {
-          movenames.push(movename + moveset[i + 1]);
+    if (includemoves) {
+      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];
+        for (let i = 0; i < moveset.length; i += 2) {
+          const movebits = moveset[i];
+          const mna = getmovename(movesetgeo, movebits, slices);
+          const movename = mna[0];
+          const inverted = mna[1];
+          if (moveset[i + 1] === 1) {
+            movenames.push(movename);
+          } else {
+            movenames.push(movename + moveset[i + 1]);
+          }
+          const mv = this.getMoveFromBits(movebits, moveset[i + 1], inverted, this.cmovesbyslice[k], setmoves, this.movesetorders[k]);
+          moves.push(mv);
         }
-        const mv = this.getMoveFromBits(movebits, moveset[i + 1], inverted, this.cmovesbyslice[k], setmoves, this.movesetorders[k]);
-        moves.push(mv);
       }
     }
-    this.ksolvemovenames = movenames;
-    let r = new OrbitsDef(setnames, setdefs, new VisibleState(solved), movenames, moves);
-    if (this.optimize) {
+    let r = new PGOrbitsDef(setnames, setdefs, new VisibleState(solved), movenames, moves);
+    if (this.options.optimizeOrbits) {
       r = r.optimize();
     }
-    if (this.scramble !== 0) {
-      r.scramble(this.scramble);
+    if (this.options.scrambleAmount !== 0) {
+      r.scramble(this.options.scrambleAmount);
     }
     return r;
   }
@@ -3463,7 +3621,7 @@ var PuzzleGeometry = class {
   }
   getsolved() {
     const r = [];
-    for (let i = 0; i < this.basefacecount; i++) {
+    for (let i = 0; i < this.baseFaceCount; i++) {
       for (let j = 0; j < this.stickersperface; j++) {
         r.push(i);
       }
@@ -3471,10 +3629,10 @@ var PuzzleGeometry = class {
     return new Perm(r);
   }
   getOrientationRotation(desiredRotation) {
-    const feature1name = desiredRotation[0];
-    const direction1 = new Quat(0, desiredRotation[1][0], -desiredRotation[1][1], desiredRotation[1][2]);
-    const feature2name = desiredRotation[2];
-    const direction2 = new Quat(0, desiredRotation[3][0], -desiredRotation[3][1], desiredRotation[3][2]);
+    const [feature1name, [x1, y1, z1]] = desiredRotation[0];
+    const direction1 = new Quat(0, x1, -y1, z1);
+    const [feature2name, [x2, y2, z2]] = desiredRotation[1];
+    const direction2 = new Quat(0, x2, -y2, z2);
     let feature1 = null;
     let feature2 = null;
     const feature1geoname = this.swizzler.unswizzle(feature1name);
@@ -3499,22 +3657,22 @@ var PuzzleGeometry = class {
     return r2.mul(r1);
   }
   getInitial3DRotation() {
-    const basefacecount = this.basefacecount;
-    let rotDesc = null;
-    if (this.puzzleOrientation) {
-      rotDesc = this.puzzleOrientation;
-    } else if (this.puzzleOrientations) {
-      rotDesc = this.puzzleOrientations[basefacecount];
+    const basefacecount = this.baseFaceCount;
+    let orientationDescription = null;
+    if (this.options.puzzleOrientation) {
+      orientationDescription = this.options.puzzleOrientation;
+    } else if (this.options.puzzleOrientations) {
+      orientationDescription = this.options.puzzleOrientations[basefacecount];
     }
-    if (!rotDesc) {
-      rotDesc = defaultOrientations()[basefacecount];
+    if (!orientationDescription) {
+      orientationDescription = defaultOrientations()[basefacecount];
     }
-    if (!rotDesc) {
+    if (!orientationDescription) {
       throw new Error("No default orientation?");
     }
-    return this.getOrientationRotation(rotDesc);
+    return this.getOrientationRotation(orientationDescription);
   }
-  generatesvg(w = 800, h = 500, trim = 10, threed = false) {
+  generate2dmapping(w = 800, h = 500, trim = 10, threed = false, twodshrink = 0.92) {
     w -= 2 * trim;
     h -= 2 * trim;
     function extendedges(a, n) {
@@ -3530,29 +3688,6 @@ var PuzzleGeometry = class {
         a.push([a[i - 1][0] + dx, a[i - 1][1] + dy]);
       }
     }
-    function noise(c) {
-      return c + 0 * (Math.random() - 0.5);
-    }
-    function drawedges(id, pts, color) {
-      return '<polygon id="' + id + '" class="sticker" style="fill: ' + color + '" points="' + pts.map((p) => noise(p[0]) + " " + noise(p[1])).join(" ") + '"/>\n';
-    }
-    let needvertexgrips = this.addrotations;
-    let neededgegrips = this.addrotations;
-    let needfacegrips = this.addrotations;
-    for (let i = 0; i < this.movesetgeos.length; i++) {
-      const msg = this.movesetgeos[i];
-      for (let j = 1; j <= 3; j += 2) {
-        if (msg[j] === "v") {
-          needvertexgrips = true;
-        }
-        if (msg[j] === "f") {
-          needfacegrips = true;
-        }
-        if (msg[j] === "e") {
-          neededgegrips = true;
-        }
-      }
-    }
     this.genperms();
     const boundarygeo = this.getboundarygeometry();
     const face0 = boundarygeo.facenames[0][0];
@@ -3571,13 +3706,13 @@ var PuzzleGeometry = class {
       [0, 0]
     ];
     extendedges(edges[net[0][0]], polyn);
-    for (let i = 0; i < net.length; i++) {
-      const f0 = net[i][0];
+    for (const neti of net) {
+      const f0 = neti[0];
       if (!edges[f0]) {
         throw new Error("Bad edge description; first edge not connected.");
       }
-      for (let j = 1; j < net[i].length; j++) {
-        const f1 = net[i][j];
+      for (let j = 1; j < neti.length; j++) {
+        const f1 = neti[j];
         if (f1 === "" || edges[f1]) {
           continue;
         }
@@ -3587,11 +3722,11 @@ var PuzzleGeometry = class {
     }
     for (const f in edges) {
       const es = edges[f];
-      for (let i = 0; i < es.length; i++) {
-        minx = Math.min(minx, es[i][0]);
-        maxx = Math.max(maxx, es[i][0]);
-        miny = Math.min(miny, es[i][1]);
-        maxy = Math.max(maxy, es[i][1]);
+      for (const esi of es) {
+        minx = Math.min(minx, esi[0]);
+        maxx = Math.max(maxx, esi[0]);
+        miny = Math.min(miny, esi[1]);
+        maxy = Math.max(maxy, esi[1]);
       }
     }
     const sc = Math.min(w / (maxx - minx), h / (maxy - miny));
@@ -3612,8 +3747,8 @@ var PuzzleGeometry = class {
     ]);
     const connectat = [];
     connectat[0] = 0;
-    for (let i = 0; i < net.length; i++) {
-      const f0 = net[i][0];
+    for (const neti of net) {
+      const f0 = neti[0];
       if (!edges2[f0]) {
         throw new Error("Bad edge description; first edge not connected.");
       }
@@ -3628,8 +3763,8 @@ var PuzzleGeometry = class {
         throw new Error("Could not find first face name " + f0);
       }
       const thisface = bg.facenames[gfi][0];
-      for (let j = 1; j < net[i].length; j++) {
-        const f1 = net[i][j];
+      for (let j = 1; j < neti.length; j++) {
+        const f1 = neti[j];
         if (f1 === "" || edges2[f1]) {
           continue;
         }
@@ -3670,26 +3805,22 @@ var PuzzleGeometry = class {
         }
       }
     }
-    const pos = this.getsolved();
-    const colormap = [];
-    const facegeo = [];
-    for (let i = 0; i < this.basefacecount; i++) {
-      colormap[i] = this.colors[this.facenames[i][1]];
-    }
     let hix = 0;
     let hiy = 0;
     const rot = this.getInitial3DRotation();
-    for (let i = 0; i < this.faces.length; i++) {
-      let face = this.faces[i];
-      face = rot.rotateface(face);
+    for (let face of this.faces) {
+      if (threed) {
+        face = face.rotate(rot);
+      }
       for (let j = 0; j < face.length; j++) {
-        hix = Math.max(hix, Math.abs(face[j].b));
-        hiy = Math.max(hiy, Math.abs(face[j].c));
+        hix = Math.max(hix, Math.abs(face.get(j).b));
+        hiy = Math.max(hiy, Math.abs(face.get(j).c));
       }
     }
     const sc2 = Math.min(h / hiy / 2, (w - trim) / hix / 4);
     const mappt2d = (fn, q) => {
       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;
         return [
@@ -3698,25 +3829,42 @@ var PuzzleGeometry = class {
         ];
       } else {
         const g = geos[this.facenames[fn][1]];
-        return [trim + q.dot(g[0]) + g[2].b, trim + h - q.dot(g[1]) - g[2].c];
+        return [
+          trim + twodshrink * q.dot(g[0]) + g[2].b,
+          trim + h - twodshrink * q.dot(g[1]) - g[2].c
+        ];
       }
     };
+    return mappt2d;
+  }
+  generatesvg(w = 800, h = 500, trim = 10, threed = false) {
+    const mappt2d = this.generate2dmapping(w, h, trim, threed);
+    function drawedges(id, pts, color) {
+      return '<polygon id="' + id + '" class="sticker" style="fill: ' + color + '" points="' + pts.map((p) => p[0] + " " + p[1]).join(" ") + '"/>\n';
+    }
+    const pos = this.getsolved();
+    const colormap = [];
+    const facegeo = [];
+    for (let i = 0; i < this.baseFaceCount; i++) {
+      colormap[i] = this.colors[this.facenames[i][1]];
+    }
     for (let i = 0; i < this.faces.length; i++) {
-      let face = this.faces[i];
+      const face = this.faces[i];
       const facenum = Math.floor(i / this.stickersperface);
-      if (threed) {
-        face = rot.rotateface(face);
+      const fg = [];
+      for (let j = 0; j < face.length; j++) {
+        fg.push(mappt2d(facenum, face.get(j)));
       }
-      facegeo.push(face.map((_) => mappt2d(facenum, _)));
+      facegeo.push(fg);
     }
     const svg = [];
-    for (let j = 0; j < this.basefacecount; j++) {
+    for (let j = 0; j < this.baseFaceCount; j++) {
       svg.push("<g>");
       svg.push("<title>" + this.facenames[j][1] + "</title>\n");
       for (let ii = 0; ii < this.stickersperface; ii++) {
         const i = j * this.stickersperface + ii;
-        const cubie = this.facetocubies[i][0];
-        const cubieori = this.facetocubies[i][1];
+        const cubie = this.facetocubie[i];
+        const cubieori = this.facetoord[i];
         const cubiesetnum = this.cubiesetnums[cubie];
         const cubieord = this.cubieordnums[cubie];
         const color = this.graybyori(cubie) ? "#808080" : colormap[pos.p[i]];
@@ -3731,122 +3879,53 @@ var PuzzleGeometry = class {
       }
       svg.push("</g>");
     }
-    const svggrips = [];
-    function addgrip(onface, name, pt, order) {
-      const pt2 = mappt2d(onface, pt);
-      for (let i = 0; i < svggrips.length; i++) {
-        if (Math.hypot(pt2[0] - svggrips[i][0], pt2[1] - svggrips[i][1]) < eps3) {
-          return;
-        }
-      }
-      svggrips.push([pt2[0], pt2[1], name, order]);
-    }
-    for (let i = 0; i < this.faceplanes.length; i++) {
-      const baseface = this.facenames[i][0];
-      let facecoords = baseface;
-      if (threed) {
-        facecoords = rot.rotateface(facecoords);
-      }
-      if (needfacegrips) {
-        let pt = this.faceplanes[i][0];
-        if (threed) {
-          pt = pt.rotatepoint(rot);
-        }
-        addgrip(i, this.faceplanes[i][1], pt, polyn);
-      }
-      for (let j = 0; j < baseface.length; j++) {
-        if (neededgegrips) {
-          const mp = baseface[j].sum(baseface[(j + 1) % baseface.length]).smul(0.5);
-          const ep = findelement(this.edgenames, mp);
-          const mpc = facecoords[j].sum(facecoords[(j + 1) % baseface.length]).smul(0.5);
-          addgrip(i, this.edgenames[ep][1], mpc, 2);
-        }
-        if (needvertexgrips) {
-          const vp = findelement(this.vertexnames, baseface[j]);
-          addgrip(i, this.vertexnames[vp][1], facecoords[j], this.cornerfaces);
-        }
-      }
-    }
     const html = '<svg id="svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 800 500">\n<style type="text/css"><![CDATA[.sticker { stroke: #000000; stroke-width: 1px; }]]></style>\n' + svg.join("") + "</svg>";
-    this.svggrips = svggrips;
     return html;
   }
-  dist(a, b) {
-    return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
-  }
-  triarea(a, b, c) {
-    const ab = this.dist(a, b);
-    const bc = this.dist(b, c);
-    const ac = this.dist(a, c);
-    const p = (ab + bc + ac) / 2;
-    return Math.sqrt(p * (p - ab) * (p - bc) * (p - ac));
-  }
-  polyarea(coords) {
-    let sum = 0;
-    for (let i = 2; i < coords.length; i++) {
-      sum += this.triarea(coords[0], coords[1], coords[i]);
-    }
-    return sum;
-  }
-  get3d(colorfrac = DEFAULT_COLOR_FRACTION, options) {
+  get3d(options) {
     const stickers = [];
-    const foundations = [];
     const rot = this.getInitial3DRotation();
     const faces = [];
-    const maxdist = 0.52 * this.basefaces[0][0].len();
-    let avgstickerarea = 0;
+    const maxdist = 0.52 * this.basefaces[0].get(0).len();
     for (let i = 0; i < this.basefaces.length; i++) {
-      const coords = rot.rotateface(this.basefaces[i]);
+      const coords = this.basefaces[i].rotate(rot);
       const name = this.facenames[i][1];
       faces.push({ coords: toFaceCoords(coords, maxdist), name });
-      avgstickerarea += this.polyarea(faces[i].coords);
     }
-    avgstickerarea /= this.faces.length;
-    const trim = Math.sqrt(avgstickerarea) * (1 - Math.sqrt(colorfrac)) / 2;
     for (let i = 0; i < this.faces.length; i++) {
       const facenum = Math.floor(i / this.stickersperface);
-      const cubie = this.facetocubies[i][0];
-      const cubieori = this.facetocubies[i][1];
+      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) ? "#808080" : this.colors[this.facenames[facenum][1]];
       if (options?.stickerColors) {
         color = options.stickerColors[i];
       }
-      let coords = rot.rotateface(this.faces[i]);
-      foundations.push({
-        coords: toFaceCoords(coords, maxdist),
-        color,
-        orbit: this.cubiesetnames[cubiesetnum],
-        ord: cubieord,
-        ori: cubieori
-      });
-      const fcoords = coords;
-      if (trim && trim > 0) {
-        coords = trimEdges(coords, trim);
-      }
+      const coords = this.faces[i].rotate(rot);
       stickers.push({
         coords: toFaceCoords(coords, maxdist),
         color,
         orbit: this.cubiesetnames[cubiesetnum],
         ord: cubieord,
-        ori: cubieori
+        ori: cubieori,
+        face: facenum
       });
+      let fcoords = coords;
       if (this.duplicatedFaces[i]) {
+        const rotdist = fcoords.length / this.duplicatedFaces[i];
         for (let jj = 1; jj < this.duplicatedFaces[i]; jj++) {
+          for (let k = 0; k < rotdist; k++) {
+            fcoords = fcoords.rotateforward();
+          }
           stickers.push({
-            coords: toFaceCoords(coords, maxdist),
-            color,
-            orbit: this.cubiesetnames[cubiesetnum],
-            ord: cubieord,
-            ori: jj
-          });
-          foundations.push({
             coords: toFaceCoords(fcoords, maxdist),
             color,
             orbit: this.cubiesetnames[cubiesetnum],
             ord: cubieord,
-            ori: jj
+            ori: jj,
+            face: facenum,
+            isDup: true
           });
         }
       }
@@ -3855,8 +3934,7 @@ var PuzzleGeometry = class {
     for (let i = 0; i < this.movesetgeos.length; i++) {
       const msg = this.movesetgeos[i];
       const order = this.movesetorders[i];
-      for (let j = 0; j < this.geonormals.length; j++) {
-        const gn = this.geonormals[j];
+      for (const gn of this.geonormals) {
         if (msg[0] === gn[1] && msg[1] === gn[2]) {
           grips.push([toCoords(gn[0].rotatepoint(rot), 1), msg[0], order]);
           grips.push([
@@ -3867,25 +3945,31 @@ var PuzzleGeometry = class {
         }
       }
     }
-    const f = function() {
-      return function(mv) {
-        return this.unswizzle(mv);
+    const twodmapper = this.generate2dmapping(2880, 2160, 0, false, 1);
+    const g = function() {
+      const irot = rot.invrot();
+      return function(facenum, coords) {
+        let q = new Quat(0, coords[0] * maxdist, -coords[1] * maxdist, coords[2] * maxdist);
+        q = q.rotatepoint(irot);
+        const x = twodmapper(facenum, q);
+        x[0] /= 2880;
+        x[1] = 1 - x[1] / 2160;
+        return x;
       };
     }().bind(this);
     return {
       stickers,
-      foundations,
       faces,
       axis: grips,
-      unswizzle: f,
-      notationMapper: this.notationMapper
+      unswizzle: this.unswizzle.bind(this),
+      notationMapper: this.notationMapper,
+      textureMapper: { getuv: g }
     };
   }
   getGeoNormal(geoname) {
     const rot = this.getInitial3DRotation();
     const grip = this.swizzler.unswizzle(geoname);
-    for (let j = 0; j < this.geonormals.length; j++) {
-      const gn = this.geonormals[j];
+    for (const gn of this.geonormals) {
       if (grip === gn[1]) {
         const r = toCoords(gn[0].rotatepoint(rot), 1);
         if (Math.abs(r[0]) < eps3 && Math.abs(r[2]) < eps3) {
@@ -3901,6 +3985,22 @@ var PuzzleGeometry = class {
     const divid = this.stickersperface;
     return Math.floor(facenum / divid);
   }
+  textForTwizzleExplorer() {
+    return `Faces ${this.baseplanerot.length}
+Stickers per face ${this.stickersperface}
+Short edge ${this.shortedge}
+Cubies ${this.cubies.length}
+Edge distance ${this.edgedistance}
+Vertex distance ${this.vertexdistance}`;
+  }
+  writeSchreierSims(tw) {
+    const os = this.getOrbitsDef(false);
+    const as = os.reassemblySize();
+    tw(`Reassembly size is ${as}`);
+    const ss = schreierSims(this.getMovesAsPerms(), tw);
+    const r = as / ss;
+    tw(`Ratio is ${r}`);
+  }
 };
 var PGNotation = class {
   constructor(pg, od) {
@@ -3916,8 +4016,8 @@ var PGNotation = class {
     const mv = this.pg.parseMove(move);
     if (this.pg.parsedmovelist) {
       let found = false;
-      for (let i = 0; i < this.pg.parsedmovelist.length; i++) {
-        if (this.pg.parsedmovelist[i][1] === mv[1] && this.pg.parsedmovelist[i][2] === mv[2] && this.pg.parsedmovelist[i][3] === mv[3] && this.pg.parsedmovelist[i][4] === mv[4]) {
+      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;
         }
       }
@@ -3931,7 +4031,7 @@ var PGNotation = class {
       bits = [slices - mv[3], slices - mv[2]];
     }
     const pgmv = this.pg.getMoveFromBits(bits, mv[5], !mv[4], this.pg.cmovesbyslice[mv[1]], void 0, this.pg.movesetorders[mv[1]]);
-    const r = OrbitsDef.transformToKPuzzle(this.orbitNames, pgmv);
+    const r = PGOrbitsDef.transformToKPuzzle(this.orbitNames, pgmv);
     this.cache[key] = r;
     return r;
   }
@@ -3947,209 +4047,15 @@ var PGNotation = class {
     return r;
   }
 };
-
-// src/cubing/puzzle-geometry/Options.ts
-function parseoptions(argv, optionlist) {
-  let argp = 0;
-  while (argp < argv.length && argv[argp][0] === "-") {
-    const option = argv[argp++];
-    if (option === "--rotations") {
-      optionlist.push("rotations", true);
-    } else if (option === "--allmoves") {
-      optionlist.push("allmoves", true);
-    } else if (option === "--outerblockmoves") {
-      optionlist.push("outerblockmoves", true);
-    } else if (option === "--vertexmoves") {
-      optionlist.push("vertexmoves", true);
-    } else if (option === "--nocorners") {
-      optionlist.push("cornersets", false);
-    } else if (option === "--noedges") {
-      optionlist.push("edgesets", false);
-    } else if (option === "--noorientation") {
-      optionlist.push("killorientation", true);
-    } else if (option === "--nocenters") {
-      optionlist.push("centersets", false);
-    } else if (option === "--omit") {
-      optionlist.push("omit", argv[argp].split(","));
-      argp++;
-    } else if (option === "--moves") {
-      optionlist.push("movelist", argv[argp].split(","));
-      argp++;
-    } else if (option === "--optimize") {
-      optionlist.push("optimize", true);
-    } else if (option === "--scramble") {
-      optionlist.push("scramble", 100);
-    } else if (option === "--fixcorner") {
-      optionlist.push("fix", "v");
-    } else if (option === "--fixedge") {
-      optionlist.push("fix", "e");
-    } else if (option === "--fixcenter") {
-      optionlist.push("fix", "f");
-    } else if (option === "--orientcenters") {
-      optionlist.push("orientcenters", true);
-    } else if (option === "--puzzleorientation") {
-      optionlist.push("puzzleorientation", argv[argp]);
-      argp++;
-    } else {
-      throw new Error("Bad option: " + option);
-    }
-  }
-  return argp;
-}
-
-// src/cubing/puzzle-geometry/SchreierSims.ts
-var FactoredNumber = class {
-  constructor() {
-    this.mult = [];
-  }
-  multiply(n) {
-    for (let f = 2; f * f <= n; f++) {
-      while (n % f === 0) {
-        if (this.mult[f] !== void 0) {
-          this.mult[f]++;
-        } else {
-          this.mult[f] = 1;
-        }
-        n /= f;
-      }
-    }
-    if (n > 1) {
-      if (this.mult[n] !== void 0) {
-        this.mult[n]++;
-      } else {
-        this.mult[n] = 1;
-      }
-    }
-  }
-  toString() {
-    let r = "";
-    for (let i = 0; i < this.mult.length; i++) {
-      if (this.mult[i] !== void 0) {
-        if (r !== "") {
-          r += "*";
-        }
-        r += i;
-        if (this.mult[i] > 1) {
-          r += "^" + this.mult[i];
-        }
-      }
-    }
-    return r;
-  }
-};
-function schreierSims(g, disp) {
-  const n = g[0].p.length;
-  const e = identity(n);
-  let sgs = [];
-  let sgsi = [];
-  let sgslen = [];
-  let Tk = [];
-  let Tklen = [];
-  function resolve(p) {
-    for (let i = p.p.length - 1; i >= 0; i--) {
-      const j = p.p[i];
-      if (j !== i) {
-        if (!sgs[i][j]) {
-          return false;
-        }
-        p = p.mul(sgsi[i][j]);
-      }
-    }
-    return true;
-  }
-  function knutha(k, p, len) {
-    Tk[k].push(p);
-    Tklen[k].push(len);
-    for (let i = 0; i < sgs[k].length; i++) {
-      if (sgs[k][i]) {
-        knuthb(k, sgs[k][i].mul(p), len + sgslen[k][i]);
-      }
-    }
-  }
-  function knuthb(k, p, len) {
-    const j = p.p[k];
-    if (!sgs[k][j]) {
-      sgs[k][j] = p;
-      sgsi[k][j] = p.inv();
-      sgslen[k][j] = len;
-      for (let i = 0; i < Tk[k].length; i++) {
-        knuthb(k, p.mul(Tk[k][i]), len + Tklen[k][i]);
-      }
-      return;
-    }
-    const p2 = p.mul(sgsi[k][j]);
-    if (!resolve(p2)) {
-      knutha(k - 1, p2, len + sgslen[k][j]);
-    }
-  }
-  function getsgs() {
-    sgs = [];
-    sgsi = [];
-    Tk = [];
-    sgslen = [];
-    Tklen = [];
-    for (let i = 0; i < n; i++) {
-      sgs.push([]);
-      sgsi.push([]);
-      sgslen.push([]);
-      Tk.push([]);
-      Tklen.push([]);
-      sgs[i][i] = e;
-      sgsi[i][i] = e;
-      sgslen[i][i] = 0;
-    }
-    let none = 0;
-    let sz = 1;
-    for (let i = 0; i < g.length; i++) {
-      knutha(n - 1, g[i], 1);
-      sz = 1;
-      let tks = 0;
-      let sollen = 0;
-      const avgs = [];
-      const mults = new FactoredNumber();
-      for (let j = 0; j < n; j++) {
-        let cnt = 0;
-        let lensum = 0;
-        for (let k = 0; k < n; k++) {
-          if (sgs[j][k]) {
-            cnt++;
-            lensum += sgslen[j][k];
-            if (j !== k) {
-              none++;
-            }
-          }
-        }
-        tks += Tk[j].length;
-        sz *= cnt;
-        if (cnt > 1) {
-          mults.multiply(cnt);
-        }
-        const avg = lensum / cnt;
-        avgs.push(avg);
-        sollen += avg;
-      }
-      disp("" + i + ": sz " + sz + " T " + tks + " sol " + sollen + " none " + none + " mults " + mults);
-    }
-    return sz;
-  }
-  return getsgs();
-}
 export {
-  Orbit,
-  OrbitDef,
-  OrbitsDef,
-  Perm,
   PuzzleGeometry,
   Quat,
-  Transformation,
-  VisibleState,
   getPuzzleGeometryByDesc,
   getPuzzleGeometryByName,
   getpuzzle,
   getpuzzles,
-  parsedesc,
-  parseoptions,
-  schreierSims,
-  useNewFaceNames
+  parseOptions,
+  parsePuzzleDescription,
+  schreierSims
 };
 //# sourceMappingURL=index.js.map