@fedify/fedify 0.9.0-dev.177 → 0.9.0-dev.181

package/CHANGES.md

@@ -8,6 +8,8 @@ Version 0.9.0
 
 To be released.
 
+ -  Added `Tombstone` class to Activity Vocabulary API.
+
  -  Added `Hashtag` class to Activity Vocabulary API.  [[#48]]
 
  -  Added `Emoji` class to Activity Vocabulary API.  [[#48]]
@@ -45,11 +47,22 @@ To be released.
      -  The signature of the `verify()` function is revamped; it now optionally
         takes a `VerifyOptions` object as the second parameter.
 
+ -  Renamed the `@fedify/fedify/httpsig` module to `@fedify/fedify/sig`, and
+    also:
+
+     -  Deprecated `sign()` function.  Use `signRequest()` instead.
+     -  Deprecated `verify()` function.  Use `verifyRequest()` instead.
+     -  Deprecated `VerifyOptions` interface.  Use `VerifyRequestOptions`
+        instead.
+
  -  Added more log messages using the [LogTape] library.  Currently the below
     logger categories are used:
 
      -  `["fedify", "federation", "actor"]`
      -  `["fedify", "federation", "http"]`
+     -  `["fedify", "sig", "http"]`
+     -  `["fedify", "sig", "key"]`
+     -  `["fedify", "sig", "owner"]`
 
 [#48]: https://github.com/dahlia/fedify/issues/48
 [#52]: https://github.com/dahlia/fedify/issues/52

package/esm/deps/jsr.io/@std/encoding/{0.224.2 → 0.224.3}/base64.js

@@ -12,15 +12,17 @@
  *   encodeBase64,
  *   decodeBase64,
  * } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert/assert-equals";
  *
- * const encoded = encodeBase64("foobar"); // "Zm9vYmFy"
+ * const foobar = new TextEncoder().encode("foobar");
  *
- * decodeBase64(encoded); // Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
+ * assertEquals(encodeBase64(foobar), "Zm9vYmFy");
+ * assertEquals(decodeBase64("Zm9vYmFy"), foobar);
  * ```
  *
  * @module
  */
-import { validateBinaryLike } from "./_util.js";
+import { validateBinaryLike } from "./_validate_binary_like.js";
 const base64abc = [
     "A",
     "B",
@@ -95,11 +97,12 @@ const base64abc = [
  * @param data The data to encode.
  * @returns The base64-encoded string.
  *
- * @example
+ * @example Usage
  * ```ts
  * import { encodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert/assert-equals";
  *
- * encodeBase64("foobar"); // "Zm9vYmFy"
+ * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
  * ```
  */
 export function encodeBase64(data) {
@@ -140,11 +143,15 @@ export function encodeBase64(data) {
  * @param b64 The base64-encoded string to decode.
  * @returns The decoded data.
  *
- * @example
+ * @example Usage
  * ```ts
  * import { decodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert/assert-equals";
  *
- * decodeBase64("Zm9vYmFy"); // Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
+ * assertEquals(
+ *   decodeBase64("Zm9vYmFy"),
+ *   new TextEncoder().encode("foobar")
+ * );
  * ```
  */
 export function decodeBase64(b64) {

package/esm/deps/jsr.io/@std/encoding/{0.224.2 → 0.224.3}/hex.js

@@ -14,15 +14,19 @@
  *   decodeHex,
  *   encodeHex,
  * } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert/assert-equals";
  *
- * const encoded = encodeHex("abc"); // "616263"
+ * assertEquals(encodeHex("abc"), "616263");
  *
- * decodeHex(encoded); // Uint8Array(3) [ 97, 98, 99 ]
+ * assertEquals(
+ *   decodeHex("616263"),
+ *   new TextEncoder().encode("abc"),
+ * );
  * ```
  *
  * @module
  */
-import { validateBinaryLike } from "./_util.js";
+import { validateBinaryLike } from "./_validate_binary_like.js";
 const hexTable = new TextEncoder().encode("0123456789abcdef");
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -48,11 +52,16 @@ function fromHexChar(byte) {
 /**
  * Converts data into a hex-encoded string.
  *
- * @example
+ * @param src The data to encode.
+ *
+ * @returns The hex-encoded string.
+ *
+ * @example Usage
  * ```ts
  * import { encodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert/assert-equals";
  *
- * encodeHex("abc"); // "616263"
+ * assertEquals(encodeHex("abc"), "616263");
  * ```
  */
 export function encodeHex(src) {
@@ -69,11 +78,19 @@ export function encodeHex(src) {
  * Decodes the given hex-encoded string. If the input is malformed, an error is
  * thrown.
  *
- * @example
+ * @param src The hex-encoded string to decode.
+ *
+ * @returns The decoded data.
+ *
+ * @example Usage
  * ```ts
  * import { decodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert/assert-equals";
  *
- * decodeHex("616263"); // Uint8Array(3) [ 97, 98, 99 ]
+ * assertEquals(
+ *   decodeHex("616263"),
+ *   new TextEncoder().encode("abc"),
+ * );
  * ```
  */
 export function decodeHex(src) {

package/esm/deps/jsr.io/@std/semver/0.224.1/can_parse.js

@@ -0,0 +1,30 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { parse } from "./parse.js";
+/**
+ * Returns true if the string can be parsed as SemVer.
+ *
+ * @example Usage
+ * ```ts
+ * import { canParse } from "@std/semver/can-parse";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(canParse("1.2.3"));
+ * assertFalse(canParse("invalid"));
+ * ```
+ *
+ * @param version The version string to check
+ * @returns `true` if the string can be parsed as SemVer, `false` otherwise
+ */
+export function canParse(version) {
+    try {
+        parse(version);
+        return true;
+    }
+    catch (err) {
+        if (!(err instanceof TypeError)) {
+            throw err;
+        }
+        return false;
+    }
+}

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/compare.js

@@ -6,6 +6,23 @@ import { checkIdentifier, compareIdentifier, compareNumber, } from "./_shared.js
  * greater.
  *
  * Sorts in ascending order if passed to `Array.sort()`,
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, compare } from "@std/semver";
+ * import { assertEquals } from "@std/assert/assert-equals";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.4");
+ *
+ * assertEquals(compare(s0, s1), -1);
+ * assertEquals(compare(s1, s0), 1);
+ * assertEquals(compare(s0, s0), 0);
+ * ```
+ *
+ * @param s0 The first SemVer to compare
+ * @param s1 The second SemVer to compare
+ * @returns `1` if `s0` is greater, `0` if equal, or `-1` if `s1` is greater
  */
 export function compare(s0, s1) {
     if (s0 === s1)

package/esm/deps/jsr.io/@std/semver/0.224.1/difference.js

@@ -0,0 +1,37 @@
+import { compareIdentifier } from "./_shared.js";
+/**
+ * Returns difference between two versions by the release type,
+ * or `undefined` if the versions are the same.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, difference } from "@std/semver";
+ * import { assertEquals } from "@std/assert/assert-equals";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.4");
+ * const s2 = parse("1.3.0");
+ * const s3 = parse("2.0.0");
+ *
+ * assertEquals(difference(s0, s1), "patch");
+ * assertEquals(difference(s0, s2), "minor");
+ * assertEquals(difference(s0, s3), "major");
+ * assertEquals(difference(s0, s0), undefined);
+ * ```
+ *
+ * @param s0 The first SemVer to compare
+ * @param s1 The second SemVer to compare
+ * @returns The release type difference or `undefined` if the versions are the same
+ */
+export function difference(s0, s1) {
+    const hasPrerelease = s0.prerelease?.length || s1.prerelease?.length;
+    if (s0.major !== s1.major)
+        return hasPrerelease ? "premajor" : "major";
+    if (s0.minor !== s1.minor)
+        return hasPrerelease ? "preminor" : "minor";
+    if (s0.patch !== s1.patch)
+        return hasPrerelease ? "prepatch" : "patch";
+    if (compareIdentifier(s0.prerelease, s1.prerelease) !== 0) {
+        return "prerelease";
+    }
+}

package/esm/deps/jsr.io/@std/semver/0.224.1/equals.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { compare } from "./compare.js";
+/**
+ * Returns `true` if both semantic versions are logically equivalent, even if they're not the exact same version object.
+ *
+ * This is equal to `compare(s0, s1) === 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, equals } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.3");
+ *
+ * assert(equals(s0, s1));
+ * assertFalse(equals(s0, parse("1.2.4")));
+ * ```
+ *
+ * @param s0 The first SemVer to compare
+ * @param s1 The second SemVer to compare
+ * @returns `true` if `s0` is equal to `s1`, `false` otherwise
+ */
+export function equals(s0, s1) {
+    return compare(s0, s1) === 0;
+}

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/format.js

@@ -17,7 +17,20 @@ function formatNumber(value) {
  *
  * If any number is positive or negative infinity then '∞' or '⧞' will be printed instead.
  *
- * @param semver The semantic version to format
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/semver/format";
+ * import { assertEquals } from "@std/assert/assert-equals";
+ *
+ * const semver = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ * assertEquals(format(semver), "1.2.3");
+ * ```
+ *
+ * @param semver The SemVer to format
  * @returns The string representation of a semantic version.
  */
 export function format(semver) {

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/format_range.js

@@ -7,7 +7,15 @@ function formatComparator(comparator) {
 }
 /**
  * Formats the range into a string
- * @example >=0.0.0 || <1.0.0
+ * @example Usage
+ * ```ts
+ * import { formatRange, parseRange } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ * assertEquals(formatRange(range), ">=1.2.3 <1.2.4");
+ * ```
+ *
  * @param range The range to format
  * @returns A string representation of the range
  */

package/esm/deps/jsr.io/@std/semver/0.224.1/greater_or_equal.js

@@ -0,0 +1,25 @@
+import { compare } from "./compare.js";
+/**
+ * Greater than or equal to comparison
+ *
+ * This is equal to `compare(s0, s1) >= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterOrEqual } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.4");
+ * assert(greaterOrEqual(s1, s0));
+ * assertFalse(greaterOrEqual(s0, s1));
+ * assert(greaterOrEqual(s0, s0));
+ * ```
+ *
+ * @param s0 The first version to compare
+ * @param s1 The second version to compare
+ * @returns `true` if `s0` is greater than or equal to `s1`, `false` otherwise
+ */
+export function greaterOrEqual(s0, s1) {
+    return compare(s0, s1) >= 0;
+}

package/esm/deps/jsr.io/@std/semver/0.224.1/greater_than.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { compare } from "./compare.js";
+/**
+ * Greater than comparison
+ *
+ * This is equal to `compare(s0, s1) > 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterThan } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.4");
+ * assert(greaterThan(s1, s0));
+ * assertFalse(greaterThan(s0, s1));
+ * assertFalse(greaterThan(s0, s0));
+ * ```
+ *
+ * @param s0 The first version to compare
+ * @param s1 The second version to compare
+ * @returns `true` if `s0` is greater than `s1`, `false` otherwise
+ */
+export function greaterThan(s0, s1) {
+    return compare(s0, s1) > 0;
+}

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/greater_than_range.js

@@ -3,7 +3,25 @@
 import { testComparatorSet } from "./_test_comparator_set.js";
 import { isWildcardComparator } from "./_shared.js";
 import { compare } from "./compare.js";
-/** Check if the semver is greater than the range. */
+/**
+ * Check if the SemVer is greater than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, greaterThanRange } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const v0 = parse("1.2.3");
+ * const v1 = parse("1.2.4");
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ * assertFalse(greaterThanRange(v0, range));
+ * assert(greaterThanRange(v1, range));
+ * ```
+ *
+ * @param semver The version to check.
+ * @param range The range to check against.
+ * @returns `true` if the semver is greater than the range, `false` otherwise.
+ */
 export function greaterThanRange(semver, range) {
     return range.every((comparatorSet) => greaterThanComparatorSet(semver, comparatorSet));
 }

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/increment.js

@@ -48,11 +48,27 @@ function bumpPrerelease(prerelease = [], identifier) {
  * If the input version has build metadata it will be preserved on the resulting version
  * unless a new build parameter is specified. Specifying `""` will unset existing build
  * metadata.
+ *
+ * @example Usage
+ * ```ts
+ * import { increment, parse } from "@std/semver";
+ * import { assertEquals } from "@std/assert/assert-equals";
+ *
+ * const version = parse("1.2.3");
+ * assertEquals(increment(version, "major"), parse("2.0.0"));
+ * assertEquals(increment(version, "minor"), parse("1.3.0"));
+ * assertEquals(increment(version, "patch"), parse("1.2.4"));
+ * assertEquals(increment(version, "prerelease"), parse("1.2.4-0"));
+ *
+ * const prerelease = parse("1.2.3-beta.0");
+ * assertEquals(increment(prerelease, "prerelease"), parse("1.2.3-beta.1"));
+ * ```
+ *
  * @param version The version to increment
  * @param release The type of increment to perform
  * @param prerelease The pre-release metadata of the new version
- * @param build The build metadata of the new version
- * @returns
+ * @param buildmetadata The build metadata of the new version
+ * @returns The new version
  */
 export function increment(version, release, prerelease, buildmetadata) {
     const build = buildmetadata !== undefined

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/is_range.js

@@ -19,6 +19,16 @@ function isComparator(value) {
  * least the correct fields.
  *
  * Adds a type assertion if true.
+ *
+ * @example Usage
+ * ```ts
+ * import { isRange } from "@std/semver/is-range";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const range = [[{ major: 1, minor: 2, patch: 3 }]];
+ * assert(isRange(range));
+ * assertFalse(isRange({}));
+ * ```
  * @param value The value to check if its a valid Range
  * @returns True if its a valid Range otherwise false.
  */

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/is_semver.js

@@ -14,6 +14,22 @@ import { isValidNumber, isValidString } from "./_shared.js";
  * considered SemVer objects and this will return true.
  *
  * A type assertion is added to the value.
+ *
+ * @example Usage
+ * ```ts
+ * import { isSemVer } from "@std/semver/is-semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const value = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ *
+ * assert(isSemVer(value));
+ * assertFalse(isSemVer({ major: 1, minor: 2 }));
+ * ```
+ *
  * @param value The value to check to see if its a valid SemVer object
  * @returns True if value is a valid SemVer otherwise false
  */

package/esm/deps/jsr.io/@std/semver/0.224.1/less_or_equal.js

@@ -0,0 +1,25 @@
+import { compare } from "./compare.js";
+/**
+ * Less than or equal to comparison
+ *
+ * This is equal to `compare(s0, s1) <= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessOrEqual } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.4");
+ * assert(lessOrEqual(s0, s1));
+ * assertFalse(lessOrEqual(s1, s0));
+ * assert(lessOrEqual(s0, s0));
+ * ```
+ *
+ * @param s0 the first version to compare
+ * @param s1 the second version to compare
+ * @returns `true` if `s0` is less than or equal to `s1`, `false` otherwise
+ */
+export function lessOrEqual(s0, s1) {
+    return compare(s0, s1) <= 0;
+}

package/esm/deps/jsr.io/@std/semver/0.224.1/less_than.js

@@ -0,0 +1,25 @@
+import { compare } from "./compare.js";
+/**
+ * Less than comparison
+ *
+ * This is equal to `compare(s0, s1) < 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessThan } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.4");
+ * assert(lessThan(s0, s1));
+ * assertFalse(lessThan(s1, s0));
+ * assertFalse(lessThan(s0, s0));
+ * ```
+ *
+ * @param s0 the first version to compare
+ * @param s1 the second version to compare
+ * @returns `true` if `s0` is less than `s1`, `false` otherwise
+ */
+export function lessThan(s0, s1) {
+    return compare(s0, s1) < 0;
+}

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/less_than_range.js

@@ -3,7 +3,25 @@
 import { testComparatorSet } from "./_test_comparator_set.js";
 import { isWildcardComparator } from "./_shared.js";
 import { compare } from "./compare.js";
-/** Check if the semver is less than the range. */
+/**
+ * Check if the SemVer is less than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, lessThanRange } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const v0 = parse("1.2.3");
+ * const v1 = parse("1.0.0");
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ * assertFalse(lessThanRange(v0, range));
+ * assert(lessThanRange(v1, range));
+ * ```
+ *
+ * @param semver The version to check.
+ * @param range The range to check against.
+ * @returns `true` if the SemVer is less than the range, `false` otherwise.
+ */
 export function lessThanRange(semver, range) {
     return range.every((comparatorSet) => lessThanComparatorSet(semver, comparatorSet));
 }
@@ -11,10 +29,10 @@ function lessThanComparatorSet(semver, comparatorSet) {
     // If the comparator set contains wildcard, then the semver is not greater than the range.
     if (comparatorSet.some(isWildcardComparator))
         return false;
-    // If the semver satisfies the comparator set, then it's not less than the range.
+    // If the SemVer satisfies the comparator set, then it's not less than the range.
     if (testComparatorSet(semver, comparatorSet))
         return false;
-    // If the semver is greater than any of the comparator set, then it's not less than the range.
+    // If the SemVer is greater than any of the comparator set, then it's not less than the range.
     if (comparatorSet.some((comparator) => greaterThanComparator(semver, comparator)))
         return false;
     return true;

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/max_satisfying.js

@@ -3,6 +3,18 @@ import { greaterThan } from "./greater_than.js";
 /**
  * Returns the highest version in the list that satisfies the range, or `undefined`
  * if none of them do.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, maxSatisfying } from "@std/semver";
+ * import { assertEquals } from "@std/assert/assert-equals";
+ *
+ * const versions = ["1.2.3", "1.2.4", "1.3.0", "2.0.0", "2.1.0"].map(parse);
+ * const range = parseRange(">=1.0.0 <2.0.0");
+ *
+ * assertEquals(maxSatisfying(versions, range), parse("1.3.0"));
+ * ```
+ *
  * @param versions The versions to check.
  * @param range The range of possible versions to compare to.
  * @returns The highest version in versions that satisfies the range.

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/min_satisfying.js

@@ -3,6 +3,18 @@ import { lessThan } from "./less_than.js";
 /**
  * Returns the lowest version in the list that satisfies the range, or `undefined` if
  * none of them do.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, minSatisfying } from "@std/semver";
+ * import { assertEquals } from "@std/assert/assert-equals";
+ *
+ * const versions = ["0.2.0", "1.2.3", "1.3.0", "2.0.0", "2.1.0"].map(parse);
+ * const range = parseRange(">=1.0.0 <2.0.0");
+ *
+ * assertEquals(minSatisfying(versions, range), parse("1.2.3"));
+ * ```
+ *
  * @param versions The versions to check.
  * @param range The range of possible versions to compare to.
  * @returns The lowest version in versions that satisfies the range.

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/mod.js

@@ -104,8 +104,8 @@
  *
  * Build metadata is `.` delimited alpha-numeric string.
  * When parsing a version it is retained on the `build: string[]` field
- * of the semver instance. When incrementing there is an additional parameter that
- * can set the build metadata on the semver instance.
+ * of the SemVer instance. When incrementing there is an additional parameter that
+ * can set the build metadata on the SemVer instance.
  *
  * ### Advanced Range Syntax
  *
@@ -293,4 +293,5 @@ export * from "./greater_or_equal.js";
 export * from "./less_than.js";
 export * from "./less_than_range.js";
 export * from "./less_or_equal.js";
+/** The SemVer spec version */
 export const SEMVER_SPEC_VERSION = "2.0.0";

package/esm/deps/jsr.io/@std/semver/0.224.1/not_equals.js

@@ -0,0 +1,24 @@
+import { compare } from "./compare.js";
+/**
+ * Not equal comparison
+ *
+ * This is equal to `compare(s0, s1) !== 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, notEquals } from "@std/semver";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * const s0 = parse("1.2.3");
+ * const s1 = parse("1.2.4");
+ * assert(notEquals(s0, s1));
+ * assertFalse(notEquals(s0, s0));
+ * ```
+ *
+ * @param s0 The first version to compare
+ * @param s1 The second version to compare
+ * @returns `true` if `s0` is not equal to `s1`, `false` otherwise
+ */
+export function notEquals(s0, s1) {
+    return compare(s0, s1) !== 0;
+}

package/esm/deps/jsr.io/@std/semver/{0.224.0 → 0.224.1}/parse.js

@@ -3,6 +3,22 @@ import { FULL_REGEXP, MAX_LENGTH } from "./_shared.js";
 /**
  * Attempt to parse a string as a semantic version, returning either a `SemVer`
  * object or throws a TypeError.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/semver/parse";
+ * import { assertEquals } from "@std/assert/assert-equals";
+ *
+ * const version = parse("1.2.3");
+ * assertEquals(version, {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ *   prerelease: [],
+ *   build: [],
+ * });
+ * ```
+ *
  * @param version The version string to parse
  * @returns A valid SemVer
  */