@fedify/fedify 1.0.0-dev.410 → 1.0.0-dev.412

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/greater_than_range.d.ts

@@ -5,18 +5,19 @@ import type { Range, SemVer } from "./types.js";
  * @example Usage
  * ```ts
  * import { parse, parseRange, greaterThanRange } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
- * const v0 = parse("1.2.3");
- * const v1 = parse("1.2.4");
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
  * const range = parseRange(">=1.2.3 <1.2.4");
- * assertFalse(greaterThanRange(v0, range));
- * assert(greaterThanRange(v1, range));
+ *
+ * assert(!greaterThanRange(version1, range));
+ * assert(greaterThanRange(version2, range));
  * ```
  *
- * @param semver The version to check.
+ * @param version The version to check.
  * @param range The range to check against.
  * @returns `true` if the semver is greater than the range, `false` otherwise.
  */
-export declare function greaterThanRange(semver: SemVer, range: Range): boolean;
+export declare function greaterThanRange(version: SemVer, range: Range): boolean;
 //# sourceMappingURL=greater_than_range.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/greater_than_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater_than_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/greater_than_range.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAK5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAIvE"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/increment.d.ts

@@ -1,6 +1,13 @@
 import type { ReleaseType, SemVer } from "./types.js";
+/** Options for {@linkcode increment}. */
+export interface IncrementOptions {
+    /** The pre-release metadata of the new version. */
+    prerelease?: string;
+    /** The build metadata of the new version. */
+    build?: string;
+}
 /**
- * Returns the new version resulting from an increment by release type.
+ * Returns the new SemVer resulting from an increment by release type.
  *
  * `premajor`, `preminor` and `prepatch` will bump the version up to the next version,
  * based on the type, and will also add prerelease metadata.
@@ -23,7 +30,7 @@ import type { ReleaseType, SemVer } from "./types.js";
  * @example Usage
  * ```ts
  * import { increment, parse } from "@std/semver";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const version = parse("1.2.3");
  * assertEquals(increment(version, "major"), parse("2.0.0"));
@@ -37,9 +44,8 @@ import type { ReleaseType, SemVer } from "./types.js";
  *
  * @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 buildmetadata The build metadata of the new version
+ * @param options Additional options
  * @returns The new version
  */
-export declare function increment(version: SemVer, release: ReleaseType, prerelease?: string, buildmetadata?: string): SemVer;
+export declare function increment(version: SemVer, release: ReleaseType, options?: IncrementOptions): SemVer;
 //# sourceMappingURL=increment.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/increment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"increment.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/increment.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAkCtD,yCAAyC;AACzC,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CA2GR"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/is_range.d.ts

@@ -10,11 +10,11 @@ import type { Range } from "./types.js";
  * @example Usage
  * ```ts
  * import { isRange } from "@std/semver/is-range";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
  * const range = [[{ major: 1, minor: 2, patch: 3 }]];
  * assert(isRange(range));
- * assertFalse(isRange({}));
+ * assert(!isRange({}));
  * ```
  * @param value The value to check if its a valid Range
  * @returns True if its a valid Range otherwise false.

package/types/deps/jsr.io/@std/semver/1.0.3/is_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/is_range.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,YAAY,CAAC;AAmBpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAGtD"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/is_semver.d.ts

@@ -15,7 +15,7 @@ import type { SemVer } from "./types.js";
  * @example Usage
  * ```ts
  * import { isSemVer } from "@std/semver/is-semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
  * const value = {
  *   major: 1,
@@ -24,7 +24,7 @@ import type { SemVer } from "./types.js";
  * };
  *
  * assert(isSemVer(value));
- * assertFalse(isSemVer({ major: 1, minor: 2 }));
+ * assert(!isSemVer({ major: 1, minor: 2 }));
  * ```
  *
  * @param value The value to check to see if its a valid SemVer object

package/types/deps/jsr.io/@std/semver/1.0.3/is_semver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_semver.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/is_semver.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAsBxD"}

package/types/deps/jsr.io/@std/semver/1.0.3/less_or_equal.d.ts

