@fedify/fedify 1.6.0-dev.812 → 1.6.0-dev.814

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

@@ -1,25 +0,0 @@
-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.5/less_than.d.ts.map

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

@@ -1,23 +0,0 @@
-import type { Range, SemVer } from "./types.js";
-/**
- * Check if the SemVer is less than the range.
- *
- * @example Usage
- * ```ts
- * import { parse, parseRange, lessThanRange } from "@std/semver";
- * import { assert } from "@std/assert";
- *
- * const version1 = parse("1.2.3");
- * const version2 = parse("1.0.0");
- * const range = parseRange(">=1.2.3 <1.2.4");
- *
- * assert(!lessThanRange(version1, range));
- * assert(lessThanRange(version2, range));
- * ```
- *
- * @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(version: SemVer, range: Range): boolean;
-//# sourceMappingURL=less_than_range.d.ts.map

package/types/deps/jsr.io/@std/semver/1.0.5/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/1.0.5/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/1.0.5/max_satisfying.d.ts

@@ -1,22 +0,0 @@
-import type { Range, SemVer } from "./types.js";
-/**
- * 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";
- *
- * 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.
- */
-export declare function maxSatisfying(versions: SemVer[], range: Range): SemVer | undefined;
-//# sourceMappingURL=max_satisfying.d.ts.map

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

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

@@ -1,22 +0,0 @@
-import type { Range, SemVer } from "./types.js";
-/**
- * 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";
- *
- * 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.
- */
-export declare function minSatisfying(versions: SemVer[], range: Range): SemVer | undefined;
-//# sourceMappingURL=min_satisfying.d.ts.map

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

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

