cubing 0.29.1 → 0.30.0

package/dist/esm/{chunk-NI7U4XAZ.js → chunk-ZQT3QSWD.js}

@@ -1,10 +1,3 @@
-import {
-  __privateAdd,
-  __privateGet,
-  __privateMethod,
-  __privateSet
-} from "./chunk-SBZRVSPK.js";
-
 // src/cubing/alg/common.ts
 var writeAlgDebugField = false;
 var Comparable = class {
@@ -232,8 +225,7 @@ var LineComment = class extends AlgCommon {
 // src/cubing/alg/alg-nodes/leaves/Newline.ts
 var Newline = class extends AlgCommon {
   toString() {
-    return `
-`;
+    return "\n";
   }
   isIdentical(other) {
     return other.is(Newline);
@@ -249,7 +241,7 @@ var Newline = class extends AlgCommon {
 // src/cubing/alg/alg-nodes/leaves/Pause.ts
 var Pause = class extends AlgCommon {
   toString() {
-    return `.`;
+    return ".";
   }
   isIdentical(other) {
     return other.is(Pause);
@@ -431,20 +423,22 @@ var AlgParser = class {
           const B = this.parseAlgWithStopping(["]"]);
           this.mustConsumeNext("]");
           switch (separator) {
-            case ":":
+            case ":": {
               algBuilder.push(
                 addCharIndices(new Conjugate(A, B), savedCharIndex, this.#idx)
               );
               crowded = true;
               algEndIdx = this.#idx;
               continue mainLoop;
-            case ",":
+            }
+            case ",": {
               algBuilder.push(
                 addCharIndices(new Commutator(A, B), savedCharIndex, this.#idx)
               );
               crowded = true;
               algEndIdx = this.#idx;
               continue mainLoop;
+            }
             default:
               throw new Error("unexpected parsing error");
           }
@@ -733,7 +727,7 @@ var QuantumMove = class extends Comparable {
     if (this.#innerLayer !== null) {
       s = String(this.#innerLayer) + s;
       if (this.#outerLayer !== null) {
-        s = String(this.#outerLayer) + "-" + s;
+        s = `${String(this.#outerLayer)}-${s}`;
       }
     }
     return s;
@@ -929,7 +923,7 @@ function dispatch(t, algNode, dataDown) {
   if (algNode.is(LineComment)) {
     return t.traverseLineComment(algNode, dataDown);
   }
-  throw new Error(`unknown AlgNode`);
+  throw new Error("unknown AlgNode");
 }
 function mustBeAlgNode(t) {
   if (t.is(Grouping) || t.is(Move) || t.is(Commutator) || t.is(Conjugate) || t.is(Pause) || t.is(Newline) || t.is(LineComment)) {
@@ -957,59 +951,184 @@ var TraversalUp = class extends TraversalDownUp {
     return mustBeAlgNode(this.traverseAlgNode(algNode));
   }
 };
-var _newPlaceholderAssociationsMap, _newPlaceholderAssociations, newPlaceholderAssociations_fn, _newAmount, newAmount_fn;
-var _Simplify = class extends TraversalDownUp {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _newPlaceholderAssociations);
-    __privateAdd(this, _newPlaceholderAssociationsMap, void 0);
+
+// src/cubing/alg/simplify/options.ts
+var DEFAULT_DIRECTIONAL = "any-direction";
+var DEFAULT_MOD_WRAP = "canonical-centered";
+var AppendOptionsHelper = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  cancelQuantum() {
+    const { cancel } = this.config;
+    if (cancel === true) {
+      return DEFAULT_DIRECTIONAL;
+    }
+    if (cancel === false) {
+      return "none";
+    }
+    return cancel?.directional ?? "none";
   }
-  *traverseAlg(alg, options) {
-    if (options.depth === 0) {
-      yield* alg.childAlgNodes();
-      return;
+  cancelAny() {
+    return this.config.cancel && this.cancelQuantum() !== "none";
+  }
+  cancelPuzzleSpecificModWrap() {
+    const { cancel } = this.config;
+    if (cancel === true || cancel === false) {
+      return DEFAULT_MOD_WRAP;
     }
-    const newAlgNodes = [];
-    let lastAlgNode = 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;
+    return cancel?.puzzleSpecificModWrap ?? DEFAULT_MOD_WRAP;
+  }
+  puzzleSpecificSimplifyOptions() {
+    return this.config.puzzleLoader?.puzzleSpecificSimplifyOptions ?? this.config.puzzleSpecificSimplifyOptions;
+  }
+};
+
+// src/cubing/alg/simplify/append.ts
+function areSameDirection(direction, move2) {
+  return direction * Math.sign(move2.amount) >= 0;
+}
+function offsetMod(x, positiveMod, offset) {
+  return ((x - offset) % positiveMod + positiveMod) % positiveMod + offset;
+}
+function experimentalAppendMove(alg, addedMove, options) {
+  const optionsHelper = new AppendOptionsHelper(options);
+  let outputPrefix = Array.from(alg.childAlgNodes());
+  let outputSuffix = [addedMove];
+  function output() {
+    return new Alg([...outputPrefix, ...outputSuffix]);
+  }
+  function modMove(move) {
+    if (optionsHelper.cancelPuzzleSpecificModWrap() === "none") {
+      return move;
+    }
+    const quantumMoveOrder = optionsHelper.puzzleSpecificSimplifyOptions()?.quantumMoveOrder;
+    if (!quantumMoveOrder) {
+      return move;
+    }
+    const mod = quantumMoveOrder(addedMove.quantum);
+    let offset;
+    switch (optionsHelper.cancelPuzzleSpecificModWrap()) {
+      case "gravity": {
+        offset = -Math.floor((mod - (move.amount < 0 ? 0 : 1)) / 2);
+        break;
+      }
+      case "canonical-centered": {
+        offset = -Math.floor((mod - 1) / 2);
+        break;
+      }
+      case "canonical-positive": {
+        offset = 0;
+        break;
+      }
+      case "preserve-sign": {
+        offset = move.amount < 0 ? 1 - mod : 0;
+        break;
+      }
+      default: {
+        throw new Error("Unknown mod wrap");
       }
-      const newMove = new Move(move.quantum, newAmount);
-      newAlgNodes.push(newMove);
-      lastAlgNode = newMove;
-      return true;
     }
-    function appendCollapsed(newAlgNode) {
-      if (collapseMoves && lastAlgNode?.is(Move) && newAlgNode.is(Move) && lastAlgNode.quantum.isIdentical(newAlgNode.quantum)) {
-        newAlgNodes.pop();
-        if (!appendMoveWithNewAmount(
-          lastAlgNode,
-          newAlgNode.amount
-        )) {
-          lastAlgNode = newAlgNodes.slice(-1)[0];
-        }
-      } else {
-        if (newAlgNode.is(Move)) {
-          appendMoveWithNewAmount(newAlgNode, 0);
-        } else {
-          newAlgNodes.push(newAlgNode);
-          lastAlgNode = newAlgNode;
+    let offsetAmount = offsetMod(move.amount, mod, offset);
+    return move.modified({ amount: offsetAmount });
+  }
+  if (optionsHelper.cancelAny()) {
+    let canCancelMoveBasedOnQuantum;
+    const axis = optionsHelper.puzzleSpecificSimplifyOptions()?.axis;
+    if (axis) {
+      canCancelMoveBasedOnQuantum = (move) => axis.areQuantumMovesSameAxis(addedMove.quantum, move.quantum);
+    } else {
+      const newMoveQuantumString = addedMove.quantum.toString();
+      canCancelMoveBasedOnQuantum = (move) => move.quantum.toString() === newMoveQuantumString;
+    }
+    const sameDirectionOnly = optionsHelper.cancelQuantum() === "same-direction";
+    const quantumDirections = /* @__PURE__ */ new Map();
+    quantumDirections.set(
+      addedMove.quantum.toString(),
+      Math.sign(addedMove.amount)
+    );
+    let i;
+    for (i = outputPrefix.length - 1; i >= 0; i--) {
+      const move = outputPrefix[i].as(Move);
+      if (!move) {
+        break;
+      }
+      if (!canCancelMoveBasedOnQuantum(move)) {
+        break;
+      }
+      const quantumKey = move.quantum.toString();
+      if (sameDirectionOnly) {
+        const existingQuantumDirectionOnAxis = quantumDirections.get(quantumKey);
+        if (existingQuantumDirectionOnAxis && !areSameDirection(existingQuantumDirectionOnAxis, move)) {
+          break;
         }
+        quantumDirections.set(quantumKey, Math.sign(move.amount));
       }
     }
-    const newOptions = {
+    const suffix = [...outputPrefix.splice(i + 1), addedMove];
+    if (axis) {
+      outputSuffix = axis.simplifySameAxisMoves(
+        suffix,
+        optionsHelper.cancelPuzzleSpecificModWrap() !== "none"
+      );
+    } else {
+      let amount = suffix.reduce(
+        (sum, move) => sum + move.amount,
+        0
+      );
+      if (quantumDirections.size !== 1) {
+        throw new Error(
+          "Internal error: multiple quantums when one was expected"
+        );
+      }
+      outputSuffix = [new Move(addedMove.quantum, amount)];
+    }
+  }
+  outputSuffix = outputSuffix.map((m) => modMove(m)).filter(
+    (move) => move.amount !== 0
+  );
+  return output();
+}
+function experimentalAppendNode(alg, leaf, options) {
+  const maybeMove = leaf.as(Move);
+  if (maybeMove) {
+    return experimentalAppendMove(alg, maybeMove, options);
+  } else {
+    return new Alg([...alg.childAlgNodes(), leaf]);
+  }
+}
+
+// src/cubing/alg/simplify/simplify.ts
+var Simplify = class extends TraversalDownUp {
+  #newPlaceholderAssociationsMap;
+  #newPlaceholderAssociations() {
+    return this.#newPlaceholderAssociationsMap ?? (this.#newPlaceholderAssociationsMap = /* @__PURE__ */ new Map());
+  }
+  #descendOptions(options) {
+    return {
+      ...options,
       depth: options.depth ? options.depth - 1 : null
     };
+  }
+  *traverseAlg(alg, options) {
+    if (options.depth === 0) {
+      yield* alg.childAlgNodes();
+      return;
+    }
+    let output = [];
+    const newOptions = this.#descendOptions(options);
     for (const algNode of alg.childAlgNodes()) {
-      for (const ancestorAlgNode of this.traverseAlgNode(algNode, newOptions)) {
-        appendCollapsed(ancestorAlgNode);
+      for (const traversedNode of this.traverseAlgNode(algNode, newOptions)) {
+        output = Array.from(
+          experimentalAppendNode(
+            new Alg(output),
+            traversedNode,
+            newOptions
+          ).childAlgNodes()
+        );
       }
     }
-    for (const newAlgNode of newAlgNodes) {
+    for (const newAlgNode of output) {
       yield newAlgNode;
     }
   }
@@ -1018,14 +1137,17 @@ var _Simplify = class extends TraversalDownUp {
       yield grouping;
       return;
     }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null
-    };
+    if (grouping.amount === 0) {
+      return;
+    }
     const newGrouping = new Grouping(
-      this.traverseAlg(grouping.alg, newOptions),
+      this.traverseAlg(grouping.alg, this.#descendOptions(options)),
       grouping.amount
     );
-    const newPlaceholder = __privateMethod(this, _newPlaceholderAssociations, newPlaceholderAssociations_fn).call(this).get(grouping);
+    if (newGrouping.alg.experimentalIsEmpty()) {
+      return;
+    }
+    const newPlaceholder = this.#newPlaceholderAssociations().get(grouping);
     if (newPlaceholder) {
       newGrouping.experimentalNISSPlaceholder = newPlaceholder;
       newPlaceholder.experimentalNISSGrouping = newGrouping;
@@ -1035,36 +1157,64 @@ var _Simplify = class extends TraversalDownUp {
   *traverseMove(move, _options) {
     yield move;
   }
+  #doChildrenCommute(A, B, options) {
+    if (A.experimentalNumChildAlgNodes() === 1 && B.experimentalNumChildAlgNodes() === 1) {
+      const aMove = Array.from(A.childAlgNodes())[0]?.as(Move);
+      const bMove = Array.from(B.childAlgNodes())[0]?.as(Move);
+      if (!(aMove && bMove)) {
+        return false;
+      }
+      if (bMove.quantum.isIdentical(aMove.quantum)) {
+        return true;
+      }
+      const appendOptionsHelper = new AppendOptionsHelper(options);
+      if (appendOptionsHelper.puzzleSpecificSimplifyOptions()?.axis?.areQuantumMovesSameAxis(
+        aMove.quantum,
+        bMove.quantum
+      )) {
+        return true;
+      }
+    }
+    return false;
+  }
   *traverseCommutator(commutator, options) {
     if (options.depth === 0) {
       yield commutator;
       return;
     }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null
-    };
-    yield new Commutator(
+    const newOptions = this.#descendOptions(options);
+    const newCommutator = new Commutator(
       this.traverseAlg(commutator.A, newOptions),
       this.traverseAlg(commutator.B, newOptions)
     );
+    if (newCommutator.A.experimentalIsEmpty() || newCommutator.B.experimentalIsEmpty() || newCommutator.A.isIdentical(newCommutator.B) || newCommutator.A.isIdentical(newCommutator.B.invert()) || this.#doChildrenCommute(newCommutator.A, newCommutator.B, options)) {
+      return;
+    }
+    yield newCommutator;
   }
   *traverseConjugate(conjugate, options) {
     if (options.depth === 0) {
       yield conjugate;
       return;
     }
-    const newOptions = {
-      depth: options.depth ? options.depth - 1 : null
-    };
-    yield new Conjugate(
+    const newOptions = this.#descendOptions(options);
+    const newConjugate = new Conjugate(
       this.traverseAlg(conjugate.A, newOptions),
       this.traverseAlg(conjugate.B, newOptions)
     );
+    if (newConjugate.B.experimentalIsEmpty()) {
+      return;
+    }
+    if (newConjugate.A.experimentalIsEmpty() || newConjugate.A.isIdentical(newConjugate.B) || newConjugate.A.isIdentical(newConjugate.B.invert()) || this.#doChildrenCommute(newConjugate.A, newConjugate.B, options)) {
+      yield* conjugate.B.childAlgNodes();
+      return;
+    }
+    yield newConjugate;
   }
   *traversePause(pause, _options) {
     if (pause.experimentalNISSGrouping) {
       const newPause = new Pause();
-      __privateMethod(this, _newPlaceholderAssociations, newPlaceholderAssociations_fn).call(this).set(
+      this.#newPlaceholderAssociations().set(
         pause.experimentalNISSGrouping,
         newPause
       );
@@ -1080,23 +1230,6 @@ var _Simplify = class extends TraversalDownUp {
     yield comment;
   }
 };
-var Simplify = _Simplify;
-_newPlaceholderAssociationsMap = new WeakMap();
-_newPlaceholderAssociations = new WeakSet();
-newPlaceholderAssociations_fn = function() {
-  return __privateGet(this, _newPlaceholderAssociationsMap) ?? __privateSet(this, _newPlaceholderAssociationsMap, /* @__PURE__ */ new Map());
-};
-_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);
 
@@ -1228,9 +1361,12 @@ var Alg = class extends AlgCommon {
     }
     return output;
   }
-  simplify(options) {
+  experimentalSimplify(options) {
     return new Alg(simplify(this, options ?? {}));
   }
+  simplify(options) {
+    return this.experimentalSimplify(options);
+  }
 };
 function spaceBetween(u1, u2) {
   if (u1.is(Newline) || u2.is(Newline)) {
@@ -1490,29 +1626,6 @@ function experimentalAlgCubingNetLink(options) {
   return url.toString();
 }
 
-// src/cubing/alg/operation.ts
-function experimentalAppendMove(alg, newMove, options) {
-  const oldAlgNodes = Array.from(alg.childAlgNodes());
-  const oldLastMove = oldAlgNodes[oldAlgNodes.length - 1];
-  if (options?.coalesce && oldLastMove && oldLastMove.quantum && oldLastMove.quantum.isIdentical(newMove.quantum)) {
-    const newAlgNodes = oldAlgNodes.slice(0, oldAlgNodes.length - 1);
-    let newAmount = oldLastMove.amount + newMove.amount;
-    const mod = options?.mod;
-    if (mod) {
-      newAmount = (newAmount % mod + mod) % mod;
-      if (newAmount * 2 > mod) {
-        newAmount -= mod;
-      }
-    }
-    if (newAmount !== 0) {
-      newAlgNodes.push(oldLastMove.modified({ amount: newAmount }));
-    }
-    return new Alg(newAlgNodes);
-  } else {
-    return new Alg([...oldAlgNodes, newMove]);
-  }
-}
-
 export {
   direct,
   directedGenerator,
@@ -1529,10 +1642,10 @@ export {
   experimentalIs,
   TraversalDownUp,
   TraversalUp,
+  experimentalAppendMove,
   Alg,
   Example,
   keyToMove,
-  experimentalAlgCubingNetLink,
-  experimentalAppendMove
+  experimentalAlgCubingNetLink
 };
-//# sourceMappingURL=chunk-NI7U4XAZ.js.map
+//# sourceMappingURL=chunk-ZQT3QSWD.js.map