diff --git a/.gitignore b/.gitignore
index beb80425216f..f8eacde7f805 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,8 @@ coverage/
 .vim
 _tmp/
 !_tmp/.keep
+*.sublime-project
+*.sublime-workspace
 
 # tsconfig for bun
 /tsconfig.json
diff --git a/semver/greater_than_range.ts b/semver/greater_than_range.ts
index 74fd277b09b2..6241728b71e5 100644
--- a/semver/greater_than_range.ts
+++ b/semver/greater_than_range.ts
@@ -54,7 +54,7 @@ function lessThanComparator(version: SemVer, comparator: Comparator): boolean {
     case undefined:
       return cmp < 0;
     case "!=":
-      return false;
+      return cmp >= 0;
     case ">":
       return cmp <= 0;
     case "<":
diff --git a/semver/greater_than_range_test.ts b/semver/greater_than_range_test.ts
index 3299f2fced0f..6edfbcbd95d1 100644
--- a/semver/greater_than_range_test.ts
+++ b/semver/greater_than_range_test.ts
@@ -65,6 +65,7 @@ Deno.test("greaterThanRange() checks if the semver is greater than the range", a
     ["<1", "1.0.0"],
     ["=0.7.x", "0.8.2"],
     ["<0.7.x", "0.7.2"],
+    ["=0.1.0", "1.0.0"],
   ] as const;
 
   for (const [range, version] of versionGtRange) {
@@ -178,7 +179,7 @@ Deno.test("greaterThanRange() handles equals operator", () => {
     build: [],
   };
   const range = [[{
-    operator: "=" as unknown as Operator,
+    operator: "=" as Operator,
     major: 1,
     minor: 0,
     patch: 0,
@@ -204,6 +205,5 @@ Deno.test("greaterThanRange() handles not equals operator", () => {
     prerelease: [],
     build: [],
   }]];
-  // FIXME(kt3k): This demonstrates a bug. This should be false
-  assertEquals(greaterThanRange(version, range), true);
+  assertEquals(greaterThanRange(version, range), false);
 });
diff --git a/semver/less_than_range.ts b/semver/less_than_range.ts
index f7d08362fe46..e93ad11f6c8b 100644
--- a/semver/less_than_range.ts
+++ b/semver/less_than_range.ts
@@ -56,7 +56,7 @@ function greaterThanComparator(
     case undefined:
       return cmp > 0;
     case "!=":
-      return false;
+      return cmp <= 0;
     case ">":
       return false;
     case "<":
diff --git a/semver/less_than_range_test.ts b/semver/less_than_range_test.ts
index 8b889a769dbc..60a5b968c99b 100644
--- a/semver/less_than_range_test.ts
+++ b/semver/less_than_range_test.ts
@@ -186,6 +186,5 @@ Deno.test("lessThanRange() handles not equals operator", () => {
     prerelease: [],
     build: [],
   }]];
-  // FIXME(kt3k): This demonstrates a bug. This should be false
-  assertEquals(lessThanRange(version, range), true);
+  assertEquals(lessThanRange(version, range), false);
 });
diff --git a/semver/parse_range.ts b/semver/parse_range.ts
index e2ba5211a07d..2494ac83d53c 100644
--- a/semver/parse_range.ts
+++ b/semver/parse_range.ts
@@ -5,7 +5,6 @@ import {
   COMPARATOR_REGEXP,
   OPERATOR_XRANGE_REGEXP,
   parseBuild,
-  parseNumber,
   parsePrerelease,
   XRANGE,
 } from "./_shared.ts";
@@ -27,29 +26,8 @@ function parseComparator(comparator: string): Comparator | null {
 
   if (!groups) return null;
 
-  const { operator, prerelease, buildmetadata } =
-    groups as ComparatorRegExpGroup;
-
-  const semver = groups.major
-    ? {
-      major: parseNumber(
-        groups.major,
-        `Cannot parse comparator ${comparator}: invalid major version`,
-      ),
-      minor: parseNumber(
-        groups.minor!,
-        `Cannot parse comparator ${comparator}: invalid minor version`,
-      ),
-      patch: parseNumber(
-        groups.patch!,
-        `Cannot parse comparator ${comparator}: invalid patch version`,
-      ),
-      prerelease: prerelease ? parsePrerelease(prerelease) : [],
-      build: buildmetadata ? parseBuild(buildmetadata) : [],
-    }
-    : ANY;
-
-  return { operator: operator || undefined, ...semver };
+  const { operator } = groups as ComparatorRegExpGroup;
+  return { operator: operator || undefined, ...ANY };
 }
 
 function isWildcard(id?: string): boolean {
@@ -159,7 +137,6 @@ function parseHyphenRange(range: string): Comparator[] | null {
     new RegExp(`^${XRANGE}\\s*$`),
   );
   const rightGroups = rightMatch?.groups;
-  if (!rightGroups) return null;
 
   const from = handleLeftHyphenRangeGroups(leftGroup as RangeRegExpGroups);
   const to = handleRightHyphenRangeGroups(rightGroups as RangeRegExpGroups);
@@ -347,7 +324,15 @@ function handleEqualOperator(groups: RangeRegExpGroups): Comparator[] {
   }
   const prerelease = parsePrerelease(groups.prerelease ?? "");
   const build = parseBuild(groups.build ?? "");
-  return [{ operator: undefined, major, minor, patch, prerelease, build }];
+
+  return [{
+    operator: groups.operator === "=" ? "=" : undefined,
+    major,
+    minor,
+    patch,
+    prerelease,
+    build,
+  }];
 }
 
 function parseOperatorRange(string: string): Comparator | Comparator[] | null {
@@ -369,13 +354,8 @@ function parseOperatorRange(string: string): Comparator | Comparator[] | null {
       return handleGreaterThanOperator(groups);
     case ">=":
       return handleGreaterOrEqualOperator(groups);
-    case "=":
-    case "":
-      return handleEqualOperator(groups);
     default:
-      throw new Error(
-        `Cannot parse version range: '${groups.operator}' is not a valid operator`,
-      );
+      return handleEqualOperator(groups);
   }
 }
 function parseOperatorRanges(string: string): (Comparator | null)[] {
@@ -409,7 +389,7 @@ function parseOperatorRanges(string: string): (Comparator | null)[] {
 export function parseRange(value: string): Range {
   const result = value
     // remove spaces between operators and versions
-    .replaceAll(/(?<=<|>|=|~|\^)(\s+)/g, "")
+    .replaceAll(/(?<=[<>=~^])(\s+)/g, "")
     .split(/\s*\|\|\s*/)
     .map((string) => parseHyphenRange(string) || parseOperatorRanges(string));
   if (result.some((r) => r.includes(null))) {
diff --git a/semver/parse_range_test.ts b/semver/parse_range_test.ts
index a0d91ab52838..aec26ddf41e8 100644
--- a/semver/parse_range_test.ts
+++ b/semver/parse_range_test.ts
@@ -106,7 +106,7 @@ Deno.test("parseRange() parse ranges of different kinds", () => {
     ["=1.2.3", [
       [
         {
-          operator: undefined,
+          operator: "=",
           major: 1,
           minor: 2,
           patch: 3,
@@ -665,6 +665,12 @@ Deno.test("parseRange() throws on invalid range", () => {
     TypeError,
     'Cannot parse version range: range "blerg" is invalid',
   );
+
+  assertThrows(
+    () => parseRange("1.b.c"),
+    TypeError,
+    'Cannot parse version range: range "1.b.c" is invalid',
+  );
 });
 
 Deno.test("parseRange() handles wildcards", () => {
@@ -677,6 +683,10 @@ Deno.test("parseRange() handles wildcards", () => {
   assertEquals(parseRange("<1.*.*"), [
     [{ operator: "<", major: 1, minor: 0, patch: 0 }],
   ]);
+  // FIXME(kt3k): The following case should equal `[{ operator: "<", major: 2, minor: 0, patch: 0 }]`
+  assertEquals(parseRange("<=1.*.2"), [
+    [{ operator: "<", major: 1, minor: NaN, patch: 0 }],
+  ]);
   assertEquals(parseRange(">=1.*.0"), [
     [{ operator: ">=", major: 1, minor: 0, patch: 0 }],
   ]);