cubing 0.22.0 → 0.24.0-pre2

package/dist/esm/chunk-37EHU3GZ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/vendor/random-uint-below/get-random-values.ts", "../../src/cubing/vendor/random-uint-below/random53BitValue.ts", "../../src/cubing/vendor/random-uint-below/random-choice.ts", "../../src/cubing/vendor/random-uint-below/index.ts"],
+  "sourcesContent": ["export type GetRandomValuesFunction = (arr: Uint32Array) => void;\n\n// This is a workaround for a `node` segfault.\n// In theory, imports are cached and safe to import multiple times: https://nodejs.org/api/esm.html#esm_urls\n// In practice, a rapid series of inline imports inside a worker causes a segfault(!) in `node`.\n// So we cache a single import reference. We avoid populating it until we first need it, so that we don't attempt to perform the import in environments that don't need or have it (e.g. browsers, `deno`).\nlet cryptoPromise: Promise<typeof import(\"crypto\")> | null = null;\n\n// `@types/node` is... lacking. This type may cause an error in the future, at which point we can hopefully use `@types/node` directly.\ntype NodeWebCrypto = typeof import(\"crypto\").webcrypto & {\n  getRandomValues: GetRandomValuesFunction;\n};\n\n// We could use top-level await to define this more statically, but that has limited transpilation support.\nexport async function getRandomValuesFactory(): Promise<GetRandomValuesFunction> {\n  if (!globalThis?.crypto?.getRandomValues) {\n    const nodeWebcrypto = (await (cryptoPromise ??= import(\"crypto\")))\n      .webcrypto as NodeWebCrypto;\n    return nodeWebcrypto.getRandomValues;\n  } else {\n    return crypto.getRandomValues.bind(crypto) as GetRandomValuesFunction;\n  }\n}\n", "import {\n  getRandomValuesFactory,\n  GetRandomValuesFunction,\n} from \"./get-random-values\";\n\n/*\n * randomInt.below(max) returns a random non-negative integer less than max (0 <= output < max).\n * `max` must be at most 2^53.\n */\n\nconst MAX_JS_PRECISE_INT = 9007199254740992;\n\nconst UPPER_HALF_MULTIPLIER = 2097152; // 2^21. We have to use multiplication because bit shifts truncate to 32 bits.\nconst LOWER_HALF_DIVIDER = 2048;\n\nfunction random53BitValue(getRandomValues: GetRandomValuesFunction): number {\n  // Construct a random 53-bit value from a 32-bit upper half and a 21-bit lower half.\n  const arr = new Uint32Array(2);\n  getRandomValues(arr);\n  const upper = arr[0];\n  const lower = arr[1];\n  return (\n    Math.floor(upper * UPPER_HALF_MULTIPLIER) +\n    Math.floor(lower / LOWER_HALF_DIVIDER)\n  );\n}\n\nfunction validateMax(max: number): void {\n  if (typeof max !== \"number\" || max < 0 || Math.floor(max) !== max) {\n    throw new Error(\n      \"randomInt.below() not called with a positive integer value.\",\n    );\n  }\n  if (max > MAX_JS_PRECISE_INT) {\n    throw new Error(\n      `Called randomInt.below() with max == ${max}, which is larger than JavaScript can handle with integer precision.`,\n    );\n  }\n}\n\n// TODO: cache generated `randomUIntBelow`?\nexport async function randomUIntBelowFactory(): Promise<\n  (max: number) => number\n> {\n  const getRandomValues = await getRandomValuesFactory();\n  const randomUIntBelow = (max: number): number => {\n    validateMax(max);\n\n    const val = random53BitValue(getRandomValues);\n    const maxUniformSamplingRange = Math.floor(MAX_JS_PRECISE_INT / max) * max;\n\n    // Rejection sampling:\n    if (val < maxUniformSamplingRange) {\n      return val % max;\n    } else {\n      // val % max would produce a biased result. This bias an be very bad if `max` is on the order of MAX_JS_PRECISE_INT. We have to try again, so just call ourselves recursively.\n      // For some values of `max` just above 9007199254740992 / 2, this happens about once on average. For other values of `max`, it's less than that (and for small values of `max` it's extremely unlikely).\n\n      // TODO: Use more bits of accuracy instead of rejection sampling to avoid DoS.\n      return randomUIntBelow(max);\n    }\n  };\n  return randomUIntBelow;\n}\n", "import { randomUIntBelowFactory } from \"./random53BitValue\";\n\n// Inspired by https://reference.wolfram.com/language/ref/RandomChoice.html\n// This library itself should be kept small, but a wrapper library may want to implement selecting multiple element without replacement as with replacement:\n// https://reference.wolfram.com/language/ref/RandomSample.html\nexport async function randomChoiceFactory<T>(): Promise<(arr: Array<T>) => T> {\n  const randomUIntBelow = await randomUIntBelowFactory();\n  return (arr: Array<T>): T => arr[randomUIntBelow(arr.length)];\n}\n", "export { randomChoiceFactory } from \"./random-choice\";\nexport { randomUIntBelowFactory } from \"./random53BitValue\";\n\n// TODO: reuse factory properly, move this to a separate file, add to impl.\nimport { randomUIntBelowFactory } from \"./random53BitValue\";\nconst randomUIntBelowPromise = randomUIntBelowFactory();\nexport async function randomPermute<T>(list: T[]): Promise<void> {\n  for (let i = 1; i < list.length; i++) {\n    const j = (await randomUIntBelowPromise)(i);\n    [list[i], list[j]] = [list[j], list[i]];\n  }\n}\n"],
+  "mappings": ";AAMA,IAAI,gBAAyD;AAQ7D,wCAAiF;AAC/E,MAAI,CAAC,YAAY,QAAQ,iBAAiB;AACxC,UAAM,gBAAiB,OAAO,mCAAkB,OAAO,aACpD;AACH,WAAO,cAAc;AAAA,SAChB;AACL,WAAO,OAAO,gBAAgB,KAAK;AAAA;AAAA;;;ACVvC,IAAM,qBAAqB;AAE3B,IAAM,wBAAwB;AAC9B,IAAM,qBAAqB;AAE3B,0BAA0B,iBAAkD;AAE1E,QAAM,MAAM,IAAI,YAAY;AAC5B,kBAAgB;AAChB,QAAM,QAAQ,IAAI;AAClB,QAAM,QAAQ,IAAI;AAClB,SACE,KAAK,MAAM,QAAQ,yBACnB,KAAK,MAAM,QAAQ;AAAA;AAIvB,qBAAqB,KAAmB;AACtC,MAAI,OAAO,QAAQ,YAAY,MAAM,KAAK,KAAK,MAAM,SAAS,KAAK;AACjE,UAAM,IAAI,MACR;AAAA;AAGJ,MAAI,MAAM,oBAAoB;AAC5B,UAAM,IAAI,MACR,wCAAwC;AAAA;AAAA;AAM9C,wCAEE;AACA,QAAM,kBAAkB,MAAM;AAC9B,QAAM,kBAAkB,CAAC,QAAwB;AAC/C,gBAAY;AAEZ,UAAM,MAAM,iBAAiB;AAC7B,UAAM,0BAA0B,KAAK,MAAM,qBAAqB,OAAO;AAGvE,QAAI,MAAM,yBAAyB;AACjC,aAAO,MAAM;AAAA,WACR;AAKL,aAAO,gBAAgB;AAAA;AAAA;AAG3B,SAAO;AAAA;;;ACzDT,qCAA8E;AAC5E,QAAM,kBAAkB,MAAM;AAC9B,SAAO,CAAC,QAAqB,IAAI,gBAAgB,IAAI;AAAA;;;ACFvD,IAAM,yBAAyB;AAC/B,6BAAuC,MAA0B;AAC/D,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,IAAK,OAAM,wBAAwB;AACzC,KAAC,KAAK,IAAI,KAAK,MAAM,CAAC,KAAK,IAAI,KAAK;AAAA;AAAA;",
+  "names": []
+}

