skill-universe 1.1.0

package/build/dev/javascript/skillc/version_constraint_test.mjs

@@ -0,0 +1,1325 @@
+import * as $should from "../gleeunit/gleeunit/should.mjs";
+import { Ok, makeError } from "./gleam.mjs";
+import * as $semver from "./skillc/semver.mjs";
+import * as $version_constraint from "./skillc/version_constraint.mjs";
+
+const FILEPATH = "test/version_constraint_test.gleam";
+
+export function parse_caret_test() {
+  return $should.be_ok($version_constraint.parse("^1.0.0"));
+}
+
+export function parse_tilde_test() {
+  return $should.be_ok($version_constraint.parse("~2.0.0"));
+}
+
+export function parse_gte_test() {
+  return $should.be_ok($version_constraint.parse(">=1.0.0"));
+}
+
+export function parse_bare_version_test() {
+  return $should.be_ok($version_constraint.parse("1.0.0"));
+}
+
+export function parse_wildcard_test() {
+  return $should.be_ok($version_constraint.parse("*"));
+}
+
+export function parse_empty_normalizes_to_wildcard_test() {
+  let $ = $version_constraint.parse("");
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      30,
+      "parse_empty_normalizes_to_wildcard_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 716, end: 764, pattern_start: 727, pattern_end: 733 }
+    )
+  }
+  return $should.equal($version_constraint.to_string(vc), "*");
+}
+
+export function parse_caret_without_version_fails_test() {
+  return $should.be_error($version_constraint.parse("^"));
+}
+
+export function parse_tilde_without_version_fails_test() {
+  return $should.be_error($version_constraint.parse("~"));
+}
+
+export function parse_invalid_semver_fails_test() {
+  return $should.be_error($version_constraint.parse("1.0"));
+}
+
+export function parse_not_semver_fails_test() {
+  return $should.be_error($version_constraint.parse("1not-semver"));
+}
+
+export function parse_unsupported_operator_fails_test() {
+  return $should.be_error($version_constraint.parse("!1.0.0"));
+}
+
+export function wildcard_to_string_test() {
+  return $should.equal(
+    $version_constraint.to_string($version_constraint.wildcard()),
+    "*",
+  );
+}
+
+export function wildcard_equality_test() {
+  let $ = $version_constraint.parse("");
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      59,
+      "wildcard_equality_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1485,
+        end: 1533,
+        pattern_start: 1496,
+        pattern_end: 1502
+      }
+    )
+  }
+  return $should.equal(vc, $version_constraint.wildcard());
+}
+
+export function to_string_caret_test() {
+  let $ = $version_constraint.parse("^1.2.3");
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      64,
+      "to_string_caret_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1621,
+        end: 1675,
+        pattern_start: 1632,
+        pattern_end: 1638
+      }
+    )
+  }
+  return $should.equal($version_constraint.to_string(vc), "^1.2.3");
+}
+
+export function to_string_tilde_test() {
+  let $ = $version_constraint.parse("~1.2.3");
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      69,
+      "to_string_tilde_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1772,
+        end: 1826,
+        pattern_start: 1783,
+        pattern_end: 1789
+      }
+    )
+  }
+  return $should.equal($version_constraint.to_string(vc), "~1.2.3");
+}
+
+export function to_string_gte_test() {
+  let $ = $version_constraint.parse(">=1.0.0");
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      74,
+      "to_string_gte_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1921,
+        end: 1976,
+        pattern_start: 1932,
+        pattern_end: 1938
+      }
+    )
+  }
+  return $should.equal($version_constraint.to_string(vc), ">=1.0.0");
+}
+
+export function to_string_exact_bare_test() {
+  let $ = $version_constraint.parse("1.0.0");
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      79,
+      "to_string_exact_bare_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2079,
+        end: 2132,
+        pattern_start: 2090,
+        pattern_end: 2096
+      }
+    )
+  }
+  return $should.equal($version_constraint.to_string(vc), "1.0.0");
+}
+
+export function satisfies_wildcard_any_version_test() {
+  let $ = $semver.parse("99.99.99");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      88,
+      "satisfies_wildcard_any_version_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2430,
+        end: 2473,
+        pattern_start: 2441,
+        pattern_end: 2446
+      }
+    )
+  }
+  let vc = $version_constraint.wildcard();
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_exact_match_test() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      98,
+      "satisfies_exact_match_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2796,
+        end: 2836,
+        pattern_start: 2807,
+        pattern_end: 2812
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      99,
+      "satisfies_exact_match_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 2839,
+        end: 2892,
+        pattern_start: 2850,
+        pattern_end: 2856
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_exact_no_match_test() {
+  let $ = $semver.parse("1.0.1");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      104,
+      "satisfies_exact_no_match_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2993,
+        end: 3033,
+        pattern_start: 3004,
+        pattern_end: 3009
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      105,
+      "satisfies_exact_no_match_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 3036,
+        end: 3089,
+        pattern_start: 3047,
+        pattern_end: 3053
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_gte_equal_test() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      114,
+      "satisfies_gte_equal_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3385,
+        end: 3425,
+        pattern_start: 3396,
+        pattern_end: 3401
+      }
+    )
+  }
+  let $1 = $version_constraint.parse(">=1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      115,
+      "satisfies_gte_equal_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 3428,
+        end: 3483,
+        pattern_start: 3439,
+        pattern_end: 3445
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_gte_greater_test() {
+  let $ = $semver.parse("2.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      120,
+      "satisfies_gte_greater_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3581,
+        end: 3621,
+        pattern_start: 3592,
+        pattern_end: 3597
+      }
+    )
+  }
+  let $1 = $version_constraint.parse(">=1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      121,
+      "satisfies_gte_greater_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 3624,
+        end: 3679,
+        pattern_start: 3635,
+        pattern_end: 3641
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_gte_less_test() {
+  let $ = $semver.parse("0.9.9");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      126,
+      "satisfies_gte_less_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3774,
+        end: 3814,
+        pattern_start: 3785,
+        pattern_end: 3790
+      }
+    )
+  }
+  let $1 = $version_constraint.parse(">=1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      127,
+      "satisfies_gte_less_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 3817,
+        end: 3872,
+        pattern_start: 3828,
+        pattern_end: 3834
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_lte_test() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      132,
+      "satisfies_lte_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3963,
+        end: 4003,
+        pattern_start: 3974,
+        pattern_end: 3979
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("<=1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      133,
+      "satisfies_lte_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4006,
+        end: 4061,
+        pattern_start: 4017,
+        pattern_end: 4023
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_lte_greater_fails_test() {
+  let $ = $semver.parse("1.0.1");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      138,
+      "satisfies_lte_greater_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4165,
+        end: 4205,
+        pattern_start: 4176,
+        pattern_end: 4181
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("<=1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      139,
+      "satisfies_lte_greater_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4208,
+        end: 4263,
+        pattern_start: 4219,
+        pattern_end: 4225
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_gt_test() {
+  let $ = $semver.parse("1.0.1");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      144,
+      "satisfies_gt_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4353,
+        end: 4393,
+        pattern_start: 4364,
+        pattern_end: 4369
+      }
+    )
+  }
+  let $1 = $version_constraint.parse(">1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      145,
+      "satisfies_gt_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4396,
+        end: 4450,
+        pattern_start: 4407,
+        pattern_end: 4413
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_gt_equal_fails_test() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      150,
+      "satisfies_gt_equal_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4551,
+        end: 4591,
+        pattern_start: 4562,
+        pattern_end: 4567
+      }
+    )
+  }
+  let $1 = $version_constraint.parse(">1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      151,
+      "satisfies_gt_equal_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4594,
+        end: 4648,
+        pattern_start: 4605,
+        pattern_end: 4611
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_lt_test() {
+  let $ = $semver.parse("0.9.9");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      156,
+      "satisfies_lt_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4738,
+        end: 4778,
+        pattern_start: 4749,
+        pattern_end: 4754
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("<1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      157,
+      "satisfies_lt_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4781,
+        end: 4835,
+        pattern_start: 4792,
+        pattern_end: 4798
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_lt_equal_fails_test() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      162,
+      "satisfies_lt_equal_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4936,
+        end: 4976,
+        pattern_start: 4947,
+        pattern_end: 4952
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("<1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      163,
+      "satisfies_lt_equal_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 4979,
+        end: 5033,
+        pattern_start: 4990,
+        pattern_end: 4996
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_caret_exact_test() {
+  let $ = $semver.parse("1.2.3");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      172,
+      "satisfies_caret_exact_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5316,
+        end: 5356,
+        pattern_start: 5327,
+        pattern_end: 5332
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("^1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      173,
+      "satisfies_caret_exact_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5359,
+        end: 5413,
+        pattern_start: 5370,
+        pattern_end: 5376
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_caret_patch_bump_test() {
+  let $ = $semver.parse("1.2.4");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      178,
+      "satisfies_caret_patch_bump_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5516,
+        end: 5556,
+        pattern_start: 5527,
+        pattern_end: 5532
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("^1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      179,
+      "satisfies_caret_patch_bump_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5559,
+        end: 5613,
+        pattern_start: 5570,
+        pattern_end: 5576
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_caret_minor_bump_test() {
+  let $ = $semver.parse("1.9.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      184,
+      "satisfies_caret_minor_bump_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5716,
+        end: 5756,
+        pattern_start: 5727,
+        pattern_end: 5732
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("^1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      185,
+      "satisfies_caret_minor_bump_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5759,
+        end: 5813,
+        pattern_start: 5770,
+        pattern_end: 5776
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_caret_major_bump_fails_test() {
+  let $ = $semver.parse("2.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      190,
+      "satisfies_caret_major_bump_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5922,
+        end: 5962,
+        pattern_start: 5933,
+        pattern_end: 5938
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("^1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      191,
+      "satisfies_caret_major_bump_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5965,
+        end: 6019,
+        pattern_start: 5976,
+        pattern_end: 5982
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_caret_lower_fails_test() {
+  let $ = $semver.parse("1.2.2");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      196,
+      "satisfies_caret_lower_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 6124,
+        end: 6164,
+        pattern_start: 6135,
+        pattern_end: 6140
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("^1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      197,
+      "satisfies_caret_lower_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 6167,
+        end: 6221,
+        pattern_start: 6178,
+        pattern_end: 6184
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_caret_zero_minor_pins_minor_test() {
+  let $ = $semver.parse("0.2.5");
+  let v1;
+  if ($ instanceof Ok) {
+    v1 = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      203,
+      "satisfies_caret_zero_minor_pins_minor_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 6370,
+        end: 6411,
+        pattern_start: 6381,
+        pattern_end: 6387
+      }
+    )
+  }
+  let $1 = $semver.parse("0.3.0");
+  let v2;
+  if ($1 instanceof Ok) {
+    v2 = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      204,
+      "satisfies_caret_zero_minor_pins_minor_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 6414,
+        end: 6455,
+        pattern_start: 6425,
+        pattern_end: 6431
+      }
+    )
+  }
+  let $2 = $version_constraint.parse("^0.2.3");
+  let vc;
+  if ($2 instanceof Ok) {
+    vc = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      205,
+      "satisfies_caret_zero_minor_pins_minor_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 6458,
+        end: 6512,
+        pattern_start: 6469,
+        pattern_end: 6475
+      }
+    )
+  }
+  $should.be_true($version_constraint.satisfies(v1, vc));
+  return $should.be_false($version_constraint.satisfies(v2, vc));
+}
+
+export function satisfies_caret_zero_zero_pins_patch_test() {
+  let $ = $semver.parse("0.0.3");
+  let v1;
+  if ($ instanceof Ok) {
+    v1 = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      212,
+      "satisfies_caret_zero_zero_pins_patch_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 6716,
+        end: 6757,
+        pattern_start: 6727,
+        pattern_end: 6733
+      }
+    )
+  }
+  let $1 = $semver.parse("0.0.4");
+  let v2;
+  if ($1 instanceof Ok) {
+    v2 = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      213,
+      "satisfies_caret_zero_zero_pins_patch_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 6760,
+        end: 6801,
+        pattern_start: 6771,
+        pattern_end: 6777
+      }
+    )
+  }
+  let $2 = $version_constraint.parse("^0.0.3");
+  let vc;
+  if ($2 instanceof Ok) {
+    vc = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      214,
+      "satisfies_caret_zero_zero_pins_patch_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 6804,
+        end: 6858,
+        pattern_start: 6815,
+        pattern_end: 6821
+      }
+    )
+  }
+  $should.be_true($version_constraint.satisfies(v1, vc));
+  return $should.be_false($version_constraint.satisfies(v2, vc));
+}
+
+export function satisfies_tilde_exact_test() {
+  let $ = $semver.parse("1.2.3");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      224,
+      "satisfies_tilde_exact_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7197,
+        end: 7237,
+        pattern_start: 7208,
+        pattern_end: 7213
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("~1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      225,
+      "satisfies_tilde_exact_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 7240,
+        end: 7294,
+        pattern_start: 7251,
+        pattern_end: 7257
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_tilde_patch_bump_test() {
+  let $ = $semver.parse("1.2.9");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      230,
+      "satisfies_tilde_patch_bump_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7397,
+        end: 7437,
+        pattern_start: 7408,
+        pattern_end: 7413
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("~1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      231,
+      "satisfies_tilde_patch_bump_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 7440,
+        end: 7494,
+        pattern_start: 7451,
+        pattern_end: 7457
+      }
+    )
+  }
+  return $should.be_true($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_tilde_minor_bump_fails_test() {
+  let $ = $semver.parse("1.3.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      236,
+      "satisfies_tilde_minor_bump_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7603,
+        end: 7643,
+        pattern_start: 7614,
+        pattern_end: 7619
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("~1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      237,
+      "satisfies_tilde_minor_bump_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 7646,
+        end: 7700,
+        pattern_start: 7657,
+        pattern_end: 7663
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_tilde_lower_fails_test() {
+  let $ = $semver.parse("1.2.2");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      242,
+      "satisfies_tilde_lower_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7805,
+        end: 7845,
+        pattern_start: 7816,
+        pattern_end: 7821
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("~1.2.3");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      243,
+      "satisfies_tilde_lower_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 7848,
+        end: 7902,
+        pattern_start: 7859,
+        pattern_end: 7865
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}
+
+export function satisfies_prerelease_lower_precedence_test() {
+  let $ = $semver.parse("1.0.0-alpha");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      254,
+      "satisfies_prerelease_lower_precedence_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 8322,
+        end: 8368,
+        pattern_start: 8333,
+        pattern_end: 8338
+      }
+    )
+  }
+  let $1 = $version_constraint.parse("^1.0.0");
+  let vc;
+  if ($1 instanceof Ok) {
+    vc = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "version_constraint_test",
+      255,
+      "satisfies_prerelease_lower_precedence_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 8371,
+        end: 8425,
+        pattern_start: 8382,
+        pattern_end: 8388
+      }
+    )
+  }
+  return $should.be_false($version_constraint.satisfies(v, vc));
+}