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

package/types/deps/jsr.io/@std/http/1.0.16/negotiation.d.ts

@@ -1,148 +0,0 @@
-/**
- * Returns an array of media types accepted by the request, in order of
- * preference. If there are no media types supplied in the request, then any
- * media type selector will be returned.
- *
- * @example Usage
- * ```ts
- * import { accepts } from "@std/http/negotiation";
- * import { assertEquals } from "@std/assert";
- *
- * const request = new Request("https://example.com/", {
- *   headers: {
- *     accept:
- *       "text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, *\/*;q=0.8",
- *   },
- * });
- *
- * assertEquals(accepts(request), [
- *   "text/html",
- *   "application/xhtml+xml",
- *   "image/webp",
- *   "application/xml",
- *   "*\/*",
- * ]);
- * ```
- *
- * @param request The request to get the acceptable media types for.
- * @returns An array of acceptable media types.
- */
-export declare function accepts(request: Pick<Request, "headers">): string[];
-/**
- * For a given set of media types, return the best match accepted in the
- * request. If no media type matches, then the function returns `undefined`.
- *
- *  @example Usage
- * ```ts
- * import { accepts } from "@std/http/negotiation";
- * import { assertEquals } from "@std/assert";
- *
- * const request = new Request("https://example.com/", {
- *   headers: {
- *     accept:
- *       "text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, *\/*;q=0.8",
- *   },
- * });
- *
- * assertEquals(accepts(request, "text/html", "image/webp"), "text/html");
- * ```
- *
- * @param request The request to get the acceptable media types for.
- * @param types An array of media types to find the best matching one from.
- * @returns The best matching media type, if any match.
- */
-export declare function accepts(request: Pick<Request, "headers">, ...types: string[]): string | undefined;
-/**
- * Returns an array of content encodings accepted by the request, in order of
- * preference. If there are no encoding supplied in the request, then `["*"]`
- * is returned, implying any encoding is accepted.
- *
- * @example Usage
- * ```ts
- * import { acceptsEncodings } from "@std/http/negotiation";
- * import { assertEquals } from "@std/assert";
- *
- * const request = new Request("https://example.com/", {
- *   headers: { "accept-encoding": "deflate, gzip;q=1.0, *;q=0.5" },
- * });
- *
- * assertEquals(acceptsEncodings(request), ["deflate", "gzip", "*"]);
- * ```
- *
- * @param request The request to get the acceptable content encodings for.
- * @returns An array of content encodings this request accepts.
- */
-export declare function acceptsEncodings(request: Pick<Request, "headers">): string[];
-/**
- * For a given set of content encodings, return the best match accepted in the
- * request. If no content encodings match, then the function returns
- * `undefined`.
- *
- * **NOTE:** You should always supply `identity` as one of the encodings
- * to ensure that there is a match when the `Accept-Encoding` header is part
- * of the request.
- *
- * @example Usage
- * ```ts
- * import { acceptsEncodings } from "@std/http/negotiation";
- * import { assertEquals } from "@std/assert";
- *
- * const request = new Request("https://example.com/", {
- *   headers: { "accept-encoding": "deflate, gzip;q=1.0, *;q=0.5" },
- * });
- *
- * assertEquals(acceptsEncodings(request, "gzip", "identity"), "gzip");
- * ```
- *
- * @param request The request to get the acceptable content encodings for.
- * @param encodings An array of encodings to find the best matching one from.
- * @returns The best matching encoding, if any match.
- */
-export declare function acceptsEncodings(request: Pick<Request, "headers">, ...encodings: string[]): string | undefined;
-/**
- * Returns an array of languages accepted by the request, in order of
- * preference. If there are no languages supplied in the request, then `["*"]`
- * is returned, imply any language is accepted.
- *
- * @example Usage
- * ```ts
- * import { acceptsLanguages } from "@std/http/negotiation";
- * import { assertEquals } from "@std/assert";
- *
- * const request = new Request("https://example.com/", {
- *   headers: {
- *     "accept-language": "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5",
- *   },
- * });
- *
- * assertEquals(acceptsLanguages(request), ["fr-CH", "fr", "en", "de", "*"]);
- * ```
- *
- * @param request The request to get the acceptable languages for.
- * @returns An array of languages this request accepts.
- */
-export declare function acceptsLanguages(request: Pick<Request, "headers">): string[];
-/**
- * For a given set of languages, return the best match accepted in the request.
- * If no languages match, then the function returns `undefined`.
- *
- * @example Usage
- * ```ts
- * import { acceptsLanguages } from "@std/http/negotiation";
- * import { assertEquals } from "@std/assert";
- *
- * const request = new Request("https://example.com/", {
- *   headers: {
- *     "accept-language": "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5",
- *   },
- * });
- *
- * assertEquals(acceptsLanguages(request, "en-gb", "en-us", "en"), "en");
- * ```
- *
- * @param request The request to get the acceptable language for.
- * @param langs An array of languages to find the best matching one from.
- * @returns The best matching language, if any match.
- */
-export declare function acceptsLanguages(request: Pick<Request, "headers">, ...langs: string[]): string | undefined;
-//# sourceMappingURL=negotiation.d.ts.map