package/dist/esm/chunk-7OPCF2OL.js

@@ -0,0 +1,274 @@
+import {
+  KState,
+  experimental3x3x3KPuzzle
+} from "./chunk-TNRZDNGH.js";
+import {
+  Alg
+} from "./chunk-EWRBHQFX.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/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 puzzleOrientationCache = new Array(6).fill(0).map(() => {
+  return new Array(6);
+});
+{
+  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());
+      puzzleOrientationCache[idxU][idxL] = transformation.invert();
+    }
+  }
+}
+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
+};
+//# sourceMappingURL=chunk-7OPCF2OL.js.map

package/dist/esm/chunk-7OPCF2OL.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/protocol/binary/orbit-indexing.ts", "../../src/cubing/protocol/binary/puzzle-orientation.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 { Alg } from \"../../alg\";\nimport { experimental3x3x3KPuzzle, KTransformation } from \"../../kpuzzle\";\nimport type { KState } from \"../../kpuzzle/KState\";\n\nexport function puzzleOrientationIdx(state: KState): [number, number] {\n  const idxU = state.stateData[\"CENTERS\"].pieces[0];\n  const idxD = state.stateData[\"CENTERS\"].pieces[5];\n  const unadjustedIdxL = state.stateData[\"CENTERS\"].pieces[1];\n  let idxL = unadjustedIdxL;\n  if (idxU < unadjustedIdxL) {\n    idxL--;\n  }\n  if (idxD < unadjustedIdxL) {\n    idxL--;\n  }\n  return [idxU, idxL];\n}\n\nconst puzzleOrientationCache: KTransformation[][] = new Array(6)\n  .fill(0)\n  .map(() => {\n    return new Array<KTransformation>(6);\n  });\n\n// We use a new block to avoid keeping a reference to temporary vars.\n// kpuzzle todo\n{\n  const uAlgs: Alg[] = [\"\", \"z\", \"x\", \"z'\", \"x'\", \"x2\"].map((s) =>\n    Alg.fromString(s),\n  );\n  const yAlg = new Alg(\"y\");\n  for (const uAlg of uAlgs) {\n    let transformation = experimental3x3x3KPuzzle.algToTransformation(uAlg);\n    for (let i = 0; i < 4; i++) {\n      transformation = transformation.applyAlg(yAlg);\n      const [idxU, idxL] = puzzleOrientationIdx(transformation.toKState());\n      puzzleOrientationCache[idxU][idxL] = transformation.invert();\n    }\n  }\n}\n\nexport function normalizePuzzleOrientation(state: KState): KState {\n  const [idxU, idxL] = puzzleOrientationIdx(state);\n  const orientationTransformation = puzzleOrientationCache[idxU][idxL];\n  return state.applyTransformation(orientationTransformation);\n}\n\n// TODO: combine with `orientPuzzle`?\nexport function reorientPuzzle(\n  state: KState,\n  idxU: number,\n  idxL: number,\n): KState {\n  return state.applyTransformation(puzzleOrientationCache[idxU][idxL].invert());\n}\n", "import { experimental3x3x3KPuzzle, KState } from \"../../kpuzzle\";\nimport {\n  identityPermutation,\n  lexToPermutation,\n  maskToOrientations,\n  orientationsToMask,\n  permutationToLex,\n} from \"./orbit-indexing\";\nimport {\n  normalizePuzzleOrientation,\n  puzzleOrientationIdx,\n  reorientPuzzle,\n} from \"./puzzle-orientation\";\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 = normalizePuzzleOrientation(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] = puzzleOrientationIdx(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": []
+}