@@ -1,298 +0,0 @@
-/**
- * The Semantic Version parser.
- *
- * Adapted directly from {@link https://github.com/npm/node-semver | semver}.
- *
- * ```ts
- * import {
- *   parse,
- *   parseRange,
- *   greaterThan,
- *   lessThan,
- *   format
- * } from "@std/semver";
- * import { assertEquals } from "@std/assert";
- *
- * const semver = parse("1.2.3");
- * assertEquals(semver, {
- *   major: 1,
- *   minor: 2,
- *   patch: 3,
- *   prerelease: [],
- *   build: []
- * });
- *
- * assertEquals(format(semver), "1.2.3");
- *
- * const range = parseRange("1.x || >=2.5.0 || 5.0.0 - 7.2.3");
- *
- * const s0 = parse("1.2.3");
- * const s1 = parse("9.8.7");
- *
- * assertEquals(greaterThan(s0, s1), false);
- * assertEquals(lessThan(s0, s1), true);
- * ```
- *
- * ## Versions
- *
- * A "version" is described by the `v2.0.0` specification found at
- * <https://semver.org>.
- *
- * A leading `"="` or `"v"` character is stripped off and ignored.
- *
- * ## Format
- *
- * Semantic versions can be formatted as strings, by default they
- * are formatted as `full`. Below is a diagram showing the various
- * formatting options.
- *
- * ```
- *           full
- *        ┌───┴───┐
- *     release    │
- *    ┌───┴───┐   │
- * primary    │   │
- *  ┌─┴─┐     │   │
- *  1.2.3-pre.1+b.1
- *  │ │ │ └─┬─┘ └┬┘
- *  │ │ │   │    └── build
- *  │ │ │   └─────── pre
- *  │ │ └─────────── patch
- *  │ └───────────── minor
- *  └─────────────── major
- * ```
- *
- * ## Ranges
- *
- * A version {@linkcode Range} is a set of {@linkcode Comparator}s which specify
- * versions that satisfy the range.
- *
- * 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
- * - `>` Greater than
- * - `>=` Greater than or equal to
- * - `=` Equal. If no operator is specified, then equality is assumed, so this
- *   operator is optional, but MAY be included.
- *
- * For example, the comparator `>=1.2.7` would match the versions `1.2.7`, `1.2.8`,
- * `2.5.3`, and `1.3.9`, but not the versions `1.2.6` or `1.1.0`.
- *
- * Comparators can be joined by whitespace to form a `comparator set`, which is
- * satisfied by the **intersection** of all of the comparators it includes.
- *
- * A range is composed of one or more comparator sets, joined by `||`. A version
- * matches a range if and only if every comparator in at least one of the
- * `||`-separated comparator sets is satisfied by the version.
- *
- * For example, the range `>=1.2.7 <1.3.0` would match the versions `1.2.7`,
- * `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`, or `1.1.0`.
- *
- * The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`, `1.2.9`,
- * and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
- *
- * ### Prerelease Tags
- *
- * If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then it will
- * only be allowed to satisfy comparator sets if at least one comparator with the
- * same `[major, minor, patch]` tuple also has a prerelease tag.
- *
- * For example, the range `>1.2.3-alpha.3` would be allowed to match the version
- * `1.2.3-alpha.7`, but it would _not_ be satisfied by `3.4.5-alpha.9`, even though
- * `3.4.5-alpha.9` is technically "greater than" `1.2.3-alpha.3` according to the
- * SemVer sort rules. The version range only accepts prerelease tags on the `1.2.3`
- * version. The version `3.4.5` _would_ satisfy the range, because it does not have
- * a prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
- *
- * The purpose for this behavior is twofold. First, prerelease versions frequently
- * are updated very quickly, and contain many breaking changes that are (by the
- * author"s design) not yet fit for public consumption. Therefore, by default, they
- * are excluded from range matching semantics.
- *
- * Second, a user who has opted into using a prerelease version has clearly
- * indicated the intent to use _that specific_ set of alpha/beta/rc versions. By
- * including a prerelease tag in the range, the user is indicating that they are
- * aware of the risk. However, it is still not appropriate to assume that they have
- * opted into taking a similar risk on the _next_ set of prerelease versions.
- *
- * #### Prerelease Identifiers
- *
- * The method {@linkcode increment} takes an additional `identifier` string
- * argument that will append the value of the string as a prerelease identifier:
- *
- * ```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
- *
- * 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.
- *
- * ### Advanced Range Syntax
- *
- * Advanced range syntax desugars to primitive comparators in deterministic ways.
- *
- * Advanced ranges may be combined in the same way as primitive comparators using
- * white space or `||`.
- *
- * #### Hyphen Ranges `X.Y.Z - A.B.C`
- *
- * Specifies an inclusive set.
- *
- * - `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
- *
- * If a partial version is provided as the first version in the inclusive range,
- * then the missing pieces are replaced with zeroes.
- *
- * - `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
- *
- * If a partial version is provided as the second version in the inclusive range,
- * then all versions that start with the supplied parts of the tuple are accepted,
- * but nothing that would be greater than the provided tuple parts.
- *
- * - `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
- * - `1.2.3 - 2` := `>=1.2.3 <3.0.0`
- *
- * #### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
- *
- * Any of `X`, `x`, or `*` may be used to "stand in" for one of the numeric values
- * in the `[major, minor, patch]` tuple.
- *
- * - `*` := `>=0.0.0` (Any version satisfies)
- * - `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
- * - `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
- *
- * A partial version range is treated as an X-Range, so the special character is in
- * fact optional.
- *
- * - `""` (empty string) := `*` := `>=0.0.0`
- * - `1` := `1.x.x` := `>=1.0.0 <2.0.0`
- * - `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
- *
- * #### Tilde Ranges `~1.2.3` `~1.2` `~1`
- *
- * Allows patch-level changes if a minor version is specified on the comparator.
- * Allows minor-level changes if not.
- *
- * - `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
- * - `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
- * - `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
- * - `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
- * - `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
- * - `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
- * - `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in the
- *   `1.2.3` version will be allowed, if they are greater than or equal to
- *   `beta.2`. So, `1.2.3-beta.4` would be allowed, but `1.2.4-beta.2` would not,
- *   because it is a prerelease of a different `[major, minor, patch]` tuple.
- *
- * #### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
- *
- * Allows changes that do not modify the left-most non-zero element in the
- * `[major, minor, patch]` tuple. In other words, this allows patch and minor
- * updates for versions `1.0.0` and above, patch updates for versions
- * `0.X >=0.1.0`, and _no_ updates for versions `0.0.X`.
- *
- * Many authors treat a `0.x` version as if the `x` were the major
- * "breaking-change" indicator.
- *
- * Caret ranges are ideal when an author may make breaking changes between `0.2.4`
- * and `0.3.0` releases, which is a common practice. However, it presumes that
- * there will _not_ be breaking changes between `0.2.4` and `0.2.5`. It allows for
- * changes that are presumed to be additive (but non-breaking), according to
- * commonly observed practices.
- *
- * - `^1.2.3` := `>=1.2.3 <2.0.0`
- * - `^0.2.3` := `>=0.2.3 <0.3.0`
- * - `^0.0.3` := `>=0.0.3 <0.0.4`
- * - `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in the
- *   `1.2.3` version will be allowed, if they are greater than or equal to
- *   `beta.2`. So, `1.2.3-beta.4` would be allowed, but `1.2.4-beta.2` would not,
- *   because it is a prerelease of a different `[major, minor, patch]` tuple.
- * - `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the `0.0.3`
- *   version _only_ will be allowed, if they are greater than or equal to `beta`.
- *   So, `0.0.3-pr.2` would be allowed.
- *
- * When parsing caret ranges, a missing `patch` value desugars to the number `0`,
- * but will allow flexibility within that value, even if the major and minor
- * versions are both `0`.
- *
- * - `^1.2.x` := `>=1.2.0 <2.0.0`
- * - `^0.0.x` := `>=0.0.0 <0.1.0`
- * - `^0.0` := `>=0.0.0 <0.1.0`
- *
- * A missing `minor` and `patch` values will desugar to zero, but also allow
- * flexibility within those values, even if the major version is zero.
- *
- * - `^1.x` := `>=1.0.0 <2.0.0`
- * - `^0.x` := `>=0.0.0 <1.0.0`
- *
- * ### Range Grammar
- *
- * Putting all this together, here is a Backus-Naur grammar for ranges, for the
- * benefit of parser authors:
- *
- * ```bnf
- * range-set  ::= range ( logical-or range ) *
- * logical-or ::= ( " " ) * "||" ( " " ) *
- * range      ::= hyphen | simple ( " " simple ) * | ""
- * hyphen     ::= partial " - " partial
- * simple     ::= primitive | partial | tilde | caret
- * primitive  ::= ( "<" | ">" | ">=" | "<=" | "=" ) partial
- * partial    ::= xr ( "." xr ( "." xr qualifier ? )? )?
- * xr         ::= "x" | "X" | "*" | nr
- * nr         ::= "0" | ["1"-"9"] ( ["0"-"9"] ) *
- * tilde      ::= "~" partial
- * caret      ::= "^" partial
- * qualifier  ::= ( "-" pre )? ( "+" build )?
- * pre        ::= parts
- * build      ::= parts
- * parts      ::= part ( "." part ) *
- * part       ::= nr | [-0-9A-Za-z]+
- * ```
- *
- * Note that, since ranges may be non-contiguous, a version might not be greater
- * than a range, less than a range, _or_ satisfy a range! For example, the range
- * `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9` until `2.0.0`, so the
- * version `1.2.10` would not be greater than the range (because `2.0.1` satisfies,
- * which is higher), nor less than the range (since `1.2.8` satisfies, which is
- * lower), and it also does not satisfy the range.
- *
- * 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 "./difference.js";
-export * from "./format.js";
-export * from "./satisfies.js";
-export * from "./increment.js";
-export * from "./is_semver.js";
-export * from "./max_satisfying.js";
-export * from "./min_satisfying.js";
-export * from "./parse_range.js";
-export * from "./parse.js";
-export * from "./range_intersects.js";
-export * from "./types.js";
-export * from "./try_parse_range.js";
-export * from "./is_range.js";
-export * from "./can_parse.js";
-export * from "./try_parse.js";
-export * from "./format_range.js";
-export * from "./equals.js";
-export * from "./not_equals.js";
-export * from "./greater_than.js";
-export * from "./greater_than_range.js";
-export * from "./greater_or_equal.js";
-export * from "./less_than.js";
-export * from "./less_than_range.js";
-export * from "./less_or_equal.js";
-//# sourceMappingURL=mod.d.ts.map

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

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

@@ -1,24 +0,0 @@
-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.5/not_equals.d.ts.map

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

@@ -1,25 +0,0 @@
-import type { SemVer } from "./types.js";
-/**
- * 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";
- *
- * const version = parse("1.2.3");
- * assertEquals(version, {
- *   major: 1,
- *   minor: 2,
- *   patch: 3,
- *   prerelease: [],
- *   build: [],
- * });
- * ```
- *
- * @throws {TypeError} If the input string is invalid.
- * @param value The version string to parse
- * @returns A valid SemVer
- */
-export declare function parse(value: string): SemVer;
-//# sourceMappingURL=parse.d.ts.map

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

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

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

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

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

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

