cubing 0.65.2 → 0.66.1

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

@@ -1,7 +1,7 @@
 import {
   Move,
   QuantumMove
-} from "../chunks/chunk-UP5VP7GL.js";
+} from "../chunks/chunk-QZK3M7IM.js";
 
 // src/cubing/puzzle-geometry/colors.ts
 var PGColors = {
@@ -690,13 +690,13 @@ function remapKPuzzleDefinition(internalDefinition, notationMapper) {
     if (!externalPrefix) {
       continue;
     }
-    const externalMoveName = externalPrefix + suffix;
-    if (!externalMoveName) {
+    const externalMoveName2 = externalPrefix + suffix;
+    if (!externalMoveName2) {
       throw new Error(
         `Missing external move name for: ${internalMoveName.toString()}`
       );
     }
-    externalDefinition.moves[externalMoveName.toString()] = transformationData;
+    externalDefinition.moves[externalMoveName2.toString()] = transformationData;
   }
   return externalDefinition;
 }
@@ -755,39 +755,25 @@ var PuzzleGeometryFullOptions = class {
   }
 };
 
-// src/cubing/puzzle-geometry/Perm.ts
+// src/cubing/puzzle-geometry/Permutation.ts
 var zeroCache = [];
-var iotaCache = [];
+var rangeCache = [];
 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];
+  return zeroCache[n] ??= new Array(n).fill(0);
 }
-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 range(n) {
+  return rangeCache[n] ??= zeros(n).map((_, i) => i);
 }
 function identity(n) {
-  return new Perm(iota(n));
+  return new Permutation(range(n));
 }
