@rednaxela101/cubing 0.63.5

package/README.md

@@ -0,0 +1,120 @@
+<img src="cubing.js.png" alt="cubing.js" width="512">
+
+# `cubing.js` lightweight fork
+
+A **lightweight fork of [`cubing.js`](https://github.com/cubing/cubing.js)**: fewer puzzles, smaller lazily-loaded chunks, and some extra visualization features.
+
+The API surface, the module layout and the build system are unchanged from upstream, so this is a drop-in replacement for `cubing` as long as you only use the puzzles listed below.
+
+- Upstream project: <https://github.com/cubing/cubing.js>
+- Upstream documentation: <https://js.cubing.net/cubing/>
+
+## Supported puzzles
+
+| Puzzle | ID | 3D | 2D net | 2D last layer | Scrambles |
+| --- | --- | :-: | :-: | :-: | --- |
+| 3×3×3 Cube | `3x3x3` | ✅ | ✅ | ✅ | random-state |
+| 2×2×2 Cube | `2x2x2` | ✅ | ✅ | ✅ | random-state |
+| 4×4×4 Cube | `4x4x4` | ✅ | ❌ | ✅ | random-state |
+| 5×5×5 Cube | `5x5x5` | ✅ | ❌ | ✅ | random-moves |
+| 6×6×6 Cube | `6x6x6` | ✅ | ❌ | ❌ | random-moves |
+| 7×7×7 Cube | `7x7x7` | ✅ | ❌ | ❌ | random-moves |
+| Square-1 | `square1` | ✅ | ✅ | ✅ | random-state |
+| Pyraminx | `pyraminx` | ✅ | ✅ | ❌ | random-state |
+| Megaminx | `megaminx` | ✅ | ❌ | ✅ | random-moves |
+| Clock | `clock` | ❌ | ✅ | ❌ | random-state |
+| Skewb | `skewb` | ✅ | ❌ | ❌ | random-state |
+| Face-Turning Octahedron | `fto` | ✅ | ✅ | ❌ | random-state |
+
+Every WCA event is supported (`222`, `333`, `444`, `555`, `666`, `777`, `333bf`, `333fm`, `333oh`, `333mbf`, `444bf`, `555bf`, `clock`, `minx`, `pyram`, `skewb`, `sq1`), plus `fto`.
+
+## Breaking changes vs. upstream
+
+### Removed puzzles
+
+These puzzles are gone from `puzzles`, from `PuzzleID`, and from the `<twisty-player puzzle="…">` attribute. Requesting one throws instead of rendering.
+
+| Removed | Upstream ID |
+| --- | --- |
+| Kilominx | `kilominx` |
+| Master Tetraminx | `master_tetraminx` |
+| Gigaminx | `gigaminx` |
+| Redi Cube | `redi_cube` |
+| Baby FTO | `baby_fto` |
+| Melinda's 2×2×2×2 | `melindas2x2x2x2` |
+| Tri-Quad | `tri_quad` |
+| Loopover | `loopover` |
+| 40×40×40 Cube | `40x40x40` |
+
+### Removed events
+
+`randomScrambleForEvent(…)` no longer accepts the Twizzle-only events that belonged to the removed puzzles: `kilominx`, `master_tetraminx`, `redi_cube`, `baby_fto`, `loopover`. Every WCA event plus `fto` still works.
+
+### Other removals
+
+- The vendored solvers for the removed puzzles (`kilosolver.js`, `master_tetraminx-solver.js`, `redi_cube.js`) are deleted.
+- The `stress-tests/40x40x40` demo page is deleted, along with its 379 kB solution file.
+- Dynamic chunk entry points were renamed (see [Re-chunking](#re-chunking)). This only matters if you were importing internal `puzzles-dynamic-*` paths directly, which is not part of the public API.
+
+## What this fork adds
+
+- **Square-1 in 3D.** New `Square1_3D` visualization strategy, now the default for `puzzle="square1"`. Upstream always rendered Square-1 flat.
+- **Square-1 2D last-layer diagrams.** `visualization="experimental-2D-LL"` on `square1`, with `OLL` and `PLL` stickerings.
+- **Better 2D Square-1 rendering.** Piece separator support in the SVG renderer: outlines between two halves of a piece hide and reappear as pieces join and split.
+- **5×5×5 2D last-layer diagrams.** `visualization="experimental-2D-LL"` on `5x5x5`, with a cached SVG built from reusable `<use>` elements.
+- **`L2E` stickering.** Last two edges, for `4x4x4`, `5x5x5` and `6x6x6`, under the Reduction group.
+
+## Rendering performance
+
+Several per-frame code paths in `cubing/twisty` were doing work that could be skipped. Measured on Chromium as the cost of one `onPositionChange(…)` call with a move in progress (minimum of 7 rounds of 3000 calls), 2026-08-27.
+
+| Puzzle | Renderer | Upstream | This fork | Change |
+| --- | --- | --- | --- | --- |
+| 3×3×3 | `Cube3D` | 11.17 µs | **3.87 µs** | -65% |
+| 7×7×7 | `PG3D` | 4.13 µs | **2.27 µs** | -45% |
+| 5×5×5 | `PG3D` | 2.63 µs | **2.00 µs** | -24% |
+| Megaminx | `PG3D` | 2.80 µs | **2.20 µs** | -21% |
+| FTO | `PG3D` | 1.93 µs | **1.70 µs** | -12% |
+| 2×2×2 | `PG3D` | 1.40 µs | **1.27 µs** | -9% |
+
+These are small in absolute terms on desktop: a 3×3×3 player drops from roughly 0.67 ms to 0.23 ms of main-thread time per second of animation. It matters for pages with many diagrams, for low-end mobile, and for apps whose main thread is already busy.
+
+## Size improvements
+
+A snapshot, not a live claim: each entry point bundled with `esbuild` (minified, ESM, `three` external), measured 2026-08-26 against upstream `3efce156`. Expect drift as the fork moves.
+
+| Entry point | Upstream | This fork | Change |
+| --- | --- | --- | --- |
+| `cubing/puzzles` | 397 kB · 75 kB gzip | **322 kB · 62 kB gzip** | -19% · -17% gzip |
+| `cubing/twisty` | 554 kB · 122 kB gzip | **479 kB · 109 kB gzip** | -14% · -11% gzip |
+| `cubing/search` | 1251 kB · 351 kB gzip | **1152 kB · 329 kB gzip** | -8% · -6% gzip |
+| `cubing/scramble` | 1249 kB · 350 kB gzip | **1151 kB · 329 kB gzip** | -8% · -6% gzip |
+
+### Re-chunking
+
+Upstream bundles several puzzles into a single lazily-loaded chunk. Displaying a 2×2×2 in 2D therefore also downloads the Clock and Square-1 artwork. This fork splits those chunks one-per-puzzle, following the per-puzzle convention the cube chunks already used.
+
+| Upstream chunk | This fork |
+| --- | --- |
+| `puzzles-dynamic-side-events` (123 kB)<br>2×2×2 + Clock + Pyraminx + Square-1 | `puzzles-dynamic-2x2x2` 7 kB<br>`puzzles-dynamic-clock` 48 kB<br>`puzzles-dynamic-pyraminx` 5 kB<br>`puzzles-dynamic-square1` 62 kB |
+| `puzzles-dynamic-unofficial` (44 kB)<br>FTO + Baby FTO + Kilominx + Loopover + Redi Cube | `puzzles-dynamic-fto` 11 kB |
+| `search-dynamic-sgs-side-events` (33 kB)<br>2×2×2 + Megaminx + Pyraminx + Skewb | `search-dynamic-sgs-2x2x2` 1 kB<br>`search-dynamic-sgs-megaminx` 28 kB<br>`search-dynamic-sgs-pyraminx` 1 kB<br>`search-dynamic-sgs-skewb` 2 kB |
+
+### What a browser actually downloads
+
+Everything is lazily loaded, so the numbers that matter are per-scenario, not per-package. Gzipped, `three.js` excluded:
+
+| Scenario | Download |
+| --- | --- |
+| `cubing/scramble` imported, nothing generated yet | 41 kB |
+| First 3×3×3 or 4×4×4 scramble | 66 kB |
+| Any other event (pulls the WASM scramble engine) | 376 kB |
+| `cubing/twisty` initial load | 86 kB |
+| `cubing/twisty` with 3D and every puzzle | 162 kB + `three.js` |
+
+### Known remaining weight
+
+Two items dominate what is left, and neither is about the puzzle list:
+
+- **The WASM scramble engine, 209 kB gzip.** It is base64-inlined into a `.js` file, which inflates the binary by 33% and compresses worse than the binary would. Shipping it as a real `.wasm` asset would bring it to 152 kB gzip. Upstream disabled that path on purpose until bundler support settled, so re-enabling it is a packaging decision rather than a code one.
+- **`three.js`, 134 kB gzip.** Only downloaded when the player renders in 3D. Setting `visualization="2D"` avoids it entirely. The `three` imports inside `cubing/twisty` are all `import type`, so there is nothing left to tree-shake there.

package/alg/index.d.ts

@@ -0,0 +1 @@
+export type * from "../dist/lib/cubing/alg/index.d.ts";

package/bluetooth/index.d.ts

@@ -0,0 +1 @@
+export type * from "../dist/lib/cubing/bluetooth/index.d.ts";

package/dist/bin/chunks/chunk-22VWCGBC.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env -S node --
+
+// src/metadata/packageVersion.ts
+var packageVersion = (
+  // biome-ignore lint/suspicious/noTsIgnore: This comment is stil present in the compiled file, where an error is *not* expected.
+  /** @ts-ignore Populated by `esbuild` at compile time. */
+  "0.63.5"
+);
+
+export {
+  packageVersion
+};
+//# sourceMappingURL=chunk-22VWCGBC.js.map

package/dist/bin/chunks/chunk-22VWCGBC.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/metadata/packageVersion.ts"],
+  "sourcesContent": ["export const packageVersion: string =\n  // biome-ignore lint/suspicious/noTsIgnore: This comment is stil present in the compiled file, where an error is *not* expected.\n  /** @ts-ignore Populated by `esbuild` at compile time. */\n  globalThis.PACKAGE_VERSION ??\n  // We don't want to pull in the dynamic code into the import graph, so we use\n  // dynamic import here. This entire fallback expression should get compiled\n  // out by `esbuild`.\n  (await import(\"./packageVersionDynamic\")).version;\n"],
+  "mappings": ";;;AAAO,IAAM;AAAA;AAAA;AAAA,EAGX;AAAA;",
+  "names": []
+}

package/dist/bin/order.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env -S node --
+import {
+  packageVersion
+} from "./chunks/chunk-22VWCGBC.js";
+
+// src/bin/order.ts
+import { basename } from "node:path";
+import { argv } from "node:process";
+import { argument, map, message, object, string } from "@optique/core";
+import { run } from "@optique/run";
+import { Alg } from "@rednaxela101/cubing/alg";
+import { KPuzzle } from "@rednaxela101/cubing/kpuzzle";
+import { getPuzzleGeometryByName } from "@rednaxela101/cubing/puzzle-geometry";
+import { puzzles } from "@rednaxela101/cubing/puzzles";
+var args = run(
+  object({
+    puzzleGeometryID: argument(string({ metavar: "PUZZLE" }), {
+      description: message`Puzzle geometry ID`
+    }),
+    alg: map(
+      argument(string({ metavar: "ALG" }), {
+        description: message`Alg`
+      }),
+      Alg.fromString
+    )
+  }),
+  {
+    programName: basename(argv[1]),
+    description: message`Example: order 3x3x3 "R U R' U R U2' R'"`,
+    help: "option",
+    completion: {
+      option: {
+        names: ["--completions"],
+        hidden: false
+      }
+    },
+    version: {
+      option: {
+        hidden: false
+      },
+      value: packageVersion
+    }
+  }
+);
+var { puzzleGeometryID, alg } = args;
+var puzzleLoader = puzzles[puzzleGeometryID];
+var kpuzzle = await (async () => {
+  if (puzzleLoader) {
+    return await puzzles[puzzleGeometryID].kpuzzle();
+  } else {
+    const pg = getPuzzleGeometryByName(puzzleGeometryID, {
+      allMoves: true
+    });
+    return new KPuzzle(pg.getKPuzzleDefinition(true));
+  }
+})();
+var order = kpuzzle.algToTransformation(alg).repetitionOrder();
+console.log(order);
+//# sourceMappingURL=order.js.map

package/dist/bin/order.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/bin/order.ts"],
+  "sourcesContent": ["/**\n\nTo run this file directly:\n\n```shell\nbun run -- ./src/bin/order.ts 3x3x3 \"R U R' U R U2' R'\"\n```\n\nTo add an `order` binary to your path and test completions:\n\n```shell\n# fish (from repo root)\nset PATH (pwd)/src/test/bin-path $PATH\norder --completions fish | source\n```\n\n```shell\n# zsh (from repo root)\nautoload -Uz compinit\ncompinit\nexport PATH=$(pwd)/src/test/bin-path:$PATH\nsource <(order --completions zsh)\n```\n\n*/\n\nimport { basename } from \"node:path\";\nimport { argv } from \"node:process\";\nimport { argument, map, message, object, string } from \"@optique/core\";\nimport { run } from \"@optique/run\";\nimport { Alg } from \"@rednaxela101/cubing/alg\";\nimport { KPuzzle } from \"@rednaxela101/cubing/kpuzzle\";\nimport { getPuzzleGeometryByName } from \"@rednaxela101/cubing/puzzle-geometry\";\nimport { puzzles } from \"@rednaxela101/cubing/puzzles\";\nimport { packageVersion } from \"../metadata/packageVersion\";\n\nconst args = run(\n  object({\n    puzzleGeometryID: argument(string({ metavar: \"PUZZLE\" }), {\n      description: message`Puzzle geometry ID`,\n    }),\n    alg: map(\n      argument(string({ metavar: \"ALG\" }), {\n        description: message`Alg`,\n      }),\n      Alg.fromString,\n    ),\n  }),\n  {\n    programName: basename(argv[1]),\n    description: message`Example: order 3x3x3 \"R U R' U R U2' R'\"`,\n    help: \"option\",\n    completion: {\n      option: {\n        names: [\"--completions\"],\n        hidden: false,\n      },\n    },\n    version: {\n      option: {\n        hidden: false,\n      },\n      value: packageVersion,\n    },\n  },\n);\n\nconst { puzzleGeometryID, alg } = args;\n\n/*\n *   Turn a name into a geometry.\n */\nconst puzzleLoader = puzzles[puzzleGeometryID];\nconst kpuzzle = await (async () => {\n  if (puzzleLoader) {\n    return await puzzles[puzzleGeometryID].kpuzzle();\n  } else {\n    const pg = getPuzzleGeometryByName(puzzleGeometryID, {\n      allMoves: true,\n    });\n    return new KPuzzle(pg.getKPuzzleDefinition(true));\n  }\n})();\n\nconst order = kpuzzle.algToTransformation(alg).repetitionOrder();\nconsole.log(order);\n"],
+  "mappings": ";;;;;;AA0BA,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB,SAAS,UAAU,KAAK,SAAS,QAAQ,cAAc;AACvD,SAAS,WAAW;AACpB,SAAS,WAAW;AACpB,SAAS,eAAe;AACxB,SAAS,+BAA+B;AACxC,SAAS,eAAe;AAGxB,IAAM,OAAO;AAAA,EACX,OAAO;AAAA,IACL,kBAAkB,SAAS,OAAO,EAAE,SAAS,SAAS,CAAC,GAAG;AAAA,MACxD,aAAa;AAAA,IACf,CAAC;AAAA,IACD,KAAK;AAAA,MACH,SAAS,OAAO,EAAE,SAAS,MAAM,CAAC,GAAG;AAAA,QACnC,aAAa;AAAA,MACf,CAAC;AAAA,MACD,IAAI;AAAA,IACN;AAAA,EACF,CAAC;AAAA,EACD;AAAA,IACE,aAAa,SAAS,KAAK,CAAC,CAAC;AAAA,IAC7B,aAAa;AAAA,IACb,MAAM;AAAA,IACN,YAAY;AAAA,MACV,QAAQ;AAAA,QACN,OAAO,CAAC,eAAe;AAAA,QACvB,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,QAAQ;AAAA,QACN,QAAQ;AAAA,MACV;AAAA,MACA,OAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,IAAM,EAAE,kBAAkB,IAAI,IAAI;AAKlC,IAAM,eAAe,QAAQ,gBAAgB;AAC7C,IAAM,UAAU,OAAO,YAAY;AACjC,MAAI,cAAc;AAChB,WAAO,MAAM,QAAQ,gBAAgB,EAAE,QAAQ;AAAA,EACjD,OAAO;AACL,UAAM,KAAK,wBAAwB,kBAAkB;AAAA,MACnD,UAAU;AAAA,IACZ,CAAC;AACD,WAAO,IAAI,QAAQ,GAAG,qBAAqB,IAAI,CAAC;AAAA,EAClD;AACF,GAAG;AAEH,IAAM,QAAQ,QAAQ,oBAAoB,GAAG,EAAE,gBAAgB;AAC/D,QAAQ,IAAI,KAAK;",
+  "names": []
+}

package/dist/bin/puzzle-geometry-bin.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env -S node --
+import {
+  packageVersion
+} from "./chunks/chunk-22VWCGBC.js";
+
+// src/bin/puzzle-geometry-bin.ts
+import { basename } from "node:path";
+import { argv } from "node:process";
+import {
+  argument,
+  constant,
+  flag,
+  integer,
+  map,
+  merge,
+  message,
+  multiple,
+  object,
+  option,
+  optional,
+  or,
+  string
+} from "@optique/core";
+import { run } from "@optique/run";
+import { Move } from "@rednaxela101/cubing/alg";
+import {
+  getPG3DNamedPuzzles,
+  PuzzleGeometry,
+  parsePuzzleDescription
+} from "@rednaxela101/cubing/puzzle-geometry";
+import { PrintableShellCommand } from "printable-shell-command";
+var puzzleList = getPG3DNamedPuzzles();
+function antiBool(optionName, description) {
+  return optional(
+    map(
+      flag(optionName, {
+        description
+      }),
+      (v) => !v
+    )
+  );
+}
+var subcommandDefaults = {
+  commentStyle: constant("hash"),
+  forceQuiet: constant(void 0)
+};
+var args = run(
+  merge(
+    object({
+      verbosity: optional(
+        or(
+          map(multiple(flag("--verbose", "-v")), (v) => v.length),
+          map(flag("--quiet", "-q"), () => 0)
+        )
+      )
+    }),
+    or(
+      object({
+        ...subcommandDefaults,
+        subcommand: constant("KSolve"),
+        subcommandFlag: flag("--ksolve", {
+          description: message`Print KSolve (\`.tws\`).`
+        })
+      }),
+      object({
+        ...subcommandDefaults,
+        subcommand: constant("SVG"),
+        subcommandFlag: flag("--svg", {
+          description: message`Print SVG. Forces \`--quiet\`.`
+        }),
+        commentStyle: constant("none"),
+        svg3D: optional(
+          option("--3d", {
+            description: message`Use 3D format for SVG file.`
+          })
+        ),
+        verbosity: constant(0)
+      }),
+      object({
+        ...subcommandDefaults,
+        subcommand: constant("GAP"),
+        subcommandFlag: flag("--gap", {
+          description: message`Print GAP output.`
+        })
+      }),
+      object({
+        ...subcommandDefaults,
+        subcommand: constant("Mathematica"),
+        subcommandFlag: flag("--mathematica", {
+          description: message`Print Mathematica output.`
+        }),
+        commentStyle: constant("Pascal")
+      }),
+      object({
+        ...subcommandDefaults,
+        subcommand: constant("Schreier-Sims"),
+        subcommandFlag: flag("--ss", {
+          description: message`Perform Schrier-Sims calculation.`
+        })
+      }),
+      object({
+        ...subcommandDefaults,
+        subcommand: constant("Canonical string analysis"),
+        subcommandFlag: flag("--canon", {
+          description: message`Print canonical string analysis.`
+        })
+      }),
+      object({
+        ...subcommandDefaults,
+        subcommand: constant("3D"),
+        subcommandFlag: flag("--3d", {
+          description: message`Print 3D information.`
+        })
+      })
+    ),
+    object({
+      // This doesn't apply to SVG, but we place it here so that it doesn't print once for each non-SVG subcommand in the help string.
+      optimizeOrbits: option("--optimize", {
+        description: message`Optimize output (when possible).`
+      }),
+      addRotations: option("--rotations", {
+        description: message`Include full-puzzle rotations as moves.`
+      }),
+      allMoves: option("--allmoves", {
+        description: message`Includes all moves (i.e., slice moves for 3x3x3).`
+      }),
+      outerBlockMoves: option("--outerblockmoves", {
+        description: message`Use outer block moves rather than slice moves.`
+      }),
+      vertexMoves: option("--vertexmoves", {
+        description: message`For tetrahedral puzzles, prefer vertex moves to face moves.`
+      }),
+      includeCornerOrbits: antiBool(
+        "--nocorners",
+        message`Ignore all corners.`
+      ),
+      excludeOrbits: optional(
+        map(
+          option("--omit", string({ metavar: "COMMA_SEPARATED_ORBITS" }), {
+            description: message`Omit orbits.`
+          }),
+          (s) => s.split(",")
+        )
+      ),
+      includeEdgeOrbits: antiBool("--noedges", message`Ignore all edges.`),
+      includeCenterOrbits: antiBool(
+        "--nocenters",
+        message`Ignore all centers.`
+      ),
+      grayCorners: option("--graycorners", {
+        description: message`Gray corners.`
+      }),
+      grayEdges: option("--grayedges", { description: message`Gray edges.` }),
+      grayCenters: option("--graycenters", {
+        description: message`Gray centers.`
+      }),
+      fixedOrientation: option("--noorientation", {
+        description: message`Ignore orientations.`
+      }),
+      orientCenters: option("--orientcenters", {
+        description: message`Give centers an orientation.`
+      })
+    }),
+    optional(
+      or(
+        object({
+          puzzleOrientation: optional(
+            map(
+              option(
+                "--puzzleorientation",
+                string({ metavar: "JSON_STRING" }),
+                {
+                  description: message`For 3D formats, give puzzle orientation.`
+                }
+              ),
+              (s) => JSON.parse(s)
+            )
+          ),
+          puzzleOrientations: constant(void 0)
+        }),
+        object({
+          puzzleOrientation: constant(void 0),
+          puzzleOrientations: optional(
+            map(
+              option(
+                "--puzzleorientations",
+                string({ metavar: "JSON_STRING" }),
+                {
+                  description: message`For 3D formats, give puzzle orientations.`
+                }
+              ),
+              (s) => JSON.parse(s)
+            )
+          )
+        })
+      )
+    ),
+    object({
+      fixedPieceType: optional(
+        or(
+          map(
+            flag("--fixcorner", {
+              description: message`Auto-select a subset of moves to keep a corner fixed in place.`
+            }),
+            () => "v"
+          ),
+          map(
+            flag("--fixedge", {
+              description: message`Auto-select a subset of moves to keep an edge fixed in place.`
+            }),
+            () => "e"
+          ),
+          map(
+            flag("--fixcenter", {
+              description: message`Auto-select a subset of moves to keep a center fixed in place.`
+            }),
+            () => "f"
+          )
+        )
+      ),
+      // TODO: this doesn't make sense for all subcommands?
+      scrambleAmount: optional(
+        option("--scramble", integer({ min: 0 }), {
+          description: message`Scramble solved position.`
+        })
+      ),
+      moveList: optional(
+        map(
+          option("--moves", string({ metavar: "COMMA_SEPARATED_MOVES" }), {
+            description: message`Restrict moves to this list. Example: \"U2,F,r\").`
+          }),
+          (s) => s.split(",").map((m) => Move.fromString(m))
+        )
+      ),
+      puzzle: map(
+        argument(string({ metavar: "PUZZLE" }), {
+          description: message`The puzzle can be given as a geometric description or by name.
+The geometric description starts with one of:
+
+- \`c\` (cube),\n
+- \`t\` (tetrahedron),\n
+- \`d\` (dodecahedron),\n
+- \`i\` (icosahedron),\n
+- \`o\` (octahedron),\n
+
+then a space, then a series of cuts. Each cut begins with one of:
+
+- \`f\` (for a cut parallel to faces),\n
+- \`v\` (for a cut perpendicular to a ray from the center through a corner),\n
+- \`e\` (for a cut perpendicular to a ray from the center through an edge),\n
+
+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.
+
+Example description: \`c f 0 v 0.577350269189626 e 0\`. Corresponds to: https://alpha.twizzle.net/explore/?puzzle=2x2x2+%2B+dino+%2B+little+chop
+
+The recognized puzzle names are: ${Object.keys(puzzleList).map((p) => JSON.stringify(p)).join(", ")}`
+        }),
+        (s) => {
+          const parsed = parsePuzzleDescription(puzzleList[s] ?? s);
+          if (parsed === null) {
+            throw new Error("Could not parse puzzle description!");
+          }
+          return parsed;
+        }
+      )
+    })
+  ),
+  {
+    programName: basename(argv[1]),
+    description: message`
+Examples:
+
+    puzzle-geometry --ss 2x2x2\n
+    puzzle-geometry --ss --fixcorner 2x2x2\n
+    puzzle-geometry --ss --moves U,F2,r 4x4x4\n
+    puzzle-geometry --ksolve --optimize --moves U,F,R megaminx\n
+    puzzle-geometry --gap --noedges megaminx
+`,
+    help: "option",
+    completion: {
+      option: {
+        names: ["--completions"],
+        hidden: false
+      }
+    },
+    version: {
+      option: {
+        hidden: false
+      },
+      value: packageVersion
+    }
+  }
+);
+if (args.verbosity !== 0) {
+  const cmd = () => {
+    const [command, ...args2] = argv;
+    return new PrintableShellCommand(command, args2).getPrintableCommand({
+      argumentLineWrapping: "inline"
+    });
+  };
+  switch (args.commentStyle) {
+    case "hash": {
+      console.log(`# ${cmd()}`);
+      break;
+    }
+    case "none": {
+      break;
+    }
+    case "Pascal": {
+      console.log(`(* ${cmd()} *)`);
+      break;
+    }
+    default:
+      throw new Error("Invalid comment style.");
+  }
+}
+function buildPuzzleGeometry() {
+  const {
+    verbosity,
+    optimizeOrbits,
+    addRotations,
+    allMoves,
+    outerBlockMoves,
+    vertexMoves,
+    includeCornerOrbits,
+    includeCenterOrbits,
+    includeEdgeOrbits,
+    excludeOrbits,
+    grayCorners,
+    grayEdges,
+    grayCenters,
+    fixedOrientation,
+    orientCenters,
+    puzzleOrientation,
+    puzzleOrientations,
+    fixedPieceType,
+    scrambleAmount,
+    moveList
+  } = args;
+  const options = {
+    verbosity,
+    optimizeOrbits,
+    addRotations,
+    allMoves,
+    outerBlockMoves,
+    vertexMoves,
+    includeCornerOrbits,
+    includeCenterOrbits,
+    includeEdgeOrbits,
+    excludeOrbits,
+    grayCorners,
+    grayEdges,
+    grayCenters,
+    fixedOrientation,
+    orientCenters,
+    puzzleOrientation,
+    puzzleOrientations,
+    fixedPieceType,
+    scrambleAmount,
+    moveList
+  };
+  const puzzleGeometry = new PuzzleGeometry(args.puzzle, options);
+  puzzleGeometry.allstickers();
+  puzzleGeometry.genperms();
+  return puzzleGeometry;
+}
+switch (args.subcommand) {
+  case "KSolve": {
+    console.log(buildPuzzleGeometry().writeksolve());
+    break;
+  }
+  case "SVG": {
+    console.log(
+      buildPuzzleGeometry().generatesvg(
+        void 0,
+        void 0,
+        void 0,
+        args.svg3D
+      )
+    );
+    break;
+  }
+  case "GAP": {
+    console.log(buildPuzzleGeometry().writegap());
+    break;
+  }
+  case "Mathematica": {
+    console.log(buildPuzzleGeometry().writemathematica());
+    break;
+  }
+  case "Schreier-Sims": {
+    buildPuzzleGeometry().writeSchreierSims(console.log);
+    break;
+  }
+  case "Canonical string analysis": {
+    buildPuzzleGeometry().showcanon(console.log);
+    break;
+  }
+  case "3D": {
+    console.log(JSON.stringify(buildPuzzleGeometry().get3d(), null, "  "));
+    break;
+  }
+  default:
+    throw new Error("Invalid subcommand.");
+}
+//# sourceMappingURL=puzzle-geometry-bin.js.map

package/dist/bin/puzzle-geometry-bin.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/bin/puzzle-geometry-bin.ts"],
+  "sourcesContent": ["/**\n\nTo run this file directly:\n\n```shell\nbun run -- ./src/bin/puzzle-geometry-bin.ts <program args>\n```\n\nTo add a `puzzle-geometry` binary to your path and test completions:\n\n```shell\n# fish (from repo root)\nset PATH (pwd)/src/test/bin-path $PATH\npuzzle-geometry --completions fish | source\n```\n\n```shell\n# zsh (from repo root)\nautoload -Uz compinit\ncompinit\nexport PATH=$(pwd)/src/test/bin-path:$PATH\nsource <(puzzle-geometry --completions zsh)\n```\n\n*/\n\nimport { basename } from \"node:path\";\nimport { argv } from \"node:process\";\nimport {\n  argument,\n  constant,\n  flag,\n  integer,\n  type Message,\n  map,\n  merge,\n  message,\n  multiple,\n  type OptionName,\n  object,\n  option,\n  optional,\n  or,\n  string,\n} from \"@optique/core\";\nimport { run } from \"@optique/run\";\nimport { Move } from \"@rednaxela101/cubing/alg\";\nimport {\n  type ExperimentalPuzzleGeometryOptions,\n  getPG3DNamedPuzzles,\n  PuzzleGeometry,\n  parsePuzzleDescription,\n} from \"@rednaxela101/cubing/puzzle-geometry\";\nimport { PrintableShellCommand } from \"printable-shell-command\";\nimport { packageVersion } from \"../metadata/packageVersion\";\n\nconst puzzleList = getPG3DNamedPuzzles();\n\n// TODO: make this a `ValueParser`?\nfunction antiBool(optionName: OptionName, description: Message) {\n  return optional(\n    map(\n      flag(optionName, {\n        description,\n      }),\n      (v) => !v,\n    ),\n  );\n}\n\n// Include using `...subcommandDefaults` at the *beginning* of a subcommand `object({ \u2026 })`.\nconst subcommandDefaults = {\n  commentStyle: constant(\"hash\"),\n  forceQuiet: constant(undefined),\n} as const;\n\nconst args = run(\n  merge(\n    object({\n      verbosity: optional(\n        or(\n          map(multiple(flag(\"--verbose\", \"-v\")), (v) => v.length),\n          map(flag(\"--quiet\", \"-q\"), () => 0),\n        ),\n      ),\n    }),\n    or(\n      object({\n        ...subcommandDefaults,\n        subcommand: constant(\"KSolve\"),\n        subcommandFlag: flag(\"--ksolve\", {\n          description: message`Print KSolve (\\`.tws\\`).`,\n        }),\n      }),\n      object({\n        ...subcommandDefaults,\n        subcommand: constant(\"SVG\"),\n        subcommandFlag: flag(\"--svg\", {\n          description: message`Print SVG. Forces \\`--quiet\\`.`,\n        }),\n        commentStyle: constant(\"none\"),\n        svg3D: optional(\n          option(\"--3d\", {\n            description: message`Use 3D format for SVG file.`,\n          }),\n        ),\n        verbosity: constant(0),\n      }),\n      object({\n        ...subcommandDefaults,\n        subcommand: constant(\"GAP\"),\n        subcommandFlag: flag(\"--gap\", {\n          description: message`Print GAP output.`,\n        }),\n      }),\n      object({\n        ...subcommandDefaults,\n        subcommand: constant(\"Mathematica\"),\n        subcommandFlag: flag(\"--mathematica\", {\n          description: message`Print Mathematica output.`,\n        }),\n        commentStyle: constant(\"Pascal\"),\n      }),\n      object({\n        ...subcommandDefaults,\n        subcommand: constant(\"Schreier-Sims\"),\n        subcommandFlag: flag(\"--ss\", {\n          description: message`Perform Schrier-Sims calculation.`,\n        }),\n      }),\n      object({\n        ...subcommandDefaults,\n        subcommand: constant(\"Canonical string analysis\"),\n        subcommandFlag: flag(\"--canon\", {\n          description: message`Print canonical string analysis.`,\n        }),\n      }),\n      object({\n        ...subcommandDefaults,\n        subcommand: constant(\"3D\"),\n        subcommandFlag: flag(\"--3d\", {\n          description: message`Print 3D information.`,\n        }),\n      }),\n    ),\n    object({\n      // This doesn't apply to SVG, but we place it here so that it doesn't print once for each non-SVG subcommand in the help string.\n      optimizeOrbits: option(\"--optimize\", {\n        description: message`Optimize output (when possible).`,\n      }),\n      addRotations: option(\"--rotations\", {\n        description: message`Include full-puzzle rotations as moves.`,\n      }),\n      allMoves: option(\"--allmoves\", {\n        description: message`Includes all moves (i.e., slice moves for 3x3x3).`,\n      }),\n      outerBlockMoves: option(\"--outerblockmoves\", {\n        description: message`Use outer block moves rather than slice moves.`,\n      }),\n      vertexMoves: option(\"--vertexmoves\", {\n        description: message`For tetrahedral puzzles, prefer vertex moves to face moves.`,\n      }),\n      includeCornerOrbits: antiBool(\n        \"--nocorners\",\n        message`Ignore all corners.`,\n      ),\n      excludeOrbits: optional(\n        map(\n          option(\"--omit\", string({ metavar: \"COMMA_SEPARATED_ORBITS\" }), {\n            description: message`Omit orbits.`,\n          }),\n          (s) => s.split(\",\"),\n        ),\n      ),\n      includeEdgeOrbits: antiBool(\"--noedges\", message`Ignore all edges.`),\n      includeCenterOrbits: antiBool(\n        \"--nocenters\",\n        message`Ignore all centers.`,\n      ),\n      grayCorners: option(\"--graycorners\", {\n        description: message`Gray corners.`,\n      }),\n      grayEdges: option(\"--grayedges\", { description: message`Gray edges.` }),\n      grayCenters: option(\"--graycenters\", {\n        description: message`Gray centers.`,\n      }),\n      fixedOrientation: option(\"--noorientation\", {\n        description: message`Ignore orientations.`,\n      }),\n      orientCenters: option(\"--orientcenters\", {\n        description: message`Give centers an orientation.`,\n      }),\n    }),\n    optional(\n      or(\n        object({\n          puzzleOrientation: optional(\n            map(\n              option(\n                \"--puzzleorientation\",\n                string({ metavar: \"JSON_STRING\" }),\n                {\n                  description: message`For 3D formats, give puzzle orientation.`,\n                },\n              ),\n              (s) => JSON.parse(s),\n            ),\n          ),\n          puzzleOrientations: constant(undefined),\n        }),\n        object({\n          puzzleOrientation: constant(undefined),\n          puzzleOrientations: optional(\n            map(\n              option(\n                \"--puzzleorientations\",\n                string({ metavar: \"JSON_STRING\" }),\n                {\n                  description: message`For 3D formats, give puzzle orientations.`,\n                },\n              ),\n              (s) => JSON.parse(s),\n            ),\n          ),\n        }),\n      ),\n    ),\n    object({\n      fixedPieceType: optional(\n        or(\n          map(\n            flag(\"--fixcorner\", {\n              description: message`Auto-select a subset of moves to keep a corner fixed in place.`,\n            }),\n            () => \"v\" as const,\n          ),\n          map(\n            flag(\"--fixedge\", {\n              description: message`Auto-select a subset of moves to keep an edge fixed in place.`,\n            }),\n            () => \"e\" as const,\n          ),\n          map(\n            flag(\"--fixcenter\", {\n              description: message`Auto-select a subset of moves to keep a center fixed in place.`,\n            }),\n            () => \"f\" as const,\n          ),\n        ),\n      ),\n      // TODO: this doesn't make sense for all subcommands?\n      scrambleAmount: optional(\n        option(\"--scramble\", integer({ min: 0 }), {\n          description: message`Scramble solved position.`,\n        }),\n      ),\n      moveList: optional(\n        map(\n          option(\"--moves\", string({ metavar: \"COMMA_SEPARATED_MOVES\" }), {\n            description: message`Restrict moves to this list. Example: \\\"U2,F,r\\\").`,\n          }),\n          (s) => s.split(\",\").map((m) => Move.fromString(m)),\n        ),\n      ),\n      puzzle: map(\n        argument(string({ metavar: \"PUZZLE\" }), {\n          description: message`The puzzle can be given as a geometric description or by name.\nThe geometric description starts with one of:\n\n- \\`c\\` (cube),\\n\n- \\`t\\` (tetrahedron),\\n\n- \\`d\\` (dodecahedron),\\n\n- \\`i\\` (icosahedron),\\n\n- \\`o\\` (octahedron),\\n\n\nthen a space, then a series of cuts. Each cut begins with one of:\n\n- \\`f\\` (for a cut parallel to faces),\\n\n- \\`v\\` (for a cut perpendicular to a ray from the center through a corner),\\n\n- \\`e\\` (for a cut perpendicular to a ray from the center through an edge),\\n\n\nfollowed by a decimal number giving a distance, where 1 is the distance\nbetween the center of the puzzle and the center of a face.\n\nExample description: \\`c f 0 v 0.577350269189626 e 0\\`. Corresponds to: https://alpha.twizzle.net/explore/?puzzle=2x2x2+%2B+dino+%2B+little+chop\n\nThe recognized puzzle names are: ${Object.keys(puzzleList)\n            .map((p) => JSON.stringify(p))\n            .join(\", \")}`,\n        }),\n        (s) => {\n          const parsed = parsePuzzleDescription(puzzleList[s] ?? s);\n          if (parsed === null) {\n            throw new Error(\"Could not parse puzzle description!\");\n          }\n          return parsed;\n        },\n      ),\n    }),\n  ),\n  {\n    programName: basename(argv[1]),\n    description: message`\nExamples:\n\n    puzzle-geometry --ss 2x2x2\\n\n    puzzle-geometry --ss --fixcorner 2x2x2\\n\n    puzzle-geometry --ss --moves U,F2,r 4x4x4\\n\n    puzzle-geometry --ksolve --optimize --moves U,F,R megaminx\\n\n    puzzle-geometry --gap --noedges megaminx\n`,\n    help: \"option\",\n    completion: {\n      option: {\n        names: [\"--completions\"],\n        hidden: false,\n      },\n    },\n    version: {\n      option: {\n        hidden: false,\n      },\n      value: packageVersion,\n    },\n  },\n);\n\nif (args.verbosity !== 0) {\n  const cmd = () => {\n    const [command, ...args] = argv;\n    return new PrintableShellCommand(command, args).getPrintableCommand({\n      argumentLineWrapping: \"inline\",\n    });\n  };\n\n  switch (args.commentStyle) {\n    case \"hash\": {\n      console.log(`# ${cmd()}`);\n      break;\n    }\n    case \"none\": {\n      break;\n    }\n    case \"Pascal\": {\n      console.log(`(* ${cmd()} *)`);\n      break;\n    }\n    default:\n      throw new Error(\"Invalid comment style.\") as never;\n  }\n}\n\nfunction buildPuzzleGeometry(): PuzzleGeometry {\n  const {\n    verbosity,\n    optimizeOrbits,\n    addRotations,\n    allMoves,\n    outerBlockMoves,\n    vertexMoves,\n    includeCornerOrbits,\n    includeCenterOrbits,\n    includeEdgeOrbits,\n    excludeOrbits,\n    grayCorners,\n    grayEdges,\n    grayCenters,\n    fixedOrientation,\n    orientCenters,\n    puzzleOrientation,\n    puzzleOrientations,\n    fixedPieceType,\n    scrambleAmount,\n    moveList,\n  } = args;\n  const options: ExperimentalPuzzleGeometryOptions = {\n    verbosity,\n    optimizeOrbits,\n    addRotations,\n    allMoves,\n    outerBlockMoves,\n    vertexMoves,\n    includeCornerOrbits,\n    includeCenterOrbits,\n    includeEdgeOrbits,\n    excludeOrbits,\n    grayCorners,\n    grayEdges,\n    grayCenters,\n    fixedOrientation,\n    orientCenters,\n    puzzleOrientation,\n    puzzleOrientations,\n    fixedPieceType,\n    scrambleAmount,\n    moveList,\n  };\n\n  const puzzleGeometry = new PuzzleGeometry(args.puzzle, options);\n  // TODO: why are these calls needed?\n  puzzleGeometry.allstickers();\n  puzzleGeometry.genperms();\n  return puzzleGeometry;\n}\n\nswitch (args.subcommand) {\n  case \"KSolve\": {\n    console.log(buildPuzzleGeometry().writeksolve());\n    break;\n  }\n  case \"SVG\": {\n    console.log(\n      buildPuzzleGeometry().generatesvg(\n        undefined,\n        undefined,\n        undefined,\n        args.svg3D,\n      ),\n    );\n    break;\n  }\n  case \"GAP\": {\n    console.log(buildPuzzleGeometry().writegap());\n    break;\n  }\n  case \"Mathematica\": {\n    console.log(buildPuzzleGeometry().writemathematica());\n    break;\n  }\n  case \"Schreier-Sims\": {\n    buildPuzzleGeometry().writeSchreierSims(console.log);\n    break;\n  }\n  case \"Canonical string analysis\": {\n    buildPuzzleGeometry().showcanon(console.log);\n    break;\n  }\n  case \"3D\": {\n    console.log(JSON.stringify(buildPuzzleGeometry().get3d(), null, \"  \"));\n    break;\n  }\n  default:\n    throw new Error(\"Invalid subcommand.\") as never;\n}\n"],
+  "mappings": ";;;;;;AA0BA,SAAS,gBAAgB;AACzB,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AACpB,SAAS,YAAY;AACrB;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,6BAA6B;AAGtC,IAAM,aAAa,oBAAoB;AAGvC,SAAS,SAAS,YAAwB,aAAsB;AAC9D,SAAO;AAAA,IACL;AAAA,MACE,KAAK,YAAY;AAAA,QACf;AAAA,MACF,CAAC;AAAA,MACD,CAAC,MAAM,CAAC;AAAA,IACV;AAAA,EACF;AACF;AAGA,IAAM,qBAAqB;AAAA,EACzB,cAAc,SAAS,MAAM;AAAA,EAC7B,YAAY,SAAS,MAAS;AAChC;AAEA,IAAM,OAAO;AAAA,EACX;AAAA,IACE,OAAO;AAAA,MACL,WAAW;AAAA,QACT;AAAA,UACE,IAAI,SAAS,KAAK,aAAa,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM;AAAA,UACtD,IAAI,KAAK,WAAW,IAAI,GAAG,MAAM,CAAC;AAAA,QACpC;AAAA,MACF;AAAA,IACF,CAAC;AAAA,IACD;AAAA,MACE,OAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY,SAAS,QAAQ;AAAA,QAC7B,gBAAgB,KAAK,YAAY;AAAA,UAC/B,aAAa;AAAA,QACf,CAAC;AAAA,MACH,CAAC;AAAA,MACD,OAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY,SAAS,KAAK;AAAA,QAC1B,gBAAgB,KAAK,SAAS;AAAA,UAC5B,aAAa;AAAA,QACf,CAAC;AAAA,QACD,cAAc,SAAS,MAAM;AAAA,QAC7B,OAAO;AAAA,UACL,OAAO,QAAQ;AAAA,YACb,aAAa;AAAA,UACf,CAAC;AAAA,QACH;AAAA,QACA,WAAW,SAAS,CAAC;AAAA,MACvB,CAAC;AAAA,MACD,OAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY,SAAS,KAAK;AAAA,QAC1B,gBAAgB,KAAK,SAAS;AAAA,UAC5B,aAAa;AAAA,QACf,CAAC;AAAA,MACH,CAAC;AAAA,MACD,OAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY,SAAS,aAAa;AAAA,QAClC,gBAAgB,KAAK,iBAAiB;AAAA,UACpC,aAAa;AAAA,QACf,CAAC;AAAA,QACD,cAAc,SAAS,QAAQ;AAAA,MACjC,CAAC;AAAA,MACD,OAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY,SAAS,eAAe;AAAA,QACpC,gBAAgB,KAAK,QAAQ;AAAA,UAC3B,aAAa;AAAA,QACf,CAAC;AAAA,MACH,CAAC;AAAA,MACD,OAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY,SAAS,2BAA2B;AAAA,QAChD,gBAAgB,KAAK,WAAW;AAAA,UAC9B,aAAa;AAAA,QACf,CAAC;AAAA,MACH,CAAC;AAAA,MACD,OAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY,SAAS,IAAI;AAAA,QACzB,gBAAgB,KAAK,QAAQ;AAAA,UAC3B,aAAa;AAAA,QACf,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,IACA,OAAO;AAAA;AAAA,MAEL,gBAAgB,OAAO,cAAc;AAAA,QACnC,aAAa;AAAA,MACf,CAAC;AAAA,MACD,cAAc,OAAO,eAAe;AAAA,QAClC,aAAa;AAAA,MACf,CAAC;AAAA,MACD,UAAU,OAAO,cAAc;AAAA,QAC7B,aAAa;AAAA,MACf,CAAC;AAAA,MACD,iBAAiB,OAAO,qBAAqB;AAAA,QAC3C,aAAa;AAAA,MACf,CAAC;AAAA,MACD,aAAa,OAAO,iBAAiB;AAAA,QACnC,aAAa;AAAA,MACf,CAAC;AAAA,MACD,qBAAqB;AAAA,QACnB;AAAA,QACA;AAAA,MACF;AAAA,MACA,eAAe;AAAA,QACb;AAAA,UACE,OAAO,UAAU,OAAO,EAAE,SAAS,yBAAyB,CAAC,GAAG;AAAA,YAC9D,aAAa;AAAA,UACf,CAAC;AAAA,UACD,CAAC,MAAM,EAAE,MAAM,GAAG;AAAA,QACpB;AAAA,MACF;AAAA,MACA,mBAAmB,SAAS,aAAa,0BAA0B;AAAA,MACnE,qBAAqB;AAAA,QACnB;AAAA,QACA;AAAA,MACF;AAAA,MACA,aAAa,OAAO,iBAAiB;AAAA,QACnC,aAAa;AAAA,MACf,CAAC;AAAA,MACD,WAAW,OAAO,eAAe,EAAE,aAAa,qBAAqB,CAAC;AAAA,MACtE,aAAa,OAAO,iBAAiB;AAAA,QACnC,aAAa;AAAA,MACf,CAAC;AAAA,MACD,kBAAkB,OAAO,mBAAmB;AAAA,QAC1C,aAAa;AAAA,MACf,CAAC;AAAA,MACD,eAAe,OAAO,mBAAmB;AAAA,QACvC,aAAa;AAAA,MACf,CAAC;AAAA,IACH,CAAC;AAAA,IACD;AAAA,MACE;AAAA,QACE,OAAO;AAAA,UACL,mBAAmB;AAAA,YACjB;AAAA,cACE;AAAA,gBACE;AAAA,gBACA,OAAO,EAAE,SAAS,cAAc,CAAC;AAAA,gBACjC;AAAA,kBACE,aAAa;AAAA,gBACf;AAAA,cACF;AAAA,cACA,CAAC,MAAM,KAAK,MAAM,CAAC;AAAA,YACrB;AAAA,UACF;AAAA,UACA,oBAAoB,SAAS,MAAS;AAAA,QACxC,CAAC;AAAA,QACD,OAAO;AAAA,UACL,mBAAmB,SAAS,MAAS;AAAA,UACrC,oBAAoB;AAAA,YAClB;AAAA,cACE;AAAA,gBACE;AAAA,gBACA,OAAO,EAAE,SAAS,cAAc,CAAC;AAAA,gBACjC;AAAA,kBACE,aAAa;AAAA,gBACf;AAAA,cACF;AAAA,cACA,CAAC,MAAM,KAAK,MAAM,CAAC;AAAA,YACrB;AAAA,UACF;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,OAAO;AAAA,MACL,gBAAgB;AAAA,QACd;AAAA,UACE;AAAA,YACE,KAAK,eAAe;AAAA,cAClB,aAAa;AAAA,YACf,CAAC;AAAA,YACD,MAAM;AAAA,UACR;AAAA,UACA;AAAA,YACE,KAAK,aAAa;AAAA,cAChB,aAAa;AAAA,YACf,CAAC;AAAA,YACD,MAAM;AAAA,UACR;AAAA,UACA;AAAA,YACE,KAAK,eAAe;AAAA,cAClB,aAAa;AAAA,YACf,CAAC;AAAA,YACD,MAAM;AAAA,UACR;AAAA,QACF;AAAA,MACF;AAAA;AAAA,MAEA,gBAAgB;AAAA,QACd,OAAO,cAAc,QAAQ,EAAE,KAAK,EAAE,CAAC,GAAG;AAAA,UACxC,aAAa;AAAA,QACf,CAAC;AAAA,MACH;AAAA,MACA,UAAU;AAAA,QACR;AAAA,UACE,OAAO,WAAW,OAAO,EAAE,SAAS,wBAAwB,CAAC,GAAG;AAAA,YAC9D,aAAa;AAAA,UACf,CAAC;AAAA,UACD,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,IAAI,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC;AAAA,QACnD;AAAA,MACF;AAAA,MACA,QAAQ;AAAA,QACN,SAAS,OAAO,EAAE,SAAS,SAAS,CAAC,GAAG;AAAA,UACtC,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mCAoBY,OAAO,KAAK,UAAU,EAC5C,IAAI,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,EAC5B,KAAK,IAAI,CAAC;AAAA,QACf,CAAC;AAAA,QACD,CAAC,MAAM;AACL,gBAAM,SAAS,uBAAuB,WAAW,CAAC,KAAK,CAAC;AACxD,cAAI,WAAW,MAAM;AACnB,kBAAM,IAAI,MAAM,qCAAqC;AAAA,UACvD;AACA,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EACA;AAAA,IACE,aAAa,SAAS,KAAK,CAAC,CAAC;AAAA,IAC7B,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASb,MAAM;AAAA,IACN,YAAY;AAAA,MACV,QAAQ;AAAA,QACN,OAAO,CAAC,eAAe;AAAA,QACvB,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,QAAQ;AAAA,QACN,QAAQ;AAAA,MACV;AAAA,MACA,OAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,IAAI,KAAK,cAAc,GAAG;AACxB,QAAM,MAAM,MAAM;AAChB,UAAM,CAAC,SAAS,GAAGA,KAAI,IAAI;AAC3B,WAAO,IAAI,sBAAsB,SAASA,KAAI,EAAE,oBAAoB;AAAA,MAClE,sBAAsB;AAAA,IACxB,CAAC;AAAA,EACH;AAEA,UAAQ,KAAK,cAAc;AAAA,IACzB,KAAK,QAAQ;AACX,cAAQ,IAAI,KAAK,IAAI,CAAC,EAAE;AACxB;AAAA,IACF;AAAA,IACA,KAAK,QAAQ;AACX;AAAA,IACF;AAAA,IACA,KAAK,UAAU;AACb,cAAQ,IAAI,MAAM,IAAI,CAAC,KAAK;AAC5B;AAAA,IACF;AAAA,IACA;AACE,YAAM,IAAI,MAAM,wBAAwB;AAAA,EAC5C;AACF;AAEA,SAAS,sBAAsC;AAC7C,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,UAA6C;AAAA,IACjD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,QAAM,iBAAiB,IAAI,eAAe,KAAK,QAAQ,OAAO;AAE9D,iBAAe,YAAY;AAC3B,iBAAe,SAAS;AACxB,SAAO;AACT;AAEA,QAAQ,KAAK,YAAY;AAAA,EACvB,KAAK,UAAU;AACb,YAAQ,IAAI,oBAAoB,EAAE,YAAY,CAAC;AAC/C;AAAA,EACF;AAAA,EACA,KAAK,OAAO;AACV,YAAQ;AAAA,MACN,oBAAoB,EAAE;AAAA,QACpB;AAAA,QACA;AAAA,QACA;AAAA,QACA,KAAK;AAAA,MACP;AAAA,IACF;AACA;AAAA,EACF;AAAA,EACA,KAAK,OAAO;AACV,YAAQ,IAAI,oBAAoB,EAAE,SAAS,CAAC;AAC5C;AAAA,EACF;AAAA,EACA,KAAK,eAAe;AAClB,YAAQ,IAAI,oBAAoB,EAAE,iBAAiB,CAAC;AACpD;AAAA,EACF;AAAA,EACA,KAAK,iBAAiB;AACpB,wBAAoB,EAAE,kBAAkB,QAAQ,GAAG;AACnD;AAAA,EACF;AAAA,EACA,KAAK,6BAA6B;AAChC,wBAAoB,EAAE,UAAU,QAAQ,GAAG;AAC3C;AAAA,EACF;AAAA,EACA,KAAK,MAAM;AACT,YAAQ,IAAI,KAAK,UAAU,oBAAoB,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;AACrE;AAAA,EACF;AAAA,EACA;AACE,UAAM,IAAI,MAAM,qBAAqB;AACzC;",
+  "names": ["args"]
+}