@@ -0,0 +1,25 @@
+import type { SemVer } from "./types.js";
+/**
+ * Less than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) <= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(lessOrEqual(version1, version2));
+ * assert(!lessOrEqual(version2, version1));
+ * assert(lessOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 the first version to compare
+ * @param version2 the second version to compare
+ * @returns `true` if `version1` is less than or equal to `version2`, `false` otherwise
+ */
+export declare function lessOrEqual(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=less_or_equal.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/less_or_equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less_or_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/less_or_equal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEvE"}

package/types/deps/jsr.io/@std/semver/1.0.3/less_than.d.ts

@@ -0,0 +1,25 @@
+import type { SemVer } from "./types.js";
+/**
+ * Less than comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) < 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessThan } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(lessThan(version1, version2));
+ * assert(!lessThan(version2, version1));
+ * assert(!lessThan(version1, version1));
+ * ```
+ *
+ * @param version1 the first version to compare
+ * @param version2 the second version to compare
+ * @returns `true` if `version1` is less than `version2`, `false` otherwise
+ */
+export declare function lessThan(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=less_than.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/less_than.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less_than.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/less_than.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEpE"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/less_than_range.d.ts

@@ -5,18 +5,19 @@ import type { Range, SemVer } from "./types.js";
  * @example Usage
  * ```ts
  * import { parse, parseRange, lessThanRange } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
- * const v0 = parse("1.2.3");
- * const v1 = parse("1.0.0");
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.0.0");
  * const range = parseRange(">=1.2.3 <1.2.4");
- * assertFalse(lessThanRange(v0, range));
- * assert(lessThanRange(v1, range));
+ *
+ * assert(!lessThanRange(version1, range));
+ * assert(lessThanRange(version2, range));
  * ```
  *
- * @param semver The version to check.
+ * @param version The version to check.
  * @param range The range to check against.
  * @returns `true` if the SemVer is less than the range, `false` otherwise.
  */
-export declare function lessThanRange(semver: SemVer, range: Range): boolean;
+export declare function lessThanRange(version: SemVer, range: Range): boolean;
 //# sourceMappingURL=less_than_range.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/less_than_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less_than_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/less_than_range.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAK5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAIpE"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/max_satisfying.d.ts

@@ -1,12 +1,12 @@
 import type { Range, SemVer } from "./types.js";
 /**
- * Returns the highest version in the list that satisfies the range, or `undefined`
+ * Returns the highest SemVer 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";
+ * import { assertEquals } from "@std/assert";
  *
  * 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");

package/types/deps/jsr.io/@std/semver/1.0.3/max_satisfying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max_satisfying.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/max_satisfying.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,EAAE,KAAK,GACX,MAAM,GAAG,SAAS,CAOpB"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/min_satisfying.d.ts

@@ -1,12 +1,12 @@
 import type { Range, SemVer } from "./types.js";
 /**
- * Returns the lowest version in the list that satisfies the range, or `undefined` if
+ * Returns the lowest SemVer 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";
+ * import { assertEquals } from "@std/assert";
  *
  * 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");

package/types/deps/jsr.io/@std/semver/1.0.3/min_satisfying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"min_satisfying.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/min_satisfying.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,EAAE,KAAK,GACX,MAAM,GAAG,SAAS,CAOpB"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/mod.d.ts

@@ -11,7 +11,7 @@
  *   lessThan,
  *   format
  * } from "@std/semver";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const semver = parse("1.2.3");
  * assertEquals(semver, {
@@ -47,28 +47,28 @@
  * formatting options.
  *
  * ```
- *           ┌───── full
- *       ┌───┴───┐
- *       ├───────── release
- *   ┌───┴───┐   │
- *   ├───────────── primary
- * ┌─┴─┐     │   │
- * 1.2.3-pre.1+b.1
- * │ │ │ └─┬─┘ └┬┘
- * │ │ │   │    └── build
- * │ │ │   └─────── pre
- * │ │ └─────────── patch
- * │ └───────────── minor
- * └─────────────── major
+ *           full
+ *        ┌───┴───┐
+ *     release    │
+ *    ┌───┴───┐   │
+ * primary    │   │
+ *  ┌─┴─┐     │   │
+ *  1.2.3-pre.1+b.1
+ *  │ │ │ └─┬─┘ └┬┘
+ *  │ │ │   │    └── build
+ *  │ │ │   └─────── pre
+ *  │ │ └─────────── patch
+ *  │ └───────────── minor
+ *  └─────────────── major
  * ```
  *
  * ## Ranges
  *
- * A `version range` is a set of `comparators` which specify versions that satisfy
- * the range.
+ * A version {@linkcode Range} is a set of {@linkcode Comparator}s which specify
+ * versions that satisfy the range.
  *
- * A `comparator` is composed of an `operator` and a `version`. The set of
- * primitive `operators` is:
+ * A {@linkcode Comparator} is composed of an {@linkcode Operator} and a
+ * {@link SemVer}. The set of primitive `operators` is:
  *
  * - `<` Less than
  * - `<=` Less than or equal to
@@ -119,12 +119,14 @@
  *
  * #### Prerelease Identifiers
  *
- * The method `.increment` takes an additional `identifier` string argument that
- * will append the value of the string as a prerelease identifier:
+ * The method {@linkcode increment} takes an additional `identifier` string
+ * argument that will append the value of the string as a prerelease identifier:
  *
- * ```javascript
- * semver.increment(parse("1.2.3"), "prerelease", "beta");
- * // "1.2.4-beta.0"
+ * ```ts
+ * import { increment, parse } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(increment(parse("1.2.3"), "prerelease", { prerelease: "alpha" }), parse("1.2.4-alpha.0"));
  * ```
  *
  * ### Build Metadata
@@ -265,18 +267,12 @@
  *
  * If you want to know if a version satisfies or does not satisfy a range, use the
  * {@linkcode satisfies} function.
- *
- *
- *
-
  *
  * @module
  */
 export * from "./compare.js";
-export * from "./constants.js";
 export * from "./difference.js";
 export * from "./format.js";
-export * from "./test_range.js";
 export * from "./satisfies.js";
 export * from "./increment.js";
 export * from "./is_semver.js";
@@ -285,8 +281,6 @@ export * from "./min_satisfying.js";
 export * from "./parse_range.js";
 export * from "./parse.js";
 export * from "./range_intersects.js";
-export * from "./range_max.js";
-export * from "./range_min.js";
 export * from "./types.js";
 export * from "./try_parse_range.js";
 export * from "./is_range.js";
@@ -301,6 +295,4 @@ 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 declare const SEMVER_SPEC_VERSION = "2.0.0";
 //# sourceMappingURL=mod.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/mod.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+QG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

package/types/deps/jsr.io/@std/semver/1.0.3/not_equals.d.ts

@@ -0,0 +1,24 @@
+import type { SemVer } from "./types.js";
+/**
+ * Not equal comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) !== 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, notEquals } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(notEquals(version1, version2));
+ * assert(!notEquals(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is not equal to `version2`, `false` otherwise
+ */
+export declare function notEquals(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=not_equals.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/not_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/not_equals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAErE"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/parse.d.ts

@@ -1,12 +1,11 @@
 import type { SemVer } from "./types.js";
 /**
- * Attempt to parse a string as a semantic version, returning either a `SemVer`
- * object or throws a TypeError.
+ * Attempt to parse a string as a semantic version, returning a SemVer object.
  *
  * @example Usage
  * ```ts
  * import { parse } from "@std/semver/parse";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const version = parse("1.2.3");
  * assertEquals(version, {
@@ -18,8 +17,9 @@ import type { SemVer } from "./types.js";
  * });
  * ```
  *
- * @param version The version string to parse
+ * @throws {TypeError} If the input string is invalid.
+ * @param value The version string to parse
  * @returns A valid SemVer
  */
-export declare function parse(version: string): SemVer;
+export declare function parse(value: string): SemVer;
 //# sourceMappingURL=parse.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/parse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAqC3C"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/parse_range.d.ts

@@ -1,11 +1,11 @@
 import type { Range } from "./types.js";
 /**
- * Parses a range string into a Range object or throws a TypeError.
+ * Parses a range string into a {@linkcode Range} object.
  *
  * @example Usage
  * ```ts
  * import { parseRange } from "@std/semver/parse-range";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const range = parseRange(">=1.0.0 <2.0.0 || >=3.0.0");
  * assertEquals(range, [
@@ -19,8 +19,9 @@ import type { Range } from "./types.js";
  * ]);
  * ```
  *
- * @param range The range set string
- * @returns A valid semantic range
+ * @throws {TypeError} If the input range is invalid.
+ * @param value The range set string
+ * @returns A valid SemVer range
  */
-export declare function parseRange(range: string): Range;
+export declare function parseRange(value: string): Range;
 //# sourceMappingURL=parse_range.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/parse_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/parse_range.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAwB,KAAK,EAAE,MAAM,YAAY,CAAC;AAsX9D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAY/C"}

package/types/deps/jsr.io/@std/semver/1.0.3/range_intersects.d.ts

@@ -0,0 +1,25 @@
+import type { Range } from "./types.js";
+/**
+ * The ranges intersect every range of AND comparators intersects with a least
+ * one range of OR ranges.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseRange, rangeIntersects } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const range1 = parseRange(">=1.0.0 <2.0.0");
+ * const range2 = parseRange(">=1.0.0 <1.2.3");
+ * const range3 = parseRange(">=1.2.3 <2.0.0");
+ *
+ * assert(rangeIntersects(range1, range2));
+ * assert(rangeIntersects(range1, range3));
+ * assert(!rangeIntersects(range2, range3));
+ * ```
+ *
+ * @param range1 range 0
+ * @param range2 range 1
+ * @returns returns true if the given ranges intersect, false otherwise
+ */
+export declare function rangeIntersects(range1: Range, range2: Range): boolean;
+//# sourceMappingURL=range_intersects.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/range_intersects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range_intersects.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/range_intersects.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,YAAY,CAAC;AA8DpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAWrE"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/satisfies.d.ts

@@ -1,11 +1,11 @@
 import type { Range, SemVer } from "./types.js";
 /**
- * Test to see if the version satisfies the range.
+ * Test to see if the SemVer satisfies the range.
  *
  * @example Usage
  * ```ts
  * import { parse, parseRange, satisfies } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
  * const version = parse("1.2.3");
  * const range0 = parseRange(">=1.0.0 <2.0.0");
@@ -14,7 +14,7 @@ import type { Range, SemVer } from "./types.js";
  *
  * assert(satisfies(version, range0));
  * assert(satisfies(version, range1));
- * assertFalse(satisfies(version, range2));
+ * assert(!satisfies(version, range2));
  * ```
  * @param version The version to test
  * @param range The range to check

package/types/deps/jsr.io/@std/semver/1.0.3/satisfies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"satisfies.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/satisfies.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAEhE"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/try_parse.d.ts

@@ -1,11 +1,11 @@
 import type { SemVer } from "./types.js";
 /**
- * Returns the parsed version, or undefined if it's not valid.
+ * Returns the parsed SemVer, or `undefined` if it's not valid.
  *
  * @example Usage
  * ```ts
  * import { tryParse } from "@std/semver/try-parse";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(tryParse("1.2.3"), { major: 1, minor: 2, patch: 3, prerelease: [], build: [] });
  * assertEquals(tryParse("1.2.3-alpha"), { major: 1, minor: 2, patch: 3, prerelease: ["alpha"], build: [] });
@@ -14,8 +14,8 @@ import type { SemVer } from "./types.js";
  * assertEquals(tryParse(" invalid "), undefined);
  * ```
  *
- * @param version The version string to parse
+ * @param value The version string to parse
  * @returns A valid SemVer or `undefined`
  */
-export declare function tryParse(version?: string): SemVer | undefined;
+export declare function tryParse(value: string): SemVer | undefined;
 //# sourceMappingURL=try_parse.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/try_parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"try_parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/try_parse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM1D"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/try_parse_range.d.ts

@@ -16,8 +16,8 @@ import type { Range } from "./types.js";
  * ]);
  * ```
  *
- * @param range The range string
+ * @param value The range string
  * @returns A Range object if valid otherwise `undefined`
  */
-export declare function tryParseRange(range: string): Range | undefined;
+export declare function tryParseRange(value: string): Range | undefined;
 //# sourceMappingURL=try_parse_range.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.3/try_parse_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"try_parse_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/try_parse_range.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAQ9D"}

package/types/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/types.d.ts

@@ -8,8 +8,19 @@ export type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" |
  */
 export type Operator = undefined | "=" | "!=" | ">" | ">=" | "<" | "<=";
 /**
- * The shape of a valid semantic version comparator
- * @example >=0.0.0
+ * The shape of a valid SemVer comparator.
+ *
+ * @example Usage
+ * ```ts
+ * import type { Comparator } from "@std/semver/types";
+ *
+ * const comparator: Comparator = {
+ *   operator: ">",
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * }
+ * ```
  */
 export interface Comparator extends SemVer {
     /** The operator */
@@ -25,9 +36,17 @@ export interface SemVer {
     minor: number;
     /** The patch version */
     patch: number;
-    /** The prerelease version */
+    /**
+     * The prerelease version
+     *
+     * @default {[]}
+     */
     prerelease?: (string | number)[];
-    /** The build metadata */
+    /**
+     * The build metadata
+     *
+     * @default {[]}
+     */
     build?: string[];
 }
 /**

package/types/deps/jsr.io/@std/semver/1.0.3/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.3/types.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,MAAM,WAAW,GACnB,KAAK,GACL,OAAO,GACP,UAAU,GACV,OAAO,GACP,UAAU,GACV,OAAO,GACP,UAAU,GACV,YAAY,CAAC;AAEjB;;GAEG;AACH,MAAM,MAAM,QAAQ,GAChB,SAAS,GACT,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,CAAC;AAET;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAW,SAAQ,MAAM;IACxC,mBAAmB;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACjC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,KAAK,GAAG,UAAU,EAAE,EAAE,CAAC"}

package/types/nodeinfo/types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { type SemVer } from "../deps/jsr.io/@std/semver/0.224.3/mod.js";
+import { type SemVer } from "../deps/jsr.io/@std/semver/1.0.3/mod.js";
 /**
  * The type of the result of parsing JSON.
  */

package/types/nodeinfo/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/nodeinfo/types.ts"],"names":[],"mappings":";AAAA,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEhF;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAA;CAAE,GACxC,SAAS,EAAE,GACX,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,CAAC;AAET;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,QAAQ,EAAE,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,UAAU,CAAC,EAAE,GAAG,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAEhB,aAAa,GACb,YAAY,GACZ,MAAM,GACN,UAAU,GACV,WAAW,GACX,SAAS,GACT,QAAQ,GACR,MAAM,GACN,MAAM,GACN,KAAK,CAAC;AAEV;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;IAE3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GAEtB,SAAS,GACT,WAAW,GACX,MAAM,GACN,MAAM,GACN,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,SAAS,CAAC;AAEd;;;GAGG;AACH,MAAM,MAAM,eAAe,GAEvB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,WAAW,GACX,WAAW,GACX,QAAQ,GACR,eAAe,GACf,WAAW,GACX,UAAU,GACV,aAAa,GACb,aAAa,GACb,SAAS,GACT,WAAW,GACX,MAAM,GACN,WAAW,GACX,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,MAAM,GACN,MAAM,GACN,QAAQ,GACR,SAAS,GACT,WAAW,GACX,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,KAAK,EAAE;QACL;;;WAGG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;QAEf;;;WAGG;QACH,cAAc,CAAC,EAAE,MAAM,CAAC;QAExB;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CA8D5D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/nodeinfo/types.ts"],"names":[],"mappings":";AAAA,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,yCAAyC,CAAC;AAE9E;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAA;CAAE,GACxC,SAAS,EAAE,GACX,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,CAAC;AAET;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,QAAQ,EAAE,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,UAAU,CAAC,EAAE,GAAG,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAEhB,aAAa,GACb,YAAY,GACZ,MAAM,GACN,UAAU,GACV,WAAW,GACX,SAAS,GACT,QAAQ,GACR,MAAM,GACN,MAAM,GACN,KAAK,CAAC;AAEV;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;IAE3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GAEtB,SAAS,GACT,WAAW,GACX,MAAM,GACN,MAAM,GACN,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,SAAS,CAAC;AAEd;;;GAGG;AACH,MAAM,MAAM,eAAe,GAEvB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,WAAW,GACX,WAAW,GACX,QAAQ,GACR,eAAe,GACf,WAAW,GACX,UAAU,GACV,aAAa,GACb,aAAa,GACb,SAAS,GACT,WAAW,GACX,MAAM,GACN,WAAW,GACX,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,MAAM,GACN,MAAM,GACN,QAAQ,GACR,SAAS,GACT,WAAW,GACX,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,KAAK,EAAE;QACL;;;WAGG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;QAEf;;;WAGG;QACH,cAAc,CAAC,EAAE,MAAM,CAAC;QAExB;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CA8D5D"}

package/esm/deps/jsr.io/@std/semver/0.224.3/_constants.js

@@ -1,10 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-export const OPERATORS = [
-    undefined,
-    "=",
-    "!=",
-    ">",
-    ">=",
-    "<",
-    "<=",
-];