package/types/deps/jsr.io/@std/http/1.0.16/negotiation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"negotiation.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/http/1.0.16/negotiation.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC;AACrE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EACjC,GAAG,KAAK,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAAC;AAatB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC;AAC9E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EACjC,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,MAAM,GAAG,SAAS,CAAC;AAetB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC;AAC9E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EACjC,GAAG,KAAK,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAAC"}

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

@@ -1,12 +0,0 @@
-import type { Comparator, SemVer } from "./types.js";
-/**
- * ANY is a sentinel value used by some range calculations. It is not a valid
- * SemVer object and should not be used directly.
- */
-export declare const ANY: SemVer;
-/**
- * A comparator which will span all valid semantic versions
- */
-export declare const ALL: Comparator;
-export declare const OPERATORS: readonly [undefined, "=", "!=", ">", ">=", "<", "<="];
-//# sourceMappingURL=_constants.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.5/_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,UAGjB,CAAC;AAEF,eAAO,MAAM,SAAS,uDAQZ,CAAC"}

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

@@ -1,44 +0,0 @@
-import type { Comparator } from "./types.js";
-export declare function compareNumber(a: number, b: number): 1 | 0 | -1;
-export declare function checkIdentifier(v1?: ReadonlyArray<string | number>, v2?: ReadonlyArray<string | number>): 1 | 0 | -1;
-export declare function compareIdentifier(v1?: ReadonlyArray<string | number>, v2?: ReadonlyArray<string | number>): 1 | 0 | -1;
-export declare const FULL_REGEXP: RegExp;
-/**
- * A version that can contain wildcards.
- * @example "x", "1.x", "1.x.x", "1.2.x", "*", "1.*", "1.*.*", "1.2.*"
- */
-export declare const XRANGE = "[v=\\s]*(?<major>0|[1-9]\\d*|x|X|\\*)(?:\\.(?<minor>0|[1-9]\\d*|x|X|\\*)(?:\\.(?<patch>0|[1-9]\\d*|x|X|\\*)(?:-(?<prerelease>(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*))?(?:\\+(?<buildmetadata>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?";
-/**
- * An operator (`~`, `~>`, `^`, `=`, `<`, `<=`, `>`, or `>=`), followed by an x-range.
- * @example "~1.x.x", "^1.2.*", ">=1.2.3"
- */
-export declare const OPERATOR_XRANGE_REGEXP: RegExp;
-/**
- * An empty string or a comparator (`=`, `<`, `<=`, `>`, or `>=`), followed by a version.
- * @example ">1.2.3"
- */
-export declare const COMPARATOR_REGEXP: RegExp;
-/**
- * Returns true if the value is a valid SemVer number.
- *
- * Must be a number. Must not be NaN. Can be positive or negative infinity.
- * Can be between 0 and MAX_SAFE_INTEGER.
- * @param value The value to check
- * @returns True if its a valid semver number
- */
-export declare function isValidNumber(value: unknown): value is number;
-export declare const MAX_LENGTH = 256;
-/**
- * Returns true if the value is a valid semver pre-release or build identifier.
- *
- * Must be a string. Must be between 1 and 256 characters long. Must match
- * the regular expression /[0-9A-Za-z-]+/.
- * @param value The value to check
- * @returns True if the value is a valid semver string.
- */
-export declare function isValidString(value: unknown): value is string;
-export declare function parsePrerelease(prerelease: string): (string | number)[];
-export declare function parseBuild(buildmetadata: string): string[];
-export declare function parseNumber(input: string, errorMessage: string): number;
-export declare function isWildcardComparator(c: Comparator): boolean;
-//# sourceMappingURL=_shared.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"_shared.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.5/_shared.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,aAAa,CAC3B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAKZ;AAED,wBAAgB,eAAe,CAC7B,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,EACvC,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,GACtC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAMZ;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,EACvC,EAAE,GAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAM,GACtC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAoBZ;AAgDD,eAAO,MAAM,WAAW,QAAkC,CAAC;AAgB3D;;;GAGG;AACH,eAAO,MAAM,MAAM,iSAC0H,CAAC;AAE9I;;;GAGG;AACH,eAAO,MAAM,sBAAsB,QAElC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAE7B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAED,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAGD,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,uBAWjD;AAED,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,YAE/C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAI9D;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAM3D"}

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

