cli-kiss 0.2.3 → 0.2.4

package/tests/unit.Reader.shortBig.ts

@@ -1,7 +1,7 @@
 import { expect, it } from "@jest/globals";
-import { ReaderArgs } from "../src";
+import { ReaderArgs, ReaderOptionParsing } from "../src";
 
-it("run", async () => {
+it("run", async function () {
   const stream = new ReaderArgs([
     "positional-0",
     "-aasof-normal",
@@ -12,47 +12,48 @@ it("run", async () => {
     "1.1",
     "-eesov-split",
     "1.2",
-    "-ffsov-join=2",
+    "-ffsov-join=2.1",
+    "-ggsov-join=2.2",
     "positional-2",
   ]);
 
   expect(stream.consumePositional()).toStrictEqual("positional-0");
 
+  const kSofUnset = stream.registerOption({
+    longs: [],
+    shorts: ["sof-unset"],
+    parsing: optionFlagParsing,
+  });
   const kSofNormal = stream.registerOption({
     shorts: ["sof-normal"],
     longs: [],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kSofPositive = stream.registerOption({
     longs: [],
     shorts: ["sof-positive"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kSofNegative = stream.registerOption({
     longs: [],
     shorts: ["sof-negative"],
-    valued: false,
-  });
-  const kSofUnset = stream.registerOption({
-    longs: [],
-    shorts: ["sof-unset"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
 
   const kAa = stream.registerOption({
     longs: [],
     shorts: ["aa"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kBb = stream.registerOption({
     longs: [],
     shorts: ["bb"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kCc = stream.registerOption({
     longs: [],
     shorts: ["cc"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-1");
@@ -60,51 +61,94 @@ it("run", async () => {
   const kSovSplit = stream.registerOption({
     longs: [],
     shorts: ["sov-split"],
-    valued: true,
+    parsing: optionValueFixedUniqueParsing,
   });
   const kSovJoin = stream.registerOption({
     longs: [],
     shorts: ["sov-join"],
-    valued: true,
+    parsing: optionValueFixedUniqueParsing,
   });
   const kSovUnset = stream.registerOption({
     longs: [],
     shorts: ["sov-unset"],
-    valued: true,
+    parsing: optionValueFixedUniqueParsing,
   });
 
   const kDd = stream.registerOption({
     longs: [],
     shorts: ["dd"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kEe = stream.registerOption({
     longs: [],
     shorts: ["ee"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kFf = stream.registerOption({
     longs: [],
     shorts: ["ff"],
-    valued: false,
+    parsing: optionFlagParsing,
+  });
+  const kGg = stream.registerOption({
+    longs: [],
+    shorts: ["gg"],
+    parsing: optionFlagParsing,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-2");
 
-  expect(stream.getOptionValues(kSofNormal)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kSofPositive)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kSofNegative)).toStrictEqual(["false"]);
   expect(stream.getOptionValues(kSofUnset)).toStrictEqual([]);
+  expect(stream.getOptionValues(kSofNormal)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
+  expect(stream.getOptionValues(kSofPositive)).toStrictEqual([
+    { inlined: "true", separated: [] },
+  ]);
+  expect(stream.getOptionValues(kSofNegative)).toStrictEqual([
+    { inlined: "false", separated: [] },
+  ]);
 
-  expect(stream.getOptionValues(kAa)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kBb)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kCc)).toStrictEqual(["true"]);
+  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(stream.getOptionValues(kSovUnset)).toStrictEqual([]);
-  expect(stream.getOptionValues(kSovSplit)).toStrictEqual(["1.1", "1.2"]);
-  expect(stream.getOptionValues(kSovJoin)).toStrictEqual(["2"]);
+  expect(stream.getOptionValues(kSovSplit)).toStrictEqual([
+    { inlined: null, separated: ["1.1"] },
+    { inlined: null, separated: ["1.2"] },
+  ]);
+  expect(stream.getOptionValues(kSovJoin)).toStrictEqual([
+    { inlined: "2.1", separated: [] },
+    { inlined: "2.2", separated: [] },
+  ]);
 
-  expect(stream.getOptionValues(kDd)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kEe)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kFf)).toStrictEqual(["true"]);
+  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: [] },
+  ]);
 });
+
+const optionFlagParsing: ReaderOptionParsing = {
+  consumeShortGroup: false,
+  consumeNextArg: () => false,
+};
+
+const optionValueFixedUniqueParsing: ReaderOptionParsing = {
+  consumeShortGroup: true,
+  consumeNextArg: (inlined, separated) =>
+    inlined === null && separated.length === 0,
+};

package/tests/unit.command.execute.ts

@@ -21,10 +21,21 @@ const rootCommand = commandChained(
   { description: "?" },
   operation(
     {
-      options: { flag: optionFlag({ short: "b", long: "boolean-flag" }) },
+      options: {
+        flagPositive: optionFlag({
+          short: "fp",
+          long: "flag-positive",
+          default: true,
+        }),
+        flagNegative: optionFlag({
+          short: "fn",
+          long: "flag-negative",
+          default: false,
+        }),
+      },
       positionals: [positionalRequired({ label: "POS-1", type: typeNumber })],
     },
-    async (context, inputs) => {
+    async function (context, inputs) {
       return { at: "root", context, inputs };
     },
   ),
@@ -45,7 +56,7 @@ const rootCommand = commandChained(
         },
         positionals: [positionalRequired({ type: typeNumber })],
       },
-      async (context, inputs) => {
+      async function (context, inputs) {
         return { at: "mid", context, inputs };
       },
     ),
@@ -57,7 +68,7 @@ const rootCommand = commandChained(
             options: {},
             positionals: [positionalRequired({ type: typeString })],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub1", context, inputs };
           },
         ),
@@ -73,7 +84,7 @@ const rootCommand = commandChained(
               positionalVariadics({ type: typeString }),
             ],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub2", context, inputs };
           },
         ),
@@ -82,13 +93,14 @@ const rootCommand = commandChained(
   ),
 );
 
-it("run", async () => {
-  const res1 = await executeInterpreted(
-    ["50", "51", "sub1", "final"],
-    "Run Context Input",
-    rootCommand,
-  );
-  expect(res1).toStrictEqual({
+it("run", async function () {
+  expect(
+    await executeInterpreted(
+      ["-fn=true", "-fp", "50", "51", "sub1", "final"],
+      "Run Context Input",
+      rootCommand,
+    ),
+  ).toStrictEqual({
     at: "sub1",
     context: {
       at: "mid",
@@ -96,7 +108,7 @@ it("run", async () => {
         at: "root",
         context: "Run Context Input",
         inputs: {
-          options: { flag: false },
+          options: { flagPositive: true, flagNegative: true },
           positionals: [50],
         },
       },
@@ -111,25 +123,56 @@ it("run", async () => {
     },
   });
 
-  const res2 = await executeInterpreted(
-    [
-      "40",
-      "41",
-      "sub2",
-      "--string-option=hello",
-      "--number-option",
-      "123.1,123.2",
-      "--number-option",
-      "123.3",
-      "88.88",
-      "a,b",
-      "final",
-      "--boolean-flag",
-    ],
-    "Run Context Input",
-    rootCommand,
-  );
-  expect(res2).toStrictEqual({
+  expect(
+    await executeInterpreted(
+      ["50", "51", "sub2", "9999.99"],
+      "Run Context Input",
+      rootCommand,
+    ),
+  ).toStrictEqual({
+    at: "sub2",
+    context: {
+      at: "mid",
+      context: {
+        at: "root",
+        context: "Run Context Input",
+        inputs: {
+          options: { flagPositive: true, flagNegative: false },
+          positionals: [50],
+        },
+      },
+      inputs: {
+        options: { string: undefined, number: [] },
+        positionals: [51],
+      },
+    },
+    inputs: {
+      options: {},
+      positionals: [9999.99, "42", []],
+    },
+  });
+
+  expect(
+    await executeInterpreted(
+      [
+        "40",
+        "41",
+        "sub2",
+        "--string-option=hello",
+        "--number-option",
+        "123.1,123.2",
+        "--number-option",
+        "123.3",
+        "88.88",
+        "a,b",
+        "final",
+        "--no-flag-positive",
+        "--no-flag-negative",
+      ],
+      "Run Context Input",
+      rootCommand,
+    ),
+  ).toStrictEqual({
     at: "sub2",
     context: {
       at: "mid",
@@ -137,7 +180,7 @@ it("run", async () => {
         at: "root",
         context: "Run Context Input",
         inputs: {
-          options: { flag: true },
+          options: { flagPositive: false, flagNegative: false },
           positionals: [40],
         },
       },

package/tests/unit.command.usage.ts

@@ -48,7 +48,7 @@ const rootCommand = commandChained<any, any, any>(
         }),
       ],
     },
-    async (context, inputs) => {
+    async function (context, inputs) {
       return { at: "root", context, inputs };
     },
   ),
@@ -92,7 +92,7 @@ const rootCommand = commandChained<any, any, any>(
           }),
         ],
       },
-      async (context, inputs) => {
+      async function (context, inputs) {
         return { at: "root", context, inputs };
       },
     ),
@@ -128,7 +128,7 @@ const rootCommand = commandChained<any, any, any>(
               }),
             ],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub1", context, inputs };
           },
         ),
@@ -185,7 +185,7 @@ const rootCommand = commandChained<any, any, any>(
               }),
             ],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub2", context, inputs };
           },
         ),
@@ -194,7 +194,7 @@ const rootCommand = commandChained<any, any, any>(
   ),
 );
 
-it("run", async () => {
+it("run", async function () {
   const usage1 = await getUsage([], rootCommand);
   const usage2 = await getUsage(["50"], rootCommand);
   const usage3 = await getUsage(["50", "51"], rootCommand);
@@ -209,16 +209,6 @@ it("run", async () => {
     rootCommand,
   );
 
-  console.log(usage1.join("\n"));
-  console.log(usage2.join("\n"));
-  console.log(usage3.join("\n"));
-  console.log(usage4.join("\n"));
-  console.log(usage5.join("\n"));
-  console.log(usage6.join("\n"));
-  console.log(usage7.join("\n"));
-  /*
-   */
-
   const usageRoot = [
     "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{[REST]...}@darkBlue}+",
     "",
@@ -233,8 +223,8 @@ it("run", async () => {
     "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*  boolean-flag description",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of the root command}-}*",
-    "  {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+",
+    " {{# Example usage of the root command}-}*",
+    " {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+",
     "",
   ];
   const usageMid = [
@@ -253,13 +243,13 @@ it("run", async () => {
     "  {{sub2}@darkCyan}+  Subcommand 2 description {{(Subcommand 2 hint)}-}*",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  complex-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of the mid command}-}*",
-    "  {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+ {{43}@darkBlue}+",
+    " {{# Example usage of the mid command}-}*",
+    " {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+ {{43}@darkBlue}+",
     "",
   ];
   const usageSub1 = [
@@ -275,13 +265,13 @@ it("run", async () => {
     "  {{<POS-STRING>}@darkBlue}+  Required positional string",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  complex-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of subcommand 1}-}*",
-    "  {{my-cli}@darkCyan}+ {{-b}@darkCyan}+ {{42}@darkBlue}+ {{43}@darkBlue}+ {{sub1}@darkCyan}+ {{valid}@darkBlue}+",
+    " {{# Example usage of subcommand 1}-}*",
+    " {{my-cli}@darkCyan}+ {{-b}@darkCyan}+ {{42}@darkBlue}+ {{43}@darkBlue}+ {{sub1}@darkCyan}+ {{valid}@darkBlue}+",
     "",
   ];
   const usageSub2 = [
@@ -299,17 +289,27 @@ it("run", async () => {
     "  {{[VARIADIC]...}@darkBlue}+  Variadic positionals strings",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  complex-option description",
-    "      {{--dudu}@darkCyan}+ {{<STRING>}@darkBlue}+                               Dudu option description {{(Dudu option hint)}-}*",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
+    "      {{--dudu}@darkCyan}+ {{<STRING>}@darkBlue}+                                   Dudu option description {{(Dudu option hint)}-}*",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of subcommand 2}-}*",
-    "  {{my-cli}@darkCyan}+ {{40}@darkBlue}+ {{41}@darkBlue}+ {{sub2}@darkCyan}+ {{--dudu}@darkCyan}+{{=}-}*{{hello}@darkBlue}+ {{50}@darkBlue}+",
+    " {{# Example usage of subcommand 2}-}*",
+    " {{my-cli}@darkCyan}+ {{40}@darkBlue}+ {{41}@darkBlue}+ {{sub2}@darkCyan}+ {{--dudu}@darkCyan}+{{=}-}*{{hello}@darkBlue}+ {{50}@darkBlue}+",
     "",
   ];
 
+  /*
+  console.log(usage1.join("\n"));
+  console.log(usage2.join("\n"));
+  console.log(usage3.join("\n"));
+  console.log(usage4.join("\n"));
+  console.log(usage5.join("\n"));
+  console.log(usage6.join("\n"));
+  console.log(usage7.join("\n"));
+   */
+
   expect(usage1).toStrictEqual(usageRoot);
   expect(usage2).toStrictEqual(usageMid);
   expect(usage3).toStrictEqual(usageMid);
@@ -338,7 +338,7 @@ async function getUsage<Context, Result>(
     */
   return usageToStyledLines({
     cliName: "my-cli",
-    commandUsage: commandDecoder.generateUsage(),
-    typoSupport: TypoSupport.tty(),
+    usage: commandDecoder.generateUsage(),
+    typoSupport: TypoSupport.mock(),
   });
 }

package/tests/unit.runner.cycle.ts

@@ -16,7 +16,7 @@ import {
   typeUrl,
 } from "../src";
 
-it("run", async () => {
+it("run", async function () {
   const rootUsage = [
     "Usage: my-cli <REQUIRED1> <SUBCOMMAND>",
     "",
@@ -30,7 +30,7 @@ it("run", async () => {
     "",
     "Options:",
     "  --flag[=no]                   Option flag description",
-    "  --repeatable <STRING>         Option repeatable description",
+    "  --repeatable <STRING> [*]     Option repeatable description",
     "  --single-value <NUMBER-ENUM>  Option single value description",
     "",
   ].join("\n");
@@ -47,9 +47,9 @@ it("run", async () => {
     "",
     "Options:",
     "  --flag[=no]                   Option flag description",
-    "  --repeatable <STRING>         Option repeatable description",
+    "  --repeatable <STRING> [*]     Option repeatable description",
     "  --single-value <NUMBER-ENUM>  Option single value description",
-    "  --url <URL>                   Option url description",
+    "  --url <URL> [*]               Option url description",
     "",
   ].join("\n");
 
@@ -101,7 +101,7 @@ it("run", async () => {
   await testCase(
     ["--invalid1", "--invalid2", "required1", "--invalid3"],
     [],
-    [rootUsage, "Error: --invalid1: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --invalid1"],
     1,
   );
   await testCase(
@@ -135,13 +135,13 @@ it("run", async () => {
   await testCase(
     ["--url", "https://example.com"],
     [],
-    [rootUsage, "Error: --url: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --url"],
     1,
   );
   await testCase(
     ["required1", "--url", "https://example.com"],
     [],
-    [rootUsage, "Error: --url: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --url"],
     1,
   );
   await testCase(
@@ -187,13 +187,13 @@ it("run", async () => {
   await testCase(
     ["--invalid", "required1", "subcommand", "required2"],
     [],
-    [rootUsage, "Error: --invalid: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --invalid"],
     1,
   );
   await testCase(
     ["required1", "subcommand", "required2", "--nope"],
     [],
-    [subcommandUsage, "Error: --nope: Unexpected unknown option"],
+    [subcommandUsage, "Error: Unexpected unknown option: --nope"],
     1,
   );
   await testCase(
@@ -283,7 +283,7 @@ it("run", async () => {
   await testCase(
     ["--url", "not-a-url", "required1", "subcommand", "required2"],
     [],
-    [rootUsage, "Error: --url: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --url"],
     1,
   );
   await testCase(
@@ -372,7 +372,7 @@ async function testCase(
           }),
         ],
       },
-      async () => {
+      async function () {
         console.log("Has executed root command");
       },
     ),
@@ -407,7 +407,7 @@ async function testCase(
               }),
             ],
           },
-          async () => {
+          async function () {
             console.log("Has executed subcommand");
           },
         ),
@@ -435,7 +435,7 @@ function makeMocked<P, R>(returns: Array<R>) {
   const history = new Array<P>();
   return {
     history,
-    call: (p: P) => {
+    call(p: P) {
       history.push(p);
       if (history.length > returns.length) {
         throw new Error(

package/tests/unit.runner.errors.ts

@@ -10,15 +10,31 @@ import {
   typeUrl,
 } from "../src";
 
-it("run", async () => {
+it("run", async function () {
   await testCase(
     ["hello"],
     '{{Error:}@darkRed}+ Unexpected argument: {{"hello"}@darkYellow}+',
   );
+  await testCase(
+    ["--nope"],
+    "{{Error:}@darkRed}+ Unexpected unknown option: {{--nope}@darkYellow}+",
+  );
   await testCase(
     ["--flag", "--flag"],
     "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set multiple times",
   );
+  await testCase(
+    ["--flag", "--no-flag"],
+    "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set in combination with: {{--no-flag}@darkCyan}+",
+  );
+  await testCase(
+    ["--no-flag", "--no-flag"],
+    "{{Error:}@darkRed}+ {{--no-flag}@darkCyan}+: Must not be set multiple times",
+  );
+  await testCase(
+    ["--single-value=a", "--single-value=b"],
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a single value, but got multiple",
+  );
   await testCase(
     ["--flag=invalid"],
     '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{<BOOLEAN>}@darkBlue}+: {{Boolean}@darkMagenta}+: Invalid value: {{"invalid"}@darkYellow}+',
@@ -59,7 +75,7 @@ async function testCase(args: Array<string>, error: string) {
         },
         positionals: [],
       },
-      async () => {},
+      async function () {},
     ),
   );
   console.log = onLogStdOut.call;
@@ -79,7 +95,7 @@ function makeMocked<P, R>(returns: Array<R>) {
   const history = new Array<P>();
   return {
     history,
-    call: (p: P) => {
+    call(p: P) {
       history.push(p);
       if (history.length > returns.length) {
         throw new Error(