@@ -1,25 +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 } 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.5/range_intersects.d.ts.map

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

@@ -1,24 +0,0 @@
-import type { Range, SemVer } from "./types.js";
-/**
- * Test to see if the SemVer satisfies the range.
- *
- * @example Usage
- * ```ts
- * import { parse, parseRange, satisfies } from "@std/semver";
- * import { assert } 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(satisfies(version, range0));
- * assert(satisfies(version, range1));
- * assert(!satisfies(version, range2));
- * ```
- * @param version The version to test
- * @param range The range to check
- * @returns true if the version is in the range
- */
-export declare function satisfies(version: SemVer, range: Range): boolean;
-//# sourceMappingURL=satisfies.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"satisfies.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.5/satisfies.ts"],"names":[],"mappings":"AAGA,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/1.0.5/try_parse.d.ts

@@ -1,21 +0,0 @@
-import type { SemVer } from "./types.js";
-/**
- * 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";
- *
- * 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: [] });
- * assertEquals(tryParse("1.2.3+build"), { major: 1, minor: 2, patch: 3, prerelease: [], build: ["build"] });
- * assertEquals(tryParse("1.2.3-alpha.1+build.1"), { major: 1, minor: 2, patch: 3, prerelease: ["alpha", 1], build: ["build", "1"] });
- * assertEquals(tryParse(" invalid "), undefined);
- * ```
- *
- * @param value The version string to parse
- * @returns A valid SemVer or `undefined`
- */
-export declare function tryParse(value: string): SemVer | undefined;
-//# sourceMappingURL=try_parse.d.ts.map

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

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

@@ -1,23 +0,0 @@
-import type { Range } from "./types.js";
-/**
- * Parses the given range string and returns a Range object. If the range string
- * is invalid, `undefined` is returned.
- *
- * @example Usage
- * ```ts
- * import { tryParseRange } from "@std/semver";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(tryParseRange(">=1.2.3 <1.2.4"), [
- *  [
- *    { operator: ">=", major: 1, minor: 2, patch: 3, prerelease: [], build: [] },
- *    { operator: "<", major: 1, minor: 2, patch: 4, prerelease: [], build: [] },
- *  ],
- * ]);
- * ```
- *
- * @param value The range string
- * @returns A Range object if valid otherwise `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.5/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/1.0.5/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"}