@@ -1,3 +0,0 @@
-import type { Comparator, SemVer } from "./types.js";
-export declare function testComparatorSet(version: SemVer, set: Comparator[]): boolean;
-//# sourceMappingURL=_test_comparator_set.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"_test_comparator_set.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.5/_test_comparator_set.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAgCrD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,UAAU,EAAE,GAChB,OAAO,CA6BT"}

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

@@ -1,17 +0,0 @@
-/**
- * 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 value The version string to check
- * @returns `true` if the string can be parsed as SemVer, `false` otherwise
- */
-export declare function canParse(value: string): boolean;
-//# sourceMappingURL=can_parse.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"can_parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/1.0.5/can_parse.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAO/C"}

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

@@ -1,28 +0,0 @@
-import type { SemVer } from "./types.js";
-/**
- * Compare two SemVers.
- *
- * Returns `0` if `version1` equals `version2`, or `1` if `version1` is greater, or `-1` if `version2` is
- * greater.
- *
- * Sorts in ascending order if passed to {@linkcode Array.sort}.
- *
- * @example Usage
- * ```ts
- * import { parse, compare } from "@std/semver";
- * import { assertEquals } from "@std/assert";
- *
- * const version1 = parse("1.2.3");
- * const version2 = parse("1.2.4");
- *
- * assertEquals(compare(version1, version2), -1);
- * assertEquals(compare(version2, version1), 1);
- * assertEquals(compare(version1, version1), 0);
- * ```
- *
- * @param version1 The first SemVer to compare
- * @param version2 The second SemVer to compare
- * @returns `1` if `version1` is greater, `0` if equal, or `-1` if `version2` is greater
- */
-export declare function compare(version1: SemVer, version2: SemVer): 1 | 0 | -1;
-//# sourceMappingURL=compare.d.ts.map

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

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

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

@@ -1,27 +0,0 @@
-import type { ReleaseType, SemVer } from "./types.js";
-/**
- * Returns difference between two SemVers by the release type,
- * or `undefined` if the SemVers are the same.
- *
- * @example Usage
- * ```ts
- * import { parse, difference } from "@std/semver";
- * import { assertEquals } from "@std/assert";
- *
- * const version1 = parse("1.2.3");
- * const version2 = parse("1.2.4");
- * const version3 = parse("1.3.0");
- * const version4 = parse("2.0.0");
- *
- * assertEquals(difference(version1, version2), "patch");
- * assertEquals(difference(version1, version3), "minor");
- * assertEquals(difference(version1, version4), "major");
- * assertEquals(difference(version1, version1), undefined);
- * ```
- *
- * @param version1 The first SemVer to compare
- * @param version2 The second SemVer to compare
- * @returns The release type difference or `undefined` if the versions are the same
- */
-export declare function difference(version1: SemVer, version2: SemVer): ReleaseType | undefined;
-//# sourceMappingURL=difference.d.ts.map

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

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

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

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

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

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

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

