text: import tap from "tap";
  import { isIndexWithin as wthn } from "../dist/ranges-is-index-within.esm";
  
  // ==============================
  // 01. One range
  // ==============================
  
  tap.test("01 - one range, both defaults and inclusive", (t) => {
    t.strictSame(wthn(1, [[0, 3]]), true, "01.01 - within range");
    t.strictSame(
      wthn(0, [[0, 3]]),
      false,
      "01.02 - on the starting of the range"
    );
    t.strictSame(
      wthn(0, [[0, 3]], { inclusiveRangeEnds: true }),
      true,
      "01.03 - on the starting of the range, inclusive"
    );
    t.strictSame(wthn(3, [[0, 3]]), false, "01.04 - on the ending of the range");
    t.strictSame(
      wthn(3, [[0, 3]], { inclusiveRangeEnds: true }),
      true,
      "01.05 - on the ending of the range, inclusive"
    );
    t.strictSame(wthn(99, [[0, 3]]), false, "01.06 - outside of the range");
    t.strictSame(
      wthn(99, [[0, 3]], { inclusiveRangeEnds: true }),
      false,
      "01.07 - outside of the range, inclusive"
    );
    t.strictSame(
      wthn(99, null, { inclusiveRangeEnds: true }),
      false,
      "01.08 - matching against null"
    );
    t.strictSame(wthn(0, null), false, "01.09 - matching against null");
    t.end();
  });
  
  tap.test("02 - one range, opts.returnMatchedRangeInsteadOfTrue", (t) => {
    t.strictSame(
      wthn(1, [[0, 3]], { returnMatchedRangeInsteadOfTrue: true }),
      [0, 3],
      "02.01 - within range"
    );
    t.strictSame(
      wthn(0, [[0, 3]], { returnMatchedRangeInsteadOfTrue: true }),
      false,
      "02.02 - on the starting of the range"
    );
    t.strictSame(
      wthn(0, [[0, 3]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      [0, 3],
      "02.03 - on the starting of the range, inclusive"
    );
    t.strictSame(
      wthn(3, [[0, 3]], { returnMatchedRangeInsteadOfTrue: true }),
      false,
      "02.04 - on the ending of the range"
    );
    t.strictSame(
      wthn(3, [[0, 3]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      [0, 3],
      "02.05 - on the ending of the range, inclusive"
    );
    t.strictSame(
      wthn(99, [[0, 3]], { returnMatchedRangeInsteadOfTrue: true }),
      false,
      "02.06 - outside of the range"
    );
    t.strictSame(
      wthn(99, [[0, 3]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "02.07 - outside of the range, inclusive"
    );
    t.end();
  });
  
  // ==============================
  // 02. Two ranges
  // ==============================
  
  tap.test("03 - two ranges, edges on defaults", (t) => {
    t.strictSame(
      wthn(1, [
        [2, 4],
        [6, 8],
      ]),
      false,
      "03.01 - outside of the range"
    );
    t.strictSame(
      wthn(5, [
        [2, 4],
        [6, 8],
      ]),
      false,
      "03.02 - outside of the range"
    );
    t.strictSame(
      wthn(9, [
        [2, 4],
        [6, 8],
      ]),
      false,
      "03.03 - outside of the range"
    );
    t.strictSame(
      wthn(3, [
        [2, 4],
        [6, 8],
      ]),
      true,
      "03.04 - outside of the range"
    );
    t.strictSame(
      wthn(7, [
        [2, 4],
        [6, 8],
      ]),
      true,
      "03.05 - outside of the range"
    );
    t.end();
  });
  
  tap.test("04 - two ranges, edges inclusive", (t) => {
    // same as 02.01
    t.strictSame(
      wthn(
        1,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      false,
      "04.01 - outside of the range"
    );
    t.strictSame(
      wthn(
        5,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      false,
      "04.02 - outside of the range"
    );
    t.strictSame(
      wthn(
        9,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      false,
      "04.03 - outside of the range"
    );
    t.strictSame(
      wthn(
        3,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "04.04 - outside of the range"
    );
    t.strictSame(
      wthn(
        7,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "04.05 - outside of the range"
    );
  
    // checking range edges:
    t.strictSame(
      wthn(
        2,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "04.06"
    );
    t.strictSame(
      wthn(
        4,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "04.07"
    );
    t.strictSame(
      wthn(
        6,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "04.08"
    );
    t.strictSame(
      wthn(
        8,
        [
          [2, 4],
          [6, 8],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "04.09"
    );
    t.end();
  });
  
  tap.test(
    "05 - two ranges, opts.returnMatchedRangeInsteadOfTrue, edges on defaults",
    (t) => {
      t.strictSame(
        wthn(
          1,
          [
            [2, 4],
            [6, 8],
          ],
          { returnMatchedRangeInsteadOfTrue: true }
        ),
        false,
        "05.01 - outside of the range"
      );
      t.strictSame(
        wthn(
          5,
          [
            [2, 4],
            [6, 8],
          ],
          { returnMatchedRangeInsteadOfTrue: true }
        ),
        false,
        "05.02 - outside of the range"
      );
      t.strictSame(
        wthn(
          9,
          [
            [2, 4],
            [6, 8],
          ],
          { returnMatchedRangeInsteadOfTrue: true }
        ),
        false,
        "05.03 - outside of the range"
      );
      t.strictSame(
        wthn(
          3,
          [
            [2, 4],
            [6, 8],
          ],
          { returnMatchedRangeInsteadOfTrue: true }
        ),
        [2, 4],
        "05.04 - outside of the range"
      );
      t.strictSame(
        wthn(
          7,
          [
            [2, 4],
            [6, 8],
          ],
          { returnMatchedRangeInsteadOfTrue: true }
        ),
        [6, 8],
        "05.05 - outside of the range"
      );
      t.end();
    }
  );
  
  tap.test(
    "06 - two ranges, opts.returnMatchedRangeInsteadOfTrue, edges inclusive",
    (t) => {
      // same as 02.01
      t.strictSame(
        wthn(
          1,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        false,
        "06.01 - outside of the range"
      );
      t.strictSame(
        wthn(
          5,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        false,
        "06.02 - outside of the range"
      );
      t.strictSame(
        wthn(
          9,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        false,
        "06.03 - outside of the range"
      );
      t.strictSame(
        wthn(
          3,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        [2, 4],
        "06.04 - outside of the range"
      );
      t.strictSame(
        wthn(
          7,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        [6, 8],
        "06.05 - outside of the range"
      );
      // checking range edges:
      t.strictSame(
        wthn(
          2,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        [2, 4],
        "06.06"
      );
      t.strictSame(
        wthn(
          4,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        [2, 4],
        "06.07"
      );
      t.strictSame(
        wthn(
          6,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        [6, 8],
        "06.08"
      );
      t.strictSame(
        wthn(
          8,
          [
            [2, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        [6, 8],
        "06.09"
      );
      t.strictSame(
        wthn(
          0,
          [
            [0, 4],
            [6, 8],
          ],
          {
            inclusiveRangeEnds: true,
            returnMatchedRangeInsteadOfTrue: true,
          }
        ),
        [0, 4],
        "06.10 - zero"
      );
      t.end();
    }
  );
  
  // ==============================
  // 03. Many ranges
  // ==============================
  
  tap.test("07 - more than two ranges, uneven count, not inclusive", (t) => {
    t.strictSame(
      wthn(5, [
        [2, 4],
        [6, 8],
        [10, 15],
        [20, 30],
        [35, 40],
        [45, 50],
        [55, 60],
      ]),
      false,
      "07.01 - outside of the range"
    );
    t.strictSame(
      wthn(
        5,
        [
          [2, 4],
          [6, 8],
          [10, 15],
          [20, 30],
          [35, 40],
          [45, 50],
          [55, 60],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "07.02 - with opts, outside of the range"
    );
    t.strictSame(
      wthn(
        5,
        [
          [2, 4],
          [6, 8],
          [10, 15],
          [20, 30],
          [35, 40],
          [45, 50],
          [55, 60],
        ],
        { inclusiveRangeEnds: true }
      ),
      false,
      "07.03 - outside of the range"
    );
    t.strictSame(
      wthn(
        5,
        [
          [2, 4],
          [6, 8],
          [10, 15],
          [20, 30],
          [35, 40],
          [45, 50],
          [55, 60],
        ],
        { returnMatchedRangeInsteadOfTrue: true, inclusiveRangeEnds: true }
      ),
      false,
      "07.04 - with opts, outside of the range"
    );
    t.end();
  });
  
  tap.test("08 - even more ranges, not inclusive", (t) => {
    t.strictSame(
      wthn(0, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.01"
    );
    t.strictSame(
      wthn(
        0,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.02-2"
    );
    t.strictSame(
      wthn(1, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.03"
    );
    t.strictSame(
      wthn(
        1,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.04-2"
    );
    t.strictSame(
      wthn(2, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.05"
    );
    t.strictSame(
      wthn(3, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.06"
    );
    t.strictSame(
      wthn(4, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.07"
    );
    t.strictSame(
      wthn(5, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.08"
    );
    t.strictSame(
      wthn(
        5,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.09-2"
    );
    t.strictSame(
      wthn(6, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.10"
    );
    t.strictSame(
      wthn(
        6,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [5, 10],
      "08.11-2"
    );
    t.strictSame(
      wthn(7, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.12"
    );
    t.strictSame(
      wthn(
        7,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [5, 10],
      "08.13"
    );
    t.strictSame(
      wthn(8, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.14"
    );
    t.strictSame(
      wthn(
        8,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [5, 10],
      "08.15-2"
    );
    t.strictSame(
      wthn(9, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.16"
    );
    t.strictSame(
      wthn(
        9,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [5, 10],
      "08.17-2"
    );
    t.strictSame(
      wthn(10, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.18"
    );
    t.strictSame(
      wthn(
        10,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.19-2"
    );
    t.strictSame(
      wthn(11, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.20"
    );
    t.strictSame(
      wthn(
        11,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.21-2"
    );
    t.strictSame(
      wthn(12, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.22"
    );
    t.strictSame(
      wthn(13, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.23"
    );
    t.strictSame(
      wthn(14, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.24"
    );
    t.strictSame(
      wthn(15, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.25"
    );
    t.strictSame(
      wthn(
        15,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "08.26-2"
    );
    t.strictSame(
      wthn(
        15,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.27-3"
    );
    t.strictSame(
      wthn(
        15,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [15, 20],
      "08.28-4"
    );
    t.strictSame(
      wthn(16, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.29"
    );
    t.strictSame(
      wthn(
        16,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [15, 20],
      "08.30-2"
    );
    t.strictSame(
      wthn(17, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.31"
    );
    t.strictSame(
      wthn(18, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.32"
    );
    t.strictSame(
      wthn(19, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.33"
    );
    t.strictSame(
      wthn(20, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.34"
    );
    t.strictSame(
      wthn(
        20,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "08.35-2"
    );
    t.strictSame(
      wthn(
        20,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.36-3"
    );
    t.strictSame(
      wthn(
        20,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [15, 20],
      "08.37-4"
    );
    t.strictSame(
      wthn(21, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.38"
    );
    t.strictSame(
      wthn(22, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.39"
    );
    t.strictSame(
      wthn(23, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.40"
    );
    t.strictSame(
      wthn(24, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.41"
    );
    t.strictSame(
      wthn(25, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.42"
    );
    t.strictSame(
      wthn(26, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.43"
    );
    t.strictSame(
      wthn(27, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.44"
    );
    t.strictSame(
      wthn(28, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.45"
    );
    t.strictSame(
      wthn(29, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.46"
    );
    t.strictSame(
      wthn(30, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.47"
    );
    t.strictSame(
      wthn(31, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.48"
    );
    t.strictSame(
      wthn(32, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.49"
    );
    t.strictSame(
      wthn(33, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.50"
    );
    t.strictSame(
      wthn(34, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.51"
    );
    t.strictSame(
      wthn(35, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.52"
    );
    t.strictSame(
      wthn(36, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.53"
    );
    t.strictSame(
      wthn(37, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.54"
    );
    t.strictSame(
      wthn(38, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.55"
    );
    t.strictSame(
      wthn(39, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.56"
    );
    t.strictSame(
      wthn(40, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.57"
    );
    t.strictSame(
      wthn(41, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.58"
    );
    t.strictSame(
      wthn(42, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.59"
    );
    t.strictSame(
      wthn(43, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.60"
    );
    t.strictSame(
      wthn(44, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.61"
    );
    t.strictSame(
      wthn(45, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.62"
    );
    t.strictSame(
      wthn(46, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.63"
    );
    t.strictSame(
      wthn(47, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.64"
    );
    t.strictSame(
      wthn(48, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.65"
    );
    t.strictSame(
      wthn(49, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.66"
    );
    t.strictSame(
      wthn(50, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.67"
    );
    t.strictSame(
      wthn(51, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.68"
    );
    t.strictSame(
      wthn(52, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.69"
    );
    t.strictSame(
      wthn(53, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.70"
    );
    t.strictSame(
      wthn(54, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.71"
    );
    t.strictSame(
      wthn(55, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.72-1"
    );
    t.strictSame(
      wthn(
        55,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "08.73-2"
    );
    t.strictSame(
      wthn(
        55,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.74-3"
    );
    t.strictSame(
      wthn(
        55,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [55, 60],
      "08.75-4"
    );
    t.strictSame(
      wthn(56, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.76-1"
    );
    t.strictSame(
      wthn(
        56,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [55, 60],
      "08.77-2"
    );
    t.strictSame(
      wthn(57, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.78"
    );
    t.strictSame(
      wthn(58, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.79"
    );
    t.strictSame(
      wthn(59, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.80"
    );
    t.strictSame(
      wthn(60, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.81"
    );
    t.strictSame(
      wthn(61, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.82"
    );
    t.strictSame(
      wthn(62, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.83"
    );
    t.strictSame(
      wthn(63, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.84"
    );
    t.strictSame(
      wthn(64, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.85-1"
    );
    t.strictSame(
      wthn(
        64,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.86-2"
    );
    t.strictSame(
      wthn(65, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.87-1"
    );
    t.strictSame(
      wthn(
        65,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.88-2"
    );
    t.strictSame(
      wthn(66, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.89-1"
    );
    t.strictSame(
      wthn(
        66,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [65, 70],
      "08.90-2"
    );
    t.strictSame(
      wthn(67, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.91"
    );
    t.strictSame(
      wthn(68, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.92-1"
    );
    t.strictSame(
      wthn(
        68,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [65, 70],
      "08.93-2"
    );
    t.strictSame(
      wthn(69, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.94"
    );
    t.strictSame(
      wthn(70, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.95"
    );
    t.strictSame(
      wthn(71, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.96"
    );
    t.strictSame(
      wthn(72, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.97"
    );
    t.strictSame(
      wthn(73, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.98"
    );
    t.strictSame(
      wthn(74, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.99"
    );
    t.strictSame(
      wthn(75, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.100"
    );
    t.strictSame(
      wthn(76, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.101-1"
    );
    t.strictSame(
      wthn(
        76,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [75, 80],
      "08.102-2"
    );
    t.strictSame(
      wthn(77, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.103"
    );
    t.strictSame(
      wthn(78, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.104"
    );
    t.strictSame(
      wthn(79, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.105"
    );
    t.strictSame(
      wthn(80, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.106"
    );
    t.strictSame(
      wthn(81, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.107"
    );
    t.strictSame(
      wthn(82, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.108"
    );
    t.strictSame(
      wthn(83, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.109"
    );
    t.strictSame(
      wthn(84, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.110"
    );
    t.strictSame(
      wthn(85, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.111"
    );
    t.strictSame(
      wthn(86, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.112-1"
    );
    t.strictSame(
      wthn(
        86,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [85, 90],
      "08.113-2"
    );
    t.strictSame(
      wthn(87, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.114"
    );
    t.strictSame(
      wthn(88, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.115"
    );
    t.strictSame(
      wthn(89, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.116"
    );
    t.strictSame(
      wthn(90, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.117"
    );
    t.strictSame(
      wthn(91, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.118"
    );
    t.strictSame(
      wthn(92, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.119"
    );
    t.strictSame(
      wthn(93, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.120"
    );
    t.strictSame(
      wthn(94, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.121"
    );
    t.strictSame(
      wthn(95, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.122"
    );
    t.strictSame(
      wthn(96, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.123"
    );
    t.strictSame(
      wthn(97, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.124-1"
    );
    t.strictSame(
      wthn(
        97,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      [95, 100],
      "08.125-2"
    );
    t.strictSame(
      wthn(98, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.126"
    );
    t.strictSame(
      wthn(99, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "08.127"
    );
    t.strictSame(
      wthn(100, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "08.128-1"
    );
    t.strictSame(
      wthn(
        100,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "08.129-2"
    );
    t.strictSame(
      wthn(
        100,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.130-3"
    );
    t.strictSame(
      wthn(
        100,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [95, 100],
      "08.131-4"
    );
  
    //
  
    t.strictSame(
      wthn(
        105,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [105, 110],
      "08.132"
    );
    t.strictSame(
      wthn(
        110,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.133"
    );
    t.strictSame(
      wthn(
        112,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.134"
    );
    t.strictSame(
      wthn(
        116,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: false }
      ),
      true,
      "08.135-1"
    );
    t.strictSame(
      wthn(
        116,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      [115, 120],
      "08.136-2"
    );
    t.strictSame(
      wthn(
        120,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.137"
    );
    t.strictSame(
      wthn(
        124,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.138-1"
    );
    t.strictSame(
      wthn(
        124,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.139-2"
    );
    t.strictSame(
      wthn(
        124,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.140-3"
    );
    t.strictSame(
      wthn(
        124,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.141-4"
    );
    t.strictSame(
      wthn(
        126,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: false }
      ),
      true,
      "08.142-1"
    );
    t.strictSame(
      wthn(
        126,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: false }
      ),
      true,
      "08.143-2"
    );
    t.strictSame(
      wthn(
        126,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [125, 130],
      "08.144-3"
    );
    t.strictSame(
      wthn(
        126,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      [125, 130],
      "08.145-4"
    );
  
    t.strictSame(
      wthn(
        130,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.146-1"
    );
    t.strictSame(
      wthn(
        130,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [125, 130],
      "08.147-2"
    );
    t.strictSame(
      wthn(
        130,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.148-3"
    );
    t.strictSame(
      wthn(
        130,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: false }
      ),
      true,
      "08.149-4"
    );
  
    // outside of the range
    t.strictSame(
      wthn(
        131,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.150-1"
    );
    t.strictSame(
      wthn(
        131,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.151-2"
    );
    t.strictSame(
      wthn(
        131,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.152-3"
    );
    t.strictSame(
      wthn(
        131,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.153-4"
    );
    t.strictSame(
      wthn(
        132,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.154-1"
    );
    t.strictSame(
      wthn(
        132,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.155-2"
    );
    t.strictSame(
      wthn(
        132,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: false }
      ),
      false,
      "08.156-3"
    );
    t.strictSame(
      wthn(
        132,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: false, returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "08.157-4"
    );
    t.end();
  });
  
  tap.test("09 - small ranges - zero", (t) => {
    t.strictSame(wthn(0, [[0, 1]]), false, "09.01 - no opts");
    t.strictSame(
      wthn(0, [[0, 1]], { inclusiveRangeEnds: false }),
      false,
      "09.02 - hardcoded opts defaults"
    );
    t.strictSame(
      wthn(0, [[0, 1]], { inclusiveRangeEnds: true }),
      true,
      "09.03 - inclusive"
    );
    t.strictSame(
      wthn(0, [
        [0, 1],
        [2, 3],
      ]),
      false,
      "09.04"
    );
    t.strictSame(
      wthn(0, [
        [0, 1],
        [1, 3],
      ]),
      false,
      "09.05 - overlap"
    );
    t.strictSame(
      wthn(0, [
        [0, 1],
        [0, 3],
      ]),
      false,
      "09.06 - overlap #2"
    );
    t.strictSame(
      wthn(0, [
        [0, 10],
        [0, 3],
      ]),
      false,
      "09.07 - overlap and wrong order"
    );
    t.strictSame(
      wthn(
        0,
        [
          [0, 10],
          [0, 3],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "09.08 - overlap and wrong order - inclusive"
    );
    t.strictSame(
      wthn(
        0,
        [
          [1, 10],
          [0, 3],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "09.09 - overlap and wrong order - inclusive"
    );
  
    // returnMatchedRangeInsteadOfTrue: true
  
    t.strictSame(
      wthn(0, [[0, 1]], { returnMatchedRangeInsteadOfTrue: true }),
      false,
      "09.10 - no opts"
    );
    t.strictSame(
      wthn(0, [[0, 1]], {
        inclusiveRangeEnds: false,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "09.11 - hardcoded opts defaults"
    );
    t.strictSame(
      wthn(0, [[0, 1]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      [0, 1],
      "09.12 - inclusive"
    );
    t.strictSame(
      wthn(
        0,
        [
          [0, 1],
          [2, 3],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "09.13"
    );
    t.strictSame(
      wthn(
        0,
        [
          [0, 1],
          [1, 3],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "09.14 - overlap"
    );
    t.strictSame(
      wthn(
        0,
        [
          [0, 1],
          [0, 3],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "09.15 - overlap #2"
    );
    t.strictSame(
      wthn(
        0,
        [
          [0, 10],
          [0, 3],
        ],
        { returnMatchedRangeInsteadOfTrue: true }
      ),
      false,
      "09.16 - overlap and wrong order"
    );
    t.strictSame(
      wthn(
        0,
        [
          [0, 10],
          [0, 3],
        ],
        {
          inclusiveRangeEnds: true,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      [0, 10],
      "09.17 - overlap and wrong order - inclusive"
    );
    t.strictSame(
      wthn(
        0,
        [
          [1, 10],
          [0, 3],
        ],
        {
          inclusiveRangeEnds: true,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      [0, 3],
      "09.18 - overlap and wrong order - inclusive"
    );
    t.end();
  });
  
  tap.test("10 - small ranges - one", (t) => {
    t.strictSame(wthn(1, [[0, 1]]), false, "10.01 - no opts");
    t.strictSame(
      wthn(1, [[0, 1]], { inclusiveRangeEnds: false }),
      false,
      "10.02 - hardcoded opts defaults"
    );
    t.strictSame(
      wthn(1, [[0, 1]], { inclusiveRangeEnds: true }),
      true,
      "10.03 - inclusive"
    );
  
    // opts.returnMatchedRangeInsteadOfTrue
    t.strictSame(
      wthn(1, [[0, 1]], { returnMatchedRangeInsteadOfTrue: true }),
      false,
      "10.04"
    );
    t.strictSame(
      wthn(1, [[0, 1]], {
        inclusiveRangeEnds: false,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "10.05 - hardcoded opts defaults"
    );
    t.strictSame(
      wthn(1, [[0, 1]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      [0, 1],
      "10.06 - inclusive"
    );
    t.end();
  });
  
  tap.test("11 - identical range endings", (t) => {
    t.strictSame(
      wthn(0, [[0, 0]], { inclusiveRangeEnds: false }),
      false,
      "11.01"
    );
    t.strictSame(
      wthn(1, [[1, 1]], { inclusiveRangeEnds: false }),
      false,
      "11.02"
    );
    t.strictSame(wthn(0, [[0, 0]], { inclusiveRangeEnds: true }), true, "11.03");
    t.strictSame(wthn(1, [[1, 1]], { inclusiveRangeEnds: true }), true, "11.04");
    t.strictSame(
      wthn(0, [[1, 1]], { inclusiveRangeEnds: true }),
      false,
      "11.05 - identical range ends, index under"
    );
    t.strictSame(
      wthn(2, [[1, 1]], { inclusiveRangeEnds: true }),
      false,
      "11.06 - identical range ends, index above"
    );
    t.strictSame(
      wthn(2, [[1, 1]], { inclusiveRangeEnds: false }),
      false,
      "11.07 - identical range ends, index above"
    );
    t.strictSame(
      wthn(
        1,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        { inclusiveRangeEnds: false }
      ),
      false,
      "11.08 - identical consecutive"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        { inclusiveRangeEnds: false }
      ),
      false,
      "11.09 - identical consecutive"
    );
    t.strictSame(
      wthn(
        3,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        { inclusiveRangeEnds: false }
      ),
      false,
      "11.10 - identical consecutive"
    );
    t.strictSame(
      wthn(
        1,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "11.11 - identical consecutive"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "11.12 - identical consecutive"
    );
    t.strictSame(
      wthn(
        3,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        { inclusiveRangeEnds: true }
      ),
      true,
      "11.13 - identical consecutive"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [3, 3],
          [4, 4],
        ],
        { inclusiveRangeEnds: true }
      ),
      false,
      "11.14 - identical consecutive with gap"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [3, 3],
          [4, 4],
        ],
        { inclusiveRangeEnds: false }
      ),
      false,
      "11.15 - identical consecutive with gap"
    );
  
    // opts.returnMatchedRangeInsteadOfTrue
    t.strictSame(
      wthn(0, [[0, 0]], {
        inclusiveRangeEnds: false,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "11.16"
    );
    t.strictSame(
      wthn(1, [[1, 1]], {
        inclusiveRangeEnds: false,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "11.17"
    );
    t.strictSame(
      wthn(0, [[0, 0]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      [0, 0],
      "11.18"
    );
    t.strictSame(
      wthn(1, [[1, 1]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      [1, 1],
      "11.19"
    );
    t.strictSame(
      wthn(0, [[1, 1]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "11.20 - identical range ends, index under"
    );
    t.strictSame(
      wthn(2, [[1, 1]], {
        inclusiveRangeEnds: true,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "11.21 - identical range ends, index above"
    );
    t.strictSame(
      wthn(2, [[1, 1]], {
        inclusiveRangeEnds: false,
        returnMatchedRangeInsteadOfTrue: true,
      }),
      false,
      "11.22 - identical range ends, index above"
    );
    t.strictSame(
      wthn(
        1,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        {
          inclusiveRangeEnds: false,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      false,
      "11.23 - identical consecutive"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        {
          inclusiveRangeEnds: false,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      false,
      "11.24 - identical consecutive"
    );
    t.strictSame(
      wthn(
        3,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        {
          inclusiveRangeEnds: false,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      false,
      "11.25 - identical consecutive"
    );
    t.strictSame(
      wthn(
        1,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        {
          inclusiveRangeEnds: true,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      [1, 1],
      "11.26 - identical consecutive"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        {
          inclusiveRangeEnds: true,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      [2, 2],
      "11.27 - identical consecutive"
    );
    t.strictSame(
      wthn(
        3,
        [
          [1, 1],
          [2, 2],
          [3, 3],
        ],
        {
          inclusiveRangeEnds: true,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      [3, 3],
      "11.28 - identical consecutive"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [3, 3],
          [4, 4],
        ],
        {
          inclusiveRangeEnds: true,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      false,
      "11.29 - identical consecutive with gap"
    );
    t.strictSame(
      wthn(
        2,
        [
          [1, 1],
          [3, 3],
          [4, 4],
        ],
        {
          inclusiveRangeEnds: false,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      false,
      "11.30 - identical consecutive with gap"
    );
    t.end();
  });
  
  // ==============================
  // 4. AD-HOC
  // ==============================
  
  tap.test("Ad-hoc #1", (t) => {
    t.strictSame(
      wthn(
        130,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40],
          [45, 50],
          [55, 60],
          [65, 70, 999], // irrelevant third element
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        { inclusiveRangeEnds: true, returnMatchedRangeInsteadOfTrue: true }
      ),
      [125, 130],
      "12.01"
    );
    t.strictSame(
      wthn(
        130,
        [
          [5, 10],
          [15, 20],
          [25, 30],
          [35, 40, 777], // irrelevant third element
          [45, 50],
          [55, 60],
          [65, 70],
          [75, 80],
          [85, 90],
          [95, 100],
          [105, 110],
          [115, 120],
          [125, 130],
        ],
        {
          inclusiveRangeEnds: true,
          returnMatchedRangeInsteadOfTrue: true,
        }
      ),
      [125, 130],
      "12.02"
    );
    t.end();
  });
  
  tap.test("Ad-hoc #2", (t) => {
    t.strictSame(
      wthn(21, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      false,
      "13"
    );
    t.end();
  });
  
  tap.test("Ad-hoc #3", (t) => {
    t.strictSame(
      wthn(6, [
        [5, 10],
        [15, 20],
        [25, 30],
        [35, 40],
        [45, 50],
        [55, 60],
        [65, 70],
        [75, 80],
        [85, 90],
        [95, 100],
        [105, 110],
        [115, 120],
        [125, 130],
      ]),
      true,
      "14"
    );
    t.end();
  });
  