cubing 0.26.3 → 0.26.6

package/dist/esm/chunk-VCOUFQGJ.js

@@ -0,0 +1,240 @@
+import {
+  experimental3x3x3KPuzzle,
+  normalize3x3x3Orientation,
+  puzzleOrientation3x3x3Cache,
+  puzzleOrientation3x3x3Idx
+} from "./chunk-VFDAQ42O.js";
+import {
+  KState
+} from "./chunk-GNKVWDWW.js";
+
+// 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/binary3x3x3.ts
+function reorientPuzzle(state, idxU, idxL) {
+  return state.applyTransformation(puzzleOrientation3x3x3Cache()[idxU][idxL].invert());
+}
+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 = normalize3x3x3Orientation(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] = puzzleOrientation3x3x3Idx(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 {
+  reid3x3x3ToTwizzleBinary,
+  twizzleBinaryToBinaryComponents,
+  binaryComponentsToReid3x3x3,
+  twizzleBinaryToReid3x3x3,
+  bufferToSpacedHex,
+  spacedHexToBuffer
+};
+//# sourceMappingURL=chunk-VCOUFQGJ.js.map

package/dist/esm/chunk-VCOUFQGJ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/protocol/binary/orbit-indexing.ts", "../../src/cubing/protocol/binary/binary3x3x3.ts", "../../src/cubing/protocol/binary/hex.ts"],
+  "sourcesContent": ["export function identityPermutation(numElems: number): number[] {\n  const arr = new Array<number>(numElems);\n  for (let i = 0; i < numElems; i++) {\n    arr[i] = i;\n  }\n  return arr;\n}\n\n// Inclusive start, exclusive end (similar to `Array.prototype.slice`)\nexport function orientationsToMask(\n  radix: number,\n  orientations: number[],\n): number {\n  let val = 0;\n  for (const orientation of orientations) {\n    val *= radix;\n    val += orientation;\n  }\n  return val;\n}\n\n// Inclusive start, exclusive end (similar to `Array.prototype.slice`)\nexport function maskToOrientations(\n  radix: number,\n  numElems: number,\n  mask: number,\n): number[] {\n  const arr = [];\n  while (mask > 0) {\n    arr.push(mask % radix);\n    mask = Math.floor(mask / radix);\n  }\n  return new Array<number>(numElems - arr.length).fill(0).concat(arr.reverse());\n}\n\n// From https://www.jaapsch.net/puzzles/compindx.htm#perm\nexport function permutationToLex(permutation: number[]): number {\n  const n = permutation.length;\n  let lexicographicIdx = 0;\n  for (let i = 0; i < n - 1; i++) {\n    lexicographicIdx = lexicographicIdx * (n - i);\n    for (let j = i + 1; j < n; j++) {\n      if (permutation[i] > permutation[j]) {\n        lexicographicIdx += 1;\n      }\n    }\n  }\n  return lexicographicIdx;\n}\n\n// From https://www.jaapsch.net/puzzles/compindx.htm#perm\nexport function lexToPermutation(\n  numPieces: number,\n  lexicographicIdx: number,\n): number[] {\n  const permutation: number[] = new Array(numPieces);\n  permutation[numPieces - 1] = 0;\n  for (let i = numPieces - 2; i >= 0; i--) {\n    permutation[i] = lexicographicIdx % (numPieces - i);\n    lexicographicIdx = Math.floor(lexicographicIdx / (numPieces - i));\n    for (let j = i + 1; j < numPieces; j++) {\n      if (permutation[j] >= permutation[i]) {\n        permutation[j] = permutation[j] + 1;\n      }\n    }\n  }\n  return permutation;\n}\n", "import { KState } from \"../../kpuzzle\";\nimport {\n  experimental3x3x3KPuzzle,\n  experimentalNormalize3x3x3Orientation,\n  experimentalPuzzleOrientation3x3x3Cache,\n  experimentalPuzzleOrientation3x3x3Idx,\n} from \"../../puzzles/cubing-private\";\nimport {\n  identityPermutation,\n  lexToPermutation,\n  maskToOrientations,\n  orientationsToMask,\n  permutationToLex,\n} from \"./orbit-indexing\";\n\n// TODO: combine with `orientPuzzle`?\nexport function reorientPuzzle(\n  state: KState,\n  idxU: number,\n  idxL: number,\n): KState {\n  return state.applyTransformation(\n    experimentalPuzzleOrientation3x3x3Cache()[idxU][idxL].invert(),\n  );\n}\n\ntype Binary3x3x3State = ArrayBuffer;\n\n// Bit lengths of the encoded components, in order.\nconst BIT_LENGTHS = [29, 12, 16, 13, 3, 2, 1, 12];\n\n// These fields are sorted by the order in which they appear in the binary format.\nexport interface Binary3x3x3Components {\n  epLex: number; // 29 bits, edge permutation\n  eoMask: number; // 12 bits, edge orientation\n  cpLex: number; // 16 bits, corner permutation\n  coMask: number; // 13 bits, corner orientation\n  poIdxU: number; // 3 bits, puzzle orientation (U face)\n  poIdxL: number; // 2 bits, puzzle orientation (L face)\n  moSupport: number; // 1 bit, center orientation support\n  moMask: number; // 12 bits, center orientation\n}\n\n// There are various clever ways to do this, but this is simple and efficient.\nfunction arraySum(arr: number[]): number {\n  let total = 0;\n  for (const entry of arr) {\n    total += entry;\n  }\n  return total;\n}\n\n// Due to limitations in JS bit operations, this is unsafe if any of the bit lengths span across the contents of more than 4 bytes.\n// - Safe: [8, 32]\n// - Unsafe: [4, 32, 4]\n// - Unsafe: [40, 4]\nfunction splitBinary(bitLengths: number[], buffy: ArrayBuffer): number[] {\n  const u8buffy = new Uint8Array(buffy);\n  let at = 0;\n  let bits = 0;\n  let accum = 0;\n  const values: number[] = [];\n  for (const bitLength of bitLengths) {\n    while (bits < bitLength) {\n      accum = (accum << 8) | u8buffy[at++];\n      bits += 8;\n    }\n    values.push((accum >> (bits - bitLength)) & ((1 << bitLength) - 1));\n    bits -= bitLength;\n  }\n  return values;\n}\n\n// See above for safety notes.\nfunction concatBinary(bitLengths: number[], values: number[]): ArrayBuffer {\n  const buffy = new Uint8Array(Math.ceil(arraySum(bitLengths) / 8));\n  let at = 0;\n  let bits = 0;\n  let accum = 0;\n  for (let i = 0; i < bitLengths.length; i++) {\n    accum = (accum << bitLengths[i]) | values[i];\n    bits += bitLengths[i];\n    while (bits >= 8) {\n      buffy[at++] = accum >> (bits - 8);\n      bits -= 8;\n    }\n  }\n  if (bits > 0) {\n    buffy[at++] = accum << (8 - bits);\n  }\n  return buffy;\n}\n\n// 0x111 (for idxU) means \"not supported\"\nfunction supportsPuzzleOrientation(components: Binary3x3x3Components): boolean {\n  return components.poIdxU !== 7;\n}\n\nexport function reid3x3x3ToBinaryComponents(\n  state: KState,\n): Binary3x3x3Components {\n  const normedState = experimentalNormalize3x3x3Orientation(state);\n\n  const epLex = permutationToLex(normedState.stateData[\"EDGES\"].pieces);\n  const eoMask = orientationsToMask(\n    2,\n    normedState.stateData[\"EDGES\"].orientation,\n  );\n  const cpLex = permutationToLex(normedState.stateData[\"CORNERS\"].pieces);\n  const coMask = orientationsToMask(\n    3,\n    normedState.stateData[\"CORNERS\"].orientation,\n  );\n  const [poIdxU, poIdxL] = experimentalPuzzleOrientation3x3x3Idx(state);\n  const moSupport = 1; // Required for now.\n  const moMask = orientationsToMask(\n    4,\n    normedState.stateData[\"CENTERS\"].orientation,\n  );\n\n  return {\n    epLex,\n    eoMask,\n    cpLex,\n    coMask,\n    poIdxU,\n    poIdxL,\n    moSupport,\n    moMask,\n  };\n}\n\nexport function binaryComponentsToTwizzleBinary(\n  components: Binary3x3x3Components,\n): Binary3x3x3State {\n  const { epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask } =\n    components;\n\n  return concatBinary(BIT_LENGTHS, [\n    epLex,\n    eoMask,\n    cpLex,\n    coMask,\n    poIdxU,\n    poIdxL,\n    moSupport,\n    moMask,\n  ]);\n}\n\nexport function reid3x3x3ToTwizzleBinary(state: KState): Binary3x3x3State {\n  const components: Binary3x3x3Components = reid3x3x3ToBinaryComponents(state);\n  return binaryComponentsToTwizzleBinary(components);\n}\n\nexport function twizzleBinaryToBinaryComponents(\n  buffer: ArrayBuffer,\n): Binary3x3x3Components {\n  const [epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask] =\n    splitBinary(BIT_LENGTHS, buffer);\n\n  return {\n    epLex,\n    eoMask,\n    cpLex,\n    coMask,\n    poIdxU,\n    poIdxL,\n    moSupport,\n    moMask,\n  };\n}\n\nexport function binaryComponentsToReid3x3x3(\n  components: Binary3x3x3Components,\n): KState {\n  if (components.moSupport !== 1) {\n    throw new Error(\"Must support center orientation.\");\n  }\n\n  const normedState = new KState(experimental3x3x3KPuzzle, {\n    EDGES: {\n      pieces: lexToPermutation(12, components.epLex),\n      orientation: maskToOrientations(2, 12, components.eoMask),\n    },\n    CORNERS: {\n      pieces: lexToPermutation(8, components.cpLex),\n      orientation: maskToOrientations(3, 8, components.coMask),\n    },\n    CENTERS: {\n      pieces: identityPermutation(6),\n      orientation: maskToOrientations(4, 6, components.moMask),\n    },\n  });\n\n  if (!supportsPuzzleOrientation(components)) {\n    return normedState;\n  }\n\n  return reorientPuzzle(normedState, components.poIdxU, components.poIdxL);\n}\n\n// Returns a list of error string.\n// An empty list means validation success.\nfunction validateComponents(components: Binary3x3x3Components): string[] {\n  const errors = [];\n  if (components.epLex < 0 || components.epLex >= 479001600) {\n    errors.push(`epLex (${components.epLex}) out of range`);\n  }\n  if (components.cpLex < 0 || components.cpLex >= 40320) {\n    errors.push(`cpLex (${components.cpLex}) out of range`);\n  }\n  if (components.coMask < 0 || components.coMask >= 6561) {\n    errors.push(`coMask (${components.coMask}) out of range`);\n  }\n  if (components.poIdxU < 0 || components.poIdxU >= 6) {\n    // 0x111 (for idxU) means \"not supported\"\n    if (supportsPuzzleOrientation(components)) {\n      errors.push(`poIdxU (${components.poIdxU}) out of range`);\n    }\n  }\n  // The following cannot be (f decoded from binary properl) out of rangey.\n  if (components.eoMask < 0 || components.eoMask >= 4096) {\n    errors.push(`eoMask (${components.eoMask}) out of range`);\n  }\n  if (components.moMask < 0 || components.moMask >= 4096) {\n    errors.push(`moMask (${components.moMask}) out of range`);\n  }\n  if (components.poIdxL < 0 || components.poIdxL >= 4) {\n    errors.push(`poIdxL (${components.poIdxL}) out of range`);\n  }\n  if (components.moSupport < 0 || components.moSupport >= 2) {\n    errors.push(`moSupport (${components.moSupport}) out of range`);\n  }\n  return errors;\n}\n\nexport function twizzleBinaryToReid3x3x3(buffy: ArrayBuffer): KState {\n  const components = twizzleBinaryToBinaryComponents(buffy);\n  const errors = validateComponents(components);\n  if (errors.length !== 0) {\n    throw new Error(`Invalid binary state components: ${errors.join(\", \")}`);\n  }\n  return binaryComponentsToReid3x3x3(components);\n}\n", "export function bufferToSpacedHex(buffer: ArrayBuffer): string {\n  // buffer is an ArrayBuffer\n  return (\n    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>\n      (\"00\" + x.toString(16)).slice(-2),\n    ) as string[]\n  ).join(\" \");\n}\n\nexport function spacedHexToBuffer(hex: string): Uint8Array {\n  return new Uint8Array(hex.split(\" \").map((c) => parseInt(c, 16)));\n}\n"],
+  "mappings": "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",
+  "names": []
+}