cubing 0.63.7 → 0.64.0

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

@@ -1,77 +1,105 @@
 import {
   Move,
   QuantumMove
-} from "../chunks/chunk-N5FJ5YIA.js";
+} from "../chunks/chunk-YFNXHRNE.js";
 
 // src/cubing/puzzle-geometry/colors.ts
+var PGColors = {
+  White: "#ffffff",
+  Orange: "#ff8000",
+  Green: "#44ee00",
+  Red: "#ff0000",
+  Blue: "#2266ff",
+  Yellow: "#f4f400",
+  LightGray: "#aaaaaa",
+  MediumGray: "#888888",
+  DarkGray: "#5c5c5c",
+  Purple: "#8800dd",
+  Cream: "#e8d0a0",
+  Pink: "#ff66cc",
+  BoldBlue: "#0000ff",
+  Aqua: "#3399ff",
+  DarkGreen: "#008800",
+  Lime: "#99ff00",
+  Teal: "#007a89",
+  Brown: "#7d3b11",
+  Lavender: "#b9a1ff",
+  SeaGreen: "#5ec4b6",
+  harcoal: "#292929",
+  Burgundy: "#980000",
+  Cerise: "#d41f69"
+};
 function defaultPlatonicColorSchemes() {
   return {
     // the colors should use the same naming convention as the nets, above.
     4: {
-      F: "#44ee00" /* Green */,
-      D: "#f4f400" /* Yellow */,
-      L: "#ff0000" /* Red */,
-      R: "#2266ff" /* Blue */
+      F: PGColors.Green,
+      D: PGColors.Yellow,
+      L: PGColors.Red,
+      R: PGColors.Blue
     },
     6: {
-      U: "#ffffff" /* White */,
-      F: "#44ee00" /* Green */,
-      R: "#ff0000" /* Red */,
-      D: "#f4f400" /* Yellow */,
-      B: "#2266ff" /* Blue */,
-      L: "#ff8000" /* Orange */
+      U: PGColors.White,
+      F: PGColors.Green,
+      R: PGColors.Red,
+      D: PGColors.Yellow,
+      B: PGColors.Blue,
+      L: PGColors.Orange
     },
     8: {
-      U: "#ffffff" /* White */,
-      F: "#44ee00" /* Green */,
-      R: "#ff0000" /* Red */,
-      D: "#f4f400" /* Yellow */,
-      BB: "#2266ff" /* Blue */,
-      L: "#8800dd" /* Purple */,
-      BL: "#ff8000" /* Orange */,
-      BR: "#888888" /* MediumGray */
+      U: PGColors.White,
+      F: PGColors.Green,
+      R: PGColors.Red,
+      D: PGColors.Yellow,
+      BB: PGColors.Blue,
+      L: PGColors.Purple,
+      BL: PGColors.Orange,
+      BR: PGColors.MediumGray
     },
     12: {
-      U: "#ffffff" /* White */,
-      F: "#008800" /* DarkGreen */,
-      R: "#ff0000" /* Red */,
-      C: "#e8d0a0" /* Cream */,
-      A: "#3399ff" /* Aqua */,
-      L: "#8800dd" /* Purple */,
-      E: "#ff66cc" /* Pink */,
-      BF: "#99ff00" /* Lime */,
-      BR: "#0000ff" /* BoldBlue */,
-      BL: "#f4f400" /* Yellow */,
-      I: "#ff8000" /* Orange */,
-      D: "#888888" /* MediumGray */
+      U: PGColors.White,
+      F: PGColors.DarkGreen,
+      R: PGColors.Red,
+      C: PGColors.Cream,
+      A: PGColors.Aqua,
+      L: PGColors.Purple,
+      E: PGColors.Pink,
+      BF: PGColors.Lime,
+      BR: PGColors.BoldBlue,
+      BL: PGColors.Yellow,
+      I: PGColors.Orange,
+      D: PGColors.MediumGray
     },
     20: {
-      R: "#f4f400" /* Yellow */,
-      C: "#d41f69" /* Cerise */,
-      F: "#008800" /* DarkGreen */,
-      E: "#5c5c5c" /* DarkGray */,
-      L: "#8800dd" /* Purple */,
-      U: "#ffffff" /* White */,
-      A: "#007a89" /* Teal */,
-      G: "#ff0000" /* Red */,
-      I: "#7d3b11" /* Brown */,
-      S: "#b9a1ff" /* Lavender */,
-      H: "#3399ff" /* Aqua */,
-      J: "#5ec4b6" /* SeaGreen */,
-      B: "#44ee00" /* Green */,
-      K: "#e8d0a0" /* Cream */,
-      D: "#aaaaaa" /* LightGray */,
-      M: "#ff66cc" /* Pink */,
-      O: "#292929" /* harcoal */,
-      P: "#ff8000" /* Orange */,
-      N: "#980000" /* Burgundy */,
-      Q: "#0000ff" /* BoldBlue */
+      R: PGColors.Yellow,
+      C: PGColors.Cerise,
+      F: PGColors.DarkGreen,
+      E: PGColors.DarkGray,
+      L: PGColors.Purple,
+      U: PGColors.White,
+      A: PGColors.Teal,
+      G: PGColors.Red,
+      I: PGColors.Brown,
+      S: PGColors.Lavender,
+      H: PGColors.Aqua,
+      J: PGColors.SeaGreen,
+      B: PGColors.Green,
+      K: PGColors.Cream,
+      D: PGColors.LightGray,
+      M: PGColors.Pink,
+      O: PGColors.harcoal,
+      P: PGColors.Orange,
+      N: PGColors.Burgundy,
+      Q: PGColors.BoldBlue
     }
   };
 }
 
 // src/cubing/puzzle-geometry/FaceNameSwizzler.ts
 var FaceNameSwizzler = class {
+  prefixFree = true;
+  gripnames = [];
+  facenames;
   constructor(facenames, gripnames_arg) {
     this.facenames = facenames;
     if (gripnames_arg) {
@@ -85,9 +113,6 @@ var FaceNameSwizzler = class {
       }
     }
   }
-  facenames;
-  prefixFree = true;
-  gripnames = [];
   setGripNames(names) {
     this.gripnames = names;
   }
@@ -216,12 +241,12 @@ var FaceNameSwizzler = class {
 
 // src/cubing/puzzle-geometry/notation-mapping/FaceRenamingMapper.ts
 var FaceRenamingMapper = class {
+  internalNames;
+  externalNames;
   constructor(internalNames, externalNames) {
     this.internalNames = internalNames;
     this.externalNames = externalNames;
   }
-  internalNames;
-  externalNames;
   // TODO:  consider putting a cache in front of this
   convertString(grip, a, b) {
     let suffix = "";
@@ -264,12 +289,12 @@ var FaceRenamingMapper = class {
 
 // src/cubing/puzzle-geometry/notation-mapping/FTONotationMapper.ts
 var FTONotationMapper = class {
+  child;
+  sw;
   constructor(child, sw) {
     this.child = child;
     this.sw = sw;
   }
-  child;
-  sw;
   notationToInternal(move) {
     if (move.family === "T" && move.innerLayer === void 0 && move.outerLayer === void 0) {
       return new Move(
@@ -299,10 +324,10 @@ var FTONotationMapper = class {
 
 // src/cubing/puzzle-geometry/notation-mapping/MegaminxScramblingNotationMapper.ts
 var MegaminxScramblingNotationMapper = class {
+  child;
   constructor(child) {
     this.child = child;
   }
-  child;
   notationToInternal(move) {
     if (move.innerLayer === void 0 && move.outerLayer === void 0) {
       if (Math.abs(move.amount) === 1) {
@@ -369,10 +394,10 @@ var NullMapper = class {
 
 // src/cubing/puzzle-geometry/notation-mapping/NxNxNCubeMapper.ts
 var NxNxNCubeMapper = class {
+  slices;
   constructor(slices) {
     this.slices = slices;
   }
-  slices;
   notationToInternal(move) {
     const grip = move.family;
     if (!(move.innerLayer || move.outerLayer)) {
@@ -494,12 +519,12 @@ var pyraminxFamilyMapWCA = {
 var pyraminxExternalQuantumY = new QuantumMove("y");
 var pyraminxInternalQuantumY = new QuantumMove("Dv");
 var PyraminxNotationMapper = class {
+  wcaHack = false;
+  map = pyraminxFamilyMap;
+  child;
   constructor(child) {
     this.child = child;
   }
-  child;
-  wcaHack = false;
-  map = pyraminxFamilyMap;
   notationToInternal(move) {
     if (this.wcaHack && move.innerLayer === 2 && move.outerLayer === null) {
       const newFamilyWCA = pyraminxFamilyMapWCA[move.family];
@@ -586,10 +611,10 @@ var skewbExternalQuantumZ = new QuantumMove("z");
 var skewbInternalQuantumZ = new QuantumMove("Fv");
 var skewbInternalQuantumZPrime = new QuantumMove("Bv");
 var SkewbNotationMapper = class {
+  child;
   constructor(child) {
     this.child = child;
   }
-  child;
   notationToInternal(move) {
     if (move.innerLayer || move.outerLayer) {
       return null;
@@ -873,12 +898,12 @@ var Perm = class _Perm {
 
 // src/cubing/puzzle-geometry/PermOriSet.ts
 var PGOrbitDef = class {
+  size;
+  mod;
   constructor(size, mod) {
     this.size = size;
     this.mod = mod;
   }
-  size;
-  mod;
   reassemblySize() {
     return factorial(this.size) * BigInt(this.mod) ** BigInt(this.size);
   }
@@ -893,6 +918,13 @@ function externalName(mapper, moveString) {
   return mv2.toString();
 }
 var PGOrbitsDef = class _PGOrbitsDef {
+  orbitnames;
+  orbitdefs;
+  solved;
+  movenames;
+  moveops;
+  isRotation;
+  forcenames;
   constructor(orbitnames, orbitdefs, solved, movenames, moveops, isRotation, forcenames) {
     this.orbitnames = orbitnames;
     this.orbitdefs = orbitdefs;
@@ -902,13 +934,6 @@ var PGOrbitsDef = class _PGOrbitsDef {
     this.isRotation = isRotation;
     this.forcenames = forcenames;
   }
-  orbitnames;
-  orbitdefs;
-  solved;
-  movenames;
-  moveops;
-  isRotation;
-  forcenames;
   toKTransformationData(t) {
     const ktransformationData = {};
     for (let i = 0; i < this.orbitnames.length; i++) {
@@ -972,12 +997,7 @@ var PGOrbitsDef = class _PGOrbitsDef {
     result.push("");
     result.push("Solved");
     for (let i = 0; i < this.orbitnames.length; i++) {
-      this.solved.orbits[i].appendDefinition(
-        result,
-        this.orbitnames[i],
-        false,
-        false
-      );
+      this.solved.orbits[i].renumberPieces().appendDefinition(result, this.orbitnames[i], false, false);
     }
     result.push("End");
     for (let i = 0; i < this.movenames.length; i++) {
@@ -1203,17 +1223,17 @@ var PGOrbitsDef = class _PGOrbitsDef {
   }
 };
 var PGOrbit = class _PGOrbit {
-  constructor(perm, ori, orimod) {
-    this.perm = perm;
-    this.ori = ori;
-    this.orimod = orimod;
+  static ktransformationCache = [];
+  static e(n, mod) {
+    return new _PGOrbit(iota(n), zeros(n), mod);
   }
   perm;
   ori;
   orimod;
-  static ktransformationCache = [];
-  static e(n, mod) {
-    return new _PGOrbit(iota(n), zeros(n), mod);
+  constructor(perm, ori, orimod) {
+    this.perm = perm;
+    this.ori = ori;
+    this.orimod = orimod;
   }
   mul(b) {
     const n = this.perm.length;
@@ -1274,6 +1294,20 @@ var PGOrbit = class _PGOrbit {
     }
     return new Perm(newPerm);
   }
+  // number the pieces in order.
+  renumberPieces() {
+    const seen = new Array(this.perm.length);
+    const newPerm = new Array(this.perm.length);
+    let id = 0;
+    for (let i = 0; i < this.perm.length; i++) {
+      const v = this.perm[i];
+      if (seen[v] === void 0) {
+        seen[v] = id++;
+      }
+      newPerm[i] = seen[v];
+    }
+    return new _PGOrbit(newPerm, this.ori, this.orimod);
+  }
   // returns tuple of sets of identical pieces in this orbit
   identicalPieces() {
     const done = [];
@@ -1387,10 +1421,10 @@ var PGOrbit = class _PGOrbit {
   }
 };
 var PGTransformBase = class {
+  orbits;
   constructor(orbits) {
     this.orbits = orbits;
   }
-  orbits;
   internalMul(b) {
     const newOrbits = [];
     for (let i = 0; i < this.orbits.length; i++) {
@@ -1506,6 +1540,8 @@ var VisibleState = class _VisibleState extends PGTransformBase {
   }
 };
 var DisjointUnion = class {
+  heads;
+  n;
   constructor(n) {
     this.n = n;
     this.heads = new Array(n);
@@ -1513,8 +1549,6 @@ var DisjointUnion = class {
       this.heads[i] = i;
     }
   }
-  n;
-  heads;
   find(v) {
     let h = this.heads[v];
     if (this.heads[h] === h) {
@@ -1607,16 +1641,16 @@ function solvethreeplanes(p1, p2, p3, planes) {
   return p;
 }
 var Quat = class _Quat {
+  a;
+  b;
+  c;
+  d;
   constructor(a, b, c, d) {
     this.a = a;
     this.b = b;
     this.c = c;
     this.d = d;
   }
-  a;
-  b;
-  c;
-  d;
   mul(q) {
     return new _Quat(
       this.a * q.a - this.b * q.b - this.c * q.c - this.d * q.d,
@@ -2208,14 +2242,14 @@ var Face = class _Face {
   }
 };
 var FaceTree = class _FaceTree {
+  face;
+  left;
+  right;
   constructor(face, left, right) {
     this.face = face;
     this.left = left;
     this.right = right;
   }
-  face;
-  left;
-  right;
   split(q) {
     const t = q.cutface(this.face);
     if (t !== null) {
@@ -2293,6 +2327,12 @@ function defaultnets() {
     ]
   };
 }
+var userFriendly2DProjections = {
+  8: [
+    ["U", "F", "L", "R"],
+    ["BB", "BR", "D", "BL"]
+  ]
+};
 var orientationDefaults = {
   4: {
     v: ["DFR", "DLF", "DRL", "FLR"],
@@ -2609,6 +2649,91 @@ function toFaceCoords(q, maxdist) {
   return r;
 }
 var PuzzleGeometry = class {
+  rotations;
+  // all members of the rotation group
+  basePlaneRotations;
+  // unique rotations of the baseplane
+  basePlanes;
+  // planes, corresponding to faces
+  faceNames;
+  // face names
+  facePlanes;
+  // face planes
+  edgeNames;
+  // edge names
+  vertexNames;
+  // vertexnames
+  geometryNormals;
+  // all geometric directions, with names and types
+  movePlanes;
+  // the planes that split moves
+  movePlanesFiltered;
+  // the planes that split moves, filtered
+  movePlaneSets;
+  // the move planes, in parallel sets
+  movePlaneNormals;
+  // one move plane
+  movesetorders;
+  // the order of rotations for each move set
+  movesetgeos;
+  // geometric feature information for move sets
+  baseFaces;
+  // polytope faces before cuts
+  faces;
+  // all the stickers
+  faceCenterMass;
+  // center of mass of all faces
+  baseFaceCount;
+  // number of base faces
+  stickersPerFace;
+  // number of stickers per face
+  shortestEdge;
+  markedFaceLookup;
+  // given a bitmap of faces, identify the marked one
+  cubies;
+  // the cubies
+  vertexDistance;
+  // vertex distance
+  edgeDistance;
+  // edge distance
+  faceToCubie;
+  // map a face to a cubie index
+  faceToCubieOrd;
+  // map a face to a cubie ord
+  moveRotations;
+  // move rotations
+  faceListHash;
+  // face list by key
+  cubieSetNames;
+  // cubie set names
+  cubieOrbitSizes;
+  // the size of each orbit
+  cubieSetNums;
+  cubieOrdNums;
+  orbitOrientations;
+  // the orientation size of each orbit
+  cubieValueMap;
+  // the map for identical cubies
+  cubieSetCubies;
+  // cubies in each cubie set
+  cmovesBySlice = [];
+  // cmoves as perms by slice
+  parsedMoveList;
+  // parsed move list
+  duplicatedFaces = [];
+  // which faces are duplicated
+  duplicatedCubies = [];
+  // which cubies are duplicated
+  fixedCubie = -1;
+  // fixed cubie, if any
+  net = [];
+  colors = [];
+  swizzler;
+  notationMapper = new NullMapper();
+  addNotationMapper = "";
+  setReidOrSpeffzOrder = false;
+  options;
+  puzzleDescription;
   constructor(puzzleDescription, options) {
     this.puzzleDescription = puzzleDescription;
     const t1 = tstart("genperms");
@@ -3065,91 +3190,6 @@ var PuzzleGeometry = class {
     }
     tend(t1);
   }
-  puzzleDescription;
-  rotations;
-  // all members of the rotation group
-  basePlaneRotations;
-  // unique rotations of the baseplane
-  basePlanes;
-  // planes, corresponding to faces
-  faceNames;
-  // face names
-  facePlanes;
-  // face planes
-  edgeNames;
-  // edge names
-  vertexNames;
-  // vertexnames
-  geometryNormals;
-  // all geometric directions, with names and types
-  movePlanes;
-  // the planes that split moves
-  movePlanesFiltered;
-  // the planes that split moves, filtered
-  movePlaneSets;
-  // the move planes, in parallel sets
-  movePlaneNormals;
-  // one move plane
-  movesetorders;
-  // the order of rotations for each move set
-  movesetgeos;
-  // geometric feature information for move sets
-  baseFaces;
-  // polytope faces before cuts
-  faces;
-  // all the stickers
-  faceCenterMass;
-  // center of mass of all faces
-  baseFaceCount;
-  // number of base faces
-  stickersPerFace;
-  // number of stickers per face
-  shortestEdge;
-  markedFaceLookup;
-  // given a bitmap of faces, identify the marked one
-  cubies;
-  // the cubies
-  vertexDistance;
-  // vertex distance
-  edgeDistance;
-  // edge distance
-  faceToCubie;
-  // map a face to a cubie index
-  faceToCubieOrd;
-  // map a face to a cubie ord
-  moveRotations;
-  // move rotations
-  faceListHash;
-  // face list by key
-  cubieSetNames;
-  // cubie set names
-  cubieOrbitSizes;
-  // the size of each orbit
-  cubieSetNums;
-  cubieOrdNums;
-  orbitOrientations;
-  // the orientation size of each orbit
-  cubieValueMap;
-  // the map for identical cubies
-  cubieSetCubies;
-  // cubies in each cubie set
-  cmovesBySlice = [];
-  // cmoves as perms by slice
-  parsedMoveList;
-  // parsed move list
-  duplicatedFaces = [];
-  // which faces are duplicated
-  duplicatedCubies = [];
-  // which cubies are duplicated
-  fixedCubie = -1;
-  // fixed cubie, if any
-  net = [];
-  colors = [];
-  swizzler;
-  notationMapper = new NullMapper();
-  addNotationMapper = "";
-  setReidOrSpeffzOrder = false;
-  options;
   keyface(face) {
     return this.keyface2(face.centermass());
   }
@@ -4776,8 +4816,68 @@ ${comment}
     };
     return mappt2d;
   }
+  // If a user-friendly mapping is provided, we prefer to use that for
+  // any 2D representations.  This involves some geometrical remapping.
+  generateUserFriendly2D(w, h, trim) {
+    const views = userFriendly2DProjections[this.baseFaceCount];
+    if (!views) {
+      return null;
+    }
+    this.genperms();
+    const faceView = [];
+    const frames = views.map((names, vi) => {
+      const fns = [];
+      for (let fi = 0; fi < names.length; fi++) {
+        for (let i = 0; i < this.faceNames.length; i++) {
+          if (this.faceNames[i][1] === names[fi]) {
+            fns[fi] = i;
+          }
+        }
+      }
+      let s = new Quat(0, 0, 0, 0);
+      for (const fn of fns) {
+        s = s.sum(this.basePlanes[fn].makenormal());
+        faceView[fn] = vi;
+      }
+      s = s.normalize();
+      const top = this.basePlanes[fns[0]].makenormal();
+      const up = top.sub(s.smul(top.dot(s))).normalize();
+      return { up, right: s.cross(up), lo: [1e9, 1e9], hi: [-1e9, -1e9] };
+    });
+    for (let fn = 0; fn < this.baseFaceCount; fn++) {
+      const fr = frames[faceView[fn]];
+      for (const v of this.faceNames[fn][0]) {
+        const p = [v.dot(fr.right), v.dot(fr.up)];
+        fr.lo = [Math.min(fr.lo[0], p[0]), Math.min(fr.lo[1], p[1])];
+        fr.hi = [Math.max(fr.hi[0], p[0]), Math.max(fr.hi[1], p[1])];
+      }
+    }
+    const gap = 0.2 * (frames[0].hi[0] - frames[0].lo[0]);
+    let totw = -gap;
+    let toth = 0;
+    for (const fr of frames) {
+      totw += fr.hi[0] - fr.lo[0] + gap;
+      toth = Math.max(toth, fr.hi[1] - fr.lo[1]);
+    }
+    const sc = Math.min((w - 2 * trim) / totw, (h - 2 * trim) / toth);
+    const left = [];
+    let x = (w - sc * totw) / 2;
+    for (const fr of frames) {
+      left.push(x - sc * fr.lo[0]);
+      x += sc * (fr.hi[0] - fr.lo[0] + gap);
+    }
+    return (fn, q) => {
+      const vi = faceView[fn];
+      const fr = frames[vi];
+      const mid = (fr.lo[1] + fr.hi[1]) / 2;
+      return [
+        left[vi] + sc * q.dot(fr.right),
+        h / 2 - sc * (q.dot(fr.up) - mid)
+      ];
+    };
+  }
   generatesvg(w = 800, h = 500, trim = 10, threed = false) {
-    const mappt2d = this.generate2dmapping(w, h, trim, threed);
+    const mappt2d = !threed && this.generateUserFriendly2D(w, h, trim) || 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(" ")}"/>
 `;
@@ -4968,12 +5068,12 @@ Vertex distance ${this.vertexDistance}`;
   }
 };
 var PGNotation = class {
+  orbitNames;
+  pg;
   constructor(pg, od) {
     this.pg = pg;
     this.orbitNames = od.orbitnames;
   }
-  pg;
-  orbitNames;
   lookupMove(move) {
     const mv = this.pg.parseMove(move);
     if (this.pg.parsedMoveList) {