cubing 0.26.2 → 0.26.5

package/dist/esm/{chunk-HD2CMNE4.js → chunk-GNKVWDWW.js}

@@ -2,7 +2,7 @@ import {
   Alg,
   Move,
   TraversalDownUp
-} from "./chunk-DO7GZAW4.js";
+} from "./chunk-FCB447RN.js";
 import {
   __privateAdd,
   __privateGet,
@@ -138,24 +138,6 @@ function moveToTransformationUncached(kpuzzle, move) {
   throw new Error(`Invalid move for KPuzzle (${kpuzzle.name()}): ${move}`);
 }
 
-// src/cubing/kpuzzle/3x3x3/puzzle-orientation.ts
-function experimentalIs3x3x3Solved(state, options) {
-  if (options.ignorePuzzleOrientation) {
-    state = normalizePuzzleOrientation(state);
-  }
-  if (options.ignoreCenterOrientation) {
-    state = new KState(state.kpuzzle, {
-      EDGES: state.stateData.EDGES,
-      CORNERS: state.stateData.CORNERS,
-      CENTERS: {
-        pieces: state.stateData.CENTERS.pieces,
-        orientation: new Array(6).fill(0)
-      }
-    });
-  }
-  return !!state.experimentalToTransformation()?.isIdentityTransformation();
-}
-
 // src/cubing/kpuzzle/KState.ts
 var KState = class {
   constructor(kpuzzle, stateData) {
@@ -202,11 +184,11 @@ var KState = class {
     }
     return new KTransformation(this.kpuzzle, transformationData);
   }
-  experimentalIs3x3x3Solved(options) {
-    if (this.kpuzzle.name() !== "3x3x3") {
-      throw new Error("`KState.experimentalIs3x3x3Solved()` only supports 3x3x3 states.");
+  experimentalIsSolved(options) {
+    if (!this.kpuzzle.definition.experimentalIsStateSolved) {
+      throw new Error("`KState.experimentalIsSolved()` is not supported for this puzzle at the moment.");
     }
-    return experimentalIs3x3x3Solved(this, options);
+    return this.kpuzzle.definition.experimentalIsStateSolved(this, options);
   }
 };
 
@@ -529,611 +511,9 @@ var KPuzzle = class {
 _moveToTransformationDataCache = new WeakMap();
 _cachedCanConvertStateToUniqueTransformation = new WeakMap();
 
-// src/cubing/kpuzzle/3x3x3/3x3x3.kpuzzle.json.ts
-var cube3x3x3KPuzzleDefinition = {
-  name: "3x3x3",
-  orbits: {
-    EDGES: { numPieces: 12, numOrientations: 2 },
-    CORNERS: { numPieces: 8, numOrientations: 3 },
-    CENTERS: { numPieces: 6, numOrientations: 4 }
-  },
-  startStateData: {
-    EDGES: {
-      pieces: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
-      orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-    },
-    CORNERS: {
-      pieces: [0, 1, 2, 3, 4, 5, 6, 7],
-      orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-    },
-    CENTERS: {
-      pieces: [0, 1, 2, 3, 4, 5],
-      orientation: [0, 0, 0, 0, 0, 0]
-    }
-  },
-  moves: {
-    U: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [1, 0, 0, 0, 0, 0]
-      }
-    },
-    y: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 5, 6, 7, 4, 10, 8, 11, 9],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 7, 4, 5, 6],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 2, 3, 4, 1, 5],
-        orientation: [1, 0, 0, 0, 0, 3]
-      }
-    },
-    x: {
-      EDGES: {
-        permutation: [4, 8, 0, 9, 6, 10, 2, 11, 5, 7, 1, 3],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [4, 0, 3, 5, 7, 6, 2, 1],
-        orientation: [2, 1, 2, 1, 1, 2, 1, 2]
-      },
-      CENTERS: {
-        permutation: [2, 1, 5, 3, 0, 4],
-        orientation: [0, 3, 0, 1, 2, 2]
-      }
-    },
-    L: {
-      EDGES: {
-        permutation: [0, 1, 2, 11, 4, 5, 6, 9, 8, 3, 10, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
-        orientation: [0, 0, 2, 1, 0, 2, 1, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 1, 0, 0, 0, 0]
-      }
-    },
-    F: {
-      EDGES: {
-        permutation: [9, 1, 2, 3, 8, 5, 6, 7, 0, 4, 10, 11],
-        orientation: [1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0]
-      },
-      CORNERS: {
-        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 1, 0, 0, 0]
-      }
-    },
-    R: {
-      EDGES: {
-        permutation: [0, 8, 2, 3, 4, 10, 6, 7, 5, 9, 1, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
-        orientation: [2, 1, 0, 0, 1, 0, 0, 2]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 1, 0, 0]
-      }
-    },
-    B: {
-      EDGES: {
-        permutation: [0, 1, 10, 3, 4, 5, 11, 7, 8, 9, 6, 2],
-        orientation: [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1]
-      },
-      CORNERS: {
-        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
-        orientation: [0, 2, 1, 0, 0, 0, 2, 1]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 0, 1, 0]
-      }
-    },
-    D: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 8, 9, 10, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 0, 0, 1]
-      }
-    },
-    z: {
-      EDGES: {
-        permutation: [9, 3, 11, 7, 8, 1, 10, 5, 0, 4, 2, 6],
-        orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [3, 2, 6, 5, 0, 4, 7, 1],
-        orientation: [1, 2, 1, 2, 2, 1, 2, 1]
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 1, 1, 3, 1]
-      }
-    },
-    M: {
-      EDGES: {
-        permutation: [2, 1, 6, 3, 0, 5, 4, 7, 8, 9, 10, 11],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [4, 1, 0, 3, 5, 2],
-        orientation: [2, 0, 0, 0, 2, 0]
-      }
-    },
-    E: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 8, 10],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 4, 1, 2, 3, 5],
-        orientation: [0, 0, 0, 0, 0, 0]
-      }
-    },
-    S: {
-      EDGES: {
-        permutation: [0, 3, 2, 7, 4, 1, 6, 5, 8, 9, 10, 11],
-        orientation: [0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 0, 1, 0, 1]
-      }
-    },
-    u: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 10, 8, 11, 9],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 2, 3, 4, 1, 5],
-        orientation: [1, 0, 0, 0, 0, 0]
-      }
-    },
-    l: {
-      EDGES: {
-        permutation: [2, 1, 6, 11, 0, 5, 4, 9, 8, 3, 10, 7],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
-        orientation: [0, 0, 2, 1, 0, 2, 1, 0]
-      },
-      CENTERS: {
-        permutation: [4, 1, 0, 3, 5, 2],
-        orientation: [2, 1, 0, 0, 2, 0]
-      }
-    },
-    f: {
-      EDGES: {
-        permutation: [9, 3, 2, 7, 8, 1, 6, 5, 0, 4, 10, 11],
-        orientation: [1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0]
-      },
-      CORNERS: {
-        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0]
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 1, 1, 0, 1]
-      }
-    },
-    r: {
-      EDGES: {
-        permutation: [4, 8, 0, 3, 6, 10, 2, 7, 5, 9, 1, 11],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
-        orientation: [2, 1, 0, 0, 1, 0, 0, 2]
-      },
-      CENTERS: {
-        permutation: [2, 1, 5, 3, 0, 4],
-        orientation: [0, 0, 0, 1, 2, 2]
-      }
-    },
-    b: {
-      EDGES: {
-        permutation: [0, 5, 10, 1, 4, 7, 11, 3, 8, 9, 6, 2],
-        orientation: [0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1]
-      },
-      CORNERS: {
-        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
-        orientation: [0, 2, 1, 0, 0, 0, 2, 1]
-      },
-      CENTERS: {
-        permutation: [3, 0, 2, 5, 4, 1],
-        orientation: [3, 3, 0, 3, 1, 3]
-      }
-    },
-    d: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 9, 11, 8, 10],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 4, 1, 2, 3, 5],
-        orientation: [0, 0, 0, 0, 0, 1]
-      }
-    }
-  }
-};
-cube3x3x3KPuzzleDefinition.moves["Uw"] = cube3x3x3KPuzzleDefinition.moves["u"];
-cube3x3x3KPuzzleDefinition.moves["Lw"] = cube3x3x3KPuzzleDefinition.moves["l"];
-cube3x3x3KPuzzleDefinition.moves["Fw"] = cube3x3x3KPuzzleDefinition.moves["f"];
-cube3x3x3KPuzzleDefinition.moves["Rw"] = cube3x3x3KPuzzleDefinition.moves["r"];
-cube3x3x3KPuzzleDefinition.moves["Bw"] = cube3x3x3KPuzzleDefinition.moves["b"];
-cube3x3x3KPuzzleDefinition.moves["Dw"] = cube3x3x3KPuzzleDefinition.moves["d"];
-cube3x3x3KPuzzleDefinition.moves["Rv"] = cube3x3x3KPuzzleDefinition.moves["x"];
-cube3x3x3KPuzzleDefinition.moves["Uv"] = cube3x3x3KPuzzleDefinition.moves["y"];
-cube3x3x3KPuzzleDefinition.moves["Fv"] = cube3x3x3KPuzzleDefinition.moves["z"];
-cube3x3x3KPuzzleDefinition.moves["Lv"] = {
-  EDGES: {
-    permutation: [2, 10, 6, 11, 0, 8, 4, 9, 1, 3, 5, 7],
-    orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-  },
-  CORNERS: {
-    permutation: [1, 7, 6, 2, 0, 3, 5, 4],
-    orientation: [2, 1, 2, 1, 1, 2, 1, 2]
-  },
-  CENTERS: {
-    permutation: [4, 1, 0, 3, 5, 2],
-    orientation: [2, 1, 0, 3, 2, 0]
-  }
-};
-cube3x3x3KPuzzleDefinition.moves["Dv"] = {
-  EDGES: {
-    permutation: [3, 0, 1, 2, 7, 4, 5, 6, 9, 11, 8, 10],
-    orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-  },
-  CORNERS: {
-    permutation: [3, 0, 1, 2, 5, 6, 7, 4],
-    orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-  },
-  CENTERS: {
-    permutation: [0, 4, 1, 2, 3, 5],
-    orientation: [3, 0, 0, 0, 0, 1]
-  }
-};
-cube3x3x3KPuzzleDefinition.moves["Bv"] = {
-  EDGES: {
-    permutation: [8, 5, 10, 1, 9, 7, 11, 3, 4, 0, 6, 2],
-    orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-  },
-  CORNERS: {
-    permutation: [4, 7, 1, 0, 5, 3, 2, 6],
-    orientation: [1, 2, 1, 2, 2, 1, 2, 1]
-  },
-  CENTERS: {
-    permutation: [3, 0, 2, 5, 4, 1],
-    orientation: [3, 3, 3, 3, 1, 3]
-  }
-};
-
-// src/cubing/kpuzzle/index.ts
-var experimental3x3x3KPuzzle = new KPuzzle(cube3x3x3KPuzzleDefinition);
-
-// src/cubing/protocol/binary/orbit-indexing.ts
-function identityPermutation(numElems) {
-  const arr = new Array(numElems);
-  for (let i = 0; i < numElems; i++) {
-    arr[i] = i;
-  }
-  return arr;
-}
-function orientationsToMask(radix, orientations) {
-  let val = 0;
-  for (const orientation of orientations) {
-    val *= radix;
-    val += orientation;
-  }
-  return val;
-}
-function maskToOrientations(radix, numElems, mask) {
-  const arr = [];
-  while (mask > 0) {
-    arr.push(mask % radix);
-    mask = Math.floor(mask / radix);
-  }
-  return new Array(numElems - arr.length).fill(0).concat(arr.reverse());
-}
-function permutationToLex(permutation) {
-  const n = permutation.length;
-  let lexicographicIdx = 0;
-  for (let i = 0; i < n - 1; i++) {
-    lexicographicIdx = lexicographicIdx * (n - i);
-    for (let j = i + 1; j < n; j++) {
-      if (permutation[i] > permutation[j]) {
-        lexicographicIdx += 1;
-      }
-    }
-  }
-  return lexicographicIdx;
-}
-function lexToPermutation(numPieces, lexicographicIdx) {
-  const permutation = new Array(numPieces);
-  permutation[numPieces - 1] = 0;
-  for (let i = numPieces - 2; i >= 0; i--) {
-    permutation[i] = lexicographicIdx % (numPieces - i);
-    lexicographicIdx = Math.floor(lexicographicIdx / (numPieces - i));
-    for (let j = i + 1; j < numPieces; j++) {
-      if (permutation[j] >= permutation[i]) {
-        permutation[j] = permutation[j] + 1;
-      }
-    }
-  }
-  return permutation;
-}
-
-// src/cubing/protocol/binary/puzzle-orientation.ts
-function puzzleOrientationIdx(state) {
-  const idxU = state.stateData["CENTERS"].pieces[0];
-  const idxD = state.stateData["CENTERS"].pieces[5];
-  const unadjustedIdxL = state.stateData["CENTERS"].pieces[1];
-  let idxL = unadjustedIdxL;
-  if (idxU < unadjustedIdxL) {
-    idxL--;
-  }
-  if (idxD < unadjustedIdxL) {
-    idxL--;
-  }
-  return [idxU, idxL];
-}
-var puzzleOrientationCacheRaw = new Array(6).fill(0).map(() => {
-  return new Array(6);
-});
-var puzzleOrientationCacheInitialized = false;
-function puzzleOrientationCache() {
-  if (!puzzleOrientationCacheInitialized) {
-    {
-      const uAlgs = ["", "z", "x", "z'", "x'", "x2"].map((s) => Alg.fromString(s));
-      const yAlg = new Alg("y");
-      for (const uAlg of uAlgs) {
-        let transformation = experimental3x3x3KPuzzle.algToTransformation(uAlg);
-        for (let i = 0; i < 4; i++) {
-          transformation = transformation.applyAlg(yAlg);
-          const [idxU, idxL] = puzzleOrientationIdx(transformation.toKState());
-          puzzleOrientationCacheRaw[idxU][idxL] = transformation.invert();
-        }
-      }
-    }
-  }
-  return puzzleOrientationCacheRaw;
-}
-function normalizePuzzleOrientation(state) {
-  const [idxU, idxL] = puzzleOrientationIdx(state);
-  const orientationTransformation = puzzleOrientationCache()[idxU][idxL];
-  return state.applyTransformation(orientationTransformation);
-}
-function reorientPuzzle(state, idxU, idxL) {
-  return state.applyTransformation(puzzleOrientationCache()[idxU][idxL].invert());
-}
-
-// src/cubing/protocol/binary/binary3x3x3.ts
-var BIT_LENGTHS = [29, 12, 16, 13, 3, 2, 1, 12];
-function arraySum(arr) {
-  let total = 0;
-  for (const entry of arr) {
-    total += entry;
-  }
-  return total;
-}
-function splitBinary(bitLengths, buffy) {
-  const u8buffy = new Uint8Array(buffy);
-  let at = 0;
-  let bits = 0;
-  let accum = 0;
-  const values = [];
-  for (const bitLength of bitLengths) {
-    while (bits < bitLength) {
-      accum = accum << 8 | u8buffy[at++];
-      bits += 8;
-    }
-    values.push(accum >> bits - bitLength & (1 << bitLength) - 1);
-    bits -= bitLength;
-  }
-  return values;
-}
-function concatBinary(bitLengths, values) {
-  const buffy = new Uint8Array(Math.ceil(arraySum(bitLengths) / 8));
-  let at = 0;
-  let bits = 0;
-  let accum = 0;
-  for (let i = 0; i < bitLengths.length; i++) {
-    accum = accum << bitLengths[i] | values[i];
-    bits += bitLengths[i];
-    while (bits >= 8) {
-      buffy[at++] = accum >> bits - 8;
-      bits -= 8;
-    }
-  }
-  if (bits > 0) {
-    buffy[at++] = accum << 8 - bits;
-  }
-  return buffy;
-}
-function supportsPuzzleOrientation(components) {
-  return components.poIdxU !== 7;
-}
-function reid3x3x3ToBinaryComponents(state) {
-  const normedState = normalizePuzzleOrientation(state);
-  const epLex = permutationToLex(normedState.stateData["EDGES"].pieces);
-  const eoMask = orientationsToMask(2, normedState.stateData["EDGES"].orientation);
-  const cpLex = permutationToLex(normedState.stateData["CORNERS"].pieces);
-  const coMask = orientationsToMask(3, normedState.stateData["CORNERS"].orientation);
-  const [poIdxU, poIdxL] = puzzleOrientationIdx(state);
-  const moSupport = 1;
-  const moMask = orientationsToMask(4, normedState.stateData["CENTERS"].orientation);
-  return {
-    epLex,
-    eoMask,
-    cpLex,
-    coMask,
-    poIdxU,
-    poIdxL,
-    moSupport,
-    moMask
-  };
-}
-function binaryComponentsToTwizzleBinary(components) {
-  const { epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask } = components;
-  return concatBinary(BIT_LENGTHS, [
-    epLex,
-    eoMask,
-    cpLex,
-    coMask,
-    poIdxU,
-    poIdxL,
-    moSupport,
-    moMask
-  ]);
-}
-function reid3x3x3ToTwizzleBinary(state) {
-  const components = reid3x3x3ToBinaryComponents(state);
-  return binaryComponentsToTwizzleBinary(components);
-}
-function twizzleBinaryToBinaryComponents(buffer) {
-  const [epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask] = splitBinary(BIT_LENGTHS, buffer);
-  return {
-    epLex,
-    eoMask,
-    cpLex,
-    coMask,
-    poIdxU,
-    poIdxL,
-    moSupport,
-    moMask
-  };
-}
-function binaryComponentsToReid3x3x3(components) {
-  if (components.moSupport !== 1) {
-    throw new Error("Must support center orientation.");
-  }
-  const normedState = new KState(experimental3x3x3KPuzzle, {
-    EDGES: {
-      pieces: lexToPermutation(12, components.epLex),
-      orientation: maskToOrientations(2, 12, components.eoMask)
-    },
-    CORNERS: {
-      pieces: lexToPermutation(8, components.cpLex),
-      orientation: maskToOrientations(3, 8, components.coMask)
-    },
-    CENTERS: {
-      pieces: identityPermutation(6),
-      orientation: maskToOrientations(4, 6, components.moMask)
-    }
-  });
-  if (!supportsPuzzleOrientation(components)) {
-    return normedState;
-  }
-  return reorientPuzzle(normedState, components.poIdxU, components.poIdxL);
-}
-function validateComponents(components) {
-  const errors = [];
-  if (components.epLex < 0 || components.epLex >= 479001600) {
-    errors.push(`epLex (${components.epLex}) out of range`);
-  }
-  if (components.cpLex < 0 || components.cpLex >= 40320) {
-    errors.push(`cpLex (${components.cpLex}) out of range`);
-  }
-  if (components.coMask < 0 || components.coMask >= 6561) {
-    errors.push(`coMask (${components.coMask}) out of range`);
-  }
-  if (components.poIdxU < 0 || components.poIdxU >= 6) {
-    if (supportsPuzzleOrientation(components)) {
-      errors.push(`poIdxU (${components.poIdxU}) out of range`);
-    }
-  }
-  if (components.eoMask < 0 || components.eoMask >= 4096) {
-    errors.push(`eoMask (${components.eoMask}) out of range`);
-  }
-  if (components.moMask < 0 || components.moMask >= 4096) {
-    errors.push(`moMask (${components.moMask}) out of range`);
-  }
-  if (components.poIdxL < 0 || components.poIdxL >= 4) {
-    errors.push(`poIdxL (${components.poIdxL}) out of range`);
-  }
-  if (components.moSupport < 0 || components.moSupport >= 2) {
-    errors.push(`moSupport (${components.moSupport}) out of range`);
-  }
-  return errors;
-}
-function twizzleBinaryToReid3x3x3(buffy) {
-  const components = twizzleBinaryToBinaryComponents(buffy);
-  const errors = validateComponents(components);
-  if (errors.length !== 0) {
-    throw new Error(`Invalid binary state components: ${errors.join(", ")}`);
-  }
-  return binaryComponentsToReid3x3x3(components);
-}
-
-// src/cubing/protocol/binary/hex.ts
-function bufferToSpacedHex(buffer) {
-  return Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join(" ");
-}
-function spacedHexToBuffer(hex) {
-  return new Uint8Array(hex.split(" ").map((c) => parseInt(c, 16)));
-}
-
 export {
-  normalizePuzzleOrientation,
-  reid3x3x3ToTwizzleBinary,
-  twizzleBinaryToBinaryComponents,
-  binaryComponentsToReid3x3x3,
-  twizzleBinaryToReid3x3x3,
-  bufferToSpacedHex,
-  spacedHexToBuffer,
   KState,
   KTransformation,
-  KPuzzle,
-  experimental3x3x3KPuzzle
+  KPuzzle
 };
-//# sourceMappingURL=chunk-HD2CMNE4.js.map
+//# sourceMappingURL=chunk-GNKVWDWW.js.map