package/dist/esm/chunk-BJIOROQC.js

@@ -0,0 +1,18 @@
+// src/cubing/vendor/comlink-everywhere/inside/index.js
+import { expose as comlinkExpose } from "comlink";
+var useNodeWorkarounds = typeof globalThis.Worker === "undefined" && typeof globalThis.WorkerNavigator === "undefined";
+function expose(api) {
+  if (useNodeWorkarounds) {
+    (async () => {
+      const { port } = await import("./node-SP4L2AKI.js");
+      comlinkExpose(api, await port());
+    })();
+  } else {
+    comlinkExpose(api);
+  }
+}
+
+export {
+  expose
+};
+//# sourceMappingURL=chunk-BJIOROQC.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/vendor/comlink-everywhere/inside/index.js"],
+  "sourcesContent": ["import { expose as comlinkExpose } from \"comlink\";\n\nconst useNodeWorkarounds =\n  typeof globalThis.Worker === \"undefined\" &&\n  typeof globalThis.WorkerNavigator === \"undefined\";\n\nexport function expose(api) {\n  if (useNodeWorkarounds) {\n    (async () => {\n      const { port } = await import(\"./node.js\");\n      comlinkExpose(api, await port());\n    })();\n  } else {\n    comlinkExpose(api);\n  }\n}\n"],
+  "mappings": ";AAAA;AAEA,IAAM,qBACJ,OAAO,WAAW,WAAW,eAC7B,OAAO,WAAW,oBAAoB;AAEjC,gBAAgB,KAAK;AAC1B,MAAI,oBAAoB;AACtB,IAAC,aAAY;AACX,YAAM,EAAE,SAAS,MAAM,OAAO;AAC9B,oBAAc,KAAK,MAAM;AAAA;AAAA,SAEtB;AACL,kBAAc;AAAA;AAAA;",
+  "names": []
+}