cubing 0.22.0 → 0.24.0-pre2

package/dist/{bin/puzzle-geometry-bin.js → esm/chunk-J2U2GRS4.js}

@@ -1,1210 +1,7 @@
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateWrapper = (obj, member, setter, getter) => {
-  return {
-    set _(value) {
-      __privateSet(obj, member, value, setter);
-    },
-    get _() {
-      return __privateGet(obj, member, getter);
-    }
-  };
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-
-// src/cubing/alg/common.ts
-var writeAlgDebugField = false;
-var Comparable = class {
-  is(c) {
-    return this instanceof c;
-  }
-  as(c) {
-    return this instanceof c ? this : null;
-  }
-};
-var AlgCommon = class extends Comparable {
-  constructor() {
-    super();
-    if (writeAlgDebugField) {
-      Object.defineProperty(this, "_debugStr", {
-        get: () => {
-          return this.toString();
-        }
-      });
-    }
-  }
-  get log() {
-    return console.log.bind(console, this, this.toString());
-  }
-};
-
-// src/cubing/alg/iteration.ts
-var IterationDirection;
-(function(IterationDirection3) {
-  IterationDirection3[IterationDirection3["Forwards"] = 1] = "Forwards";
-  IterationDirection3[IterationDirection3["Backwards"] = -1] = "Backwards";
-})(IterationDirection || (IterationDirection = {}));
-function toggleDirection(iterationDirection, flip = true) {
-  if (!flip) {
-    return iterationDirection;
-  }
-  switch (iterationDirection) {
-    case 1:
-      return -1;
-    case -1:
-      return 1;
-  }
-}
-function direct(g, iterDir) {
-  return iterDir === -1 ? Array.from(g).reverse() : g;
-}
-function reverse(g) {
-  return Array.from(g).reverse();
-}
-
-// src/cubing/alg/limits.ts
-var MAX_INT = 2147483647;
-var MAX_INT_DESCRIPTION = "2^31 - 1";
-var MIN_INT = -2147483648;
-
-// src/cubing/alg/AlgBuilder.ts
-var _units;
-var AlgBuilder = class {
-  constructor() {
-    __privateAdd(this, _units, []);
-  }
-  push(u) {
-    __privateGet(this, _units).push(u);
-  }
-  experimentalPushAlg(alg) {
-    for (const u of alg.units()) {
-      this.push(u);
-    }
-  }
-  experimentalNumUnits() {
-    return __privateGet(this, _units).length;
-  }
-  toAlg() {
-    return new Alg(__privateGet(this, _units));
-  }
-  reset() {
-    __privateSet(this, _units, []);
-  }
-};
-_units = new WeakMap();
-
-// src/cubing/alg/units/containers/Commutator.ts
-var _A, _B;
-var _Commutator = class extends AlgCommon {
-  constructor(aSource, bSource) {
-    super();
-    __privateAdd(this, _A, void 0);
-    __privateAdd(this, _B, void 0);
-    __privateSet(this, _A, experimentalEnsureAlg(aSource));
-    __privateSet(this, _B, experimentalEnsureAlg(bSource));
-  }
-  get A() {
-    return __privateGet(this, _A);
-  }
-  get B() {
-    return __privateGet(this, _B);
-  }
-  isIdentical(other) {
-    const otherAsCommutator = other.as(_Commutator);
-    return !!(otherAsCommutator?.A.isIdentical(this.A) && otherAsCommutator?.B.isIdentical(this.B));
-  }
-  invert() {
-    return new _Commutator(__privateGet(this, _B), __privateGet(this, _A));
-  }
-  *experimentalExpand(iterDir = IterationDirection.Forwards, depth) {
-    depth ?? (depth = Infinity);
-    if (depth === 0) {
-      yield iterDir === IterationDirection.Forwards ? this : this.invert();
-    } else {
-      if (iterDir === IterationDirection.Forwards) {
-        yield* this.A.experimentalExpand(IterationDirection.Forwards, depth - 1);
-        yield* this.B.experimentalExpand(IterationDirection.Forwards, depth - 1);
-        yield* this.A.experimentalExpand(IterationDirection.Backwards, depth - 1);
-        yield* this.B.experimentalExpand(IterationDirection.Backwards, depth - 1);
-      } else {
-        yield* this.B.experimentalExpand(IterationDirection.Forwards, depth - 1);
-        yield* this.A.experimentalExpand(IterationDirection.Forwards, depth - 1);
-        yield* this.B.experimentalExpand(IterationDirection.Backwards, depth - 1);
-        yield* this.A.experimentalExpand(IterationDirection.Backwards, depth - 1);
-      }
-    }
-  }
-  toString() {
-    return `[${__privateGet(this, _A).toString()}, ${__privateGet(this, _B).toString()}]`;
-  }
-};
-var Commutator = _Commutator;
-_A = new WeakMap();
-_B = new WeakMap();
-
-// src/cubing/alg/units/containers/Conjugate.ts
-var _A2, _B2;
-var _Conjugate = class extends AlgCommon {
-  constructor(aSource, bSource) {
-    super();
-    __privateAdd(this, _A2, void 0);
-    __privateAdd(this, _B2, void 0);
-    __privateSet(this, _A2, experimentalEnsureAlg(aSource));
-    __privateSet(this, _B2, experimentalEnsureAlg(bSource));
-  }
-  get A() {
-    return __privateGet(this, _A2);
-  }
-  get B() {
-    return __privateGet(this, _B2);
-  }
-  isIdentical(other) {
-    const otherAsConjugate = other.as(_Conjugate);
-    return !!(otherAsConjugate?.A.isIdentical(this.A) && otherAsConjugate?.B.isIdentical(this.B));
-  }
-  invert() {
-    return new _Conjugate(__privateGet(this, _A2), __privateGet(this, _B2).invert());
-  }
-  *experimentalExpand(iterDir, depth) {
-    depth ?? (depth = Infinity);
-    if (depth === 0) {
-      yield iterDir === IterationDirection.Forwards ? this : this.invert();
-    } else {
-      yield* this.A.experimentalExpand(IterationDirection.Forwards, depth - 1);
-      yield* this.B.experimentalExpand(iterDir, depth - 1);
-      yield* this.A.experimentalExpand(IterationDirection.Backwards, depth - 1);
-    }
-  }
-  toString() {
-    return `[${this.A}: ${this.B}]`;
-  }
-};
-var Conjugate = _Conjugate;
-_A2 = new WeakMap();
-_B2 = new WeakMap();
-
-// src/cubing/alg/units/leaves/LineComment.ts
-var _text;
-var _LineComment = class extends AlgCommon {
-  constructor(commentText) {
-    super();
-    __privateAdd(this, _text, void 0);
-    if (commentText.includes("\n") || commentText.includes("\r")) {
-      throw new Error("LineComment cannot contain newline");
-    }
-    __privateSet(this, _text, commentText);
-  }
-  get text() {
-    return __privateGet(this, _text);
-  }
-  isIdentical(other) {
-    const otherAsLineComment = other;
-    return other.is(_LineComment) && __privateGet(this, _text) === __privateGet(otherAsLineComment, _text);
-  }
-  invert() {
-    return this;
-  }
-  *experimentalExpand(_iterDir = IterationDirection.Forwards, _depth = Infinity) {
-    yield this;
-  }
-  toString() {
-    return `//${__privateGet(this, _text)}`;
-  }
-};
-var LineComment = _LineComment;
-_text = new WeakMap();
-
-// src/cubing/alg/units/leaves/Newline.ts
-var Newline = class extends AlgCommon {
-  toString() {
-    return `
-`;
-  }
-  isIdentical(other) {
-    return other.is(Newline);
-  }
-  invert() {
-    return this;
-  }
-  *experimentalExpand(_iterDir = IterationDirection.Forwards, _depth = Infinity) {
-    yield this;
-  }
-};
-
-// src/cubing/alg/units/leaves/Pause.ts
-var Pause = class extends AlgCommon {
-  toString() {
-    return `.`;
-  }
-  isIdentical(other) {
-    return other.is(Pause);
-  }
-  invert() {
-    return this;
-  }
-  *experimentalExpand(_iterDir = IterationDirection.Forwards, _depth = Infinity) {
-    yield this;
-  }
-};
-
-// src/cubing/alg/parse.ts
-function parseIntWithEmptyFallback(n, emptyFallback) {
-  return n ? parseInt(n) : emptyFallback;
-}
-var amountRegex = /^(\d+)?('?)/;
-var moveStartRegex = /^[_\dA-Za-z]/;
-var quantumMoveRegex = /^((([1-9]\d*)-)?([1-9]\d*))?([_A-Za-z]+)?/;
-var commentTextRegex = /^[^\n]*/;
-var square1PairStart = /^(-?\d+), ?/;
-var square1PairEnd = /^(-?\d+)\)/;
-function parseAlg(s) {
-  return new AlgParser().parseAlg(s);
-}
-function parseMove(s) {
-  return new AlgParser().parseMove(s);
-}
-function parseQuantumMove(s) {
-  return new AlgParser().parseQuantumMove(s);
-}
-function addCharIndices(t, startCharIndex, endCharIndex) {
-  const parsedT = t;
-  parsedT.startCharIndex = startCharIndex;
-  parsedT.endCharIndex = endCharIndex;
-  return parsedT;
-}
-function transferCharIndex(from, to) {
-  if ("startCharIndex" in from) {
-    to.startCharIndex = from.startCharIndex;
-  }
-  if ("endCharIndex" in from) {
-    to.endCharIndex = from.endCharIndex;
-  }
-  return to;
-}
-var _input, _idx;
-var AlgParser = class {
-  constructor() {
-    __privateAdd(this, _input, "");
-    __privateAdd(this, _idx, 0);
-  }
-  parseAlg(input) {
-    __privateSet(this, _input, input);
-    __privateSet(this, _idx, 0);
-    const alg = this.parseAlgWithStopping([]);
-    this.mustBeAtEndOfInput();
-    return alg;
-  }
-  parseMove(input) {
-    __privateSet(this, _input, input);
-    __privateSet(this, _idx, 0);
-    const move = this.parseMoveImpl();
-    this.mustBeAtEndOfInput();
-    return move;
-  }
-  parseQuantumMove(input) {
-    __privateSet(this, _input, input);
-    __privateSet(this, _idx, 0);
-    const quantumMove = this.parseQuantumMoveImpl();
-    this.mustBeAtEndOfInput();
-    return quantumMove;
-  }
-  mustBeAtEndOfInput() {
-    if (__privateGet(this, _idx) !== __privateGet(this, _input).length) {
-      throw new Error("parsing unexpectedly ended early");
-    }
-  }
-  parseAlgWithStopping(stopBefore) {
-    let algStartIdx = __privateGet(this, _idx);
-    let algEndIdx = __privateGet(this, _idx);
-    const algBuilder = new AlgBuilder();
-    let crowded = false;
-    const mustNotBeCrowded = (idx) => {
-      if (crowded) {
-        throw new Error(`Unexpected character at index ${idx}. Are you missing a space?`);
-      }
-    };
-    mainLoop:
-      while (__privateGet(this, _idx) < __privateGet(this, _input).length) {
-        const savedCharIndex = __privateGet(this, _idx);
-        if (stopBefore.includes(__privateGet(this, _input)[__privateGet(this, _idx)])) {
-          return addCharIndices(algBuilder.toAlg(), algStartIdx, algEndIdx);
-        }
-        if (this.tryConsumeNext(" ")) {
-          crowded = false;
-          if (algBuilder.experimentalNumUnits() === 0) {
-            algStartIdx = __privateGet(this, _idx);
-          }
-          continue mainLoop;
-        } else if (moveStartRegex.test(__privateGet(this, _input)[__privateGet(this, _idx)])) {
-          mustNotBeCrowded(savedCharIndex);
-          const move = this.parseMoveImpl();
-          algBuilder.push(move);
-          crowded = true;
-          algEndIdx = __privateGet(this, _idx);
-          continue mainLoop;
-        } else if (this.tryConsumeNext("(")) {
-          mustNotBeCrowded(savedCharIndex);
-          const sq1PairStartMatch = this.tryRegex(square1PairStart);
-          if (sq1PairStartMatch) {
-            const topAmountString = sq1PairStartMatch[1];
-            const savedCharIndexD = __privateGet(this, _idx);
-            const sq1PairEndMatch = this.parseRegex(square1PairEnd);
-            const uMove = addCharIndices(new Move(new QuantumMove("U_SQ_"), parseInt(topAmountString)), savedCharIndex + 1, savedCharIndex + 1 + topAmountString.length);
-            const dMove = addCharIndices(new Move(new QuantumMove("D_SQ_"), parseInt(sq1PairEndMatch[1])), savedCharIndexD, __privateGet(this, _idx) - 1);
-            const alg = addCharIndices(new Alg([uMove, dMove]), savedCharIndex + 1, __privateGet(this, _idx) - 1);
-            algBuilder.push(addCharIndices(new Grouping(alg), savedCharIndex, __privateGet(this, _idx)));
-            crowded = true;
-            algEndIdx = __privateGet(this, _idx);
-            continue mainLoop;
-          } else {
-            const alg = this.parseAlgWithStopping([")"]);
-            this.mustConsumeNext(")");
-            const amount = this.parseAmount();
-            algBuilder.push(addCharIndices(new Grouping(alg, amount), savedCharIndex, __privateGet(this, _idx)));
-            crowded = true;
-            algEndIdx = __privateGet(this, _idx);
-            continue mainLoop;
-          }
-        } else if (this.tryConsumeNext("[")) {
-          mustNotBeCrowded(savedCharIndex);
-          const A = this.parseAlgWithStopping([",", ":"]);
-          const separator = this.popNext();
-          const B = this.parseAlgWithStopping(["]"]);
-          this.mustConsumeNext("]");
-          switch (separator) {
-            case ":":
-              algBuilder.push(addCharIndices(new Conjugate(A, B), savedCharIndex, __privateGet(this, _idx)));
-              crowded = true;
-              algEndIdx = __privateGet(this, _idx);
-              continue mainLoop;
-            case ",":
-              algBuilder.push(addCharIndices(new Commutator(A, B), savedCharIndex, __privateGet(this, _idx)));
-              crowded = true;
-              algEndIdx = __privateGet(this, _idx);
-              continue mainLoop;
-            default:
-              throw "unexpected parsing error";
-          }
-        } else if (this.tryConsumeNext("\n")) {
-          algBuilder.push(addCharIndices(new Newline(), savedCharIndex, __privateGet(this, _idx)));
-          crowded = false;
-          algEndIdx = __privateGet(this, _idx);
-          continue mainLoop;
-        } else if (this.tryConsumeNext("/")) {
-          if (this.tryConsumeNext("/")) {
-            mustNotBeCrowded(savedCharIndex);
-            const [text] = this.parseRegex(commentTextRegex);
-            algBuilder.push(addCharIndices(new LineComment(text), savedCharIndex, __privateGet(this, _idx)));
-            crowded = false;
-            algEndIdx = __privateGet(this, _idx);
-            continue mainLoop;
-          } else {
-            algBuilder.push(addCharIndices(new Move("_SLASH_"), savedCharIndex, __privateGet(this, _idx)));
-            crowded = true;
-            algEndIdx = __privateGet(this, _idx);
-            continue mainLoop;
-          }
-        } else if (this.tryConsumeNext(".")) {
-          mustNotBeCrowded(savedCharIndex);
-          algBuilder.push(addCharIndices(new Pause(), savedCharIndex, __privateGet(this, _idx)));
-          crowded = true;
-          algEndIdx = __privateGet(this, _idx);
-          continue mainLoop;
-        } else {
-          throw new Error(`Unexpected character: ${this.popNext()}`);
-        }
-      }
-    if (__privateGet(this, _idx) !== __privateGet(this, _input).length) {
-      throw new Error("did not finish parsing?");
-    }
-    if (stopBefore.length > 0) {
-      throw new Error("expected stopping");
-    }
-    return addCharIndices(algBuilder.toAlg(), algStartIdx, algEndIdx);
-  }
-  parseQuantumMoveImpl() {
-    const [, , , outerLayerStr, innerLayerStr, family] = this.parseRegex(quantumMoveRegex);
-    return new QuantumMove(family, parseIntWithEmptyFallback(innerLayerStr, void 0), parseIntWithEmptyFallback(outerLayerStr, void 0));
-  }
-  parseMoveImpl() {
-    const savedCharIndex = __privateGet(this, _idx);
-    if (this.tryConsumeNext("/")) {
-      return addCharIndices(new Move("_SLASH_"), savedCharIndex, __privateGet(this, _idx));
-    }
-    let quantumMove = this.parseQuantumMoveImpl();
-    let [amount, hadEmptyAbsAmount] = this.parseAmountAndTrackEmptyAbsAmount();
-    const suffix = this.parseMoveSuffix();
-    if (suffix) {
-      if (amount < 0) {
-        throw new Error("uh-oh");
-      }
-      if ((suffix === "++" || suffix === "--") && amount !== 1) {
-        throw new Error("Pochmann ++ or -- moves cannot have an amount other than 1.");
-      }
-      if ((suffix === "++" || suffix === "--") && !hadEmptyAbsAmount) {
-        throw new Error("Pochmann ++ or -- moves cannot have an amount written as a number.");
-      }
-      if ((suffix === "+" || suffix === "-") && hadEmptyAbsAmount) {
-        throw new Error("Clock dial moves must have an amount written as a natural number followed by + or -.");
-      }
-      if (suffix.startsWith("+")) {
-        quantumMove = quantumMove.modified({
-          family: `${quantumMove.family}_${suffix === "+" ? "PLUS" : "PLUSPLUS"}_`
-        });
-      }
-      if (suffix.startsWith("-")) {
-        quantumMove = quantumMove.modified({
-          family: `${quantumMove.family}_${suffix === "-" ? "PLUS" : "PLUSPLUS"}_`
-        });
-        amount *= -1;
-      }
-    }
-    const move = addCharIndices(new Move(quantumMove, amount), savedCharIndex, __privateGet(this, _idx));
-    return move;
-  }
-  parseMoveSuffix() {
-    if (this.tryConsumeNext("+")) {
-      if (this.tryConsumeNext("+")) {
-        return "++";
-      }
-      return "+";
-    }
-    if (this.tryConsumeNext("-")) {
-      if (this.tryConsumeNext("-")) {
-        return "--";
-      }
-      return "-";
-    }
-    return null;
-  }
-  parseAmountAndTrackEmptyAbsAmount() {
-    const savedIdx = __privateGet(this, _idx);
-    const [, absAmountStr, primeStr] = this.parseRegex(amountRegex);
-    if (absAmountStr?.startsWith("0") && absAmountStr !== "0") {
-      throw new Error(`Error at char index ${savedIdx}: An amount can only start with 0 if it's exactly the digit 0.`);
-    }
-    return [
-      parseIntWithEmptyFallback(absAmountStr, 1) * (primeStr === "'" ? -1 : 1),
-      !absAmountStr
-    ];
-  }
-  parseAmount() {
-    const savedIdx = __privateGet(this, _idx);
-    const [, absAmountStr, primeStr] = this.parseRegex(amountRegex);
-    if (absAmountStr?.startsWith("0") && absAmountStr !== "0") {
-      throw new Error(`Error at char index ${savedIdx}: An amount number can only start with 0 if it's exactly the digit 0.`);
-    }
-    return parseIntWithEmptyFallback(absAmountStr, 1) * (primeStr === "'" ? -1 : 1);
-  }
-  parseRegex(regex) {
-    const arr = regex.exec(this.remaining());
-    if (arr === null) {
-      throw new Error("internal parsing error");
-    }
-    __privateSet(this, _idx, __privateGet(this, _idx) + arr[0].length);
-    return arr;
-  }
-  tryRegex(regex) {
-    const arr = regex.exec(this.remaining());
-    if (arr === null) {
-      return null;
-    }
-    __privateSet(this, _idx, __privateGet(this, _idx) + arr[0].length);
-    return arr;
-  }
-  remaining() {
-    return __privateGet(this, _input).slice(__privateGet(this, _idx));
-  }
-  popNext() {
-    const next = __privateGet(this, _input)[__privateGet(this, _idx)];
-    __privateWrapper(this, _idx)._++;
-    return next;
-  }
-  tryConsumeNext(expected) {
-    if (__privateGet(this, _input)[__privateGet(this, _idx)] === expected) {
-      __privateWrapper(this, _idx)._++;
-      return true;
-    }
-    return false;
-  }
-  mustConsumeNext(expected) {
-    const next = this.popNext();
-    if (next !== expected) {
-      throw new Error(`expected \`${expected}\` while parsing, encountered ${next}`);
-    }
-    return next;
-  }
-};
-_input = new WeakMap();
-_idx = new WeakMap();
-
-// src/cubing/alg/warnOnce.ts
-var warned = new Set();
-function warnOnce(s) {
-  if (!warned.has(s)) {
-    console.warn(s);
-    warned.add(s);
-  }
-}
-
-// src/cubing/alg/units/QuantumWithAmount.ts
-var QuantumWithAmount = class {
-  constructor(quantum, amount = 1) {
-    this.quantum = quantum;
-    this.amount = amount;
-    if (!Number.isInteger(this.amount) || this.amount < MIN_INT || this.amount > MAX_INT) {
-      throw new Error(`Unit amount absolute value must be a non-negative integer from ${MAX_INT_DESCRIPTION} to ${MAX_INT_DESCRIPTION}.`);
-    }
-  }
-  suffix() {
-    let s = "";
-    const absAmount = Math.abs(this.amount);
-    if (absAmount !== 1) {
-      s += absAmount;
-    }
-    if (this.amount < 0) {
-      s += "'";
-    }
-    return s;
-  }
-  isIdentical(other) {
-    return this.quantum.isIdentical(other.quantum) && this.amount === other.amount;
-  }
-  *experimentalExpand(iterDir, depth) {
-    const absAmount = Math.abs(this.amount);
-    const newIterDir = toggleDirection(iterDir, this.amount < 0);
-    for (let i = 0; i < absAmount; i++) {
-      yield* this.quantum.experimentalExpand(newIterDir, depth);
-    }
-  }
-};
-
-// src/cubing/alg/units/leaves/Move.ts
-var _family, _innerLayer, _outerLayer;
-var _QuantumMove = class extends Comparable {
-  constructor(family, innerLayer, outerLayer) {
-    super();
-    __privateAdd(this, _family, void 0);
-    __privateAdd(this, _innerLayer, void 0);
-    __privateAdd(this, _outerLayer, void 0);
-    __privateSet(this, _family, family);
-    __privateSet(this, _innerLayer, innerLayer ?? null);
-    __privateSet(this, _outerLayer, outerLayer ?? null);
-    Object.freeze(this);
-    if (__privateGet(this, _innerLayer) !== null && (!Number.isInteger(__privateGet(this, _innerLayer)) || __privateGet(this, _innerLayer) < 1 || __privateGet(this, _innerLayer) > MAX_INT)) {
-      throw new Error(`QuantumMove inner layer must be a positive integer below ${MAX_INT_DESCRIPTION}.`);
-    }
-    if (__privateGet(this, _outerLayer) !== null && (!Number.isInteger(__privateGet(this, _outerLayer)) || __privateGet(this, _outerLayer) < 1 || __privateGet(this, _outerLayer) > MAX_INT)) {
-      throw new Error(`QuantumMove outer layer must be a positive integer below ${MAX_INT_DESCRIPTION}.`);
-    }
-    if (__privateGet(this, _outerLayer) !== null && __privateGet(this, _innerLayer) !== null && __privateGet(this, _innerLayer) <= __privateGet(this, _outerLayer)) {
-      throw new Error("QuantumMove outer layer must be smaller than inner layer.");
-    }
-    if (__privateGet(this, _outerLayer) !== null && __privateGet(this, _innerLayer) === null) {
-      throw new Error("QuantumMove with an outer layer must have an inner layer");
-    }
-  }
-  static fromString(s) {
-    return parseQuantumMove(s);
-  }
-  modified(modifications) {
-    return new _QuantumMove(modifications.family ?? __privateGet(this, _family), modifications.innerLayer ?? __privateGet(this, _innerLayer), modifications.outerLayer ?? __privateGet(this, _outerLayer));
-  }
-  isIdentical(other) {
-    const otherAsQuantumMove = other;
-    return other.is(_QuantumMove) && __privateGet(this, _family) === __privateGet(otherAsQuantumMove, _family) && __privateGet(this, _innerLayer) === __privateGet(otherAsQuantumMove, _innerLayer) && __privateGet(this, _outerLayer) === __privateGet(otherAsQuantumMove, _outerLayer);
-  }
-  get family() {
-    return __privateGet(this, _family);
-  }
-  get outerLayer() {
-    return __privateGet(this, _outerLayer);
-  }
-  get innerLayer() {
-    return __privateGet(this, _innerLayer);
-  }
-  experimentalExpand() {
-    throw new Error("experimentalExpand() cannot be called on a `QuantumMove` directly.");
-  }
-  toString() {
-    let s = __privateGet(this, _family);
-    if (__privateGet(this, _innerLayer) !== null) {
-      s = String(__privateGet(this, _innerLayer)) + s;
-      if (__privateGet(this, _outerLayer) !== null) {
-        s = String(__privateGet(this, _outerLayer)) + "-" + s;
-      }
-    }
-    return s;
-  }
-};
-var QuantumMove = _QuantumMove;
-_family = new WeakMap();
-_innerLayer = new WeakMap();
-_outerLayer = new WeakMap();
-var _quantumWithAmount;
-var _Move = class extends AlgCommon {
-  constructor(...args) {
-    super();
-    __privateAdd(this, _quantumWithAmount, void 0);
-    if (typeof args[0] === "string") {
-      if (args[1] ?? null) {
-        __privateSet(this, _quantumWithAmount, new QuantumWithAmount(QuantumMove.fromString(args[0]), args[1]));
-        return;
-      } else {
-        return _Move.fromString(args[0]);
-      }
-    }
-    __privateSet(this, _quantumWithAmount, new QuantumWithAmount(args[0], args[1]));
-  }
-  isIdentical(other) {
-    const otherAsMove = other.as(_Move);
-    return !!otherAsMove && __privateGet(this, _quantumWithAmount).isIdentical(__privateGet(otherAsMove, _quantumWithAmount));
-  }
-  invert() {
-    return transferCharIndex(this, new _Move(__privateGet(this, _quantumWithAmount).quantum, -this.amount));
-  }
-  *experimentalExpand(iterDir = IterationDirection.Forwards) {
-    if (iterDir === IterationDirection.Forwards) {
-      yield this;
-    } else {
-      yield this.modified({
-        amount: -this.amount
-      });
-    }
-  }
-  get quantum() {
-    return __privateGet(this, _quantumWithAmount).quantum;
-  }
-  modified(modifications) {
-    return new _Move(__privateGet(this, _quantumWithAmount).quantum.modified(modifications), modifications.amount ?? this.amount);
-  }
-  static fromString(s) {
-    return parseMove(s);
-  }
-  get amount() {
-    return __privateGet(this, _quantumWithAmount).amount;
-  }
-  get type() {
-    warnOnce("deprecated: type");
-    return "blockMove";
-  }
-  get family() {
-    return __privateGet(this, _quantumWithAmount).quantum.family ?? void 0;
-  }
-  get outerLayer() {
-    return __privateGet(this, _quantumWithAmount).quantum.outerLayer ?? void 0;
-  }
-  get innerLayer() {
-    return __privateGet(this, _quantumWithAmount).quantum.innerLayer ?? void 0;
-  }
-  toString() {
-    if (this.family === "_SLASH_") {
-      return "/";
-    }
-    if (this.family.endsWith("_PLUS_")) {
-      return __privateGet(this, _quantumWithAmount).quantum.toString().slice(0, -6) + Math.abs(this.amount) + (this.amount < 0 ? "-" : "+");
-    }
-    if (this.family.endsWith("_PLUSPLUS_")) {
-      const absAmount = Math.abs(this.amount);
-      return __privateGet(this, _quantumWithAmount).quantum.toString().slice(0, -10) + (absAmount === 1 ? "" : absAmount) + (this.amount < 0 ? "--" : "++");
-    }
-    return __privateGet(this, _quantumWithAmount).quantum.toString() + __privateGet(this, _quantumWithAmount).suffix();
-  }
-};
-var Move = _Move;
-_quantumWithAmount = new WeakMap();
-
-// src/cubing/alg/units/containers/Grouping.ts
-var Square1TupleFormatter = class {
-  constructor() {
-    this.quantumU_SQ_ = null;
-    this.quantumD_SQ_ = null;
-  }
-  format(grouping) {
-    const amounts = this.tuple(grouping);
-    if (!amounts) {
-      return null;
-    }
-    return `(${amounts.map((move) => move.amount).join(", ")})`;
-  }
-  tuple(grouping) {
-    this.quantumU_SQ_ || (this.quantumU_SQ_ = new QuantumMove("U_SQ_"));
-    this.quantumD_SQ_ || (this.quantumD_SQ_ = new QuantumMove("D_SQ_"));
-    const quantumAlg = grouping.alg;
-    if (quantumAlg.experimentalNumUnits() === 2) {
-      const [U, D] = quantumAlg.units();
-      if (U.as(Move)?.quantum.isIdentical(this.quantumU_SQ_) && D.as(Move)?.quantum.isIdentical(this.quantumD_SQ_)) {
-        if (grouping.amount !== 1) {
-          throw new Error("Square-1 tuples cannot have an amount other than 1.");
-        }
-        return [U, D];
-      }
-    }
-    return null;
-  }
-};
-var square1TupleFormatterInstance = new Square1TupleFormatter();
-var _quantumWithAmount2;
-var _Grouping = class extends AlgCommon {
-  constructor(algSource, amount) {
-    super();
-    __privateAdd(this, _quantumWithAmount2, void 0);
-    const alg = experimentalEnsureAlg(algSource);
-    __privateSet(this, _quantumWithAmount2, new QuantumWithAmount(alg, amount));
-  }
-  isIdentical(other) {
-    const otherAsGrouping = other;
-    return other.is(_Grouping) && __privateGet(this, _quantumWithAmount2).isIdentical(__privateGet(otherAsGrouping, _quantumWithAmount2));
-  }
-  get alg() {
-    return __privateGet(this, _quantumWithAmount2).quantum;
-  }
-  get amount() {
-    return __privateGet(this, _quantumWithAmount2).amount;
-  }
-  get experimentalRepetitionSuffix() {
-    return __privateGet(this, _quantumWithAmount2).suffix();
-  }
-  invert() {
-    return new _Grouping(__privateGet(this, _quantumWithAmount2).quantum, -__privateGet(this, _quantumWithAmount2).amount);
-  }
-  *experimentalExpand(iterDir = IterationDirection.Forwards, depth) {
-    depth ?? (depth = Infinity);
-    if (depth === 0) {
-      yield iterDir === IterationDirection.Forwards ? this : this.invert();
-    } else {
-      yield* __privateGet(this, _quantumWithAmount2).experimentalExpand(iterDir, depth - 1);
-    }
-  }
-  static fromString() {
-    throw new Error("unimplemented");
-  }
-  toString() {
-    return square1TupleFormatterInstance.format(this) ?? `(${__privateGet(this, _quantumWithAmount2).quantum.toString()})${__privateGet(this, _quantumWithAmount2).suffix()}`;
-  }
-  experimentalAsSquare1Tuple() {
-    return square1TupleFormatterInstance.tuple(this);
-  }
-};
-var Grouping = _Grouping;
-_quantumWithAmount2 = new WeakMap();
-
-// src/cubing/alg/is.ts
-function experimentalIs(v, c) {
-  return v instanceof c;
-}
-function experimentalIsUnit(v) {
-  return experimentalIs(v, Grouping) || experimentalIs(v, LineComment) || experimentalIs(v, Commutator) || experimentalIs(v, Conjugate) || experimentalIs(v, Move) || experimentalIs(v, Newline) || experimentalIs(v, Pause);
-}
-
-// src/cubing/alg/traversal.ts
-function dispatch(t, unit, dataDown) {
-  if (unit.is(Grouping)) {
-    return t.traverseGrouping(unit, dataDown);
-  }
-  if (unit.is(Move)) {
-    return t.traverseMove(unit, dataDown);
-  }
-  if (unit.is(Commutator)) {
-    return t.traverseCommutator(unit, dataDown);
-  }
-  if (unit.is(Conjugate)) {
-    return t.traverseConjugate(unit, dataDown);
-  }
-  if (unit.is(Pause)) {
-    return t.traversePause(unit, dataDown);
-  }
-  if (unit.is(Newline)) {
-    return t.traverseNewline(unit, dataDown);
-  }
-  if (unit.is(LineComment)) {
-    return t.traverseLineComment(unit, dataDown);
-  }
-  throw new Error(`unknown unit`);
-}
-function assertIsUnit(t) {
-  if (t.is(Grouping) || t.is(Move) || t.is(Commutator) || t.is(Conjugate) || t.is(Pause) || t.is(Newline) || t.is(LineComment)) {
-    return t;
-  }
-  throw "internal error: expected unit";
-}
-var TraversalDownUp = class {
-  traverseUnit(unit, dataDown) {
-    return dispatch(this, unit, dataDown);
-  }
-  traverseIntoUnit(unit, dataDown) {
-    return assertIsUnit(this.traverseUnit(unit, dataDown));
-  }
-};
-var _newAmount, newAmount_fn;
-var _Simplify = class extends TraversalDownUp {
-  *traverseAlg(alg, options) {
-    if (options.depth === 0) {
-      yield* alg.units();
-      return;
-    }
-    const newUnits = [];
-    let lastUnit = null;
-    const collapseMoves = options?.collapseMoves ?? true;
-    function appendMoveWithNewAmount(move, deltaAmount) {
-      var _a;
-      const newAmount = __privateMethod(_a = _Simplify, _newAmount, newAmount_fn).call(_a, move, deltaAmount, options);
-      if (newAmount === 0) {
-        return false;
-      }
-      const newMove = new Move(move.quantum, newAmount);
-      newUnits.push(newMove);
-      lastUnit = newMove;
-      return true;
-    }
-    function appendCollapsed(newUnit) {
-      if (collapseMoves && lastUnit?.is(Move) && newUnit.is(Move) && lastUnit.quantum.isIdentical(newUnit.quantum)) {
-        newUnits.pop();
-        if (!appendMoveWithNewAmount(lastUnit, newUnit.amount)) {
-          lastUnit = newUnits.slice(-1)[0];
-        }
-      } else {
-        if (newUnit.is(Move)) {
-          appendMoveWithNewAmount(newUnit, 0);
-        } else {
-          newUnits.push(newUnit);
-          lastUnit = newUnit;
-        }
-      }
-    }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null
-    };
-    for (const unit of alg.units()) {
-      for (const ancestorUnit of this.traverseUnit(unit, newOptions)) {
-        appendCollapsed(ancestorUnit);
-      }
-    }
-    for (const unit of newUnits) {
-      yield unit;
-    }
-  }
-  *traverseGrouping(grouping, options) {
-    if (options.depth === 0) {
-      yield grouping;
-      return;
-    }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null
-    };
-    yield new Grouping(this.traverseAlg(grouping.alg, newOptions));
-  }
-  *traverseMove(move, _options) {
-    yield move;
-  }
-  *traverseCommutator(commutator, options) {
-    if (options.depth === 0) {
-      yield commutator;
-      return;
-    }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null
-    };
-    yield new Commutator(this.traverseAlg(commutator.A, newOptions), this.traverseAlg(commutator.B, newOptions));
-  }
-  *traverseConjugate(conjugate, options) {
-    if (options.depth === 0) {
-      yield conjugate;
-      return;
-    }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null
-    };
-    yield new Conjugate(this.traverseAlg(conjugate.A, newOptions), this.traverseAlg(conjugate.B, newOptions));
-  }
-  *traversePause(pause, _options) {
-    yield pause;
-  }
-  *traverseNewline(newline, _options) {
-    yield newline;
-  }
-  *traverseLineComment(comment, _options) {
-    yield comment;
-  }
-};
-var Simplify = _Simplify;
-_newAmount = new WeakSet();
-newAmount_fn = function(move, deltaAmount, options) {
-  let newAmount = move.amount + deltaAmount;
-  if (options?.quantumMoveOrder) {
-    const order = options.quantumMoveOrder(move.quantum);
-    const min = Math.floor(order / 2) + 1 - order;
-    newAmount = (newAmount % order + order - min) % order + min;
-  }
-  return newAmount;
-};
-__privateAdd(Simplify, _newAmount);
-var simplifyInstance = new Simplify();
-var simplify = simplifyInstance.traverseAlg.bind(simplifyInstance);
-
-// src/cubing/alg/Alg.ts
-function toIterable(input) {
-  if (!input) {
-    return [];
-  }
-  if (experimentalIs(input, Alg)) {
-    return input.units();
-  }
-  if (typeof input === "string") {
-    return parseAlg(input).units();
-  }
-  const iter = input;
-  if (typeof iter[Symbol.iterator] === "function") {
-    return iter;
-  }
-  throw "Invalid unit";
-}
-function experimentalEnsureAlg(alg) {
-  if (experimentalIs(alg, Alg)) {
-    return alg;
-  }
-  return new Alg(alg);
-}
-var _units2;
-var _Alg = class extends AlgCommon {
-  constructor(alg) {
-    super();
-    __privateAdd(this, _units2, void 0);
-    __privateSet(this, _units2, Array.from(toIterable(alg)));
-    for (const unit of __privateGet(this, _units2)) {
-      if (!experimentalIsUnit(unit)) {
-        throw new Error("An alg can only contain units.");
-      }
-    }
-  }
-  isIdentical(other) {
-    const otherAsAlg = other;
-    if (!other.is(_Alg)) {
-      return false;
-    }
-    const l1 = Array.from(__privateGet(this, _units2));
-    const l2 = Array.from(__privateGet(otherAsAlg, _units2));
-    if (l1.length !== l2.length) {
-      return false;
-    }
-    for (let i = 0; i < l1.length; i++) {
-      if (!l1[i].isIdentical(l2[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  invert() {
-    return new _Alg(reverse(Array.from(__privateGet(this, _units2)).map((u) => u.invert())));
-  }
-  *experimentalExpand(iterDir = IterationDirection.Forwards, depth) {
-    depth ?? (depth = Infinity);
-    for (const unit of direct(__privateGet(this, _units2), iterDir)) {
-      yield* unit.experimentalExpand(iterDir, depth);
-    }
-  }
-  expand(options) {
-    return new _Alg(this.experimentalExpand(IterationDirection.Forwards, options?.depth ?? Infinity));
-  }
-  *experimentalLeafMoves() {
-    for (const leaf of this.experimentalExpand()) {
-      if (leaf.is(Move)) {
-        yield leaf;
-      }
-    }
-  }
-  concat(input) {
-    return new _Alg(Array.from(__privateGet(this, _units2)).concat(Array.from(toIterable(input))));
-  }
-  experimentalIsEmpty() {
-    for (const _ of __privateGet(this, _units2)) {
-      return false;
-    }
-    return true;
-  }
-  static fromString(s) {
-    return parseAlg(s);
-  }
-  *units() {
-    for (const unit of __privateGet(this, _units2)) {
-      yield unit;
-    }
-  }
-  experimentalNumUnits() {
-    return Array.from(__privateGet(this, _units2)).length;
-  }
-  get type() {
-    warnOnce("deprecated: type");
-    return "sequence";
-  }
-  toString() {
-    let output = "";
-    let previousUnit = null;
-    for (const unit of __privateGet(this, _units2)) {
-      if (previousUnit) {
-        output += spaceBetween(previousUnit, unit);
-      }
-      output += unit.toString();
-      previousUnit = unit;
-    }
-    return output;
-  }
-  simplify(options) {
-    return new _Alg(simplify(this, options ?? {}));
-  }
-};
-var Alg = _Alg;
-_units2 = new WeakMap();
-function spaceBetween(u1, u2) {
-  if (u1.is(Newline) || u2.is(Newline)) {
-    return "";
-  }
-  if (u1.is(LineComment) && !u2.is(Newline)) {
-    return "\n";
-  }
-  return " ";
-}
-
-// src/cubing/alg/example.ts
-var Example = {
-  Sune: new Alg([
-    new Move("R", 1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("U", 1),
-    new Move("R", 1),
-    new Move("U", -2),
-    new Move("R", -1)
-  ]),
-  AntiSune: new Alg([
-    new Move("R", 1),
-    new Move("U", 2),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("R", 1),
-    new Move("U", -1),
-    new Move("R", -1)
-  ]),
-  SuneCommutator: new Alg([
-    new Commutator(new Alg([new Move("R", 1), new Move("U", 1), new Move("R", -2)]), new Alg([
-      new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
-    ]))
-  ]),
-  Niklas: new Alg([
-    new Move("R", 1),
-    new Move("U", -1),
-    new Move("L", -1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("L", 1),
-    new Move("U", 1)
-  ]),
-  EPerm: new Alg([
-    new Move("x", -1),
-    new Commutator(new Alg([
-      new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", -1)]))
-    ]), new Alg([new Move("D", 1)])),
-    new Commutator(new Alg([
-      new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
-    ]), new Alg([new Move("D", 1)])),
-    new Move("x", 1)
-  ]),
-  FURURFCompact: new Alg([
-    new Conjugate(new Alg([new Move("F", 1)]), new Alg([
-      new Commutator(new Alg([new Move("U", 1)]), new Alg([new Move("R", 1)]))
-    ]))
-  ]),
-  APermCompact: new Alg([
-    new Conjugate(new Alg([new Move("R", 2)]), new Alg([
-      new Commutator(new Alg([new Move("F", 2)]), new Alg([new Move("R", -1), new Move("B", -1), new Move("R", 1)]))
-    ]))
-  ]),
-  FURURFMoves: new Alg([
-    new Move("F", 1),
-    new Move("U", 1),
-    new Move("R", 1),
-    new Move("U", -1),
-    new Move("R", -1),
-    new Move("F", -1)
-  ]),
-  TPerm: new Alg([
-    new Move("R", 1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("R", -1),
-    new Move("F", 1),
-    new Move("R", 2),
-    new Move("U", -1),
-    new Move("R", -1),
-    new Move("U", -1),
-    new Move("R", 1),
-    new Move("U", 1),
-    new Move("R", -1),
-    new Move("F", -1)
-  ]),
-  HeadlightSwaps: new Alg([
-    new Conjugate(new Alg([new Move("F", 1)]), new Alg([
-      new Grouping(new Alg([
-        new Commutator(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
-      ]), 3)
-    ]))
-  ]),
-  TriplePause: new Alg([new Pause(), new Pause(), new Pause()])
-};
-
-// src/cubing/alg/keyboard.ts
-var cubeKeyMapping = {
-  73: new Move("R"),
-  75: new Move("R'"),
-  87: new Move("B"),
-  79: new Move("B'"),
-  83: new Move("D"),
-  76: new Move("D'"),
-  68: new Move("L"),
-  69: new Move("L'"),
-  74: new Move("U"),
-  70: new Move("U'"),
-  72: new Move("F"),
-  71: new Move("F'"),
-  78: new Move("x'"),
-  67: new Move("l"),
-  82: new Move("l'"),
-  85: new Move("r"),
-  77: new Move("r'"),
-  88: new Move("d"),
-  188: new Move("d'"),
-  84: new Move("x"),
-  89: new Move("x"),
-  66: new Move("x'"),
-  186: new Move("y"),
-  59: new Move("y"),
-  65: new Move("y'"),
-  80: new Move("z"),
-  81: new Move("z'"),
-  90: new Move("M'"),
-  190: new Move("M'")
-};
+import {
+  Move,
+  QuantumMove
+} from "./chunk-EWRBHQFX.js";
 
 // src/cubing/puzzle-geometry/FaceNameSwizzler.ts
 var FaceNameSwizzler = class {
@@ -1648,21 +445,54 @@ var SkewbNotationMapper = class {
 };
 
 // src/cubing/puzzle-geometry/Options.ts
-function asstructured(v) {
-  if (typeof v === "string") {
-    return JSON.parse(v);
-  }
-  return v;
-}
-function asboolean(v) {
-  if (typeof v === "string") {
-    if (v === "false") {
-      return false;
+function parseOptions(argv) {
+  let argp = 0;
+  const options = {};
+  while (argp < argv.length && argv[argp][0] === "-") {
+    const option = argv[argp++];
+    if (option === "--rotations") {
+      options.addRotations = true;
+    } else if (option === "--allmoves") {
+      options.allMoves = true;
+    } else if (option === "--outerblockmoves") {
+      options.outerBlockMoves = true;
+    } else if (option === "--vertexmoves") {
+      options.vertexMoves = true;
+    } else if (option === "--nocorners") {
+      options.includeCornerOrbits = false;
+    } else if (option === "--noedges") {
+      options.includeEdgeOrbits = false;
+    } else if (option === "--noorientation") {
+      options.fixedOrientation = true;
+    } else if (option === "--nocenters") {
+      options.includeCenterOrbits = false;
+    } else if (option === "--omit") {
+      options.excludeOrbits = argv[argp].split(",");
+      argp++;
+    } else if (option === "--moves") {
+      options.moveList = argv[argp].split(",");
+      argp++;
+    } else if (option === "--optimize") {
+      options.optimizeOrbits = true;
+    } else if (option === "--scramble") {
+      options.scrambleAmount = 100;
+    } else if (option === "--fixcorner") {
+      options.fixedPieceType = "v";
+    } else if (option === "--fixedge") {
+      options.fixedPieceType = "e";
+    } else if (option === "--fixcenter") {
+      options.fixedPieceType = "f";
+    } else if (option === "--orientcenters") {
+      options.orientCenters = true;
+    } else if (option === "--puzzleorientation") {
+      options.puzzleOrientation = JSON.parse(argv[argp]);
+      argp++;
+    } else {
+      throw new Error("Bad option: " + option);
     }
-    return true;
-  } else {
-    return v ? true : false;
   }
+  const puzzleDescription = parsePuzzleDescription(argv.slice(argp).join(" "));
+  return { puzzleDescription, options };
 }
 var PuzzleGeometryFullOptions = class {
   constructor(options = {}) {
@@ -1688,62 +518,6 @@ var PuzzleGeometryFullOptions = class {
     Object.assign(this, options);
   }
 };
-function parsePGOptionList(optionlist) {
-  const options = {};
-  if (optionlist !== void 0) {
-    if (optionlist.length % 2 !== 0) {
-      throw new Error("Odd length in option list?");
-    }
-    for (let i = 0; i < optionlist.length; i += 2) {
-      if (optionlist[i] === "verbose") {
-        options.verbosity = (options.verbosity ?? 0) + 1;
-      } else if (optionlist[i] === "quiet") {
-        options.verbosity = 0;
-      } else if (optionlist[i] === "allmoves") {
-        options.allMoves = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "outerblockmoves") {
-        options.outerBlockMoves = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "vertexmoves") {
-        options.vertexMoves = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "rotations") {
-        options.addRotations = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "cornersets") {
-        options.includeCornerOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "centersets") {
-        options.includeCenterOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "edgesets") {
-        options.includeEdgeOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "omit") {
-        options.excludeOrbits = optionlist[i + 1];
-      } else if (optionlist[i] === "graycorners") {
-        options.grayCorners = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "graycenters") {
-        options.grayCenters = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "grayedges") {
-        options.grayEdges = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "movelist") {
-        options.moveList = asstructured(optionlist[i + 1]);
-      } else if (optionlist[i] === "killorientation") {
-        options.fixedOrientation = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "optimize") {
-        options.optimizeOrbits = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "scramble") {
-        options.scrambleAmount = optionlist[i + 1];
-      } else if (optionlist[i] === "fix") {
-        options.fixedPieceType = optionlist[i + 1];
-      } else if (optionlist[i] === "orientcenters") {
-        options.orientCenters = asboolean(optionlist[i + 1]);
-      } else if (optionlist[i] === "puzzleorientation") {
-        options.puzzleOrientation = asstructured(optionlist[i + 1]);
-      } else if (optionlist[i] === "puzzleorientations") {
-        options.puzzleOrientations = asstructured(optionlist[i + 1]);
-      } else {
-        throw new Error("Bad option while processing option list " + optionlist[i]);
-      }
-    }
-  }
-  return options;
-}
 
 // src/cubing/puzzle-geometry/Perm.ts
 var zeroCache = [];
@@ -1876,6 +650,7 @@ var PGOrbitDef = class {
     return factorial(this.size) * Math.pow(this.mod, this.size);
   }
 };
+var lastGlobalDefinitionCounter = 0;
 function externalName(mapper, moveString) {
   const mv = Move.fromString(moveString);
   const mv2 = mapper.notationToExternal(mv);
@@ -1892,14 +667,14 @@ var PGOrbitsDef = class {
     this.movenames = movenames;
     this.moveops = moveops;
   }
-  transformToKPuzzle(t) {
+  transformToKTransformationData(t) {
     const mp = {};
     for (let j = 0; j < this.orbitnames.length; j++) {
       mp[this.orbitnames[j]] = t.orbits[j].toKPuzzle();
     }
     return mp;
   }
-  static transformToKPuzzle(orbitnames, t) {
+  static transformToKTransformationData(orbitnames, t) {
     const mp = {};
     for (let j = 0; j < orbitnames.length; j++) {
       mp[orbitnames[j]] = t.orbits[j].toKPuzzle();
@@ -1939,7 +714,7 @@ var PGOrbitsDef = class {
     }
     return result;
   }
-  toKPuzzle(includemoves) {
+  toKPuzzleDefinition(includemoves) {
     const orbits = {};
     const start = {};
     for (let i = 0; i < this.orbitnames.length; i++) {
@@ -1947,15 +722,24 @@ var PGOrbitsDef = class {
         numPieces: this.orbitdefs[i].size,
         orientations: this.orbitdefs[i].mod
       };
-      start[this.orbitnames[i]] = this.solved.orbits[i].toKPuzzle();
+      const startTransformation = this.solved.orbits[i].toKPuzzle();
+      start[this.orbitnames[i]] = {
+        pieces: startTransformation.permutation,
+        orientation: startTransformation.orientation
+      };
     }
     const moves = {};
     if (includemoves) {
       for (let i = 0; i < this.movenames.length; i++) {
-        moves[this.movenames[i]] = this.transformToKPuzzle(this.moveops[i]);
+        moves[this.movenames[i]] = this.transformToKTransformationData(this.moveops[i]);
       }
     }
-    return { name: "PG3D", orbits, startPieces: start, moves };
+    return {
+      name: `PG3D #${++lastGlobalDefinitionCounter}`,
+      orbits,
+      startStateData: start,
+      moves
+    };
   }
   optimize() {
     const neworbitnames = [];
@@ -3231,9 +2015,12 @@ function findelement(a, p) {
   }
   throw new Error("Element not found");
 }
-function getpuzzles() {
+function getPG3DNamedPuzzles() {
   return PGPuzzles;
 }
+function getPuzzleDescriptionString(puzzleName) {
+  return PGPuzzles[puzzleName];
+}
 function parsePuzzleDescription(s) {
   const a = s.split(/ /).filter(Boolean);
   if (a.length % 2 === 0) {
@@ -3252,6 +2039,19 @@ function parsePuzzleDescription(s) {
   }
   return { shape, cuts };
 }
+function getPuzzleGeometryByDesc(desc, options = {}) {
+  const parsed = parsePuzzleDescription(desc);
+  if (parsed === null) {
+    throw new Error("Could not parse the puzzle description");
+  }
+  const pg = new PuzzleGeometry(parsed, Object.assign({}, { allMoves: true }, options));
+  pg.allstickers();
+  pg.genperms();
+  return pg;
+}
+function getPuzzleGeometryByName(puzzleName, options) {
+  return getPuzzleGeometryByDesc(PGPuzzles[puzzleName], options);
+}
 function getmovename(geo, bits, slices) {
   let inverted = false;
   if (slices - bits[1] < bits[0]) {
@@ -3315,6 +2115,7 @@ function toFaceCoords(q, maxdist) {
 }
 var PuzzleGeometry = class {
   constructor(puzzleDescription, options) {
+    this.puzzleDescription = puzzleDescription;
     this.cmovesbyslice = [];
     this.duplicatedFaces = [];
     this.duplicatedCubies = [];
@@ -4550,14 +3351,14 @@ var PuzzleGeometry = class {
     const od = this.getOrbitsDef(false);
     return this.header("# ") + od.toKsolve(name, this.notationMapper).join("\n");
   }
-  writekpuzzle(fortwisty = true, includemoves = true) {
+  getKPuzzleDefinition(fortwisty = true, includemoves = true) {
     const od = this.getOrbitsDef(fortwisty, includemoves);
-    const r = od.toKPuzzle(includemoves);
-    if (!r) {
+    const internalDefinition = od.toKPuzzleDefinition(includemoves);
+    internalDefinition.exprimentalPuzzleDescription = this.puzzleDescription;
+    if (!internalDefinition) {
       throw new Error("Missing definition!");
     }
-    r.moveNotation = new PGNotation(this, od);
-    return r;
+    return internalDefinition;
   }
   getMoveFromBits(moverange, amount, inverted, axiscmoves, setmoves, movesetorder) {
     const moveorbits = [];
@@ -5218,14 +4019,9 @@ Vertex distance ${this.vertexdistance}`;
 var PGNotation = class {
   constructor(pg, od) {
     this.pg = pg;
-    this.cache = {};
     this.orbitNames = od.orbitnames;
   }
   lookupMove(move) {
-    const key = this.moveToKeyString(move);
-    if (key in this.cache) {
-      return this.cache[key];
-    }
     const mv = this.pg.parseMove(move);
     if (this.pg.parsedmovelist) {
       let found = false;
@@ -5235,7 +4031,7 @@ var PGNotation = class {
         }
       }
       if (!found) {
-        return void 0;
+        return null;
       }
     }
     let bits = [mv[2], mv[3]];
@@ -5244,201 +4040,21 @@ var PGNotation = class {
       bits = [slices - mv[3], slices - mv[2]];
     }
     const pgmv = this.pg.getMoveFromBits(bits, mv[5], !mv[4], this.pg.cmovesbyslice[mv[1]], void 0, this.pg.movesetorders[mv[1]]);
-    const r = PGOrbitsDef.transformToKPuzzle(this.orbitNames, pgmv);
-    this.cache[key] = r;
-    return r;
-  }
-  moveToKeyString(move) {
-    let r = "";
-    if (move.outerLayer) {
-      r = r + move.outerLayer + ",";
-    }
-    if (move.innerLayer) {
-      r = r + move.innerLayer + ",";
-    }
-    r = r + move.family + "," + move.amount;
+    const r = PGOrbitsDef.transformToKTransformationData(this.orbitNames, pgmv);
     return r;
   }
 };
 
-// src/bin/puzzle-geometry-bin.ts
-var dosvg = false;
-var doss = false;
-var doksolve = false;
-var dogap = false;
-var docanon = false;
-var do3d = false;
-if (typeof process !== "undefined" && process.argv && process.argv.length <= 2) {
-  console.log(`Usage:  puzzle-geometry [options] [puzzle]
-
-Options:
---ksolve: write ksolve (tws) file
---svg: write SVG (default is flat; --3d makes it 3D)
---gap: write gap
---ss: execute Schrier-Sims calculation
---3d: use 3D format for SVG file
---canon: write canonical string analysis
---rotations: include full-puzzle rotations as moves
---allmoves: includes all moves (i.e., slice moves for 3x3x3)
---outerblockmoves: use outer block moves rather than slice moves
---vertexmoves: for tetrahedral puzzles, prefer vertex moves to face moves
---nocorners: ignore all corners
---noedges: ignore all edges
---nocenters: ignore all centers
---noorientation: ignore orientations
---orientcenters: give centers an orientation
---puzzleorientation:  for 3D formats, give puzzle orientation
---moves movenames: restrict moves to this list (e.g, U2,F,r)
---optimize: optimize tws/ksolve/gap output
---scramble: scramble solved position
---fixcorner: choose moves to keep one corner fixed
---fixedge: choose moves to keep one edge fixed
---fixcenter: choose moves to keep one center fixed
---verbose (-v): make verbose
-
-The puzzle can be given as a geometric description or by name.
-The geometric description starts with c (cube), t (tetrahedron),
-d (dodecahedron), i (icosahedron), or o (octahedron), then a
-space, then a series of cuts.  Each cut begins with f (for a
-cut parallel to faces), v (for a cut perpendicular to a ray
-from the center through a corner), or e (for a cut perpendicular
-to a ray from the center through an edge) followed by a decimal
-number giving a distance, where 1 is the distance between the
-center of the puzzle and the center of a face.
-
-The puzzle names recognized are 2x2x2 through 13x13x13, 20x20x20,
-master skewb, professor skewb, compy cube, helicopter, dino,
-little chop, pyramorphix, mastermorphix, pyraminx, Jing pyraminx,
-master paramorphix, megaminx, gigaminx, pentultimate, starminx,
-starminx 2, pyraminx crystal, chopasaurus, big chop, skewb diamond,
-FTO, Christopher's jewel, octastar, Trajber's octahedron, radio chop,
-icosamate, icosahedron 2, icosahedron 3, icosahedron static faces,
-icosahedron moving faces, and Eitan's star.
-
-Examples:
-   puzzlegeometry --ss 2x2x2
-   puzzlegeometry --ss --fixcorner 2x2x2
-   puzzlegeometry --ss --moves U,F2,r 4x4x4
-   puzzlegeometry --ksolve --optimize --moves U,F,R megaminx
-   puzzlegeometry --gap --noedges megaminx
-`);
-}
-if (typeof process !== "undefined" && process.argv && process.argv.length >= 3) {
-  let desc;
-  const puzzleList = getpuzzles();
-  let argp = 2;
-  const optionlist = [];
-  let showargs = true;
-  while (argp < process.argv.length && process.argv[argp][0] === "-") {
-    const option = process.argv[argp++];
-    if (option === "--verbose" || option === "-v") {
-      optionlist.push("verbose", true);
-    } else if (option === "--quiet" || option === "-q") {
-      optionlist.push("quiet", true);
-      showargs = false;
-    } else if (option === "--ksolve") {
-      doksolve = true;
-    } else if (option === "--svg") {
-      showargs = false;
-      optionlist.push("quiet", true);
-      dosvg = true;
-    } else if (option === "--gap") {
-      dogap = true;
-    } else if (option === "--ss") {
-      doss = true;
-    } else if (option === "--3d") {
-      do3d = true;
-    } else if (option === "--canon") {
-      docanon = true;
-    } else if (option === "--rotations") {
-      optionlist.push("rotations", true);
-    } else if (option === "--allmoves") {
-      optionlist.push("allmoves", true);
-    } else if (option === "--outerblockmoves") {
-      optionlist.push("outerblockmoves", true);
-    } else if (option === "--vertexmoves") {
-      optionlist.push("vertexmoves", true);
-    } else if (option === "--nocorners") {
-      optionlist.push("cornersets", false);
-    } else if (option === "--noedges") {
-      optionlist.push("edgesets", false);
-    } else if (option === "--noorientation") {
-      optionlist.push("killorientation", true);
-    } else if (option === "--nocenters") {
-      optionlist.push("centersets", false);
-    } else if (option === "--omit") {
-      optionlist.push("omit", process.argv[argp].split(","));
-      argp++;
-    } else if (option === "--moves") {
-      optionlist.push("movelist", process.argv[argp].split(","));
-      argp++;
-    } else if (option === "--optimize") {
-      optionlist.push("optimize", true);
-    } else if (option === "--scramble") {
-      optionlist.push("scramble", 100);
-    } else if (option === "--fixcorner") {
-      optionlist.push("fix", "v");
-    } else if (option === "--fixedge") {
-      optionlist.push("fix", "e");
-    } else if (option === "--fixcenter") {
-      optionlist.push("fix", "f");
-    } else if (option === "--orientcenters") {
-      optionlist.push("orientcenters", true);
-    } else if (option === "--puzzleorientation") {
-      optionlist.push("puzzleorientation", process.argv[argp]);
-      argp++;
-    } else {
-      throw new Error("Bad option: " + option);
-    }
-  }
-  for (const [name, curDesc] of Object.entries(puzzleList)) {
-    if (name === process.argv[argp]) {
-      desc = curDesc;
-      break;
-    }
-  }
-  let puzzleDescription;
-  if (showargs) {
-    console.log("# " + process.argv.join(" "));
-  }
-  if (desc !== void 0) {
-    const parsed = parsePuzzleDescription(desc);
-    if (parsed === null) {
-      throw new Error("Could not parse puzzle description!");
-    }
-    puzzleDescription = parsed;
-    argp++;
-  } else {
-    const cuts = [];
-    const cutarg = argp++;
-    while (argp + 1 < process.argv.length && process.argv[argp].length === 1) {
-      cuts.push({
-        cutType: process.argv[argp],
-        distance: parseFloat(process.argv[argp + 1])
-      });
-      argp += 2;
-    }
-    puzzleDescription = { shape: process.argv[cutarg], cuts };
-  }
-  const options = parsePGOptionList(optionlist);
-  const pg = new PuzzleGeometry(puzzleDescription, options);
-  pg.allstickers();
-  pg.genperms();
-  if (argp < process.argv.length) {
-    throw new Error("Unprocessed content at end of command line");
-  }
-  if (dogap) {
-    console.log(pg.writegap());
-  } else if (doksolve) {
-    console.log(pg.writeksolve());
-  } else if (dosvg) {
-    console.log(pg.generatesvg(void 0, void 0, void 0, do3d));
-  } else if (do3d) {
-    console.log(JSON.stringify(pg.get3d()));
-  } else if (doss) {
-    pg.writeSchreierSims(console.log);
-  } else if (docanon) {
-    pg.showcanon((_) => console.log(_));
-  }
-}
-//# sourceMappingURL=puzzle-geometry-bin.js.map
+export {
+  parseOptions,
+  Quat,
+  schreierSims,
+  getPG3DNamedPuzzles,
+  getPuzzleDescriptionString,
+  parsePuzzleDescription,
+  getPuzzleGeometryByDesc,
+  getPuzzleGeometryByName,
+  PuzzleGeometry,
+  PGNotation
+};
+//# sourceMappingURL=chunk-J2U2GRS4.js.map