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

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

@@ -1 +0,0 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/compare.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAOzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CASZ"}

package/types/deps/jsr.io/@std/semver/0.224.3/constants.d.ts

@@ -1,43 +0,0 @@
-import type { Comparator, SemVer } from "./types.js";
-/**
- * MAX is a sentinel value used by some range calculations.
- * It is equivalent to `∞.∞.∞`.
- */
-export declare const MAX: SemVer;
-/**
- * The minimum valid SemVer object. Equivalent to `0.0.0`.
- */
-export declare const MIN: SemVer;
-/**
- * A sentinel value used to denote an invalid SemVer object
- * which may be the result of impossible ranges or comparator operations.
- * @example
- * ```ts
- * import { equals } from "@std/semver/equals";
- * import { parse } from "@std/semver/parse";
- * import { INVALID } from "@std/semver/constants"
- * equals(parse("1.2.3"), INVALID);
- * ```
- */
-export declare const INVALID: SemVer;
-/**
- * ANY is a sentinel value used by some range calculations. It is not a valid
- * SemVer object and should not be used directly.
- * @example
- * ```ts
- * import { equals } from "@std/semver/equals";
- * import { parse } from "@std/semver/parse";
- * import { ANY } from "@std/semver/constants"
- * equals(parse("1.2.3"), ANY); // false
- * ```
- */
-export declare const ANY: SemVer;
-/**
- * A comparator which will span all valid semantic versions
- */
-export declare const ALL: Comparator;
-/**
- * A comparator which will not span any semantic versions
- */
-export declare const NONE: Comparator;
-//# sourceMappingURL=constants.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/constants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,MAMjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE,MAMjB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,EAAE,MAMrB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG,EAAE,MAMjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE,UAGjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,UAGlB,CAAC"}

package/types/deps/jsr.io/@std/semver/0.224.3/difference.d.ts

@@ -1,27 +0,0 @@
-import type { ReleaseType, SemVer } from "./types.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 declare function difference(s0: SemVer, s1: SemVer): ReleaseType | undefined;
-//# sourceMappingURL=difference.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"difference.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/difference.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAU1E"}

package/types/deps/jsr.io/@std/semver/0.224.3/equals.d.ts

@@ -1,24 +0,0 @@
-import type { SemVer } from "./types.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 declare function equals(s0: SemVer, s1: SemVer): boolean;
-//# sourceMappingURL=equals.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/equals.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAEtD"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"format_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/format_range.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,YAAY,CAAC;AAOpD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAGhD"}

package/types/deps/jsr.io/@std/semver/0.224.3/greater_or_equal.d.ts

@@ -1,24 +0,0 @@
-import type { SemVer } from "./types.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 declare function greaterOrEqual(s0: SemVer, s1: SemVer): boolean;
-//# sourceMappingURL=greater_or_equal.d.ts.map

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

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

package/types/deps/jsr.io/@std/semver/0.224.3/greater_than.d.ts

@@ -1,24 +0,0 @@
-import type { SemVer } from "./types.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 declare function greaterThan(s0: SemVer, s1: SemVer): boolean;
-//# sourceMappingURL=greater_than.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"greater_than.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/greater_than.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE3D"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"increment.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/increment.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAkCtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW,EACpB,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CAyGR"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"is_range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.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/is_semver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is_semver.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.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,CAuBxD"}

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

@@ -1,24 +0,0 @@
-import type { SemVer } from "./types.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 declare function lessOrEqual(s0: SemVer, s1: SemVer): boolean;
-//# sourceMappingURL=less_or_equal.d.ts.map

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

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

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

@@ -1,24 +0,0 @@
-import type { SemVer } from "./types.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 declare function lessThan(s0: SemVer, s1: SemVer): boolean;
-//# sourceMappingURL=less_than.d.ts.map

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"max_satisfying.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.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/min_satisfying.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"min_satisfying.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.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/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/mod.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiRG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,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,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,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;AAEnC,8BAA8B;AAC9B,eAAO,MAAM,mBAAmB,UAAU,CAAC"}

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

@@ -1,23 +0,0 @@
-import type { SemVer } from "./types.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 declare function notEquals(s0: SemVer, s1: SemVer): boolean;
-//# sourceMappingURL=not_equals.d.ts.map

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

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

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

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

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

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

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