-function factorial(a) {
-  let r = BigInt(1);
-  while (a > 1) {
-    r *= BigInt(a);
-    a--;
+function factorial(n) {
+  let output = BigInt(1);
+  while (n > 1) {
+    output *= BigInt(n);
+    n--;
   }
-  return r;
+  return output;
 }
 function gcd(a, b) {
   if (a > b) {
@@ -805,56 +791,56 @@ function gcd(a, b) {
 function lcm(a, b) {
   return a / gcd(a, b) * b;
 }
-var Perm = class _Perm {
-  n;
-  // length
-  p;
+var Permutation = class _Permutation {
+  permutation;
   // The permutation itself
   constructor(a) {
-    this.n = a.length;
-    this.p = a;
+    this.permutation = a;
+  }
+  get length() {
+    return this.permutation.length;
   }
   toString() {
-    return `Perm[${this.p.join(" ")}]`;
+    return `Perm[${this.permutation.join(" ")}]`;
   }
-  mul(p2) {
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[i] = p2.p[this.p[i]];
+  multiply(p2) {
+    const c = Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      c[i] = p2.permutation[this.permutation[i]];
     }
-    return new _Perm(c);
+    return new _Permutation(c);
   }
-  rmul(p2) {
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[i] = this.p[p2.p[i]];
+  rightMultiply(p2) {
+    const c = Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      c[i] = this.permutation[p2.permutation[i]];
     }
-    return new _Perm(c);
+    return new _Permutation(c);
   }
-  inv() {
-    const c = Array(this.n);
-    for (let i = 0; i < this.n; i++) {
-      c[this.p[i]] = i;
+  invert() {
+    const c = Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      c[this.permutation[i]] = i;
     }
-    return new _Perm(c);
+    return new _Permutation(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];
+  compare(p2) {
+    for (let i = 0; i < this.length; i++) {
+      if (this.permutation[i] !== p2.permutation[i]) {
+        return this.permutation[i] - p2.permutation[i];
       }
     }
     return 0;
   }
   toGap() {
     const cyc = [];
-    const seen = new Array(this.n);
-    for (let i = 0; i < this.p.length; i++) {
-      if (seen[i] || this.p[i] === i) {
+    const seen = new Array(this.length);
+    for (let i = 0; i < this.permutation.length; i++) {
+      if (seen[i] || this.permutation[i] === i) {
         continue;
       }
       const incyc = [];
-      for (let j = this.p[i]; !seen[j]; j = this.p[j]) {
+      for (let j = this.permutation[i]; !seen[j]; j = this.permutation[j]) {
         incyc.push(1 + j);
         seen[j] = true;
       }
@@ -864,13 +850,13 @@ var Perm = class _Perm {
   }
   toMathematica() {
     const cyc = [];
-    const seen = new Array(this.n);
-    for (let i = 0; i < this.p.length; i++) {
-      if (seen[i] || this.p[i] === i) {
+    const seen = new Array(this.length);
+    for (let i = 0; i < this.permutation.length; i++) {
+      if (seen[i] || this.permutation[i] === i) {
         continue;
       }
       const incyc = [];
-      for (let j = this.p[i]; !seen[j]; j = this.p[j]) {
+      for (let j = this.permutation[i]; !seen[j]; j = this.permutation[j]) {
         incyc.push(1 + j);
         seen[j] = true;
       }
@@ -879,72 +865,72 @@ var Perm = class _Perm {
     return `Cycles[{${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) {
+    let output = 1;
+    const seen = new Array(this.length);
+    for (let i = 0; i < this.permutation.length; i++) {
+      if (seen[i] || this.permutation[i] === i) {
         continue;
       }
-      let cs = 0;
-      for (let j = i; !seen[j]; j = this.p[j]) {
-        cs++;
+      let cycleLength = 0;
+      for (let j = i; !seen[j]; j = this.permutation[j]) {
+        cycleLength++;
         seen[j] = true;
       }
-      r = lcm(r, cs);
+      output = lcm(output, cycleLength);
     }
-    return r;
+    return output;
   }
 };
 
-// src/cubing/puzzle-geometry/PermOriSet.ts
+// src/cubing/puzzle-geometry/PGOrbit.ts
 var PGOrbitDef = class {
-  size;
-  mod;
+  numPieces;
+  numOrientations;
   constructor(size, mod) {
-    this.size = size;
-    this.mod = mod;
+    this.numPieces = size;
+    this.numOrientations = mod;
   }
   reassemblySize() {
-    return factorial(this.size) * BigInt(this.mod) ** BigInt(this.size);
+    return factorial(this.numPieces) * BigInt(this.numOrientations) ** BigInt(this.numPieces);
   }
 };
 var lastGlobalDefinitionCounter = 0;
-function externalName(mapper, moveString) {
-  const mv = Move.fromString(moveString);
-  const mv2 = mapper.notationToExternal(mv);
-  if (mv2 === null || mv === mv2) {
+function externalMoveName(mapper, moveString) {
+  const internalMove = Move.fromString(moveString);
+  const externalMove = mapper.notationToExternal(internalMove);
+  if (externalMove === null || internalMove === externalMove) {
     return moveString;
   }
-  return mv2.toString();
+  return externalMove.toString();
 }
 var PGOrbitsDef = class _PGOrbitsDef {
-  orbitnames;
-  orbitdefs;
+  orbitNames;
+  orbitDefs;
   solved;
-  movenames;
-  moveops;
+  moveNames;
+  moveOps;
   isRotation;
-  forcenames;
-  constructor(orbitnames, orbitdefs, solved, movenames, moveops, isRotation, forcenames) {
-    this.orbitnames = orbitnames;
-    this.orbitdefs = orbitdefs;
+  forceNames;
+  constructor(orbitNames, orbitDefs, solved, moveNames, moveOps, isRotation, forceNames) {
+    this.orbitNames = orbitNames;
+    this.orbitDefs = orbitDefs;
     this.solved = solved;
-    this.movenames = movenames;
-    this.moveops = moveops;
+    this.moveNames = moveNames;
+    this.moveOps = moveOps;
     this.isRotation = isRotation;
-    this.forcenames = forcenames;
+    this.forceNames = forceNames;
   }
   toKTransformationData(t) {
     const ktransformationData = {};
-    for (let i = 0; i < this.orbitnames.length; i++) {
-      ktransformationData[this.orbitnames[i]] = t.orbits[i].toKTransformationOrbitData();
+    for (let i = 0; i < this.orbitNames.length; i++) {
+      ktransformationData[this.orbitNames[i]] = t.orbits[i].toKTransformationOrbitData();
     }
     return ktransformationData;
   }
   toKPatternData(t) {
     const kpatternData = {};
-    for (let i = 0; i < this.orbitnames.length; i++) {
-      kpatternData[this.orbitnames[i]] = t.orbits[i].toKPatternOrbitData();
+    for (let i = 0; i < this.orbitNames.length; i++) {
+      kpatternData[this.orbitNames[i]] = t.orbits[i].toKPatternOrbitData();
     }
     return kpatternData;
   }
@@ -957,54 +943,54 @@ var PGOrbitsDef = class _PGOrbitsDef {
     return mp;
   }
   describeSet(s, r, mapper) {
-    const n = this.orbitdefs[s].size;
-    const m = new Array(n);
-    for (let i = 0; i < n; i++) {
-      m[i] = [];
+    const { numPieces } = this.orbitDefs[s];
+    const moveNames = new Array(numPieces);
+    for (let i = 0; i < numPieces; i++) {
+      moveNames[i] = [];
     }
-    for (let i = 0; i < this.movenames.length; i++) {
+    for (let i = 0; i < this.moveNames.length; i++) {
       if (this.isRotation[i]) {
         continue;
       }
-      let mvname = this.movenames[i];
-      if (!this.forcenames[i]) {
-        mvname = externalName(mapper, mvname);
-        if (mvname[mvname.length - 1] === "'") {
-          mvname = mvname.substring(0, mvname.length - 1);
+      let moveName = this.moveNames[i];
+      if (!this.forceNames[i]) {
+        moveName = externalMoveName(mapper, moveName);
+        if (moveName[moveName.length - 1] === "'") {
+          moveName = moveName.substring(0, moveName.length - 1);
         }
       }
-      const pd = this.moveops[i].orbits[s];
-      for (let j = 0; j < n; j++) {
-        if (pd.perm[j] !== j || pd.ori[j] !== 0) {
-          m[j].push(mvname);
+      const pd = this.moveOps[i].orbits[s];
+      for (let j = 0; j < numPieces; j++) {
+        if (pd.permutation[j] !== j || pd.orientationDelta[j] !== 0) {
+          moveNames[j].push(moveName);
         }
       }
     }
-    for (let j = 0; j < n; j++) {
-      r.push(`# ${j + 1} ${m[j].join(" ")}`);
+    for (let j = 0; j < numPieces; j++) {
+      r.push(`# ${j + 1} ${moveNames[j].join(" ")}`);
     }
   }
   toKsolve(name, mapper = new NullMapper()) {
     const result = [];
     result.push(`Name ${name}`);
     result.push("");
-    for (let i = 0; i < this.orbitnames.length; i++) {
+    for (let i = 0; i < this.orbitNames.length; i++) {
       result.push(
-        `Set ${this.orbitnames[i]} ${this.orbitdefs[i].size} ${this.orbitdefs[i].mod}`
+        `Set ${this.orbitNames[i]} ${this.orbitDefs[i].numPieces} ${this.orbitDefs[i].numOrientations}`
       );
       this.describeSet(i, result, mapper);
     }
     result.push("");
     result.push("Solved");
-    for (let i = 0; i < this.orbitnames.length; i++) {
-      this.solved.orbits[i].renumberPieces().appendDefinition(result, this.orbitnames[i], false, false);
+    for (let i = 0; i < this.orbitNames.length; i++) {
+      this.solved.orbits[i].renumberPieces().appendDefinition(result, this.orbitNames[i], false, false);
     }
     result.push("End");
-    for (let i = 0; i < this.movenames.length; i++) {
+    for (let i = 0; i < this.moveNames.length; i++) {
       result.push("");
-      let name2 = this.movenames[i];
-      if (!this.forcenames[i]) {
-        name2 = externalName(mapper, this.movenames[i]);
+      let name2 = this.moveNames[i];
+      if (!this.forceNames[i]) {
+        name2 = externalMoveName(mapper, this.moveNames[i]);
       }
       let doinv = false;
       if (name2[name2.length - 1] === "'") {
@@ -1012,13 +998,13 @@ var PGOrbitsDef = class _PGOrbitsDef {
         name2 = name2.substring(0, name2.length - 1);
       }
       result.push(`Move ${name2}`);
-      for (let j = 0; j < this.orbitnames.length; j++) {
+      for (let j = 0; j < this.orbitNames.length; j++) {
         if (doinv) {
-          this.moveops[i].orbits[j].inv().appendDefinition(result, this.orbitnames[j], true);
+          this.moveOps[i].orbits[j].invert().appendDefinition(result, this.orbitNames[j], true);
         } else {
-          this.moveops[i].orbits[j].appendDefinition(
+          this.moveOps[i].orbits[j].appendDefinition(
             result,
-            this.orbitnames[j],
+            this.orbitNames[j],
             true
           );
         }
@@ -1031,22 +1017,22 @@ var PGOrbitsDef = class _PGOrbitsDef {
   toKPuzzleDefinition(includemoves) {
     const orbits = [];
     const defaultPatternData = {};
-    for (let i = 0; i < this.orbitnames.length; i++) {
+    for (let i = 0; i < this.orbitNames.length; i++) {
       orbits.push({
-        orbitName: this.orbitnames[i],
-        numPieces: this.orbitdefs[i].size,
-        numOrientations: this.orbitdefs[i].mod
+        orbitName: this.orbitNames[i],
+        numPieces: this.orbitDefs[i].numPieces,
+        numOrientations: this.orbitDefs[i].numOrientations
       });
       const defaultPatternFrom = this.solved.orbits[i].toKTransformationOrbitData();
-      defaultPatternData[this.orbitnames[i]] = {
+      defaultPatternData[this.orbitNames[i]] = {
         pieces: defaultPatternFrom.permutation,
         orientation: defaultPatternFrom.orientationDelta
       };
     }
     const moves = {};
     if (includemoves) {
-      for (let i = 0; i < this.movenames.length; i++) {
-        moves[this.movenames[i]] = this.toKTransformationData(this.moveops[i]);
+      for (let i = 0; i < this.moveNames.length; i++) {
+        moves[this.moveNames[i]] = this.toKTransformationData(this.moveOps[i]);
       }
     }
     return {
@@ -1057,127 +1043,134 @@ var PGOrbitsDef = class _PGOrbitsDef {
     };
   }
   optimize() {
-    const neworbitnames = [];
-    const neworbitdefs = [];
-    const newsolved = [];
-    const newmoveops = [];
-    for (let j = 0; j < this.moveops.length; j++) {
-      newmoveops.push([]);
-    }
-    for (let i = 0; i < this.orbitdefs.length; i++) {
-      const om = this.orbitdefs[i].mod;
-      const n = this.orbitdefs[i].size;
-      const du = new DisjointUnion(n);
-      const changed = new Array(this.orbitdefs[i].size);
-      for (let k = 0; k < n; k++) {
+    const newOrbitNames = [];
+    const newOrbitDefs = [];
+    const newSolved = [];
+    const newMoveOps = this.moveOps.map(() => []);
+    for (let j = 0; j < this.moveOps.length; j++) {
+      newMoveOps.push([]);
+    }
+    for (let i = 0; i < this.orbitDefs.length; i++) {
+      const { numPieces, numOrientations } = this.orbitDefs[i];
+      const disjointUion = new DisjointUnion(numPieces);
+      const changed = new Array(this.orbitDefs[i].numPieces);
+      for (let k = 0; k < numPieces; k++) {
         changed[k] = false;
       }
-      for (let j = 0; j < this.moveops.length; j++) {
-        for (let k = 0; k < n; k++) {
-          if (this.moveops[j].orbits[i].perm[k] !== k || this.moveops[j].orbits[i].ori[k] !== 0) {
+      for (let j = 0; j < this.moveOps.length; j++) {
+        for (let k = 0; k < numPieces; k++) {
+          if (this.moveOps[j].orbits[i].permutation[k] !== k || this.moveOps[j].orbits[i].orientationDelta[k] !== 0) {
             if (!this.isRotation[j]) {
               changed[k] = true;
             }
-            du.union(k, this.moveops[j].orbits[i].perm[k]);
+            disjointUion.union(k, this.moveOps[j].orbits[i].permutation[k]);
           }
         }
       }
-      let keepori = true;
-      if (om > 1) {
-        keepori = false;
-        const duo = new DisjointUnion(this.orbitdefs[i].size * om);
-        for (let j = 0; j < this.moveops.length; j++) {
-          for (let k = 0; k < n; k++) {
-            if (this.moveops[j].orbits[i].perm[k] !== k || this.moveops[j].orbits[i].ori[k] !== 0) {
-              for (let o = 0; o < om; o++) {
-                duo.union(
-                  k * om + o,
-                  this.moveops[j].orbits[i].perm[k] * om + (o + this.moveops[j].orbits[i].ori[k]) % om
+      let keepOrientation = true;
+      if (numOrientations > 1) {
+        keepOrientation = false;
+        const disjointUnion = new DisjointUnion(
+          this.orbitDefs[i].numPieces * numOrientations
+        );
+        for (let j = 0; j < this.moveOps.length; j++) {
+          for (let k = 0; k < numPieces; k++) {
+            if (this.moveOps[j].orbits[i].permutation[k] !== k || this.moveOps[j].orbits[i].orientationDelta[k] !== 0) {
+              for (let o = 0; o < numOrientations; o++) {
+                disjointUnion.union(
+                  k * numOrientations + o,
+                  this.moveOps[j].orbits[i].permutation[k] * numOrientations + (o + this.moveOps[j].orbits[i].orientationDelta[k]) % numOrientations
                 );
               }
             }
           }
         }
-        for (let j = 0; !keepori && j < n; j++) {
-          for (let o = 1; o < om; o++) {
-            if (duo.find(j * om) === duo.find(j * om + o)) {
-              keepori = true;
+        for (let j = 0; !keepOrientation && j < numPieces; j++) {
+          for (let o = 1; o < numOrientations; o++) {
+            if (disjointUnion.find(j * numOrientations) === disjointUnion.find(j * numOrientations + o)) {
+              keepOrientation = true;
             }
           }
         }
-        for (let j = 0; !keepori && j < n; j++) {
+        for (let j = 0; !keepOrientation && j < numPieces; j++) {
           for (let k = 0; k < j; k++) {
-            if (this.solved.orbits[i].perm[j] === this.solved.orbits[i].perm[k]) {
-              keepori = true;
+            if (this.solved.orbits[i].permutation[j] === this.solved.orbits[i].permutation[k]) {
+              keepOrientation = true;
             }
           }
         }
       }
-      let nontriv = -1;
+      let nontrivial = -1;
       let multiple = false;
-      for (let j = 0; j < this.orbitdefs[i].size; j++) {
+      for (let j = 0; j < this.orbitDefs[i].numPieces; j++) {
         if (changed[j]) {
-          const h = du.find(j);
-          if (nontriv < 0) {
-            nontriv = h;
-          } else if (nontriv !== h) {
+          const h = disjointUion.find(j);
+          if (nontrivial < 0) {
+            nontrivial = h;
+          } else if (nontrivial !== h) {
             multiple = true;
           }
         }
       }
-      for (let j = 0; j < this.orbitdefs[i].size; j++) {
+      for (let j = 0; j < this.orbitDefs[i].numPieces; j++) {
         if (!changed[j]) {
           continue;
         }
-        const h = du.find(j);
+        const h = disjointUion.find(j);
         if (h !== j) {
           continue;
         }
         const no = [];
         const on = [];
         let nv = 0;
-        for (let k = 0; k < this.orbitdefs[i].size; k++) {
-          if (du.find(k) === j) {
+        for (let k = 0; k < this.orbitDefs[i].numPieces; k++) {
+          if (disjointUion.find(k) === j) {
             no[nv] = k;
             on[k] = nv;
             nv++;
           }
         }
         if (multiple) {
-          neworbitnames.push(`${this.orbitnames[i]}_p${j}`);
+          newOrbitNames.push(`${this.orbitNames[i]}_p${j}`);
         } else {
-          neworbitnames.push(this.orbitnames[i]);
+          newOrbitNames.push(this.orbitNames[i]);
         }
-        if (keepori) {
-          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));
+        if (keepOrientation) {
+          newOrbitDefs.push(
+            new PGOrbitDef(nv, this.orbitDefs[i].numOrientations)
+          );
+          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 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()
+          newOrbitDefs.push(new PGOrbitDef(nv, 1));
+          newSolved.push(
+            this.solved.orbits[i].remapVS(no, nv).forgetOrientations()
+          );
+          for (let k = 0; k < this.moveOps.length; k++) {
+            newMoveOps[k].push(
+              this.moveOps[k].orbits[i].remap(no, on, nv).forgetOrientations()
             );
           }
         }
       }
     }
     return new _PGOrbitsDef(
-      neworbitnames,
-      neworbitdefs,
-      new VisibleState(newsolved),
-      this.movenames,
-      newmoveops.map((_) => new PGTransform(_)),
+      newOrbitNames,
+      newOrbitDefs,
+      new VisibleState(newSolved),
+      this.moveNames,
+      newMoveOps.map((_) => new PGTransform(_)),
       this.isRotation,
-      this.forcenames
+      this.forceNames
     );
   }
   // replace the solved state with a new scrambled state.
   scramble(n) {
-    this.solved = this.solved.mul(this.getScrambleTransformation(n));
+    this.solved = this.solved.applyTransformation(
+      this.getScrambleTransformation(n)
+    );
   }
   // generate a new "random" position based on an entropy pool
   // this should be significantly faster and more random than just
@@ -1187,8 +1180,8 @@ var PGOrbitsDef = class _PGOrbitsDef {
       n = 100;
     }
     const pool = [];
-    for (let i = 0; i < this.moveops.length; i++) {
-      pool[i] = this.moveops[i];
+    for (let i = 0; i < this.moveOps.length; i++) {
+      pool[i] = this.moveOps[i];
     }
     for (let i = 0; i < pool.length; i++) {
       const j = Math.floor(Math.random() * pool.length);
@@ -1202,167 +1195,167 @@ var PGOrbitsDef = class _PGOrbitsDef {
     for (let i = 0; i < n; i++) {
       const ri = Math.floor(Math.random() * pool.length);
       const rj = Math.floor(Math.random() * pool.length);
-      const rm = Math.floor(Math.random() * this.moveops.length);
-      pool[ri] = pool[ri].mul(pool[rj]).mul(this.moveops[rm]);
+      const rm = Math.floor(Math.random() * this.moveOps.length);
+      pool[ri] = pool[ri].compose(pool[rj]).compose(this.moveOps[rm]);
       if (Math.random() < 0.1) {
-        pool[ri] = pool[ri].mul(this.moveops[rm]);
+        pool[ri] = pool[ri].compose(this.moveOps[rm]);
       }
     }
     let s = pool[0];
     for (let i = 1; i < pool.length; i++) {
-      s = s.mul(pool[i]);
+      s = s.compose(pool[i]);
     }
     return s;
   }
   reassemblySize() {
     let n = BigInt(1);
-    for (let i = 0; i < this.orbitdefs.length; i++) {
-      n *= this.orbitdefs[i].reassemblySize();
+    for (let i = 0; i < this.orbitDefs.length; i++) {
+      n *= this.orbitDefs[i].reassemblySize();
     }
     return n;
   }
 };
 var PGOrbit = class _PGOrbit {
   static ktransformationCache = [];
-  static e(n, mod) {
-    return new _PGOrbit(iota(n), zeros(n), mod);
-  }
-  perm;
-  ori;
-  orimod;
-  constructor(perm, ori, orimod) {
-    this.perm = perm;
-    this.ori = ori;
-    this.orimod = orimod;
-  }
-  mul(b) {
-    const n = this.perm.length;
-    const newPerm = new Array(n);
-    if (this.orimod === 1) {
+  static identity(numPieces, numOrientations) {
+    return new _PGOrbit(range(numPieces), zeros(numPieces), numOrientations);
+  }
+  permutation;
+  orientationDelta;
+  numOrientations;
+  constructor(permutation, orientationDelta, numOrientations) {
+    this.permutation = permutation;
+    this.orientationDelta = orientationDelta;
+    this.numOrientations = numOrientations;
+  }
+  applyTransformation(b) {
+    const n = this.permutation.length;
+    const newPermutation = new Array(n);
+    if (this.numOrientations === 1) {
       for (let i = 0; i < n; i++) {
-        newPerm[i] = this.perm[b.perm[i]];
+        newPermutation[i] = this.permutation[b.permutation[i]];
       }
-      return new _PGOrbit(newPerm, this.ori, this.orimod);
+      return new _PGOrbit(
+        newPermutation,
+        this.orientationDelta,
+        this.numOrientations
+      );
     } else {
-      const newOri = new Array(n);
+      const newOrientationDelta = 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;
+        newPermutation[i] = this.permutation[b.permutation[i]];
+        newOrientationDelta[i] = (this.orientationDelta[b.permutation[i]] + b.orientationDelta[i]) % this.numOrientations;
       }
-      return new _PGOrbit(newPerm, newOri, this.orimod);
+      return new _PGOrbit(
+        newPermutation,
+        newOrientationDelta,
+        this.numOrientations
+      );
     }
   }
-  inv() {
-    const n = this.perm.length;
+  invert() {
+    const n = this.permutation.length;
     const newPerm = new Array(n);
     const newOri = new Array(n);
     for (let i = 0; i < n; i++) {
-      newPerm[this.perm[i]] = i;
-      newOri[this.perm[i]] = (this.orimod - this.ori[i]) % this.orimod;
+      newPerm[this.permutation[i]] = i;
+      newOri[this.permutation[i]] = (this.numOrientations - this.orientationDelta[i]) % this.numOrientations;
     }
-    return new _PGOrbit(newPerm, newOri, this.orimod);
+    return new _PGOrbit(newPerm, newOri, this.numOrientations);
   }
   equal(b) {
-    const n = this.perm.length;
+    const n = this.permutation.length;
     for (let i = 0; i < n; i++) {
-      if (this.perm[i] !== b.perm[i] || this.ori[i] !== b.ori[i]) {
+      if (this.permutation[i] !== b.permutation[i] || this.orientationDelta[i] !== b.orientationDelta[i]) {
         return false;
       }
     }
     return true;
   }
-  // in-place mutator
-  killOri() {
-    const n = this.perm.length;
+  /**
+   * Set the number of orientations to 1, so that orientations are effectively
+   * no longer tracked for this orbit.
+   */
+  forgetOrientations() {
+    const n = this.permutation.length;
     for (let i = 0; i < n; i++) {
-      this.ori[i] = 0;
+      this.orientationDelta[i] = 0;
     }
-    this.orimod = 1;
+    this.numOrientations = 1;
     return this;
   }
-  toPerm() {
-    const o = this.orimod;
-    if (o === 1) {
-      return new Perm(this.perm);
+  toPermutation() {
+    const { numOrientations } = this;
+    if (numOrientations === 1) {
+      return new Permutation(this.permutation);
     }
-    const n = this.perm.length;
-    const newPerm = new Array(n * o);
+    const n = this.permutation.length;
+    const newPerm = new Array(n * numOrientations);
     for (let i = 0; i < n; i++) {
-      for (let j = 0; j < o; j++) {
-        newPerm[i * o + j] = o * this.perm[i] + (this.ori[i] + j) % o;
+      for (let j = 0; j < numOrientations; j++) {
+        newPerm[i * numOrientations + j] = numOrientations * this.permutation[i] + (this.orientationDelta[i] + j) % numOrientations;
       }
     }
-    return new Perm(newPerm);
+    return new Permutation(newPerm);
   }
   // number the pieces in order.
   renumberPieces() {
-    const seen = new Array(this.perm.length);
-    const newPerm = new Array(this.perm.length);
+    const seen = new Array(this.permutation.length);
+    const newPerm = new Array(this.permutation.length);
     let id = 0;
-    for (let i = 0; i < this.perm.length; i++) {
-      const v = this.perm[i];
+    for (let i = 0; i < this.permutation.length; i++) {
+      const v = this.permutation[i];
       if (seen[v] === void 0) {
         seen[v] = id++;
       }
       newPerm[i] = seen[v];
     }
-    return new _PGOrbit(newPerm, this.ori, this.orimod);
+    return new _PGOrbit(newPerm, this.orientationDelta, this.numOrientations);
   }
-  // returns tuple of sets of identical pieces in this orbit
+  // returns tuple of arrays of indices identical pieces in this orbit
   identicalPieces() {
-    const done = [];
-    const n = this.perm.length;
-    const r = [];
-    for (let i = 0; i < n; i++) {
-      const v = this.perm[i];
-      if (done[v] === void 0) {
-        const s = [i];
-        done[v] = true;
-        for (let j = i + 1; j < n; j++) {
-          if (this.perm[j] === v) {
-            s.push(j);
-          }
-        }
-        r.push(s);
-      }
+    const output = {};
+    for (let i = 0; i < this.permutation.length; i++) {
+      const pieceNumber = this.permutation[i];
+      (output[pieceNumber] ??= []).push(i);
     }
-    return r;
+    return output;
   }
   order() {
-    return this.toPerm().order();
+    return this.toPermutation().order();
   }
   isIdentity() {
-    const n = this.perm.length;
-    if (this.perm === iota(n) && this.ori === zeros(n)) {
+    const n = this.permutation.length;
+    if (this.permutation === range(n) && this.orientationDelta === zeros(n)) {
       return true;
     }
     for (let i = 0; i < n; i++) {
-      if (this.perm[i] !== i || this.ori[i] !== 0) {
+      if (this.permutation[i] !== i || this.orientationDelta[i] !== 0) {
         return false;
       }
     }
     return true;
   }
   zeroOris() {
-    const n = this.perm.length;
-    if (this.ori === zeros(n)) {
+    const n = this.permutation.length;
+    if (this.orientationDelta === zeros(n)) {
       return true;
     }
     for (let i = 0; i < n; i++) {
-      if (this.ori[i] !== 0) {
+      if (this.orientationDelta[i] !== 0) {
         return false;
       }
     }
     return true;
   }
   remap(no, on, nv) {
-    const newPerm = new Array(nv);
-    const newOri = new Array(nv);
+    const newPermutation = new Array(nv);
+    const newOrientation = new Array(nv);
     for (let i = 0; i < nv; i++) {
-      newPerm[i] = on[this.perm[no[i]]];
-      newOri[i] = this.ori[no[i]];
+      newPermutation[i] = on[this.permutation[no[i]]];
+      newOrientation[i] = this.orientationDelta[no[i]];
     }
-    return new _PGOrbit(newPerm, newOri, this.orimod);
+    return new _PGOrbit(newPermutation, newOrientation, this.numOrientations);
   }
   remapVS(no, nv) {
     const newPerm = new Array(nv);
@@ -1370,52 +1363,55 @@ var PGOrbit = class _PGOrbit {
     let nextNew = 0;
     const reassign = [];
     for (let i = 0; i < nv; i++) {
-      const ov = this.perm[no[i]];
+      const ov = this.permutation[no[i]];
       if (reassign[ov] === void 0) {
         reassign[ov] = nextNew++;
       }
       newPerm[i] = reassign[ov];
-      newOri[i] = this.ori[no[i]];
+      newOri[i] = this.orientationDelta[no[i]];
     }
-    return new _PGOrbit(newPerm, newOri, this.orimod);
+    return new _PGOrbit(newPerm, newOri, this.numOrientations);
   }
   appendDefinition(result, name, useVS, concise = true) {
     if (concise && this.isIdentity()) {
       return;
     }
     result.push(name);
-    result.push(this.perm.map((_) => _ + 1).join(" "));
+    result.push(this.permutation.map((_) => _ + 1).join(" "));
     if (!this.zeroOris()) {
       if (useVS) {
-        const newori = new Array(this.ori.length);
+        const newori = new Array(this.orientationDelta.length);
         for (let i = 0; i < newori.length; i++) {
-          newori[this.perm[i]] = this.ori[i];
+          newori[this.permutation[i]] = this.orientationDelta[i];
         }
         result.push(newori.join(" "));
       } else {
-        result.push(this.ori.join(" "));
+        result.push(this.orientationDelta.join(" "));
       }
     }
   }
   toKTransformationOrbitData() {
-    const n = this.perm.length;
+    const n = this.permutation.length;
     if (this.isIdentity()) {
       if (!_PGOrbit.ktransformationCache[n]) {
         _PGOrbit.ktransformationCache[n] = {
-          permutation: iota(n),
+          permutation: range(n),
           orientationDelta: zeros(n)
         };
       }
       return _PGOrbit.ktransformationCache[n];
     } else {
-      return { permutation: this.perm, orientationDelta: this.ori };
+      return {
+        permutation: this.permutation,
+        orientationDelta: this.orientationDelta
+      };
     }
   }
   toKPatternOrbitData() {
-    const n = this.perm.length;
+    const n = this.permutation.length;
     return {
-      pieces: this.perm,
-      orientation: this.ori,
+      pieces: this.permutation,
+      orientation: this.orientationDelta,
       orientationMod: zeros(n)
     };
   }
@@ -1425,17 +1421,17 @@ var PGTransformBase = class {
   constructor(orbits) {
     this.orbits = orbits;
   }
-  internalMul(b) {
+  internalApplyTransformation(b) {
     const newOrbits = [];
     for (let i = 0; i < this.orbits.length; i++) {
-      newOrbits.push(this.orbits[i].mul(b.orbits[i]));
+      newOrbits.push(this.orbits[i].applyTransformation(b.orbits[i]));
     }
     return newOrbits;
   }
-  internalInv() {
+  internalInvert() {
     const newOrbits = [];
     for (const orbit of this.orbits) {
-      newOrbits.push(orbit.inv());
+      newOrbits.push(orbit.invert());
     }
     return newOrbits;
   }
@@ -1447,40 +1443,39 @@ var PGTransformBase = class {
     }
     return true;
   }
-  killOri() {
+  forgetOrientations() {
     for (const orbit of this.orbits) {
-      orbit.killOri();
+      orbit.forgetOrientations();
     }
     return this;
   }
-  toPerm() {
+  toPermutation() {
     const perms = [];
     let n = 0;
     for (const orbit of this.orbits) {
-      const p = orbit.toPerm();
+      const p = orbit.toPermutation();
       perms.push(p);
-      n += p.n;
+      n += p.length;
     }
     const newPerm = new Array(n);
     n = 0;
     for (const p of perms) {
-      for (let j = 0; j < p.n; j++) {
-        newPerm[n + j] = n + p.p[j];
+      for (let j = 0; j < p.length; j++) {
+        newPerm[n + j] = n + p.permutation[j];
       }
-      n += p.n;
+      n += p.length;
     }
-    return new Perm(newPerm);
+    return new Permutation(newPerm);
   }
   identicalPieces() {
     const r = [];
     let n = 0;
     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));
+      const o = orbit.numOrientations;
+      for (const occurences of Object.values(orbit.identicalPieces())) {
+        r.push(occurences.map((i) => i * o + n));
       }
-      n += o * orbit.perm.length;
+      n += o * orbit.permutation.length;
     }
     return r;
   }
@@ -1493,50 +1488,52 @@ var PGTransformBase = class {
   }
 };
 var PGTransform = class _PGTransform extends PGTransformBase {
-  mul(b) {
-    return new _PGTransform(this.internalMul(b));
+  compose(b) {
+    return new _PGTransform(this.internalApplyTransformation(b));
   }
-  mulScalar(n) {
-    if (n === 0) {
-      return this.e();
+  multiplyByScalar(s) {
+    if (s === 0) {
+      return this.identity();
     }
     let t = this;
-    if (n < 0) {
-      t = t.inv();
-      n = -n;
+    if (s < 0) {
+      t = t.inverrt();
+      s = -s;
     }
-    while ((n & 1) === 0) {
-      t = t.mul(t);
-      n >>= 1;
+    while ((s & 1) === 0) {
+      t = t.compose(t);
+      s >>= 1;
     }
-    if (n === 1) {
+    if (s === 1) {
       return t;
     }
-    let s = t;
-    let r = this.e();
-    while (n > 0) {
-      if (n & 1) {
-        r = r.mul(s);
+    let transform = t;
+    let r = this.identity();
+    while (s > 0) {
+      if (s & 1) {
+        r = r.compose(transform);
       }
-      if (n > 1) {
-        s = s.mul(s);
+      if (s > 1) {
+        transform = transform.compose(transform);
       }
-      n >>= 1;
+      s >>= 1;
     }
     return r;
   }
-  inv() {
-    return new _PGTransform(this.internalInv());
+  inverrt() {
+    return new _PGTransform(this.internalInvert());
   }
-  e() {
+  identity() {
     return new _PGTransform(
-      this.orbits.map((_) => PGOrbit.e(_.perm.length, _.orimod))
+      this.orbits.map(
+        (orbit) => PGOrbit.identity(orbit.permutation.length, orbit.numOrientations)
+      )
     );
   }
 };
 var VisibleState = class _VisibleState extends PGTransformBase {
-  mul(b) {
-    return new _VisibleState(this.internalMul(b));
+  applyTransformation(b) {
+    return new _VisibleState(this.internalApplyTransformation(b));
   }
 };
 var DisjointUnion = class {
@@ -1568,23 +1565,23 @@ var DisjointUnion = class {
     }
   }
 };
-function showcanon(g, disp) {
-  const n = g.moveops.length;
+function showCanonical(g, disp) {
+  const n = g.moveOps.length;
   if (n > 30) {
     throw new Error("Canon info too big for bitmask");
   }
   const orders = [];
   const commutes = [];
   for (let i = 0; i < n; i++) {
-    const permA = g.moveops[i];
+    const permA = g.moveOps[i];
     orders.push(permA.order());
     let bits = 0;
     for (let j = 0; j < n; j++) {
       if (j === i) {
         continue;
       }
-      const permB = g.moveops[j];
-      if (permA.mul(permB).equal(permB.mul(permA))) {
+      const permB = g.moveOps[j];
+      if (permA.compose(permB).equal(permB.compose(permA))) {
         bits |= 1 << j;
       }
     }
@@ -2089,7 +2086,7 @@ var FactoredNumber = class {
   }
 };
 function schreierSims(g, disp) {
-  const n = g[0].p.length;
+  const n = g[0].permutation.length;
   const e = identity(n);
   let sgs = [];
   let sgsi = [];
@@ -2097,13 +2094,13 @@ function schreierSims(g, disp) {
   let Tk = [];
   let Tklen = [];
   function resolve(p) {
-    for (let i = p.p.length - 1; i >= 0; i--) {
-      const j = p.p[i];
+    for (let i = p.permutation.length - 1; i >= 0; i--) {
+      const j = p.permutation[i];
       if (j !== i) {
         if (!sgs[i][j]) {
           return false;
         }
-        p = p.mul(sgsi[i][j]);
+        p = p.multiply(sgsi[i][j]);
       }
     }
     return true;
@@ -2113,22 +2110,22 @@ function schreierSims(g, disp) {
     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]);
+        knuthb(k, sgs[k][i].multiply(p), len + sgslen[k][i]);
       }
     }
   }
   function knuthb(k, p, len) {
-    const j = p.p[k];
+    const j = p.permutation[k];
     if (!sgs[k][j]) {
       sgs[k][j] = p;
-      sgsi[k][j] = p.inv();
+      sgsi[k][j] = p.invert();
       sgslen[k][j] = len;
       for (let i = 0; i < Tk[k].length; i++) {
-        knuthb(k, p.mul(Tk[k][i]), len + Tklen[k][i]);
+        knuthb(k, p.multiply(Tk[k][i]), len + Tklen[k][i]);
       }
       return;
     }
-    const p2 = p.mul(sgsi[k][j]);
+    const p2 = p.multiply(sgsi[k][j]);
     if (!resolve(p2)) {
       knutha(k - 1, p2, len + sgslen[k][j]);
     }
@@ -4168,10 +4165,10 @@ ${comment}
     const os = this.getOrbitsDef(false);
     const r = [];
     const mvs = [];
-    for (let i = 0; i < os.moveops.length; i++) {
-      let movename = os.movenames[i];
-      if (!os.forcenames[i]) {
-        movename = `M_${externalName(this.notationMapper, movename)}`;
+    for (let i = 0; i < os.moveOps.length; i++) {
+      let movename = os.moveNames[i];
+      if (!os.forceNames[i]) {
+        movename = `M_${externalMoveName(this.notationMapper, movename)}`;
       }
       movename = `M_${movename}`;
       let doinv = false;
@@ -4181,9 +4178,11 @@ ${comment}
       }
       mvs.push(movename);
       if (doinv) {
-        r.push(`${movename}:=${os.moveops[i].toPerm().inv().toGap()};`);
+        r.push(
+          `${movename}:=${os.moveOps[i].toPermutation().invert().toGap()};`
+        );
       } else {
-        r.push(`${movename}:=${os.moveops[i].toPerm().toGap()};`);
+        r.push(`${movename}:=${os.moveOps[i].toPermutation().toGap()};`);
       }
     }
     r.push("Gen:=[");
@@ -4203,8 +4202,8 @@ ${comment}
     const r = [];
     const mvs = [];
     r.push(`(* ${this.header("").trim()} *)`);
-    for (let i = 0; i < os.moveops.length; i++) {
-      let movename = `m${externalName(this.notationMapper, os.movenames[i])}`;
+    for (let i = 0; i < os.moveOps.length; i++) {
+      let movename = `m${externalMoveName(this.notationMapper, os.moveNames[i])}`;
       let doinv = false;
       if (movename[movename.length - 1] === "'") {
         movename = movename.substring(0, movename.length - 1);
@@ -4212,9 +4211,11 @@ ${comment}
       }
       mvs.push(movename);
       if (doinv) {
-        r.push(`${movename}=${os.moveops[i].toPerm().inv().toMathematica()};`);
+        r.push(
+          `${movename}=${os.moveOps[i].toPermutation().invert().toMathematica()};`
+        );
       } else {
-        r.push(`${movename}=${os.moveops[i].toPerm().toMathematica()};`);
+        r.push(`${movename}=${os.moveOps[i].toPermutation().toMathematica()};`);
       }
     }
     r.push(`gen={${mvs.join(",")}};`);
@@ -4238,7 +4239,7 @@ ${comment}
     const perms = [];
     const oris = [];
     for (const len of this.cubieOrbitSizes) {
-      perms.push(iota(len));
+      perms.push(range(len));
       oris.push(zeros(len));
     }
     for (let m = moverange[0]; m <= moverange[1]; m++) {
@@ -4255,7 +4256,7 @@ ${comment}
           inc = mperm.length - 2;
           oinc = mperm.length - 1;
         }
-        if (perms[setnum] === iota(this.cubieOrbitSizes[setnum])) {
+        if (perms[setnum] === range(this.cubieOrbitSizes[setnum])) {
           perms[setnum] = perms[setnum].slice();
           if (this.orbitOrientations[setnum] > 1 && // TODO: refactor to avoid non-null-assertion
           !this.options.fixedOrientation) {
@@ -4272,14 +4273,14 @@ ${comment}
         }
       }
     }
-    let lastId = new PGOrbit(iota(24), zeros(24), 1);
+    let lastId = new PGOrbit(range(24), zeros(24), 1);
     for (let ii = 0; ii < this.cubieSetNames.length; ii++) {
       if (setmoves && !setmoves[ii]) {
         continue;
       }
       if (this.orbitOrientations[ii] === 1 || this.options.fixedOrientation) {
-        if (perms[ii] === iota(lastId.perm.length)) {
-          if (perms[ii] !== lastId.perm) {
+        if (perms[ii] === range(lastId.permutation.length)) {
+          if (perms[ii] !== lastId.permutation) {
             lastId = new PGOrbit(perms[ii], oris[ii], 1);
           }
           moveorbits.push(lastId);
@@ -4298,7 +4299,7 @@ ${comment}
     }
     let mv = new PGTransform(moveorbits);
     if (amount !== 1) {
-      mv = mv.mulScalar(amount);
+      mv = mv.multiplyByScalar(amount);
     }
     return mv;
   }
@@ -4589,10 +4590,10 @@ ${comment}
     return od.toKTransformationData(od.getScrambleTransformation(n));
   }
   getMovesAsPerms() {
-    return this.getOrbitsDef(false).moveops.map((_) => _.toPerm());
+    return this.getOrbitsDef(false).moveOps.map((_) => _.toPermutation());
   }
   showcanon(disp) {
-    showcanon(this.getOrbitsDef(false), disp);
+    showCanonical(this.getOrbitsDef(false), disp);
   }
   getsolved() {
     const r = [];
@@ -4601,7 +4602,7 @@ ${comment}
         r.push(i);
       }
     }
-    return new Perm(r);
+    return new Permutation(r);
   }
   // Given a rotation description that says to align feature1
   // with a given vector, and then as much as possible feature2
@@ -4908,7 +4909,7 @@ ${comment}
         const cubieori = this.faceToCubieOrd[i];
         const cubiesetnum = this.cubieSetNums[cubie];
         const cubieord = this.cubieOrdNums[cubie];
-        const color = this.graybyori(cubie) ? "#808080" : colormap[pos.p[i]];
+        const color = this.graybyori(cubie) ? "#808080" : colormap[pos.permutation[i]];
         let id = `${this.cubieSetNames[cubiesetnum]}-l${cubieord}-o${cubieori}`;
         svg.push(drawedges(id, facegeo[i], color));
         if (this.duplicatedFaces[i]) {
@@ -5072,7 +5073,7 @@ var PGNotation = class {
   pg;
   constructor(pg, od) {
     this.pg = pg;
-    this.orbitNames = od.orbitnames;
+    this.orbitNames = od.orbitNames;
   }
   lookupMove(move) {
     const mv = this.pg.parseMove(move);
@@ -5121,4 +5122,3 @@ export {
   parsePuzzleDescription,
   schreierSims
 };
-//# sourceMappingURL=index.js.map