@@ -1,22 +0,0 @@
-import type { SemVer } from "./types.js";
-/**
- * Format a SemVer object into a string.
- *
- * @example Usage
- * ```ts
- * import { format } from "@std/semver/format";
- * import { assertEquals } from "@std/assert";
- *
- * const semver = {
- *   major: 1,
- *   minor: 2,
- *   patch: 3,
- * };
- * assertEquals(format(semver), "1.2.3");
- * ```
- *
- * @param version The SemVer to format
- * @returns The string representation of a semantic version.
- */
-export declare function format(version: SemVer): string;
-//# sourceMappingURL=format.d.ts.map

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

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

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

@@ -1,18 +0,0 @@
-import type { Range } from "./types.js";
-/**
- * Formats the SemVerrange into a string.
- *
- * @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 SemVer range
- */
-export declare function formatRange(range: Range): string;
-//# sourceMappingURL=format_range.d.ts.map

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

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

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

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

package/types/deps/jsr.io/@std/semver/1.0.5/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/1.0.5/greater_or_equal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1E"}

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

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

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

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

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

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

@@ -1,51 +0,0 @@
-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 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.
- *
- * If called from a non-prerelease version, the `prerelease` will work the same as
- * `prepatch`. The patch version is incremented and then is made into a prerelease. If
- * the input version is already a prerelease it will simply increment the prerelease
- * metadata.
- *
- * If a prerelease identifier is specified without a number then a number will be added.
- * For example `pre` will result in `pre.0`. If the existing version already has a
- * prerelease with a number and its the same prerelease identifier then the number
- * will be incremented. If the identifier differs from the new identifier then the new
- * identifier is applied and the number is reset to `0`.
- *
- * 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";
- *
- * 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 options Additional options
- * @returns The new version
- */
-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.5/increment.d.ts.map

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

@@ -1,23 +0,0 @@
-import type { Range } from "./types.js";
-/**
- * Does a deep check on the object to determine if its a valid range.
- *
- * Objects with extra fields are still considered valid if they have at
- * least the correct fields.
- *
- * Adds a type assertion if true.
- *
- * @example Usage
- * ```ts
- * import { isRange } from "@std/semver/is-range";
- * import { assert } from "@std/assert";
- *
- * const range = [[{ major: 1, minor: 2, patch: 3 }]];
- * assert(isRange(range));
- * assert(!isRange({}));
- * ```
- * @param value The value to check if its a valid Range
- * @returns True if its a valid Range otherwise false.
- */
-export declare function isRange(value: unknown): value is Range;
-//# sourceMappingURL=is_range.d.ts.map

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

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

@@ -1,34 +0,0 @@
-import type { SemVer } from "./types.js";
-/**
- * Checks to see if value is a valid SemVer object. It does a check
- * into each field including prerelease and build.
- *
- * Some invalid SemVer sentinels can still return true such as ANY and INVALID.
- * An object which has the same value as a sentinel but isn't reference equal
- * will still fail.
- *
- * Objects which are valid SemVer objects but have _extra_ fields are still
- * 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 } from "@std/assert";
- *
- * const value = {
- *   major: 1,
- *   minor: 2,
- *   patch: 3,
- * };
- *
- * assert(isSemVer(value));
- * assert(!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
- */
-export declare function isSemVer(value: unknown): value is SemVer;
-//# sourceMappingURL=is_semver.d.ts.map

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

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

@@ -1,25 +0,0 @@
-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.5/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/1.0.5/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"}