cubing 0.23.0 → 0.24.0-pre1

package/dist/esm/chunk-X6JHXPDX.js

@@ -1,2359 +0,0 @@
-import {
-  Alg,
-  Move
-} 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/kpuzzle/transformations.ts
-var lasto;
-function isIdentity(omod, o) {
-  if (o === lasto) {
-    return true;
-  }
-  const perm = o.permutation;
-  const n = perm.length;
-  for (let idx = 0; idx < n; idx++) {
-    if (perm[idx] !== idx) {
-      return false;
-    }
-  }
-  if (omod > 1) {
-    const ori = o.orientation;
-    for (let idx = 0; idx < n; idx++) {
-      if (ori[idx] !== 0) {
-        return false;
-      }
-    }
-  }
-  lasto = o;
-  return true;
-}
-function combineTransformations(def, t1, t2) {
-  const newTrans = {};
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o1 = t1[orbitName];
-    const o2 = t2[orbitName];
-    if (isIdentity(oDef.orientations, o2)) {
-      newTrans[orbitName] = o1;
-    } else if (isIdentity(oDef.orientations, o1)) {
-      newTrans[orbitName] = o2;
-    } else {
-      const newPerm = new Array(oDef.numPieces);
-      if (oDef.orientations === 1) {
-        for (let idx = 0; idx < oDef.numPieces; idx++) {
-          newPerm[idx] = o1.permutation[o2.permutation[idx]];
-        }
-        newTrans[orbitName] = {
-          permutation: newPerm,
-          orientation: o1.orientation
-        };
-      } else {
-        const newOri = new Array(oDef.numPieces);
-        for (let idx = 0; idx < oDef.numPieces; idx++) {
-          newOri[idx] = (o1.orientation[o2.permutation[idx]] + o2.orientation[idx]) % oDef.orientations;
-          newPerm[idx] = o1.permutation[o2.permutation[idx]];
-        }
-        newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
-      }
-    }
-  }
-  return newTrans;
-}
-function multiplyTransformations(def, t, amount) {
-  if (amount < 0) {
-    return multiplyTransformations(def, invertTransformation(def, t), -amount);
-  }
-  if (amount === 0) {
-    return identityTransformation(def);
-  }
-  if (amount === 1) {
-    return t;
-  }
-  let halfish = t;
-  if (amount !== 2) {
-    halfish = multiplyTransformations(def, t, Math.floor(amount / 2));
-  }
-  const twiceHalfish = combineTransformations(def, halfish, halfish);
-  if (amount % 2 === 0) {
-    return twiceHalfish;
-  } else {
-    return combineTransformations(def, t, twiceHalfish);
-  }
-}
-function identityTransformation(definition) {
-  const transformation = {};
-  for (const orbitName in definition.orbits) {
-    const orbitDefinition = definition.orbits[orbitName];
-    if (!lasto || lasto.permutation.length !== orbitDefinition.numPieces) {
-      const newPermutation = new Array(orbitDefinition.numPieces);
-      const newOrientation = new Array(orbitDefinition.numPieces);
-      for (let i = 0; i < orbitDefinition.numPieces; i++) {
-        newPermutation[i] = i;
-        newOrientation[i] = 0;
-      }
-      const orbitTransformation = {
-        permutation: newPermutation,
-        orientation: newOrientation
-      };
-      lasto = orbitTransformation;
-    }
-    transformation[orbitName] = lasto;
-  }
-  return transformation;
-}
-function invertTransformation(def, t) {
-  const newTrans = {};
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o = t[orbitName];
-    if (isIdentity(oDef.orientations, o)) {
-      newTrans[orbitName] = o;
-    } else if (oDef.orientations === 1) {
-      const newPerm = new Array(oDef.numPieces);
-      for (let idx = 0; idx < oDef.numPieces; idx++) {
-        newPerm[o.permutation[idx]] = idx;
-      }
-      newTrans[orbitName] = {
-        permutation: newPerm,
-        orientation: o.orientation
-      };
-    } else {
-      const newPerm = new Array(oDef.numPieces);
-      const newOri = new Array(oDef.numPieces);
-      for (let idx = 0; idx < oDef.numPieces; idx++) {
-        const fromIdx = o.permutation[idx];
-        newPerm[fromIdx] = idx;
-        newOri[fromIdx] = (oDef.orientations - o.orientation[idx] + oDef.orientations) % oDef.orientations;
-      }
-      newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
-    }
-  }
-  return newTrans;
-}
-function gcd(a, b) {
-  if (b) {
-    return gcd(b, a % b);
-  }
-  return a;
-}
-function transformationOrder(def, t) {
-  let r = 1;
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o = t[orbitName];
-    const d = new Array(oDef.numPieces);
-    for (let idx = 0; idx < oDef.numPieces; idx++) {
-      if (!d[idx]) {
-        let w = idx;
-        let om = 0;
-        let pm = 0;
-        for (; ; ) {
-          d[w] = true;
-          om = om + o.orientation[w];
-          pm = pm + 1;
-          w = o.permutation[w];
-          if (w === idx) {
-            break;
-          }
-        }
-        if (om !== 0) {
-          pm = pm * oDef.orientations / gcd(oDef.orientations, om);
-        }
-        r = r * pm / gcd(r, pm);
-      }
-    }
-  }
-  return r;
-}
-function areOrbitTransformationsEquivalent(def, orbitName, t1, t2, options = {}) {
-  const oDef = def.orbits[orbitName];
-  const o1 = t1[orbitName];
-  const o2 = t2[orbitName];
-  for (let idx = 0; idx < oDef.numPieces; idx++) {
-    if (!options?.ignoreOrientation && o1.orientation[idx] !== o2.orientation[idx]) {
-      return false;
-    }
-    if (!options?.ignorePermutation && o1.permutation[idx] !== o2.permutation[idx]) {
-      return false;
-    }
-  }
-  return true;
-}
-function areTransformationsEquivalent(def, t1, t2) {
-  for (const orbitName in def.orbits) {
-    if (!areOrbitTransformationsEquivalent(def, orbitName, t1, t2)) {
-      return false;
-    }
-  }
-  return true;
-}
-function areStatesEquivalent(def, t1, t2) {
-  return areTransformationsEquivalent(def, combineTransformations(def, def.startPieces, t1), combineTransformations(def, def.startPieces, t2));
-}
-
-// src/cubing/kpuzzle/kpuzzle.ts
-function transformationForQuantumMove(def, quantumMove) {
-  const transformation = getNotationLayer(def).lookupMove(new Move(quantumMove));
-  if (!transformation) {
-    throw new Error("Unknown move: " + quantumMove.toString());
-  }
-  return transformation;
-}
-function transformationForMove(def, move) {
-  const transformation = getNotationLayer(def).lookupMove(move);
-  if (!transformation) {
-    throw new Error("Unknown move: " + move.toString());
-  }
-  return transformation;
-}
-function getNotationLayer(def) {
-  if (!def.moveNotation) {
-    def.moveNotation = new KPuzzleMoveNotation(def);
-  }
-  return def.moveNotation;
-}
-var KPuzzleMoveNotation = class {
-  constructor(def) {
-    this.def = def;
-    this.cache = {};
-  }
-  lookupMove(move) {
-    const key = move.toString();
-    let r = this.cache[key];
-    if (r) {
-      return r;
-    }
-    const quantumKey = move.quantum.toString();
-    r = this.def.moves[quantumKey];
-    if (r) {
-      r = multiplyTransformations(this.def, r, move.amount);
-      this.cache[key] = r;
-    } else {
-      r = this.def.moves[move.toString()];
-      if (r) {
-        this.cache[key] = r;
-      } else {
-        r = this.def.moves[move.invert().toString()];
-        if (r) {
-          r = multiplyTransformations(this.def, r, -1);
-          this.cache[key] = r;
-        }
-      }
-    }
-    return r;
-  }
-};
-var KPuzzle = class {
-  constructor(definition) {
-    this.definition = definition;
-    this.state = identityTransformation(definition);
-  }
-  reset() {
-    this.state = identityTransformation(this.definition);
-  }
-  serialize() {
-    let output = "";
-    for (const orbitName in this.definition.orbits) {
-      output += orbitName + "\n";
-      output += this.state[orbitName].permutation.join(" ") + "\n";
-      output += this.state[orbitName].orientation.join(" ") + "\n";
-    }
-    output = output.slice(0, output.length - 1);
-    return output;
-  }
-  applyMove(move) {
-    this.state = combineTransformations(this.definition, this.state, transformationForMove(this.definition, move));
-  }
-  applyAlg(alg) {
-    for (const move of alg.experimentalLeafMoves()) {
-      this.applyMove(move);
-    }
-  }
-};
-
-// src/cubing/kpuzzle/canonicalize.ts
-var InternalMove = class {
-  constructor(base, twist) {
-    this.base = base;
-    this.twist = twist;
-  }
-  getTransformation(canon) {
-    return canon.transforms[this.base][this.twist];
-  }
-  asString(canon) {
-    const mod = canon.moveorder[this.base];
-    let tw = this.twist % mod;
-    while (tw + tw > mod) {
-      tw -= mod;
-    }
-    while (tw + tw <= -mod) {
-      tw += mod;
-    }
-    const nam = canon.movenames[this.base];
-    if (tw === 1) {
-      return nam;
-    } else if (tw === -1) {
-      return nam + "'";
-    } else if (tw > 0) {
-      return nam + tw;
-    } else if (tw < 0) {
-      return nam + -tw + "'";
-    } else {
-      throw new Error("Stringifying null move?");
-    }
-  }
-};
-var Canonicalizer = class {
-  constructor(def) {
-    this.def = def;
-    this.commutes = [];
-    this.moveorder = [];
-    this.movenames = [];
-    this.transforms = [];
-    this.moveindex = {};
-    const basemoves = def.moves;
-    const id = identityTransformation(def);
-    for (const mv1 in basemoves) {
-      this.moveindex[mv1] = this.movenames.length;
-      this.movenames.push(mv1);
-      this.transforms.push([id, basemoves[mv1]]);
-    }
-    this.baseMoveCount = this.movenames.length;
-    for (let i = 0; i < this.baseMoveCount; i++) {
-      this.commutes.push([]);
-      const t1 = this.transforms[i][1];
-      for (let j = 0; j < this.baseMoveCount; j++) {
-        const t2 = this.transforms[j][1];
-        const ab = combineTransformations(def, t1, t2);
-        const ba = combineTransformations(def, t2, t1);
-        this.commutes[i][j] = areTransformationsEquivalent(def, ab, ba);
-      }
-    }
-    for (let i = 0; i < this.baseMoveCount; i++) {
-      const t1 = this.transforms[i][1];
-      let ct = t1;
-      let order = 1;
-      for (let mult = 2; !areTransformationsEquivalent(def, id, ct); mult++) {
-        order++;
-        ct = combineTransformations(def, ct, t1);
-        this.transforms[i].push(ct);
-      }
-      this.moveorder[i] = order;
-    }
-  }
-  blockMoveToInternalMove(move) {
-    const quantumMoveStr = move.quantum.toString();
-    if (!(quantumMoveStr in this.def.moves)) {
-      throw new Error("! move " + quantumMoveStr + " not in def.");
-    }
-    const ind = this.moveindex[quantumMoveStr];
-    const mod = this.moveorder[ind];
-    let tw = move.amount % mod;
-    if (tw < 0) {
-      tw = (tw + mod) % mod;
-    }
-    return new InternalMove(ind, tw);
-  }
-  sequenceToSearchSequence(alg, tr) {
-    const ss = new SearchSequence(this, tr);
-    for (const move of alg.experimentalLeafMoves()) {
-      ss.appendOneMove(this.blockMoveToInternalMove(move));
-    }
-    return ss;
-  }
-  mergeSequenceToSearchSequence(alg, tr) {
-    const ss = new SearchSequence(this, tr);
-    for (const move of alg.experimentalLeafMoves()) {
-      ss.mergeOneMove(this.blockMoveToInternalMove(move));
-    }
-    return ss;
-  }
-};
-var SearchSequence = class {
-  constructor(canon, tr) {
-    this.canon = canon;
-    this.moveseq = [];
-    if (tr) {
-      this.trans = tr;
-    } else {
-      this.trans = identityTransformation(canon.def);
-    }
-  }
-  clone() {
-    const r = new SearchSequence(this.canon, this.trans);
-    r.moveseq = [...this.moveseq];
-    return r;
-  }
-  mergeOneMove(mv) {
-    const r = this.onlyMergeOneMove(mv);
-    this.trans = combineTransformations(this.canon.def, this.trans, mv.getTransformation(this.canon));
-    return r;
-  }
-  appendOneMove(mv) {
-    this.moveseq.push(mv);
-    this.trans = combineTransformations(this.canon.def, this.trans, mv.getTransformation(this.canon));
-    return 1;
-  }
-  popMove() {
-    const mv = this.moveseq.pop();
-    if (!mv) {
-      throw new Error("Can't pop an empty sequence");
-    }
-    this.trans = combineTransformations(this.canon.def, this.trans, this.canon.transforms[mv.base][this.canon.moveorder[mv.base] - mv.twist]);
-    return 1;
-  }
-  oneMoreTwist() {
-    const lastmv = this.moveseq[this.moveseq.length - 1];
-    this.trans = combineTransformations(this.canon.def, this.trans, this.canon.transforms[lastmv.base][1]);
-    this.moveseq[this.moveseq.length - 1] = new InternalMove(lastmv.base, lastmv.twist + 1);
-    return 0;
-  }
-  onlyMergeOneMove(mv) {
-    let j = this.moveseq.length - 1;
-    while (j >= 0) {
-      if (mv.base === this.moveseq[j].base) {
-        const mo = this.canon.moveorder[mv.base];
-        let twist = (mv.twist + this.moveseq[j].twist) % mo;
-        if (twist < 0) {
-          twist = (twist + mo) % mo;
-        }
-        if (twist === 0) {
-          this.moveseq.splice(j, 1);
-          return -1;
-        } else {
-          this.moveseq[j] = new InternalMove(mv.base, twist);
-          return 0;
-        }
-      } else if (this.canon.commutes[mv.base][this.moveseq[j].base]) {
-        j--;
-      } else {
-        break;
-      }
-    }
-    this.moveseq.push(mv);
-    return 1;
-  }
-  mergeSequence(seq) {
-    let r = this.moveseq.length;
-    for (let i = 0; i < seq.moveseq.length; i++) {
-      const mv = seq.moveseq[i];
-      const d = this.onlyMergeOneMove(mv);
-      r += d;
-    }
-    this.trans = combineTransformations(this.canon.def, this.trans, seq.trans);
-    return r;
-  }
-  getSequenceAsString() {
-    const r = [];
-    for (const mv of this.moveseq) {
-      r.push(mv.asString(this.canon));
-    }
-    return r.join(" ");
-  }
-};
-var CanonicalSequenceIterator = class {
-  constructor(canon, state) {
-    this.canon = canon;
-    this.ss = new SearchSequence(canon, state);
-    this.targetLength = 0;
-  }
-  nextState(base, canonstate) {
-    const newstate = [];
-    for (const prevbase of canonstate) {
-      if (prevbase === base) {
-        return null;
-      } else if (!this.canon.commutes[prevbase][base]) {
-      } else if (base < prevbase) {
-        return null;
-      } else {
-        newstate.push(prevbase);
-      }
-    }
-    return newstate;
-  }
-  *genSequence(togo, canonstate) {
-    if (togo === 0) {
-      yield this.ss;
-    } else {
-      for (let base = 0; base < this.canon.baseMoveCount; base++) {
-        const newstate = this.nextState(base, canonstate);
-        if (newstate) {
-          newstate.push(base);
-          for (let tw = 1; tw < this.canon.moveorder[base]; tw++) {
-            this.ss.appendOneMove(new InternalMove(base, tw));
-            yield* this.genSequence(togo - 1, newstate);
-            this.ss.popMove();
-          }
-        }
-      }
-    }
-    return null;
-  }
-  *generator() {
-    for (let d = 0; ; d++) {
-      yield* this.genSequence(d, []);
-    }
-  }
-  *genSequenceTree(canonstate) {
-    const r = yield this.ss;
-    if (r > 0) {
-      return null;
-    }
-    for (let base = 0; base < this.canon.baseMoveCount; base++) {
-      const newstate = this.nextState(base, canonstate);
-      if (newstate) {
-        newstate.push(base);
-        for (let tw = 1; tw < this.canon.moveorder[base]; tw++) {
-          this.ss.appendOneMove(new InternalMove(base, tw));
-          yield* this.genSequenceTree(newstate);
-          this.ss.popMove();
-        }
-      }
-    }
-    return null;
-  }
-};
-
-// src/cubing/kpuzzle/parser/parser-peggy.js
-function peg$subclass(child, parent) {
-  function C() {
-    this.constructor = child;
-  }
-  C.prototype = parent.prototype;
-  child.prototype = new C();
-}
-function peg$SyntaxError(message, expected, found, location) {
-  this.message = message;
-  this.expected = expected;
-  this.found = found;
-  this.location = location;
-  this.name = "SyntaxError";
-  if (typeof Error.captureStackTrace === "function") {
-    Error.captureStackTrace(this, peg$SyntaxError);
-  }
-}
-peg$subclass(peg$SyntaxError, Error);
-peg$SyntaxError.buildMessage = function(expected, found) {
-  var DESCRIBE_EXPECTATION_FNS = {
-    literal: function(expectation) {
-      return '"' + literalEscape(expectation.text) + '"';
-    },
-    class: function(expectation) {
-      var escapedParts = expectation.parts.map(function(part) {
-        return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part);
-      });
-      return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
-    },
-    any: function() {
-      return "any character";
-    },
-    end: function() {
-      return "end of input";
-    },
-    other: function(expectation) {
-      return expectation.description;
-    }
-  };
-  function hex(ch) {
-    return ch.charCodeAt(0).toString(16).toUpperCase();
-  }
-  function literalEscape(s) {
-    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
-      return "\\x0" + hex(ch);
-    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
-      return "\\x" + hex(ch);
-    });
-  }
-  function classEscape(s) {
-    return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
-      return "\\x0" + hex(ch);
-    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
-      return "\\x" + hex(ch);
-    });
-  }
-  function describeExpectation(expectation) {
-    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
-  }
-  function describeExpected(expected2) {
-    var descriptions = expected2.map(describeExpectation);
-    var i, j;
-    descriptions.sort();
-    if (descriptions.length > 0) {
-      for (i = 1, j = 1; i < descriptions.length; i++) {
-        if (descriptions[i - 1] !== descriptions[i]) {
-          descriptions[j] = descriptions[i];
-          j++;
-        }
-      }
-      descriptions.length = j;
-    }
-    switch (descriptions.length) {
-      case 1:
-        return descriptions[0];
-      case 2:
-        return descriptions[0] + " or " + descriptions[1];
-      default:
-        return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
-    }
-  }
-  function describeFound(found2) {
-    return found2 ? '"' + literalEscape(found2) + '"' : "end of input";
-  }
-  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
-};
-function peg$parse(input, options) {
-  options = options !== void 0 ? options : {};
-  var peg$FAILED = {};
-  var peg$startRuleFunctions = { start: peg$parsestart };
-  var peg$startRuleFunction = peg$parsestart;
-  var peg$c0 = function(def) {
-    return fixMoves(def);
-  };
-  var peg$c1 = /^[A-Za-z0-9<>]/;
-  var peg$c2 = peg$classExpectation([["A", "Z"], ["a", "z"], ["0", "9"], "<", ">"], false, false);
-  var peg$c3 = function(characters) {
-    return characters.join("");
-  };
-  var peg$c4 = /^[A-Za-z]/;
-  var peg$c5 = peg$classExpectation([
-    ["A", "Z"],
-    ["a", "z"]
-  ], false, false);
-  var peg$c6 = /^[A-Za-z0-9]/;
-  var peg$c7 = peg$classExpectation([
-    ["A", "Z"],
-    ["a", "z"],
-    ["0", "9"]
-  ], false, false);
-  var peg$c8 = function(first, rest) {
-    return [first].concat(rest).join("");
-  };
-  var peg$c9 = /^[0-9]/;
-  var peg$c10 = peg$classExpectation([["0", "9"]], false, false);
-  var peg$c11 = function(characters) {
-    return parseInt(characters.join(""), 10);
-  };
-  var peg$c12 = " ";
-  var peg$c13 = peg$literalExpectation(" ", false);
-  var peg$c14 = "Name";
-  var peg$c15 = peg$literalExpectation("Name", false);
-  var peg$c16 = function(identifier) {
-    return identifier;
-  };
-  var peg$c17 = "Set";
-  var peg$c18 = peg$literalExpectation("Set", false);
-  var peg$c19 = function(set_identifier, num_pieces, num_orientations) {
-    return [
-      set_identifier,
-      { numPieces: num_pieces, orientations: num_orientations }
-    ];
-  };
-  var peg$c20 = function(orbit, orbits) {
-    orbits[orbit[0]] = orbit[1];
-    return orbits;
-  };
-  var peg$c21 = function(orbit) {
-    const orbits = {};
-    orbits[orbit[0]] = orbit[1];
-    return orbits;
-  };
-  var peg$c22 = "\n";
-  var peg$c23 = peg$literalExpectation("\n", false);
-  var peg$c24 = function(num, nums) {
-    return [num].concat(nums);
-  };
-  var peg$c25 = function(num) {
-    return [num];
-  };
-  var peg$c26 = function(nums) {
-    return fixPermutation(nums);
-  };
-  var peg$c27 = function(set_identifier, permutation, nums) {
-    return [set_identifier, { permutation, orientation: nums }];
-  };
-  var peg$c28 = function(set_identifier, permutation) {
-    return [
-      set_identifier,
-      {
-        permutation,
-        orientation: new Array(permutation.length).fill(0)
-      }
-    ];
-  };
-  var peg$c29 = function(definition, definitions) {
-    definitions[definition[0]] = definition[1];
-    return definitions;
-  };
-  var peg$c30 = function(definition) {
-    const definitions = {};
-    definitions[definition[0]] = definition[1];
-    return definitions;
-  };
-  var peg$c31 = "Solved";
-  var peg$c32 = peg$literalExpectation("Solved", false);
-  var peg$c33 = "End";
-  var peg$c34 = peg$literalExpectation("End", false);
-  var peg$c35 = function(definitions) {
-    return definitions;
-  };
-  var peg$c36 = "Move";
-  var peg$c37 = peg$literalExpectation("Move", false);
-  var peg$c38 = function(identifier, definitions) {
-    return [identifier, definitions];
-  };
-  var peg$c39 = function(move, moves) {
-    moves[move[0]] = move[1];
-    return moves;
-  };
-  var peg$c40 = function(move) {
-    const moves = {};
-    moves[move[0]] = move[1];
-    return moves;
-  };
-  var peg$c41 = function(name, orbits, start_pieces, moves) {
-    return {
-      name,
-      orbits,
-      moves,
-      startPieces: start_pieces
-    };
-  };
-  var peg$currPos = 0;
-  var peg$savedPos = 0;
-  var peg$posDetailsCache = [{ line: 1, column: 1 }];
-  var peg$maxFailPos = 0;
-  var peg$maxFailExpected = [];
-  var peg$silentFails = 0;
-  var peg$result;
-  if ("startRule" in options) {
-    if (!(options.startRule in peg$startRuleFunctions)) {
-      throw new Error(`Can't start parsing from rule "` + options.startRule + '".');
-    }
-    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
-  }
-  function text() {
-    return input.substring(peg$savedPos, peg$currPos);
-  }
-  function location() {
-    return peg$computeLocation(peg$savedPos, peg$currPos);
-  }
-  function expected(description, location2) {
-    location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
-    throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location2);
-  }
-  function error(message, location2) {
-    location2 = location2 !== void 0 ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
-    throw peg$buildSimpleError(message, location2);
-  }
-  function peg$literalExpectation(text2, ignoreCase) {
-    return { type: "literal", text: text2, ignoreCase };
-  }
-  function peg$classExpectation(parts, inverted, ignoreCase) {
-    return {
-      type: "class",
-      parts,
-      inverted,
-      ignoreCase
-    };
-  }
-  function peg$anyExpectation() {
-    return { type: "any" };
-  }
-  function peg$endExpectation() {
-    return { type: "end" };
-  }
-  function peg$otherExpectation(description) {
-    return { type: "other", description };
-  }
-  function peg$computePosDetails(pos) {
-    var details = peg$posDetailsCache[pos];
-    var p;
-    if (details) {
-      return details;
-    } else {
-      p = pos - 1;
-      while (!peg$posDetailsCache[p]) {
-        p--;
-      }
-      details = peg$posDetailsCache[p];
-      details = {
-        line: details.line,
-        column: details.column
-      };
-      while (p < pos) {
-        if (input.charCodeAt(p) === 10) {
-          details.line++;
-          details.column = 1;
-        } else {
-          details.column++;
-        }
-        p++;
-      }
-      peg$posDetailsCache[pos] = details;
-      return details;
-    }
-  }
-  function peg$computeLocation(startPos, endPos) {
-    var startPosDetails = peg$computePosDetails(startPos);
-    var endPosDetails = peg$computePosDetails(endPos);
-    return {
-      start: {
-        offset: startPos,
-        line: startPosDetails.line,
-        column: startPosDetails.column
-      },
-      end: {
-        offset: endPos,
-        line: endPosDetails.line,
-        column: endPosDetails.column
-      }
-    };
-  }
-  function peg$fail(expected2) {
-    if (peg$currPos < peg$maxFailPos) {
-      return;
-    }
-    if (peg$currPos > peg$maxFailPos) {
-      peg$maxFailPos = peg$currPos;
-      peg$maxFailExpected = [];
-    }
-    peg$maxFailExpected.push(expected2);
-  }
-  function peg$buildSimpleError(message, location2) {
-    return new peg$SyntaxError(message, null, null, location2);
-  }
-  function peg$buildStructuredError(expected2, found, location2) {
-    return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected2, found), expected2, found, location2);
-  }
-  function peg$parsestart() {
-    var s0, s1;
-    s0 = peg$currPos;
-    s1 = peg$parseDEFINITION_FILE();
-    if (s1 !== peg$FAILED) {
-      peg$savedPos = s0;
-      s1 = peg$c0(s1);
-    }
-    s0 = s1;
-    return s0;
-  }
-  function peg$parseIDENTIFIER() {
-    var s0, s1, s2;
-    s0 = peg$currPos;
-    s1 = [];
-    if (peg$c1.test(input.charAt(peg$currPos))) {
-      s2 = input.charAt(peg$currPos);
-      peg$currPos++;
-    } else {
-      s2 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c2);
-      }
-    }
-    if (s2 !== peg$FAILED) {
-      while (s2 !== peg$FAILED) {
-        s1.push(s2);
-        if (peg$c1.test(input.charAt(peg$currPos))) {
-          s2 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s2 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$c2);
-          }
-        }
-      }
-    } else {
-      s1 = peg$FAILED;
-    }
-    if (s1 !== peg$FAILED) {
-      peg$savedPos = s0;
-      s1 = peg$c3(s1);
-    }
-    s0 = s1;
-    return s0;
-  }
-  function peg$parseSET_IDENTIFIER() {
-    var s0, s1, s2, s3;
-    s0 = peg$currPos;
-    if (peg$c4.test(input.charAt(peg$currPos))) {
-      s1 = input.charAt(peg$currPos);
-      peg$currPos++;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c5);
-      }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = [];
-      if (peg$c6.test(input.charAt(peg$currPos))) {
-        s3 = input.charAt(peg$currPos);
-        peg$currPos++;
-      } else {
-        s3 = peg$FAILED;
-        if (peg$silentFails === 0) {
-          peg$fail(peg$c7);
-        }
-      }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
-        if (peg$c6.test(input.charAt(peg$currPos))) {
-          s3 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s3 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$c7);
-          }
-        }
-      }
-      if (s2 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s1 = peg$c8(s1, s2);
-        s0 = s1;
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    return s0;
-  }
-  function peg$parseNUMBER() {
-    var s0, s1, s2;
-    s0 = peg$currPos;
-    s1 = [];
-    if (peg$c9.test(input.charAt(peg$currPos))) {
-      s2 = input.charAt(peg$currPos);
-      peg$currPos++;
-    } else {
-      s2 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c10);
-      }
-    }
-    if (s2 !== peg$FAILED) {
-      while (s2 !== peg$FAILED) {
-        s1.push(s2);
-        if (peg$c9.test(input.charAt(peg$currPos))) {
-          s2 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s2 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$c10);
-          }
-        }
-      }
-    } else {
-      s1 = peg$FAILED;
-    }
-    if (s1 !== peg$FAILED) {
-      peg$savedPos = s0;
-      s1 = peg$c11(s1);
-    }
-    s0 = s1;
-    return s0;
-  }
-  function peg$parseSPACE() {
-    var s0;
-    if (input.charCodeAt(peg$currPos) === 32) {
-      s0 = peg$c12;
-      peg$currPos++;
-    } else {
-      s0 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c13);
-      }
-    }
-    return s0;
-  }
-  function peg$parseNAME() {
-    var s0, s1, s2, s3;
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 4) === peg$c14) {
-      s1 = peg$c14;
-      peg$currPos += 4;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c15);
-      }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseSPACE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseIDENTIFIER();
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s1 = peg$c16(s3);
-          s0 = s1;
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    return s0;
-  }
-  function peg$parseORBIT() {
-    var s0, s1, s2, s3, s4, s5, s6, s7;
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 3) === peg$c17) {
-      s1 = peg$c17;
-      peg$currPos += 3;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c18);
-      }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseSPACE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseSET_IDENTIFIER();
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseSPACE();
-          if (s4 !== peg$FAILED) {
-            s5 = peg$parseNUMBER();
-            if (s5 !== peg$FAILED) {
-              s6 = peg$parseSPACE();
-              if (s6 !== peg$FAILED) {
-                s7 = peg$parseNUMBER();
-                if (s7 !== peg$FAILED) {
-                  peg$savedPos = s0;
-                  s1 = peg$c19(s3, s5, s7);
-                  s0 = s1;
-                } else {
-                  peg$currPos = s0;
-                  s0 = peg$FAILED;
-                }
-              } else {
-                peg$currPos = s0;
-                s0 = peg$FAILED;
-              }
-            } else {
-              peg$currPos = s0;
-              s0 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    return s0;
-  }
-  function peg$parseORBITS() {
-    var s0, s1, s2, s3;
-    s0 = peg$currPos;
-    s1 = peg$parseORBIT();
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseNEWLINE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseORBITS();
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s1 = peg$c20(s1, s3);
-          s0 = s1;
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    if (s0 === peg$FAILED) {
-      s0 = peg$currPos;
-      s1 = peg$parseORBIT();
-      if (s1 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s1 = peg$c21(s1);
-      }
-      s0 = s1;
-    }
-    return s0;
-  }
-  function peg$parseNEWLINE() {
-    var s0;
-    if (input.charCodeAt(peg$currPos) === 10) {
-      s0 = peg$c22;
-      peg$currPos++;
-    } else {
-      s0 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c23);
-      }
-    }
-    return s0;
-  }
-  function peg$parseNEWLINES() {
-    var s0, s1;
-    s0 = [];
-    if (input.charCodeAt(peg$currPos) === 10) {
-      s1 = peg$c22;
-      peg$currPos++;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c23);
-      }
-    }
-    if (s1 !== peg$FAILED) {
-      while (s1 !== peg$FAILED) {
-        s0.push(s1);
-        if (input.charCodeAt(peg$currPos) === 10) {
-          s1 = peg$c22;
-          peg$currPos++;
-        } else {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$c23);
-          }
-        }
-      }
-    } else {
-      s0 = peg$FAILED;
-    }
-    return s0;
-  }
-  function peg$parseOPTIONAL_NEWLINES() {
-    var s0, s1;
-    s0 = [];
-    if (input.charCodeAt(peg$currPos) === 10) {
-      s1 = peg$c22;
-      peg$currPos++;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c23);
-      }
-    }
-    while (s1 !== peg$FAILED) {
-      s0.push(s1);
-      if (input.charCodeAt(peg$currPos) === 10) {
-        s1 = peg$c22;
-        peg$currPos++;
-      } else {
-        s1 = peg$FAILED;
-        if (peg$silentFails === 0) {
-          peg$fail(peg$c23);
-        }
-      }
-    }
-    return s0;
-  }
-  function peg$parseNUMBERS() {
-    var s0, s1, s2, s3;
-    s0 = peg$currPos;
-    s1 = peg$parseNUMBER();
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseSPACE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseNUMBERS();
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s1 = peg$c24(s1, s3);
-          s0 = s1;
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    if (s0 === peg$FAILED) {
-      s0 = peg$currPos;
-      s1 = peg$parseNUMBER();
-      if (s1 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s1 = peg$c25(s1);
-      }
-      s0 = s1;
-    }
-    return s0;
-  }
-  function peg$parsePERMUTATION() {
-    var s0, s1;
-    s0 = peg$currPos;
-    s1 = peg$parseNUMBERS();
-    if (s1 !== peg$FAILED) {
-      peg$savedPos = s0;
-      s1 = peg$c26(s1);
-    }
-    s0 = s1;
-    return s0;
-  }
-  function peg$parseDEFINITION() {
-    var s0, s1, s2, s3, s4, s5;
-    s0 = peg$currPos;
-    s1 = peg$parseSET_IDENTIFIER();
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseNEWLINE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parsePERMUTATION();
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseNEWLINE();
-          if (s4 !== peg$FAILED) {
-            s5 = peg$parseNUMBERS();
-            if (s5 !== peg$FAILED) {
-              peg$savedPos = s0;
-              s1 = peg$c27(s1, s3, s5);
-              s0 = s1;
-            } else {
-              peg$currPos = s0;
-              s0 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    if (s0 === peg$FAILED) {
-      s0 = peg$currPos;
-      s1 = peg$parseSET_IDENTIFIER();
-      if (s1 !== peg$FAILED) {
-        s2 = peg$parseNEWLINE();
-        if (s2 !== peg$FAILED) {
-          s3 = peg$parsePERMUTATION();
-          if (s3 !== peg$FAILED) {
-            peg$savedPos = s0;
-            s1 = peg$c28(s1, s3);
-            s0 = s1;
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    }
-    return s0;
-  }
-  function peg$parseDEFINITIONS() {
-    var s0, s1, s2, s3;
-    s0 = peg$currPos;
-    s1 = peg$parseDEFINITION();
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseNEWLINE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseDEFINITIONS();
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s1 = peg$c29(s1, s3);
-          s0 = s1;
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    if (s0 === peg$FAILED) {
-      s0 = peg$currPos;
-      s1 = peg$parseDEFINITION();
-      if (s1 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s1 = peg$c30(s1);
-      }
-      s0 = s1;
-    }
-    return s0;
-  }
-  function peg$parseSTART_PIECES() {
-    var s0, s1, s2, s3, s4, s5;
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 6) === peg$c31) {
-      s1 = peg$c31;
-      peg$currPos += 6;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c32);
-      }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseNEWLINE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseDEFINITIONS();
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseNEWLINE();
-          if (s4 !== peg$FAILED) {
-            if (input.substr(peg$currPos, 3) === peg$c33) {
-              s5 = peg$c33;
-              peg$currPos += 3;
-            } else {
-              s5 = peg$FAILED;
-              if (peg$silentFails === 0) {
-                peg$fail(peg$c34);
-              }
-            }
-            if (s5 !== peg$FAILED) {
-              peg$savedPos = s0;
-              s1 = peg$c35(s3);
-              s0 = s1;
-            } else {
-              peg$currPos = s0;
-              s0 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    return s0;
-  }
-  function peg$parseMOVE() {
-    var s0, s1, s2, s3, s4, s5, s6, s7;
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 4) === peg$c36) {
-      s1 = peg$c36;
-      peg$currPos += 4;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) {
-        peg$fail(peg$c37);
-      }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseSPACE();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseIDENTIFIER();
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseNEWLINE();
-          if (s4 !== peg$FAILED) {
-            s5 = peg$parseDEFINITIONS();
-            if (s5 !== peg$FAILED) {
-              s6 = peg$parseNEWLINE();
-              if (s6 !== peg$FAILED) {
-                if (input.substr(peg$currPos, 3) === peg$c33) {
-                  s7 = peg$c33;
-                  peg$currPos += 3;
-                } else {
-                  s7 = peg$FAILED;
-                  if (peg$silentFails === 0) {
-                    peg$fail(peg$c34);
-                  }
-                }
-                if (s7 !== peg$FAILED) {
-                  peg$savedPos = s0;
-                  s1 = peg$c38(s3, s5);
-                  s0 = s1;
-                } else {
-                  peg$currPos = s0;
-                  s0 = peg$FAILED;
-                }
-              } else {
-                peg$currPos = s0;
-                s0 = peg$FAILED;
-              }
-            } else {
-              peg$currPos = s0;
-              s0 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    return s0;
-  }
-  function peg$parseMOVES() {
-    var s0, s1, s2, s3;
-    s0 = peg$currPos;
-    s1 = peg$parseMOVE();
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseNEWLINES();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseMOVES();
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s1 = peg$c39(s1, s3);
-          s0 = s1;
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    if (s0 === peg$FAILED) {
-      s0 = peg$currPos;
-      s1 = peg$parseMOVE();
-      if (s1 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s1 = peg$c40(s1);
-      }
-      s0 = s1;
-    }
-    return s0;
-  }
-  function peg$parseDEFINITION_FILE() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8;
-    s0 = peg$currPos;
-    s1 = peg$parseNAME();
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parseNEWLINES();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseORBITS();
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseNEWLINES();
-          if (s4 !== peg$FAILED) {
-            s5 = peg$parseSTART_PIECES();
-            if (s5 !== peg$FAILED) {
-              s6 = peg$parseNEWLINES();
-              if (s6 !== peg$FAILED) {
-                s7 = peg$parseMOVES();
-                if (s7 !== peg$FAILED) {
-                  s8 = peg$parseOPTIONAL_NEWLINES();
-                  if (s8 !== peg$FAILED) {
-                    peg$savedPos = s0;
-                    s1 = peg$c41(s1, s3, s5, s7);
-                    s0 = s1;
-                  } else {
-                    peg$currPos = s0;
-                    s0 = peg$FAILED;
-                  }
-                } else {
-                  peg$currPos = s0;
-                  s0 = peg$FAILED;
-                }
-              } else {
-                peg$currPos = s0;
-                s0 = peg$FAILED;
-              }
-            } else {
-              peg$currPos = s0;
-              s0 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    return s0;
-  }
-  function fixPermutation(permutation) {
-    return permutation.map((x) => x - 1);
-  }
-  function fixMoves(def) {
-    for (const moveName in def.moves) {
-      const move = def.moves[moveName];
-      for (const orbitName in def.orbits) {
-        const moveOrbit = move[orbitName];
-        const oldOrientation = moveOrbit.orientation;
-        const perm = moveOrbit.permutation;
-        const newOrientation = new Array(oldOrientation.length);
-        for (let i = 0; i < perm.length; i++) {
-          newOrientation[i] = oldOrientation[perm[i]];
-        }
-        moveOrbit.orientation = newOrientation;
-      }
-    }
-    return def;
-  }
-  peg$result = peg$startRuleFunction();
-  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
-    return peg$result;
-  } else {
-    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
-      peg$fail(peg$endExpectation());
-    }
-    throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
-  }
-}
-
-// src/cubing/kpuzzle/parser/parser-shim.ts
-var pegParseKPuzzleDefinition = peg$parse;
-
-// src/cubing/kpuzzle/svg.ts
-var xmlns = "http://www.w3.org/2000/svg";
-var svgCounter = 0;
-function nextSVGID() {
-  svgCounter += 1;
-  return "svg" + svgCounter.toString();
-}
-var colorMaps = {
-  dim: {
-    "white": "#dddddd",
-    "orange": "#884400",
-    "limegreen": "#008800",
-    "red": "#660000",
-    "rgb(34, 102, 255)": "#000088",
-    "yellow": "#888800"
-  },
-  oriented: {
-    "white": "#ff88ff",
-    "orange": "#ff88ff",
-    "limegreen": "#ff88ff",
-    "red": "#ff88ff",
-    "rgb(34, 102, 255)": "#ff88ff",
-    "yellow": "#ff88ff"
-  },
-  ignored: {
-    "white": "#444444",
-    "orange": "#444444",
-    "limegreen": "#444444",
-    "red": "#444444",
-    "rgb(34, 102, 255)": "#444444",
-    "yellow": "#444444"
-  },
-  invisible: {
-    "white": "#00000000",
-    "orange": "#00000000",
-    "limegreen": "#00000000",
-    "red": "#00000000",
-    "rgb(34, 102, 255)": "#00000000",
-    "yellow": "#00000000"
-  }
-};
-var KPuzzleSVGWrapper = class {
-  constructor(kPuzzleDefinition, svgSource, experimentalAppearance) {
-    this.kPuzzleDefinition = kPuzzleDefinition;
-    this.originalColors = {};
-    this.gradients = {};
-    if (!svgSource) {
-      throw new Error(`No SVG definition for puzzle type: ${kPuzzleDefinition.name}`);
-    }
-    this.svgID = nextSVGID();
-    this.element = document.createElement("div");
-    this.element.classList.add("svg-wrapper");
-    this.element.innerHTML = svgSource;
-    const svgElem = this.element.querySelector("svg");
-    if (!svgElem) {
-      throw new Error("Could not get SVG element");
-    }
-    if (xmlns !== svgElem.namespaceURI) {
-      throw new Error("Unexpected XML namespace");
-    }
-    svgElem.style.maxWidth = "100%";
-    svgElem.style.maxHeight = "100%";
-    this.gradientDefs = document.createElementNS(xmlns, "defs");
-    svgElem.insertBefore(this.gradientDefs, svgElem.firstChild);
-    for (const orbitName in kPuzzleDefinition.orbits) {
-      const orbitDefinition = kPuzzleDefinition.orbits[orbitName];
-      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
-        for (let orientation = 0; orientation < orbitDefinition.orientations; orientation++) {
-          const id = this.elementID(orbitName, idx, orientation);
-          const elem = this.elementByID(id);
-          let originalColor = elem.style.fill;
-          if (experimentalAppearance) {
-            (() => {
-              const a = experimentalAppearance.orbits;
-              if (!a) {
-                return;
-              }
-              const orbitAppearance = a[orbitName];
-              if (!orbitAppearance) {
-                return;
-              }
-              const pieceAppearance = orbitAppearance.pieces[idx];
-              if (!pieceAppearance) {
-                return;
-              }
-              const faceletAppearance = pieceAppearance.facelets[orientation];
-              if (!faceletAppearance) {
-                return;
-              }
-              const appearance = typeof faceletAppearance === "string" ? faceletAppearance : faceletAppearance?.appearance;
-              const colorMap = colorMaps[appearance];
-              if (colorMap) {
-                originalColor = colorMap[originalColor];
-              }
-            })();
-          } else {
-            originalColor = elem.style.fill;
-          }
-          this.originalColors[id] = originalColor;
-          this.gradients[id] = this.newGradient(id, originalColor);
-          this.gradientDefs.appendChild(this.gradients[id]);
-          elem.setAttribute("style", `fill: url(#grad-${this.svgID}-${id})`);
-        }
-      }
-    }
-  }
-  drawKPuzzle(kpuzzle, nextState, fraction) {
-    this.draw(kpuzzle.definition, kpuzzle.state, nextState, fraction);
-  }
-  draw(definition, state, nextState, fraction) {
-    for (const orbitName in definition.orbits) {
-      const orbitDefinition = definition.orbits[orbitName];
-      const curOrbitState = state[orbitName];
-      const nextOrbitState = nextState ? nextState[orbitName] : null;
-      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
-        for (let orientation = 0; orientation < orbitDefinition.orientations; orientation++) {
-          const id = this.elementID(orbitName, idx, orientation);
-          const fromCur = this.elementID(orbitName, curOrbitState.permutation[idx], (orbitDefinition.orientations - curOrbitState.orientation[idx] + orientation) % orbitDefinition.orientations);
-          let singleColor = false;
-          if (nextOrbitState) {
-            const fromNext = this.elementID(orbitName, nextOrbitState.permutation[idx], (orbitDefinition.orientations - nextOrbitState.orientation[idx] + orientation) % orbitDefinition.orientations);
-            if (fromCur === fromNext) {
-              singleColor = true;
-            }
-            fraction = fraction || 0;
-            const easedBackwardsPercent = 100 * (1 - fraction * fraction * (2 - fraction * fraction));
-            this.gradients[id].children[0].setAttribute("stop-color", this.originalColors[fromCur]);
-            this.gradients[id].children[1].setAttribute("stop-color", this.originalColors[fromCur]);
-            this.gradients[id].children[1].setAttribute("offset", `${Math.max(easedBackwardsPercent - 5, 0)}%`);
-            this.gradients[id].children[2].setAttribute("offset", `${Math.max(easedBackwardsPercent - 5, 0)}%`);
-            this.gradients[id].children[3].setAttribute("offset", `${easedBackwardsPercent}%`);
-            this.gradients[id].children[4].setAttribute("offset", `${easedBackwardsPercent}%`);
-            this.gradients[id].children[4].setAttribute("stop-color", this.originalColors[fromNext]);
-            this.gradients[id].children[5].setAttribute("stop-color", this.originalColors[fromNext]);
-          } else {
-            singleColor = true;
-          }
-          if (singleColor) {
-            this.gradients[id].children[0].setAttribute("stop-color", this.originalColors[fromCur]);
-            this.gradients[id].children[1].setAttribute("stop-color", this.originalColors[fromCur]);
-            this.gradients[id].children[1].setAttribute("offset", `100%`);
-            this.gradients[id].children[2].setAttribute("offset", `100%`);
-            this.gradients[id].children[3].setAttribute("offset", `100%`);
-            this.gradients[id].children[4].setAttribute("offset", `100%`);
-          }
-        }
-      }
-    }
-  }
-  newGradient(id, originalColor) {
-    const grad = document.createElementNS(xmlns, "radialGradient");
-    grad.setAttribute("id", `grad-${this.svgID}-${id}`);
-    grad.setAttribute("r", `70.7107%`);
-    const stopDefs = [
-      { offset: 0, color: originalColor },
-      { offset: 0, color: originalColor },
-      { offset: 0, color: "black" },
-      { offset: 0, color: "black" },
-      { offset: 0, color: originalColor },
-      { offset: 100, color: originalColor }
-    ];
-    for (const stopDef of stopDefs) {
-      const stop = document.createElementNS(xmlns, "stop");
-      stop.setAttribute("offset", `${stopDef.offset}%`);
-      stop.setAttribute("stop-color", stopDef.color);
-      stop.setAttribute("stop-opacity", "1");
-      grad.appendChild(stop);
-    }
-    return grad;
-  }
-  elementID(orbitName, idx, orientation) {
-    return orbitName + "-l" + idx + "-o" + orientation;
-  }
-  elementByID(id) {
-    return this.element.querySelector("#" + id);
-  }
-};
-
-// src/cubing/kpuzzle/3x3x3/3x3x3.kpuzzle.json.ts
-var cube3x3x3KPuzzle = {
-  name: "3x3x3",
-  orbits: {
-    EDGES: { numPieces: 12, orientations: 2 },
-    CORNERS: { numPieces: 8, orientations: 3 },
-    CENTERS: { numPieces: 6, orientations: 4 }
-  },
-  startPieces: {
-    EDGES: {
-      permutation: [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: {
-      permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-      orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-    },
-    CENTERS: {
-      permutation: [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]
-      }
-    }
-  }
-};
-cube3x3x3KPuzzle.moves["Uw"] = cube3x3x3KPuzzle.moves["u"];
-cube3x3x3KPuzzle.moves["Lw"] = cube3x3x3KPuzzle.moves["l"];
-cube3x3x3KPuzzle.moves["Fw"] = cube3x3x3KPuzzle.moves["f"];
-cube3x3x3KPuzzle.moves["Rw"] = cube3x3x3KPuzzle.moves["r"];
-cube3x3x3KPuzzle.moves["Bw"] = cube3x3x3KPuzzle.moves["b"];
-cube3x3x3KPuzzle.moves["Dw"] = cube3x3x3KPuzzle.moves["d"];
-cube3x3x3KPuzzle.moves["Rv"] = cube3x3x3KPuzzle.moves["x"];
-cube3x3x3KPuzzle.moves["Uv"] = cube3x3x3KPuzzle.moves["y"];
-cube3x3x3KPuzzle.moves["Fv"] = cube3x3x3KPuzzle.moves["z"];
-cube3x3x3KPuzzle.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]
-  }
-};
-cube3x3x3KPuzzle.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]
-  }
-};
-cube3x3x3KPuzzle.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/puzzle-orientation.ts
-function experimentalIs3x3x3Solved(transformation, options) {
-  const normalized = normalizePuzzleOrientation(transformation);
-  if (options.ignoreCenterOrientation) {
-    return areOrbitTransformationsEquivalent(cube3x3x3KPuzzle, "EDGES", normalized, cube3x3x3KPuzzle.startPieces) && areOrbitTransformationsEquivalent(cube3x3x3KPuzzle, "CORNERS", normalized, cube3x3x3KPuzzle.startPieces);
-  } else {
-    return areTransformationsEquivalent(cube3x3x3KPuzzle, normalized, cube3x3x3KPuzzle.startPieces);
-  }
-}
-
-// src/cubing/protocol/binary/puzzle-orientation.ts
-function puzzleOrientationIdx(state) {
-  const idxU = state["CENTERS"].permutation[0];
-  const idxD = state["CENTERS"].permutation[5];
-  const unadjustedIdxL = state["CENTERS"].permutation[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 orientationKpuzzle = new KPuzzle(cube3x3x3KPuzzle);
-  const uAlgs = ["", "z", "x", "z'", "x'", "x2"].map((s) => Alg.fromString(s));
-  const yAlg = new Alg("y");
-  for (const uAlg of uAlgs) {
-    orientationKpuzzle.reset();
-    orientationKpuzzle.applyAlg(uAlg);
-    for (let i = 0; i < 4; i++) {
-      orientationKpuzzle.applyAlg(yAlg);
-      const [idxU, idxL] = puzzleOrientationIdx(orientationKpuzzle.state);
-      puzzleOrientationCache[idxU][idxL] = invertTransformation(cube3x3x3KPuzzle, orientationKpuzzle.state);
-    }
-  }
-}
-function normalizePuzzleOrientation(s) {
-  const [idxU, idxL] = puzzleOrientationIdx(s);
-  const orientationTransformation = puzzleOrientationCache[idxU][idxL];
-  return combineTransformations(cube3x3x3KPuzzle, s, orientationTransformation);
-}
-function reorientPuzzle(s, idxU, idxL) {
-  const orientationTransformation = invertTransformation(cube3x3x3KPuzzle, puzzleOrientationCache[idxU][idxL]);
-  return combineTransformations(cube3x3x3KPuzzle, s, orientationTransformation);
-}
-
-// 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["EDGES"].permutation);
-  const eoMask = orientationsToMask(2, normedState["EDGES"].orientation);
-  const cpLex = permutationToLex(normedState["CORNERS"].permutation);
-  const coMask = orientationsToMask(3, normedState["CORNERS"].orientation);
-  const [poIdxU, poIdxL] = puzzleOrientationIdx(state);
-  const moSupport = 1;
-  const moMask = orientationsToMask(4, normedState["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 = {
-    EDGES: {
-      permutation: lexToPermutation(12, components.epLex),
-      orientation: maskToOrientations(2, 12, components.eoMask)
-    },
-    CORNERS: {
-      permutation: lexToPermutation(8, components.cpLex),
-      orientation: maskToOrientations(3, 8, components.coMask)
-    },
-    CENTERS: {
-      permutation: 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 {
-  combineTransformations,
-  multiplyTransformations,
-  identityTransformation,
-  invertTransformation,
-  transformationOrder,
-  areOrbitTransformationsEquivalent,
-  areTransformationsEquivalent,
-  areStatesEquivalent,
-  transformationForQuantumMove,
-  transformationForMove,
-  KPuzzle,
-  Canonicalizer,
-  SearchSequence,
-  CanonicalSequenceIterator,
-  pegParseKPuzzleDefinition,
-  KPuzzleSVGWrapper,
-  cube3x3x3KPuzzle,
-  normalizePuzzleOrientation,
-  reid3x3x3ToTwizzleBinary,
-  twizzleBinaryToBinaryComponents,
-  binaryComponentsToReid3x3x3,
-  twizzleBinaryToReid3x3x3,
-  bufferToSpacedHex,
-  spacedHexToBuffer,
-  experimentalIs3x3x3Solved
-};
-//# sourceMappingURL=chunk-X6JHXPDX.js.map