@flowscripter/dynamic-cli-framework 1.2.1 → 1.3.0

package/tests/runtime/values/subCommandValuePopulation.test.ts

@@ -22,61 +22,38 @@ describe("subCommandValuePopulation tests", () => {
   test("Option argument", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "f",
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "f",
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo", "bar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo", "bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo=bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo=bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["-f", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f", "bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["-f=bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f=bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "goo=1 and goo=2"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo", "goo=1 and goo=2"], undefined);
     expectExtractResult(result, { foo: "goo=1 and goo=2" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo=goo=1 and goo=2"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo=goo=1 and goo=2"], undefined);
     expectExtractResult(result, { foo: "goo=1 and goo=2" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -84,101 +61,86 @@ describe("subCommandValuePopulation tests", () => {
   test("Option types", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.NUMBER,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.NUMBER,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo", "1.1"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo", "1.1"], undefined);
     expectExtractResult(result, { foo: "1.1" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.INTEGER,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.INTEGER,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["-f", "1"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f", "1"], undefined);
     expectExtractResult(result, { foo: "1" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.SECRET,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.SECRET,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["-f", "xxx"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f", "xxx"], undefined);
     expectExtractResult(result, { foo: "xxx" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["-f", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f", "bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["-f"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f"], undefined);
     expectExtractResult(result, { foo: "true" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -186,54 +148,35 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "f",
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "f",
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo", "bar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo", "bar"], undefined);
     expectExtractResult(result, { foo: ["bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "bar", "--foo", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo", "bar", "--foo", "bar"], undefined);
     expectExtractResult(result, { foo: ["bar", "bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo=bar", "--foo", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo=bar", "--foo", "bar"], undefined);
     expectExtractResult(result, { foo: ["bar", "bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo=bar", "-f", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo=bar", "-f", "bar"], undefined);
     expectExtractResult(result, { foo: ["bar", "bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo=bar", "-f=bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo=bar", "-f=bar"], undefined);
     expectExtractResult(result, { foo: ["bar", "bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -241,58 +184,53 @@ describe("subCommandValuePopulation tests", () => {
   test("Option argument configured value is overridden by arg", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo", "bar"],
-      { foo: "nope" },
-    );
+    let result = populateSubCommandValues(command, ["--foo", "bar"], {
+      foo: "nope",
+    });
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "1"],
-      { foo: 2 },
-    );
+    result = populateSubCommandValues(command, ["--foo", "1"], { foo: 2 });
     expectExtractResult(result, { foo: "1" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "true"],
-      { foo: false },
-    );
+    result = populateSubCommandValues(command, ["--foo", "true"], {
+      foo: false,
+    });
     expectExtractResult(result, { foo: "true" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -300,61 +238,52 @@ describe("subCommandValuePopulation tests", () => {
   test("Option argument default value is overridden by configured value", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        defaultValue: "nope",
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          defaultValue: "nope",
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      [],
-      { foo: "bar" },
-    );
+    let result = populateSubCommandValues(command, [], { foo: "bar" });
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-        defaultValue: 2,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+          defaultValue: 2,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: 1 },
-    );
+    result = populateSubCommandValues(command, [], { foo: 1 });
     expectExtractResult(result, { foo: 1 }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        defaultValue: false,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          defaultValue: false,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: true },
-    );
+    result = populateSubCommandValues(command, [], { foo: true });
     expectExtractResult(result, { foo: true }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -362,61 +291,52 @@ describe("subCommandValuePopulation tests", () => {
   test("Option argument default value is overridden by arg", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        defaultValue: "nope",
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          defaultValue: "nope",
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo", "bar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo", "bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-        defaultValue: 2,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+          defaultValue: 2,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "1"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo", "1"], undefined);
     expectExtractResult(result, { foo: "1" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        defaultValue: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          defaultValue: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "false"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo", "false"], undefined);
     expectExtractResult(result, { foo: "false" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -424,58 +344,49 @@ describe("subCommandValuePopulation tests", () => {
   test("Option argument configured value is used if no arg provided", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      [],
-      { foo: "bar" },
-    );
+    let result = populateSubCommandValues(command, [], { foo: "bar" });
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: 1 },
-    );
+    result = populateSubCommandValues(command, [], { foo: 1 });
     expectExtractResult(result, { foo: 1 }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: false },
-    );
+    result = populateSubCommandValues(command, [], { foo: false });
     expectExtractResult(result, { foo: false }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -483,75 +394,64 @@ describe("subCommandValuePopulation tests", () => {
   test("Two options", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isArray: false,
-      }, {
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isArray: false,
+        },
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo", "bar", "--goo=gar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo", "bar", "--goo=gar"], undefined);
     expectExtractResult(result, { foo: "bar", goo: "gar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        isArray: false,
-      }, {
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          isArray: false,
+        },
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "--goo=gar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo", "--goo=gar"], undefined);
     expectExtractResult(result, { foo: "true", goo: "gar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        isArray: true,
-      }, {
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          isArray: true,
+        },
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      [
-        "--foo",
-        "--foo",
-        "false",
-        "--goo=gar",
-      ],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo", "--foo", "false", "--goo=gar"], undefined);
     expectExtractResult(result, { foo: ["true", "false"], goo: "gar" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -559,74 +459,64 @@ describe("subCommandValuePopulation tests", () => {
   test("Interleaved option arrays", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isArray: true,
-      }, {
-        name: "goo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        isArray: true,
-        shortAlias: "g",
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isArray: true,
+        },
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          isArray: true,
+          shortAlias: "g",
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "--foo",
-        "bar1",
-        "--goo=true",
-        "--foo",
-        "bar2",
-        "--goo=false",
-      ],
+      ["--foo", "bar1", "--goo=true", "--foo", "bar2", "--goo=false"],
       undefined,
     );
     expectExtractResult(
       result,
-      { foo: ["bar1", "bar2"], goo: ["true", "false"] },
+      {
+        foo: ["bar1", "bar2"],
+        goo: ["true", "false"],
+      },
       [],
     );
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
       command,
-      [
-        "--foo",
-        "bar1",
-        "--goo=true",
-        "--goo=false",
-        "--foo",
-        "bar2",
-      ],
+      ["--foo", "bar1", "--goo=true", "--goo=false", "--foo", "bar2"],
       undefined,
     );
     expectExtractResult(
       result,
-      { foo: ["bar1", "bar2"], goo: ["true", "false"] },
+      {
+        foo: ["bar1", "bar2"],
+        goo: ["true", "false"],
+      },
       [],
     );
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
       command,
-      [
-        "--foo",
-        "bar1",
-        "-g",
-        "--foo",
-        "bar2",
-        "-g=false",
-      ],
+      ["--foo", "bar1", "-g", "--foo", "bar2", "-g=false"],
       undefined,
     );
     expectExtractResult(
       result,
-      { foo: ["bar1", "bar2"], goo: ["true", "false"] },
+      {
+        foo: ["bar1", "bar2"],
+        goo: ["true", "false"],
+      },
       [],
     );
     expect(result.invalidArgument).toBeUndefined();
@@ -635,28 +525,21 @@ describe("subCommandValuePopulation tests", () => {
   test("Unknown option name", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--goo=moo"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--goo=moo"], undefined);
     expectExtractResult(result, {}, ["--goo=moo"]);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--goo", "moo"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--goo", "moo"], undefined);
     expectExtractResult(result, {}, ["--goo", "moo"]);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -664,48 +547,33 @@ describe("subCommandValuePopulation tests", () => {
   test("Illegal option syntax", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["-foo=moo"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["-foo=moo"], undefined);
     expectExtractResult(result, {}, ["-foo=moo"]);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--f", "moo"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--f", "moo"], undefined);
     expectExtractResult(result, {}, ["--f", "moo"]);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo=", "moo"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo=", "moo"], undefined);
     expectExtractResult(result, {}, ["moo"]);
     expect(result.invalidArgument).toEqual({
       name: "foo",
       reason: InvalidArgumentReason.MISSING_VALUE,
     });
 
-    result = populateSubCommandValues(
-      command,
-      ["-f=", "moo"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f=", "moo"], undefined);
     expectExtractResult(result, {}, ["moo"]);
     expect(result.invalidArgument).toEqual({
       name: "f",
@@ -717,41 +585,36 @@ describe("subCommandValuePopulation tests", () => {
     let command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["bar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "bar",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "bar",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["foo", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["foo", "bar"], undefined);
     expectExtractResult(result, { foo: "foo", bar: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -760,55 +623,46 @@ describe("subCommandValuePopulation tests", () => {
     let command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["1"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["1"], undefined);
     expectExtractResult(result, { foo: "1" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
-    result = populateSubCommandValues(
-      command,
-      ["bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
-    result = populateSubCommandValues(
-      command,
-      ["true"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["true"], undefined);
     expectExtractResult(result, { foo: "true" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -817,22 +671,20 @@ describe("subCommandValuePopulation tests", () => {
     const command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    const result = populateSubCommandValues(
-      command,
-      ["f1", "f2"],
-      undefined,
-    );
+    const result = populateSubCommandValues(command, ["f1", "f2"], undefined);
     expectExtractResult(result, { foo1: "f1", foo2: "f2" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -841,29 +693,22 @@ describe("subCommandValuePopulation tests", () => {
     const command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-        isVarargOptional: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+          isVarargOptional: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["bar", "bar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["bar", "bar"], undefined);
     expectExtractResult(result, { foo: ["bar", "bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["bar"], undefined);
     expectExtractResult(result, { foo: ["bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
@@ -876,48 +721,34 @@ describe("subCommandValuePopulation tests", () => {
     const command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "bar",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-        isVarargOptional: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "bar",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+          isVarargOptional: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["foo"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["foo"], undefined);
     expectExtractResult(result, { foo: "foo" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["foo", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["foo", "bar"], undefined);
     expectExtractResult(result, { foo: "foo", bar: ["bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["foo", "bar", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["foo", "bar", "bar"], undefined);
     expectExtractResult(result, { foo: "foo", bar: ["bar", "bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["foo"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["foo"], undefined);
     expectExtractResult(result, { foo: "foo" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -925,294 +756,269 @@ describe("subCommandValuePopulation tests", () => {
   test("String options either side of positionals", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "goo1",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "1",
-      }, {
-        name: "goo2",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "2",
-      }],
-      positionals: [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "goo1",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "1",
+        },
+        {
+          name: "goo2",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "2",
+        },
+      ],
+      positionals: [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "--goo1=g1",
-        "f1",
-        "f2",
-        "--goo2=g2",
-      ],
+      ["--goo1=g1", "f1", "f2", "--goo2=g2"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "g1",
-      goo2: "g2",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "g1",
+        goo2: "g2",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
       command,
-      [
-        "--goo1",
-        "g1",
-        "f1",
-        "f2",
-        "--goo2",
-        "g2",
-      ],
+      ["--goo1", "g1", "f1", "f2", "--goo2", "g2"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "g1",
-      goo2: "g2",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "g1",
+        goo2: "g2",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      [
-        "-1",
-        "g1",
-        "f1",
-        "f2",
-        "-2",
-        "g2",
-      ],
-      undefined,
+    result = populateSubCommandValues(command, ["-1", "g1", "f1", "f2", "-2", "g2"], undefined);
+    expectExtractResult(
+      result,
+      {
+        goo1: "g1",
+        goo2: "g2",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
     );
-    expectExtractResult(result, {
-      goo1: "g1",
-      goo2: "g2",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Boolean options either side of positionals", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "goo1",
-        shortAlias: "1",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }, {
-        name: "goo2",
-        shortAlias: "2",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
-      positionals: [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "goo1",
+          shortAlias: "1",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+        {
+          name: "goo2",
+          shortAlias: "2",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
+      positionals: [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      [
-        "--goo1",
-        "f1",
-        "f2",
-        "--goo2",
-      ],
-      undefined,
+    let result = populateSubCommandValues(command, ["--goo1", "f1", "f2", "--goo2"], undefined);
+    expectExtractResult(
+      result,
+      {
+        goo1: "true",
+        goo2: "true",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
     );
-    expectExtractResult(result, {
-      goo1: "true",
-      goo2: "true",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
       command,
-      [
-        "--goo1",
-        "true",
-        "f1",
-        "f2",
-        "--goo2",
-        "false",
-      ],
+      ["--goo1", "true", "f1", "f2", "--goo2", "false"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "true",
-      goo2: "false",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "true",
+        goo2: "false",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
       command,
-      [
-        "-1",
-        "true",
-        "f1",
-        "f2",
-        "-2",
-        "false",
-      ],
+      ["-1", "true", "f1", "f2", "-2", "false"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "true",
-      goo2: "false",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "true",
+        goo2: "false",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Option array either side of positional", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        isArray: true,
-        type: ArgumentValueTypeName.STRING,
-      }],
-      positionals: [{
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo",
+          isArray: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      positionals: [
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "--foo",
-        "f1",
-        "goo1",
-        "--foo",
-        "f2",
-      ],
+      ["--foo", "f1", "goo1", "--foo", "f2"],
       undefined,
     );
-    expectExtractResult(result, {
-      foo: ["f1", "f2"],
-      goo: "goo1",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        foo: ["f1", "f2"],
+        goo: "goo1",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        isArray: true,
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
-      positionals: [{
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo",
+          isArray: true,
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
+      positionals: [
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
     result = populateSubCommandValues(
       command,
-      [
-        "--foo",
-        "true",
-        "goo1",
-        "--foo",
-        "false",
-      ],
+      ["--foo", "true", "goo1", "--foo", "false"],
       undefined,
     );
-    expectExtractResult(result, {
-      foo: ["true", "false"],
-      goo: "goo1",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        foo: ["true", "false"],
+        goo: "goo1",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "goo1", "--foo"],
-      undefined,
+    result = populateSubCommandValues(command, ["--foo", "goo1", "--foo"], undefined);
+    expectExtractResult(
+      result,
+      {
+        foo: ["true", "true"],
+        goo: "goo1",
+      },
+      [],
     );
-    expectExtractResult(result, {
-      foo: ["true", "true"],
-      goo: "goo1",
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Unused option after used option", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      [
-        "--foo",
-        "bar",
-        "--goo",
-        "gar",
-      ],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo", "bar", "--goo", "gar"], undefined);
     expectExtractResult(result, { foo: "bar" }, ["--goo", "gar"]);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo=bar", "--goo=gar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo=bar", "--goo=gar"], undefined);
     expectExtractResult(result, { foo: "bar" }, ["--goo=gar"]);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["-f", "--goo", "gar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["-f", "--goo", "gar"], undefined);
     expectExtractResult(result, { foo: "true" }, ["--goo", "gar"]);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1220,54 +1026,39 @@ describe("subCommandValuePopulation tests", () => {
   test("Unused option before used option", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      [
-        "--goo",
-        "gar",
-        "--foo",
-        "bar",
-      ],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--goo", "gar", "--foo", "bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, ["--goo", "gar"]);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--goo=gar", "--foo=bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--goo=gar", "--foo=bar"], undefined);
     expectExtractResult(result, { foo: "bar" }, ["--goo=gar"]);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        shortAlias: "f",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
+      options: [
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["--goo", "gar", "-f"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--goo", "gar", "-f"], undefined);
     expectExtractResult(result, { foo: "true" }, ["--goo", "gar"]);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1275,51 +1066,48 @@ describe("subCommandValuePopulation tests", () => {
   test("Unused option after positional", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo1",
-        shortAlias: "1",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      positionals: [{
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo1",
+          shortAlias: "1",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      positionals: [
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     const result = populateSubCommandValues(
       command,
-      [
-        "--foo1",
-        "bar",
-        "foo2",
-        "--goo",
-        "gar",
-      ],
+      ["--foo1", "bar", "foo2", "--goo", "gar"],
       undefined,
     );
-    expectExtractResult(result, { foo1: "bar", foo2: "foo2" }, [
-      "--goo",
-      "gar",
-    ]);
+    expectExtractResult(result, { foo1: "bar", foo2: "foo2" }, ["--goo", "gar"]);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Unused option before positional", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo1",
-        shortAlias: "1",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      positionals: [{
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo1",
+          shortAlias: "1",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      positionals: [
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     const result = populateSubCommandValues(
@@ -1333,10 +1121,7 @@ describe("subCommandValuePopulation tests", () => {
       ],
       undefined,
     );
-    expectExtractResult(result, { foo1: "bar", foo2: "--goo" }, [
-      "gar",
-      "foo2",
-    ]);
+    expectExtractResult(result, { foo1: "bar", foo2: "--goo" }, ["gar", "foo2"]);
     expect(result.invalidArgument).toBeUndefined();
   });
 
@@ -1344,19 +1129,16 @@ describe("subCommandValuePopulation tests", () => {
     const command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    const result = populateSubCommandValues(
-      command,
-      ["bar", "goo"],
-      undefined,
-    );
+    const result = populateSubCommandValues(command, ["bar", "goo"], undefined);
     expectExtractResult(result, { foo: "bar" }, ["goo"]);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1364,39 +1146,33 @@ describe("subCommandValuePopulation tests", () => {
   test("Unused positional after optional", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo", "bar", "goo"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo", "bar", "goo"], undefined);
     expectExtractResult(result, { foo: "bar" }, ["goo"]);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "goo"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo", "goo"], undefined);
     expectExtractResult(result, { foo: "true" }, ["goo"]);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1404,281 +1180,283 @@ describe("subCommandValuePopulation tests", () => {
   test("Positionals either side of options", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "goo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "goo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      positionals: [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "goo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      positionals: [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "f1",
-        "--goo1",
-        "g1",
-        "--goo2",
-        "g2",
-        "f2",
-      ],
+      ["f1", "--goo1", "g1", "--goo2", "g2", "f2"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "g1",
-      goo2: "g2",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "g1",
+        goo2: "g2",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "goo1",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }, {
-        name: "goo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      positionals: [{
-        name: "foo1",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }, {
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "goo1",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+        {
+          name: "goo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      positionals: [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    result = populateSubCommandValues(
-      command,
-      [
-        "true",
-        "--goo1",
-        "--goo2",
-        "g2",
-        "f2",
-      ],
-      undefined,
+    result = populateSubCommandValues(command, ["true", "--goo1", "--goo2", "g2", "f2"], undefined);
+    expectExtractResult(
+      result,
+      {
+        goo1: "true",
+        goo2: "g2",
+        foo1: "true",
+        foo2: "f2",
+      },
+      [],
     );
-    expectExtractResult(result, {
-      goo1: "true",
-      goo2: "g2",
-      foo1: "true",
-      foo2: "f2",
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Positionals and non-boolean options interleaved", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "goo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "goo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      positionals: [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "goo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      positionals: [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "f1",
-        "--goo1",
-        "g1",
-        "f2",
-        "--goo2",
-        "g2",
-      ],
+      ["f1", "--goo1", "g1", "f2", "--goo2", "g2"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "g1",
-      goo2: "g2",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "g1",
+        goo2: "g2",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
       command,
-      [
-        "--goo1",
-        "g1",
-        "f1",
-        "--goo2",
-        "g2",
-        "f2",
-      ],
+      ["--goo1", "g1", "f1", "--goo2", "g2", "f2"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "g1",
-      goo2: "g2",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "g1",
+        goo2: "g2",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Positionals and boolean options interleaved", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "goo1",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }, {
-        name: "goo2",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
-      positionals: [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-      }, {
-        name: "foo2",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "goo1",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+        {
+          name: "goo2",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
+      positionals: [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "f1",
-        "--goo1",
-        "true",
-        "f2",
-        "--goo2",
-        "true",
-      ],
+      ["f1", "--goo1", "true", "f2", "--goo2", "true"],
       undefined,
     );
-    expectExtractResult(result, {
-      goo1: "true",
-      goo2: "true",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        goo1: "true",
+        goo2: "true",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["f1", "--goo1", "f2", "--goo2"],
-      undefined,
+    result = populateSubCommandValues(command, ["f1", "--goo1", "f2", "--goo2"], undefined);
+    expectExtractResult(
+      result,
+      {
+        goo1: "true",
+        goo2: "true",
+        foo1: "f1",
+        foo2: "f2",
+      },
+      [],
     );
-    expectExtractResult(result, {
-      goo1: "true",
-      goo2: "true",
-      foo1: "f1",
-      foo2: "f2",
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Array option before vararg positional", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isArray: true,
-      }],
-      positionals: [{
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isArray: true,
+        },
+      ],
+      positionals: [
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     const result = populateSubCommandValues(
       command,
-      [
-        "--foo",
-        "f1",
-        "--foo",
-        "f2",
-        "g1",
-        "g2",
-      ],
+      ["--foo", "f1", "--foo", "f2", "g1", "g2"],
       undefined,
     );
-    expectExtractResult(result, {
-      foo: ["f1", "f2"],
-      goo: ["g1", "g2"],
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        foo: ["f1", "f2"],
+        goo: ["g1", "g2"],
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Vararg positional before array option", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isArray: true,
-      }],
-      positionals: [{
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-        isVarargOptional: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isArray: true,
+        },
+      ],
+      positionals: [
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+          isVarargOptional: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "g1",
-        "g2",
-        "--foo",
-        "f1",
-        "--foo",
-        "f2",
-      ],
+      ["g1", "g2", "--foo", "f1", "--foo", "f2"],
       undefined,
     );
-    expectExtractResult(result, {
-      foo: ["f1", "f2"],
-      goo: ["g1", "g2"],
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        foo: ["f1", "f2"],
+        goo: ["g1", "g2"],
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo", "f1", "--foo", "f2"],
-      undefined,
+    result = populateSubCommandValues(command, ["--foo", "f1", "--foo", "f2"], undefined);
+    expectExtractResult(
+      result,
+      {
+        foo: ["f1", "f2"],
+      },
+      [],
     );
-    expectExtractResult(result, {
-      foo: ["f1", "f2"],
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
@@ -1686,55 +1464,46 @@ describe("subCommandValuePopulation tests", () => {
     let command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["1"],
-      { foo: 2 },
-    );
+    let result = populateSubCommandValues(command, ["1"], { foo: 2 });
     expectExtractResult(result, { foo: "1" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
-    result = populateSubCommandValues(
-      command,
-      ["bar"],
-      { foo: "nope" },
-    );
+    result = populateSubCommandValues(command, ["bar"], { foo: "nope" });
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
-      execute: async (): Promise<void> => {
-      },
-    };
-    result = populateSubCommandValues(
-      command,
-      ["true"],
-      { foo: false },
-    );
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
+      execute: async (): Promise<void> => {},
+    };
+    result = populateSubCommandValues(command, ["true"], { foo: false });
     expectExtractResult(result, { foo: "true" }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1743,58 +1512,49 @@ describe("subCommandValuePopulation tests", () => {
     let command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-        isVarargOptional: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+          isVarargOptional: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      [],
-      { foo: 1 },
-    );
+    let result = populateSubCommandValues(command, [], { foo: 1 });
     expectExtractResult(result, { foo: 1 }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargOptional: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargOptional: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: "bar" },
-    );
+    result = populateSubCommandValues(command, [], { foo: "bar" });
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        isVarargOptional: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          isVarargOptional: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: true },
-    );
+    result = populateSubCommandValues(command, [], { foo: true });
     expectExtractResult(result, { foo: true }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1803,61 +1563,52 @@ describe("subCommandValuePopulation tests", () => {
     let command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-        isVarargOptional: false,
-        isVarargMultiple: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+          isVarargOptional: false,
+          isVarargMultiple: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      [],
-      { foo: 1 },
-    );
+    let result = populateSubCommandValues(command, [], { foo: 1 });
     expectExtractResult(result, { foo: 1 }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargOptional: false,
-        isVarargMultiple: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargOptional: false,
+          isVarargMultiple: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: "bar" },
-    );
+    result = populateSubCommandValues(command, [], { foo: "bar" });
     expectExtractResult(result, { foo: "bar" }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        isVarargOptional: false,
-        isVarargMultiple: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          isVarargOptional: false,
+          isVarargMultiple: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
-    result = populateSubCommandValues(
-      command,
-      [],
-      { foo: true },
-    );
+    result = populateSubCommandValues(command, [], { foo: true });
     expectExtractResult(result, { foo: true }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1865,21 +1616,20 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array configured single values completely overridden by multiple args", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    const result = populateSubCommandValues(
-      command,
-      ["--foo", "bar1", "--foo", "bar2"],
-      { foo: ["bar"] },
-    );
+    const result = populateSubCommandValues(command, ["--foo", "bar1", "--foo", "bar2"], {
+      foo: ["bar"],
+    });
     expectExtractResult(result, { foo: ["bar1", "bar2"] }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1887,21 +1637,20 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array configured multiple values partially overridden by arg", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    const result = populateSubCommandValues(
-      command,
-      ["--foo", "bar"],
-      { foo: ["bar1", "bar2"] },
-    );
+    const result = populateSubCommandValues(command, ["--foo", "bar"], {
+      foo: ["bar1", "bar2"],
+    });
     expectExtractResult(result, { foo: ["bar", "bar2"] }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1910,13 +1659,14 @@ describe("subCommandValuePopulation tests", () => {
     const command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     const result = populateSubCommandValues(command, ["bar", "bar"], {
@@ -1930,13 +1680,14 @@ describe("subCommandValuePopulation tests", () => {
     const command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     const result = populateSubCommandValues(command, ["bar"], {
@@ -1949,46 +1700,31 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array using indices", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "f",
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "f",
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo[0]", "bar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo[0]", "bar"], undefined);
     expectExtractResult(result, { foo: ["bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[1]", "bar1", "--foo[0]", "bar0"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo[1]", "bar1", "--foo[0]", "bar0"], undefined);
     expectExtractResult(result, { foo: ["bar0", "bar1"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[0]=bar0", "--foo[1]", "bar1"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo[0]=bar0", "--foo[1]", "bar1"], undefined);
     expectExtractResult(result, { foo: ["bar0", "bar1"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[1]=bar1", "-f[0]", "bar0"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo[1]=bar1", "-f[0]", "bar0"], undefined);
     expectExtractResult(result, { foo: ["bar0", "bar1"] }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -1996,22 +1732,19 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array invalid indices", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "f",
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "f",
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo[1]", "bar"],
-      undefined,
-    );
+    let result = populateSubCommandValues(command, ["--foo[1]", "bar"], undefined);
     let expected = {
       foo: [] as Array<string>,
     };
@@ -2019,11 +1752,7 @@ describe("subCommandValuePopulation tests", () => {
     expectExtractResult(result, expected, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[2]", "bar2", "--foo[0]", "bar0"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo[2]", "bar2", "--foo[0]", "bar0"], undefined);
     expected = {
       foo: [] as Array<string>,
     };
@@ -2036,30 +1765,27 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array missing indices populated by configured defaults", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "f",
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "f",
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--foo[1]", "bar"],
-      { foo: ["car"] },
-    );
+    let result = populateSubCommandValues(command, ["--foo[1]", "bar"], {
+      foo: ["car"],
+    });
     expectExtractResult(result, { foo: ["car", "bar"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[2]", "bar1", "--foo[0]", "bar0"],
-      { foo: ["bar", "car"] },
-    );
+    result = populateSubCommandValues(command, ["--foo[2]", "bar1", "--foo[0]", "bar0"], {
+      foo: ["bar", "car"],
+    });
     expectExtractResult(result, { foo: ["bar0", "car", "bar1"] }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
@@ -2067,104 +1793,112 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array using indices either side of positional", () => {
     let command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        isArray: true,
-        type: ArgumentValueTypeName.STRING,
-      }],
-      positionals: [{
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo",
+          isArray: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      positionals: [
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
       command,
-      [
-        "--foo[0]",
-        "f1",
-        "goo1",
-        "--foo[1]",
-        "f2",
-      ],
+      ["--foo[0]", "f1", "goo1", "--foo[1]", "f2"],
       undefined,
     );
-    expectExtractResult(result, {
-      foo: ["f1", "f2"],
-      goo: "goo1",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        foo: ["f1", "f2"],
+        goo: "goo1",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
     command = {
       name: "command",
-      options: [{
-        name: "foo",
-        isArray: true,
-        type: ArgumentValueTypeName.BOOLEAN,
-      }],
-      positionals: [{
-        name: "goo",
-        type: ArgumentValueTypeName.STRING,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      options: [
+        {
+          name: "foo",
+          isArray: true,
+          type: ArgumentValueTypeName.BOOLEAN,
+        },
+      ],
+      positionals: [
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
     result = populateSubCommandValues(
       command,
-      [
-        "--foo[1]",
-        "true",
-        "goo1",
-        "--foo[0]",
-        "false",
-      ],
+      ["--foo[1]", "true", "goo1", "--foo[0]", "false"],
       undefined,
     );
-    expectExtractResult(result, {
-      foo: ["false", "true"],
-      goo: "goo1",
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        foo: ["false", "true"],
+        goo: "goo1",
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[1]", "goo1", "--foo[0]"],
-      undefined,
+    result = populateSubCommandValues(command, ["--foo[1]", "goo1", "--foo[0]"], undefined);
+    expectExtractResult(
+      result,
+      {
+        foo: ["true", "true"],
+        goo: "goo1",
+      },
+      [],
     );
-    expectExtractResult(result, {
-      foo: ["true", "true"],
-      goo: "goo1",
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Option complex values", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        shortAlias: "a",
-        properties: [{
-          name: "beta",
+      options: [
+        {
+          name: "alpha",
           type: ComplexValueTypeName.COMPLEX,
-          shortAlias: "b",
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "g",
-          }, {
-            name: "delta",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "d",
-          }],
-        }],
-      }],
+          shortAlias: "a",
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              shortAlias: "b",
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "g",
+                },
+                {
+                  name: "delta",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "d",
+                },
+              ],
+            },
+          ],
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
@@ -2172,49 +1906,59 @@ describe("subCommandValuePopulation tests", () => {
       ["--alpha.beta.gamma", "foo", "--alpha.beta.delta", "bar"],
       undefined,
     );
-    expectExtractResult(result, {
-      alpha: { beta: { gamma: "foo", delta: "bar" } },
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: { gamma: "foo", delta: "bar" } },
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["-a.b.g", "foo", "-a.b.d", "bar"],
-      undefined,
+    result = populateSubCommandValues(command, ["-a.b.g", "foo", "-a.b.d", "bar"], undefined);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: { gamma: "foo", delta: "bar" } },
+      },
+      [],
     );
-    expectExtractResult(result, {
-      alpha: { beta: { gamma: "foo", delta: "bar" } },
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Option arrays of complex values and vice versa", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        shortAlias: "a",
-        isArray: true,
-        properties: [{
-          name: "beta",
+      options: [
+        {
+          name: "alpha",
           type: ComplexValueTypeName.COMPLEX,
-          shortAlias: "b",
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "g",
-          }, {
-            name: "delta",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "d",
-            isArray: true,
-          }],
-        }],
-      }],
+          shortAlias: "a",
+          isArray: true,
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              shortAlias: "b",
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "g",
+                },
+                {
+                  name: "delta",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "d",
+                  isArray: true,
+                },
+              ],
+            },
+          ],
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
@@ -2222,19 +1966,23 @@ describe("subCommandValuePopulation tests", () => {
       ["--alpha.beta.gamma", "foo", "--alpha.beta.delta", "bar"],
       undefined,
     );
-    expectExtractResult(result, {
-      alpha: [{ beta: { gamma: "foo", delta: ["bar"] } }],
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        alpha: [{ beta: { gamma: "foo", delta: ["bar"] } }],
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["-a[0].b.d[0]", "bar"],
-      undefined,
+    result = populateSubCommandValues(command, ["-a[0].b.d[0]", "bar"], undefined);
+    expectExtractResult(
+      result,
+      {
+        alpha: [{ beta: { delta: ["bar"] } }],
+      },
+      [],
     );
-    expectExtractResult(result, {
-      alpha: [{ beta: { delta: ["bar"] } }],
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
@@ -2242,9 +1990,13 @@ describe("subCommandValuePopulation tests", () => {
       ["-a[0].b.g", "foo", "-a[0].b.d[0]", "bar"],
       undefined,
     );
-    expectExtractResult(result, {
-      alpha: [{ beta: { gamma: "foo", delta: ["bar"] } }],
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        alpha: [{ beta: { gamma: "foo", delta: ["bar"] } }],
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
 
     result = populateSubCommandValues(
@@ -2265,39 +2017,52 @@ describe("subCommandValuePopulation tests", () => {
       ],
       undefined,
     );
-    expectExtractResult(result, {
-      alpha: [{ beta: { gamma: "foo", delta: ["bar", "car"] } }, {
-        beta: { gamma: "foo", delta: ["car", "bar"] },
-      }],
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        alpha: [
+          { beta: { gamma: "foo", delta: ["bar", "car"] } },
+          {
+            beta: { gamma: "foo", delta: ["car", "bar"] },
+          },
+        ],
+      },
+      [],
+    );
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Option complex values with invalid properties", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        shortAlias: "a",
-        properties: [{
-          name: "beta",
+      options: [
+        {
+          name: "alpha",
           type: ComplexValueTypeName.COMPLEX,
-          shortAlias: "b",
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "g",
-          }, {
-            name: "delta",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "d",
-          }],
-        }],
-      }],
+          shortAlias: "a",
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              shortAlias: "b",
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "g",
+                },
+                {
+                  name: "delta",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "d",
+                },
+              ],
+            },
+          ],
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
@@ -2305,54 +2070,56 @@ describe("subCommandValuePopulation tests", () => {
       ["--alpha.beta.delta", "bar", "--alpha.beta.gamma"],
       undefined,
     );
-    expectExtractResult(result, {
-      alpha: { beta: { delta: "bar" } },
-    }, []);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: { delta: "bar" } },
+      },
+      [],
+    );
     expect(result.invalidArgument).toEqual({
-      argument:
-        ((command.options[0] as ComplexOption).properties[0] as ComplexOption)
-          .properties[0],
+      argument: ((command.options[0] as ComplexOption).properties[0] as ComplexOption)
+        .properties[0],
       name: "--alpha.beta.gamma",
       reason: InvalidArgumentReason.MISSING_VALUE,
     });
 
-    result = populateSubCommandValues(
-      command,
-      ["-a.b.g", "foo", "--alpha.beta.delta"],
-      undefined,
+    result = populateSubCommandValues(command, ["-a.b.g", "foo", "--alpha.beta.delta"], undefined);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: { gamma: "foo" } },
+      },
+      [],
     );
-    expectExtractResult(result, {
-      alpha: { beta: { gamma: "foo" } },
-    }, []);
     expect(result.invalidArgument).toEqual({
-      argument:
-        ((command.options[0] as ComplexOption).properties[0] as ComplexOption)
-          .properties[1],
+      argument: ((command.options[0] as ComplexOption).properties[0] as ComplexOption)
+        .properties[1],
       name: "--alpha.beta.delta",
       reason: InvalidArgumentReason.MISSING_VALUE,
     });
 
-    result = populateSubCommandValues(
-      command,
-      ["-a.b.x", "foo"],
-      undefined,
+    result = populateSubCommandValues(command, ["-a.b.x", "foo"], undefined);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: {} },
+      },
+      ["foo"],
     );
-    expectExtractResult(result, {
-      alpha: { beta: {} },
-    }, ["foo"]);
     expect(result.invalidArgument).toEqual({
       name: "-a.b.x",
       reason: InvalidArgumentReason.UNKNOWN_PROPERTY,
     });
 
-    result = populateSubCommandValues(
-      command,
-      ["-a.b.g.a", "foo"],
-      undefined,
+    result = populateSubCommandValues(command, ["-a.b.g.a", "foo"], undefined);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: {} },
+      },
+      ["foo"],
     );
-    expectExtractResult(result, {
-      alpha: { beta: {} },
-    }, ["foo"]);
     expect(result.invalidArgument).toEqual({
       name: "-a.b.g.a",
       reason: InvalidArgumentReason.UNKNOWN_PROPERTY,
@@ -2362,62 +2129,73 @@ describe("subCommandValuePopulation tests", () => {
   test("Option complex values with missing properties supplied by configured defaults", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        shortAlias: "a",
-        properties: [{
-          name: "beta",
+      options: [
+        {
+          name: "alpha",
           type: ComplexValueTypeName.COMPLEX,
-          shortAlias: "b",
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "g",
-          }, {
-            name: "delta",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "d",
-          }],
-        }],
-      }],
+          shortAlias: "a",
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              shortAlias: "b",
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "g",
+                },
+                {
+                  name: "delta",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "d",
+                },
+              ],
+            },
+          ],
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    let result = populateSubCommandValues(
-      command,
-      ["--alpha.beta.delta", "bar"],
-      { alpha: { beta: { gamma: "foo" } } },
+    let result = populateSubCommandValues(command, ["--alpha.beta.delta", "bar"], {
+      alpha: { beta: { gamma: "foo" } },
+    });
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: { gamma: "foo", delta: "bar" } },
+      },
+      [],
     );
-    expectExtractResult(result, {
-      alpha: { beta: { gamma: "foo", delta: "bar" } },
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["-a.b.g", "foo"],
-      { alpha: { beta: { delta: "bar" } } },
+    result = populateSubCommandValues(command, ["-a.b.g", "foo"], {
+      alpha: { beta: { delta: "bar" } },
+    });
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: { gamma: "foo", delta: "bar" } },
+      },
+      [],
     );
-    expectExtractResult(result, {
-      alpha: { beta: { gamma: "foo", delta: "bar" } },
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Option array check for maximum array size", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
     const potentialArgs: Array<string> = [];
@@ -2429,11 +2207,7 @@ describe("subCommandValuePopulation tests", () => {
       values.foo.push(`bar${i}`);
     }
 
-    let result = populateSubCommandValues(
-      command,
-      potentialArgs,
-      undefined,
-    );
+    let result = populateSubCommandValues(command, potentialArgs, undefined);
     expectExtractResult(result, values, ["--foo=bar256"]);
     expect(result.invalidArgument).toEqual({
       argument: command.options[0],
@@ -2441,11 +2215,7 @@ describe("subCommandValuePopulation tests", () => {
       name: "foo",
     });
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[256]=bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo[256]=bar"], undefined);
     expectExtractResult(result, {}, []);
     expect(result.invalidArgument).toEqual({
       argument: command.options[0],
@@ -2453,11 +2223,7 @@ describe("subCommandValuePopulation tests", () => {
       name: "foo",
     });
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[256]", "bar"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo[256]", "bar"], undefined);
     expectExtractResult(result, {}, ["bar"]);
     expect(result.invalidArgument).toEqual({
       argument: command.options[0],
@@ -2469,15 +2235,16 @@ describe("subCommandValuePopulation tests", () => {
   test("Option array using mix of explicit and implicit indices", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        shortAlias: "f",
-        isArray: true,
-      }],
+      options: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          shortAlias: "f",
+          isArray: true,
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
     let result = populateSubCommandValues(
@@ -2496,11 +2263,7 @@ describe("subCommandValuePopulation tests", () => {
     expectExtractResult(result, { foo: ["bar0", "bar1", "bar2"] }, []);
     expect(result.invalidArgument).toBeUndefined();
 
-    result = populateSubCommandValues(
-      command,
-      ["--foo[2]", "bar2", "--foo", "bar3"],
-      undefined,
-    );
+    result = populateSubCommandValues(command, ["--foo[2]", "bar2", "--foo", "bar3"], undefined);
 
     const values = { foo: [] as Array<string | undefined> };
     values.foo[2] = "bar2";
@@ -2514,13 +2277,14 @@ describe("subCommandValuePopulation tests", () => {
     const command: SubCommand = {
       name: "command",
       options: [],
-      positionals: [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-      }],
-      execute: async (): Promise<void> => {
-      },
+      positionals: [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+        },
+      ],
+      execute: async (): Promise<void> => {},
     };
 
     const potentialArgs: Array<string> = [];
@@ -2532,11 +2296,7 @@ describe("subCommandValuePopulation tests", () => {
       values.foo.push(`bar${i}`);
     }
 
-    const result = populateSubCommandValues(
-      command,
-      potentialArgs,
-      undefined,
-    );
+    const result = populateSubCommandValues(command, potentialArgs, undefined);
     expectExtractResult(result, values, ["bar256"]);
     expect(result.invalidArgument).toEqual({
       argument: command.positionals[0],
@@ -2548,38 +2308,44 @@ describe("subCommandValuePopulation tests", () => {
   test("Option path invalid reference to complex option", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        shortAlias: "a",
-        properties: [{
-          name: "beta",
+      options: [
+        {
+          name: "alpha",
           type: ComplexValueTypeName.COMPLEX,
-          shortAlias: "b",
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "g",
-          }, {
-            name: "delta",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "d",
-          }],
-        }],
-      }],
+          shortAlias: "a",
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              shortAlias: "b",
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "g",
+                },
+                {
+                  name: "delta",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "d",
+                },
+              ],
+            },
+          ],
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    const result = populateSubCommandValues(
-      command,
-      ["--alpha.beta", "foo"],
-      undefined,
+    const result = populateSubCommandValues(command, ["--alpha.beta", "foo"], undefined);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: {} },
+      },
+      ["foo"],
     );
-    expectExtractResult(result, {
-      alpha: { beta: {} },
-    }, ["foo"]);
     expect(result.invalidArgument).toEqual({
       argument: (command.options[0] as ComplexOption).properties[0],
       reason: InvalidArgumentReason.OPTION_IS_COMPLEX,
@@ -2590,65 +2356,71 @@ describe("subCommandValuePopulation tests", () => {
   test("Complex options with duplicated names and aliases ok if not siblings", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        shortAlias: "a",
-        properties: [{
-          name: "beta",
+      options: [
+        {
+          name: "alpha",
           type: ComplexValueTypeName.COMPLEX,
-          shortAlias: "b",
-          properties: [{
-            name: "alpha",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "a",
-          }],
-        }],
-      }],
+          shortAlias: "a",
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              shortAlias: "b",
+              properties: [
+                {
+                  name: "alpha",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "a",
+                },
+              ],
+            },
+          ],
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    const result = populateSubCommandValues(
-      command,
-      ["-a.b.a", "foo"],
-      undefined,
+    const result = populateSubCommandValues(command, ["-a.b.a", "foo"], undefined);
+    expectExtractResult(
+      result,
+      {
+        alpha: { beta: { alpha: "foo" } },
+      },
+      [],
     );
-    expectExtractResult(result, {
-      alpha: { beta: { alpha: "foo" } },
-    }, []);
     expect(result.invalidArgument).toBeUndefined();
   });
 
   test("Option path check for maximum nesting", () => {
     const command: SubCommand = {
       name: "command",
-      options: [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        shortAlias: "a",
-        properties: [{
-          name: "beta",
+      options: [
+        {
+          name: "alpha",
           type: ComplexValueTypeName.COMPLEX,
-          shortAlias: "b",
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.STRING,
-            shortAlias: "g",
-          }],
-        }],
-      }],
+          shortAlias: "a",
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              shortAlias: "b",
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                  shortAlias: "g",
+                },
+              ],
+            },
+          ],
+        },
+      ],
       positionals: [],
-      execute: async (): Promise<void> => {
-      },
+      execute: async (): Promise<void> => {},
     };
 
-    const result = populateSubCommandValues(
-      command,
-      ["-a.b.g.d.e.f.g.h.i.j.k", "foo"],
-      undefined,
-    );
+    const result = populateSubCommandValues(command, ["-a.b.g.d.e.f.g.h.i.j.k", "foo"], undefined);
     expectExtractResult(result, {}, ["foo"]);
     expect(result.invalidArgument).toEqual({
       reason: InvalidArgumentReason.NESTING_DEPTH_EXCEEDED,