cli-kiss 0.2.6 → 0.2.8

package/tests/unit.Reader.commons.ts

@@ -1,5 +1,9 @@
 import { expect, it } from "@jest/globals";
-import { ReaderArgs, ReaderOptionParsing } from "../src";
+import {
+  ReaderArgs,
+  ReaderOptionNextGuard,
+  ReaderOptionRestGuard,
+} from "../src";
 
 it("run", async function () {
   const stream = new ReaderArgs([
@@ -36,105 +40,97 @@ it("run", async function () {
 
   expect(stream.consumePositional()).toStrictEqual("positional-0");
 
-  const kFlagUnset = stream.registerOption({
-    longs: ["flag-unset"],
-    shorts: [],
-    parsing: optionFlagParsing,
+  const kFlagUnset = stream.registerOptionLong({
+    key: "flag-unset",
+    nextGuard: optionFlagNextGuard,
   });
-  const kFlagNo = stream.registerOption({
-    longs: ["no-flag-no"],
-    shorts: [],
-    parsing: optionFlagParsing,
+  const kFlagNo = stream.registerOptionLong({
+    key: "no-flag-no",
+    nextGuard: optionFlagNextGuard,
   });
-  const kFlagNormal = stream.registerOption({
-    longs: ["flag-normal"],
-    shorts: [],
-    parsing: optionFlagParsing,
+  const kFlagNormal = stream.registerOptionLong({
+    key: "flag-normal",
+    nextGuard: optionFlagNextGuard,
   });
-  const kFlagPositive = stream.registerOption({
-    longs: ["flag-positive"],
-    shorts: [],
-    parsing: optionFlagParsing,
+  const kFlagPositive = stream.registerOptionLong({
+    key: "flag-positive",
+    nextGuard: optionFlagNextGuard,
   });
-  const kFlagNegative = stream.registerOption({
-    longs: ["flag-negative"],
-    shorts: [],
-    parsing: optionFlagParsing,
+  const kFlagNegative = stream.registerOptionLong({
+    key: "flag-negative",
+    nextGuard: optionFlagNextGuard,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-1");
 
-  const kOptionUnset = stream.registerOption({
-    longs: ["option-unset"],
-    shorts: [],
-    parsing: optionValueFixedUniqueParsing,
+  const kOptionUnset = stream.registerOptionLong({
+    key: "option-unset",
+    nextGuard: optionValuedNextGuard,
   });
-  const kOptionSplit = stream.registerOption({
-    longs: ["option-split"],
-    shorts: [],
-    parsing: optionValueFixedUniqueParsing,
+  const kOptionSplit = stream.registerOptionLong({
+    key: "option-split",
+    nextGuard: optionValuedNextGuard,
   });
-  const kOptionJoin = stream.registerOption({
-    longs: ["option-join"],
-    shorts: [],
-    parsing: optionValueFixedUniqueParsing,
+  const kOptionJoin = stream.registerOptionLong({
+    key: "option-join",
+    nextGuard: optionValuedNextGuard,
   });
 
-  const kA = stream.registerOption({
-    longs: [],
-    shorts: ["a"],
-    parsing: optionFlagParsing,
+  const kA = stream.registerOptionShort({
+    key: "a",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kB = stream.registerOption({
-    longs: [],
-    shorts: ["b"],
-    parsing: optionValueFixedUniqueParsing,
+  const kB = stream.registerOptionShort({
+    key: "b",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
 
-  const kC = stream.registerOption({
-    longs: [],
-    shorts: ["c"],
-    parsing: optionFlagParsing,
+  const kC = stream.registerOptionShort({
+    key: "c",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kD = stream.registerOption({
-    longs: [],
-    shorts: ["d"],
-    parsing: optionValueFixedUniqueParsing,
+  const kD = stream.registerOptionShort({
+    key: "d",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
 
-  const kE = stream.registerOption({
-    longs: [],
-    shorts: ["e"],
-    parsing: optionFlagParsing,
+  const kE = stream.registerOptionShort({
+    key: "e",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kF = stream.registerOption({
-    longs: [],
-    shorts: ["f"],
-    parsing: optionValueFixedUniqueParsing,
+  const kF = stream.registerOptionShort({
+    key: "f",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-2");
 
-  const kG = stream.registerOption({
-    longs: [],
-    shorts: ["g"],
-    parsing: optionFlagParsing,
+  const kG = stream.registerOptionShort({
+    key: "g",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kH = stream.registerOption({
-    longs: [],
-    shorts: ["h"],
-    parsing: optionFlagParsing,
+  const kH = stream.registerOptionShort({
+    key: "h",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
 
-  const kI = stream.registerOption({
-    longs: [],
-    shorts: ["i"],
-    parsing: optionFlagParsing,
+  const kI = stream.registerOptionShort({
+    key: "i",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kJ = stream.registerOption({
-    longs: [],
-    shorts: ["j"],
-    parsing: optionFlagParsing,
+  const kJ = stream.registerOptionShort({
+    key: "j",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-3");
@@ -145,76 +141,56 @@ it("run", async function () {
   expect(stream.consumePositional()).toStrictEqual("positional-4");
   expect(stream.consumePositional()).toStrictEqual(undefined);
 
-  expect(stream.getOptionValues(kFlagUnset)).toStrictEqual([]);
-  expect(stream.getOptionValues(kFlagNo)).toStrictEqual([
+  expect(kFlagUnset().values).toStrictEqual([]);
+  expect(kFlagNo().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kFlagNormal().values).toStrictEqual([
     { inlined: null, separated: [] },
   ]);
-  expect(stream.getOptionValues(kFlagNormal)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kFlagPositive)).toStrictEqual([
+  expect(kFlagPositive().values).toStrictEqual([
     { inlined: "true", separated: [] },
   ]);
-  expect(stream.getOptionValues(kFlagNegative)).toStrictEqual([
+  expect(kFlagNegative().values).toStrictEqual([
     { inlined: "false", separated: [] },
   ]);
 
-  expect(stream.getOptionValues(kOptionUnset)).toStrictEqual([]);
-  expect(stream.getOptionValues(kOptionSplit)).toStrictEqual([
+  expect(kOptionUnset().values).toStrictEqual([]);
+  expect(kOptionSplit().values).toStrictEqual([
     { inlined: null, separated: ["1.1"] },
     { inlined: null, separated: ["1.2"] },
   ]);
-  expect(stream.getOptionValues(kOptionJoin)).toStrictEqual([
+  expect(kOptionJoin().values).toStrictEqual([
     { inlined: "2.1", separated: [] },
     { inlined: "2.2", separated: [] },
   ]);
 
-  expect(stream.getOptionValues(kA)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kB)).toStrictEqual([
+  expect(kA().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kB().values).toStrictEqual([
     { inlined: null, separated: ["3.1"] },
     { inlined: null, separated: ["3.2"] },
   ]);
 
-  expect(stream.getOptionValues(kC)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kD)).toStrictEqual([
+  expect(kC().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kD().values).toStrictEqual([
     { inlined: "4.1", separated: [] },
     { inlined: "4.2", separated: [] },
   ]);
 
-  expect(stream.getOptionValues(kE)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kF)).toStrictEqual([
+  expect(kE().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kF().values).toStrictEqual([
     { inlined: "5.1", separated: [] },
     { inlined: "5.2", separated: [] },
   ]);
 
-  expect(stream.getOptionValues(kG)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kH)).toStrictEqual([
-    { inlined: "FALSE", separated: [] },
-  ]);
+  expect(kG().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kH().values).toStrictEqual([{ inlined: "FALSE", separated: [] }]);
 
-  expect(stream.getOptionValues(kI)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kJ)).toStrictEqual([
-    { inlined: "TRUE", separated: [] },
-  ]);
+  expect(kI().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kJ().values).toStrictEqual([{ inlined: "TRUE", separated: [] }]);
 });
 
-const optionFlagParsing: ReaderOptionParsing = {
-  consumeShortGroup: false,
-  consumeNextArg: () => false,
-};
+const optionFlagRestGuard: ReaderOptionRestGuard = () => false;
+const optionFlagNextGuard: ReaderOptionNextGuard = () => false;
 
-const optionValueFixedUniqueParsing: ReaderOptionParsing = {
-  consumeShortGroup: true,
-  consumeNextArg: (inlined, separated) =>
-    inlined === null && separated.length === 0,
-};
+const optionValuedRestGuard: ReaderOptionRestGuard = () => true;
+const optionValuedNextGuard: ReaderOptionNextGuard = (value) =>
+  value.inlined === null && value.separated.length === 0;

package/tests/unit.Reader.parsings.ts

@@ -3,47 +3,35 @@ import { ReaderArgs } from "../src";
 
 it("run", async function () {
   const readerArgs1 = new ReaderArgs(["--val=1", "A", "B", "STOP", "C"]);
-  const kOptionVariadicStop = readerArgs1.registerOption({
-    longs: ["val"],
-    shorts: [],
-    parsing: {
-      consumeShortGroup: true,
-      consumeNextArg: (_inlined, separated, nextArg) =>
-        nextArg !== undefined && separated[separated.length - 1] !== "STOP",
-    },
+  const kOptionVariadicStop = readerArgs1.registerOptionLong({
+    key: "val",
+    nextGuard: (value, nextArg) =>
+      nextArg !== undefined &&
+      value.separated[value.separated.length - 1] !== "STOP",
   });
   expect(readerArgs1.consumePositional()).toStrictEqual("C");
   expect(readerArgs1.consumePositional()).toStrictEqual(undefined);
-  expect(readerArgs1.getOptionValues(kOptionVariadicStop)).toStrictEqual([
+  expect(kOptionVariadicStop().values).toStrictEqual([
     { inlined: "1", separated: ["A", "B", "STOP"] },
   ]);
 
   const readerArgs2 = new ReaderArgs(["--val=1", "A", "B", "C"]);
-  const kOptionVariadicFull = readerArgs2.registerOption({
-    longs: ["val"],
-    shorts: [],
-    parsing: {
-      consumeShortGroup: true,
-      consumeNextArg: (_inlined, _separated, nextArg) => nextArg !== undefined,
-    },
+  const kOptionVariadicFull = readerArgs2.registerOptionLong({
+    key: "val",
+    nextGuard: (_value, nextArg) => nextArg !== undefined,
   });
   expect(readerArgs2.consumePositional()).toStrictEqual(undefined);
-  expect(readerArgs2.getOptionValues(kOptionVariadicFull)).toStrictEqual([
+  expect(kOptionVariadicFull().values).toStrictEqual([
     { inlined: "1", separated: ["A", "B", "C"] },
   ]);
 
   const readerArgs3 = new ReaderArgs(["--val=2", "A", "B", "--val=1", "C"]);
-  const kOptionVariadicKeyed = readerArgs3.registerOption({
-    longs: ["val"],
-    shorts: [],
-    parsing: {
-      consumeShortGroup: true,
-      consumeNextArg: (inlined, separated) =>
-        separated.length < Number(inlined ?? "0"),
-    },
+  const kOptionVariadicKeyed = readerArgs3.registerOptionLong({
+    key: "val",
+    nextGuard: (value) => value.separated.length < Number(value.inlined ?? "0"),
   });
   expect(readerArgs3.consumePositional()).toStrictEqual(undefined);
-  expect(readerArgs3.getOptionValues(kOptionVariadicKeyed)).toStrictEqual([
+  expect(kOptionVariadicKeyed().values).toStrictEqual([
     { inlined: "2", separated: ["A", "B"] },
     { inlined: "1", separated: ["C"] },
   ]);

package/tests/unit.Reader.shortBig.ts

@@ -1,5 +1,9 @@
 import { expect, it } from "@jest/globals";
-import { ReaderArgs, ReaderOptionParsing } from "../src";
+import {
+  ReaderArgs,
+  ReaderOptionNextGuard,
+  ReaderOptionRestGuard,
+} from "../src";
 
 it("run", async function () {
   const stream = new ReaderArgs([
@@ -19,136 +23,117 @@ it("run", async function () {
 
   expect(stream.consumePositional()).toStrictEqual("positional-0");
 
-  const kSofUnset = stream.registerOption({
-    longs: [],
-    shorts: ["sof-unset"],
-    parsing: optionFlagParsing,
+  const kSofUnset = stream.registerOptionShort({
+    key: "sof-unset",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kSofNormal = stream.registerOption({
-    shorts: ["sof-normal"],
-    longs: [],
-    parsing: optionFlagParsing,
+  const kSofNormal = stream.registerOptionShort({
+    key: "sof-normal",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kSofPositive = stream.registerOption({
-    longs: [],
-    shorts: ["sof-positive"],
-    parsing: optionFlagParsing,
+  const kSofPositive = stream.registerOptionShort({
+    key: "sof-positive",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kSofNegative = stream.registerOption({
-    longs: [],
-    shorts: ["sof-negative"],
-    parsing: optionFlagParsing,
+  const kSofNegative = stream.registerOptionShort({
+    key: "sof-negative",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
 
-  const kAa = stream.registerOption({
-    longs: [],
-    shorts: ["aa"],
-    parsing: optionFlagParsing,
+  const kAa = stream.registerOptionShort({
+    key: "aa",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kBb = stream.registerOption({
-    longs: [],
-    shorts: ["bb"],
-    parsing: optionFlagParsing,
+  const kBb = stream.registerOptionShort({
+    key: "bb",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kCc = stream.registerOption({
-    longs: [],
-    shorts: ["cc"],
-    parsing: optionFlagParsing,
+  const kCc = stream.registerOptionShort({
+    key: "cc",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-1");
 
-  const kSovSplit = stream.registerOption({
-    longs: [],
-    shorts: ["sov-split"],
-    parsing: optionValueFixedUniqueParsing,
+  const kSovSplit = stream.registerOptionShort({
+    key: "sov-split",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
-  const kSovJoin = stream.registerOption({
-    longs: [],
-    shorts: ["sov-join"],
-    parsing: optionValueFixedUniqueParsing,
+  const kSovJoin = stream.registerOptionShort({
+    key: "sov-join",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
-  const kSovUnset = stream.registerOption({
-    longs: [],
-    shorts: ["sov-unset"],
-    parsing: optionValueFixedUniqueParsing,
+  const kSovUnset = stream.registerOptionShort({
+    key: "sov-unset",
+    restGuard: optionValuedRestGuard,
+    nextGuard: optionValuedNextGuard,
   });
 
-  const kDd = stream.registerOption({
-    longs: [],
-    shorts: ["dd"],
-    parsing: optionFlagParsing,
+  const kDd = stream.registerOptionShort({
+    key: "dd",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kEe = stream.registerOption({
-    longs: [],
-    shorts: ["ee"],
-    parsing: optionFlagParsing,
+  const kEe = stream.registerOptionShort({
+    key: "ee",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kFf = stream.registerOption({
-    longs: [],
-    shorts: ["ff"],
-    parsing: optionFlagParsing,
+
+  const kFf = stream.registerOptionShort({
+    key: "ff",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
-  const kGg = stream.registerOption({
-    longs: [],
-    shorts: ["gg"],
-    parsing: optionFlagParsing,
+  const kGg = stream.registerOptionShort({
+    key: "gg",
+    restGuard: optionFlagRestGuard,
+    nextGuard: optionFlagNextGuard,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-2");
 
-  expect(stream.getOptionValues(kSofUnset)).toStrictEqual([]);
-  expect(stream.getOptionValues(kSofNormal)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kSofPositive)).toStrictEqual([
+  expect(kSofUnset().values).toStrictEqual([]);
+  expect(kSofNormal().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kSofPositive().values).toStrictEqual([
     { inlined: "true", separated: [] },
   ]);
-  expect(stream.getOptionValues(kSofNegative)).toStrictEqual([
+  expect(kSofNegative().values).toStrictEqual([
     { inlined: "false", separated: [] },
   ]);
 
-  expect(stream.getOptionValues(kAa)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kBb)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kCc)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
+  expect(kAa().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kBb().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kCc().values).toStrictEqual([{ inlined: null, separated: [] }]);
 
-  expect(stream.getOptionValues(kSovUnset)).toStrictEqual([]);
-  expect(stream.getOptionValues(kSovSplit)).toStrictEqual([
+  expect(kSovUnset().values).toStrictEqual([]);
+  expect(kSovSplit().values).toStrictEqual([
     { inlined: null, separated: ["1.1"] },
     { inlined: null, separated: ["1.2"] },
   ]);
-  expect(stream.getOptionValues(kSovJoin)).toStrictEqual([
+  expect(kSovJoin().values).toStrictEqual([
     { inlined: "2.1", separated: [] },
     { inlined: "2.2", separated: [] },
   ]);
 
-  expect(stream.getOptionValues(kDd)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kEe)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kFf)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(stream.getOptionValues(kGg)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
+  expect(kDd().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kEe().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kFf().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kGg().values).toStrictEqual([{ inlined: null, separated: [] }]);
 });
 
-const optionFlagParsing: ReaderOptionParsing = {
-  consumeShortGroup: false,
-  consumeNextArg: () => false,
-};
+const optionFlagRestGuard: ReaderOptionRestGuard = () => false;
+const optionFlagNextGuard: ReaderOptionNextGuard = () => false;
 
-const optionValueFixedUniqueParsing: ReaderOptionParsing = {
-  consumeShortGroup: true,
-  consumeNextArg: (inlined, separated) =>
-    inlined === null && separated.length === 0,
-};
+const optionValuedRestGuard: ReaderOptionRestGuard = () => true;
+const optionValuedNextGuard: ReaderOptionNextGuard = (value) =>
+  value.inlined === null && value.separated.length === 0;

package/tests/unit.command.aliases.ts

@@ -0,0 +1,100 @@
+import { expect, it } from "@jest/globals";
+import {
+  command,
+  operation,
+  optionFlag,
+  optionRepeatable,
+  optionSingleValue,
+  ReaderArgs,
+  type,
+} from "../src";
+
+it("run", async function () {
+  const cmd = command(
+    { description: "Description" },
+    operation(
+      {
+        options: {
+          option: optionRepeatable({
+            long: "option",
+            type: type(),
+            aliases: {
+              longs: ["option-alias1", "option-alias2"],
+              shorts: ["pts", "o"],
+            },
+          }),
+          flag1: optionFlag({
+            long: "flag1",
+            aliases: {
+              longs: ["flag1-alias"],
+              shorts: ["fa"],
+            },
+          }),
+          flag2: optionFlag({
+            long: "flag2",
+            aliases: {
+              longs: ["flag2-alias"],
+              shorts: ["fb"],
+            },
+          }),
+          weird: optionRepeatable({
+            long: "2",
+            aliases: {
+              shorts: ["2o"],
+            },
+            type: type(),
+          }),
+          v1: optionSingleValue({
+            long: "v1",
+            aliases: {
+              shorts: ["va"],
+            },
+            type: type(),
+            impliedValueIfNotInlined: () => "bypass",
+            fallbackValueIfAbsent: () => undefined,
+          }),
+          v2: optionSingleValue({
+            long: "v2",
+            aliases: {
+              shorts: ["vb"],
+            },
+            type: type(),
+            impliedValueIfNotInlined: () => "bypass",
+            fallbackValueIfAbsent: () => undefined,
+          }),
+        },
+        positionals: [],
+      },
+      async function (_context, inputs) {
+        return inputs;
+      },
+    ),
+  );
+  const readerArgs = new ReaderArgs([
+    "--option=1.1",
+    "--option-alias1=1.2",
+    "--option-alias2",
+    "1.3",
+    "-pts=1.4",
+    "-vbva=42",
+    "-o",
+    "1.5",
+    "--flag1-alias",
+    "--2=woops",
+    "-fb2o=1.6",
+  ]);
+  const decoder = cmd.consumeAndMakeDecoder(readerArgs);
+  const interpreter = decoder.decodeAndMakeInterpreter();
+  const output = await interpreter.executeWithContext({});
+  expect(output).toStrictEqual({
+    options: {
+      option: ["1.1", "1.2", "1.3", "1.4", "1.5"],
+      flag1: true,
+      flag2: true,
+      weird: ["woops", "1.6"],
+      v1: "42",
+      v2: "bypass",
+    },
+    positionals: [],
+  });
+});