@@ -1,24 +0,0 @@
-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, assertFalse } from "@std/assert";
- *
- * const r0 = parseRange(">=1.0.0 <2.0.0");
- * const r1 = parseRange(">=1.0.0 <1.2.3");
- * const r2 = parseRange(">=1.2.3 <2.0.0");
- *
- * assert(rangeIntersects(r0, r1));
- * assert(rangeIntersects(r0, r2));
- * assertFalse(rangeIntersects(r1, r2));
- * ```
- *
- * @param r0 range 0
- * @param r1 range 1
- * @returns returns true if the given ranges intersect, false otherwise
- */
-export declare function rangeIntersects(r0: Range, r1: Range): boolean;
-//# sourceMappingURL=range_intersects.d.ts.map

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

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

package/types/deps/jsr.io/@std/semver/0.224.3/range_max.d.ts

@@ -1,25 +0,0 @@
-import type { Range, SemVer } from "./types.js";
-/**
- * The maximum valid SemVer for a given range or INVALID
- *
- * @example Usage
- * ```ts
- * import { parseRange } from "@std/semver/parse-range";
- * import { rangeMax } from "@std/semver/range-max";
- * import { equals } from "@std/semver/equals";
- * import { assert } from "@std/assert/assert";
- *
- * assert(equals(rangeMax(parseRange(">1.0.0 <=2.0.0")), { major: 2, minor: 0, patch: 0 }));
- * ```
- *
- * @param range The range to calculate the max for
- * @returns A valid SemVer or INVALID
- *
- * @deprecated This will be removed in 1.0.0. Use {@linkcode greaterThanRange} or
- * {@linkcode lessThanRange} for comparing ranges and SemVers. The maximum
- * version of a range is often not well defined, and therefore this API
- * shouldn't be used. See
- * {@link https://github.com/denoland/deno_std/issues/4365} for details.
- */
-export declare function rangeMax(range: Range): SemVer;
-//# sourceMappingURL=range_max.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"range_max.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/range_max.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAyC5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAU7C"}

package/types/deps/jsr.io/@std/semver/0.224.3/range_min.d.ts

@@ -1,25 +0,0 @@
-import type { Range, SemVer } from "./types.js";
-/**
- * The minimum valid SemVer for a given range or INVALID
- *
- * @example Usage
- * ```ts
- * import { parseRange } from "@std/semver/parse-range";
- * import { rangeMin } from "@std/semver/range-min";
- * import { equals } from "@std/semver/equals";
- * import { assert } from "@std/assert/assert";
- *
- * assert(equals(rangeMin(parseRange(">=1.0.0 <2.0.0")), { major: 1, minor: 0, patch: 0 }));
- * ```
- *
- * @param range The range to calculate the min for
- * @returns A valid SemVer or INVALID
- *
- * @deprecated This will be removed in 1.0.0. Use {@linkcode greaterThanRange} or
- * {@linkcode lessThanRange} for comparing ranges and SemVers. The minimum
- * version of a range is often not well defined, and therefore this API
- * shouldn't be used. See
- * {@link https://github.com/denoland/deno_std/issues/4365} for details.
- */
-export declare function rangeMin(range: Range): SemVer;
-//# sourceMappingURL=range_min.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"range_min.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/range_min.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAgC5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAU7C"}

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

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

package/types/deps/jsr.io/@std/semver/0.224.3/test_range.d.ts

@@ -1,27 +0,0 @@
-import type { Range, SemVer } from "./types.js";
-/**
- * Test to see if the version satisfies the range.
- *
- * @example Usage
- * ```ts
- * import { parse, parseRange, testRange } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
- *
- * const version = parse("1.2.3");
- * const range0 = parseRange(">=1.0.0 <2.0.0");
- * const range1 = parseRange(">=1.0.0 <1.3.0");
- * const range2 = parseRange(">=1.0.0 <1.2.3");
- *
- * assert(testRange(version, range0));
- * assert(testRange(version, range1));
- * assertFalse(testRange(version, range2));
- * ```
- * @param version The version to test
- * @param range The range to check
- * @returns true if the version is in the range
- *
- * @deprecated This will be removed in 1.0.0. Use {@linkcode satisfies}
- * instead. See https://github.com/denoland/deno_std/pull/4364.
- */
-export declare function testRange(version: SemVer, range: Range): boolean;
-//# sourceMappingURL=test_range.d.ts.map

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.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;;;GAGG;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,6BAA6B;IAC7B,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACjC,yBAAyB;IACzB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,KAAK,GAAG,UAAU,EAAE,EAAE,CAAC"}