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

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

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

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

@@ -1,71 +0,0 @@
-/**
- * MAX is a sentinel value used by some range calculations.
- * It is equivalent to `∞.∞.∞`.
- */
-export const MAX = {
-    major: Number.POSITIVE_INFINITY,
-    minor: Number.POSITIVE_INFINITY,
-    patch: Number.POSITIVE_INFINITY,
-    prerelease: [],
-    build: [],
-};
-/**
- * The minimum valid SemVer object. Equivalent to `0.0.0`.
- */
-export const MIN = {
-    major: 0,
-    minor: 0,
-    patch: 0,
-    prerelease: [],
-    build: [],
-};
-/**
- * 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 const INVALID = {
-    major: Number.NEGATIVE_INFINITY,
-    minor: Number.POSITIVE_INFINITY,
-    patch: Number.POSITIVE_INFINITY,
-    prerelease: [],
-    build: [],
-};
-/**
- * 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 const ANY = {
-    major: Number.NaN,
-    minor: Number.NaN,
-    patch: Number.NaN,
-    prerelease: [],
-    build: [],
-};
-/**
- * A comparator which will span all valid semantic versions
- */
-export const ALL = {
-    operator: undefined,
-    ...ANY,
-};
-/**
- * A comparator which will not span any semantic versions
- */
-export const NONE = {
-    operator: "<",
-    ...MIN,
-};

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

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

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

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

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

@@ -1,48 +0,0 @@
-import { isWildcardComparator } from "./_shared.js";
-function formatNumber(value) {
-    if (value === Number.POSITIVE_INFINITY) {
-        return "∞";
-    }
-    else if (value === Number.NEGATIVE_INFINITY) {
-        return "⧞";
-    }
-    else {
-        return value.toFixed(0);
-    }
-}
-/**
- * Format a SemVer object into a string.
- *
- * If any number is NaN then NaN will be printed.
- *
- * If any number is positive or negative infinity then '∞' or '⧞' will be printed instead.
- *
- * @example Usage
- * ```ts
- * import { format } from "@std/semver/format";
- * import { assertEquals } from "@std/assert/assert-equals";
- *
- * const semver = {
- *   major: 1,
- *   minor: 2,
- *   patch: 3,
- * };
- * assertEquals(format(semver), "1.2.3");
- * ```
- *
- * @param semver The SemVer to format
- * @returns The string representation of a semantic version.
- */
-export function format(semver) {
-    if (isWildcardComparator(semver)) {
-        return "*";
-    }
-    const major = formatNumber(semver.major);
-    const minor = formatNumber(semver.minor);
-    const patch = formatNumber(semver.patch);
-    const pre = semver.prerelease?.join(".") ?? "";
-    const build = semver.build?.join(".") ?? "";
-    const primary = `${major}.${minor}.${patch}`;
-    const release = [primary, pre].filter((v) => v).join("-");
-    return [release, build].filter((v) => v).join("+");
-}

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

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

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

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

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

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

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

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

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

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

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

@@ -1,50 +0,0 @@
-import { parseBuild, parseNumber, parsePrerelease } from "./_shared.js";
-import { FULL_REGEXP, MAX_LENGTH } from "./_shared.js";
-/**
- * Attempt to parse a string as a semantic version, returning either a `SemVer`
- * object or throws a TypeError.
- *
- * @example Usage
- * ```ts
- * import { parse } from "@std/semver/parse";
- * import { assertEquals } from "@std/assert/assert-equals";
- *
- * const version = parse("1.2.3");
- * assertEquals(version, {
- *   major: 1,
- *   minor: 2,
- *   patch: 3,
- *   prerelease: [],
- *   build: [],
- * });
- * ```
- *
- * @param version The version string to parse
- * @returns A valid SemVer
- */
-export function parse(version) {
-    if (typeof version !== "string") {
-        throw new TypeError(`version must be a string`);
-    }
-    if (version.length > MAX_LENGTH) {
-        throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
-    }
-    version = version.trim();
-    const groups = version.match(FULL_REGEXP)?.groups;
-    if (!groups)
-        throw new TypeError(`Invalid Version: ${version}`);
-    const major = parseNumber(groups.major, "Invalid major version");
-    const minor = parseNumber(groups.minor, "Invalid minor version");
-    const patch = parseNumber(groups.patch, "Invalid patch version");
-    const prerelease = groups.prerelease
-        ? parsePrerelease(groups.prerelease)
-        : [];
-    const build = groups.buildmetadata ? parseBuild(groups.buildmetadata) : [];
-    return {
-        major,
-        minor,
-        patch,
-        prerelease,
-        build,
-    };
-}

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

@@ -1,77 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { INVALID, MAX } from "./constants.js";
-import { satisfies } from "./satisfies.js";
-import { greaterThan } from "./greater_than.js";
-import { isWildcardComparator } from "./_shared.js";
-function comparatorMax(comparator) {
-    const semver = comparator;
-    if (isWildcardComparator(comparator))
-        return MAX;
-    switch (comparator.operator) {
-        case "!=":
-        case ">":
-        case ">=":
-            return MAX;
-        case undefined:
-        case "=":
-        case "<=":
-            return {
-                major: semver.major,
-                minor: semver.minor,
-                patch: semver.patch,
-                prerelease: semver.prerelease,
-                build: semver.build,
-            };
-        case "<": {
-            const patch = semver.patch - 1;
-            const minor = patch >= 0 ? semver.minor : semver.minor - 1;
-            const major = minor >= 0 ? semver.major : semver.major - 1;
-            // if you try to do <0.0.0 it will Give you -∞.∞.∞
-            // which means no SemVer can compare successfully to it.
-            if (major < 0)
-                return INVALID;
-            return {
-                major,
-                minor: minor >= 0 ? minor : Number.POSITIVE_INFINITY,
-                patch: patch >= 0 ? patch : Number.POSITIVE_INFINITY,
-                prerelease: [],
-                build: [],
-            };
-        }
-    }
-}
-/**
- * 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 function rangeMax(range) {
-    let max;
-    for (const comparators of range) {
-        for (const comparator of comparators) {
-            const candidate = comparatorMax(comparator);
-            if (!satisfies(candidate, range))
-                continue;
-            max = (max && greaterThan(max, candidate)) ? max : candidate;
-        }
-    }
-    return max ?? INVALID;
-}

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

@@ -1,68 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { INVALID, MAX, MIN } from "./constants.js";
-import { satisfies } from "./satisfies.js";
-import { lessThan } from "./less_than.js";
-import { greaterThan } from "./greater_than.js";
-import { increment } from "./increment.js";
-import { isWildcardComparator } from "./_shared.js";
-function comparatorMin(comparator) {
-    const semver = comparator;
-    if (isWildcardComparator(semver))
-        return MIN;
-    switch (comparator.operator) {
-        case ">":
-            return semver.prerelease && semver.prerelease.length > 0
-                ? increment(semver, "pre")
-                : increment(semver, "patch");
-        case "!=":
-        case "<=":
-        case "<":
-            // The min(<0.0.0) is MAX
-            return greaterThan(semver, MIN) ? MIN : MAX;
-        case ">=":
-        case undefined:
-        case "=":
-            return {
-                major: semver.major,
-                minor: semver.minor,
-                patch: semver.patch,
-                prerelease: semver.prerelease,
-                build: semver.build,
-            };
-    }
-}
-/**
- * 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 function rangeMin(range) {
-    let min;
-    for (const comparators of range) {
-        for (const comparator of comparators) {
-            const candidate = comparatorMin(comparator);
-            if (!satisfies(candidate, range))
-                continue;
-            min = (min && lessThan(min, candidate)) ? min : candidate;
-        }
-    }
-    return min ?? INVALID;
-}

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

@@ -1,28 +0,0 @@
-import { satisfies } from "./satisfies.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 function testRange(version, range) {
-    return satisfies(version, range);
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"_validate_binary_like.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/0.224.3/_validate_binary_like.ts"],"names":[],"mappings":"AAeA,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAa9D"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/0.224.3/base64.ts"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAmC5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQpD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base64url.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/0.224.3/base64url.ts"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GACtC,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAE1D"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/0.224.3/hex.ts"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAUxE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAiBjD"}

package/types/deps/jsr.io/@std/http/0.224.5/_negotiation/common.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/http/0.224.5/_negotiation/common.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CAQnE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAEpD"}

package/types/deps/jsr.io/@std/http/0.224.5/_negotiation/encoding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/http/0.224.5/_negotiation/encoding.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AA4GH;;qCAEqC;AACrC,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,MAAM,EAAE,CAkBV"}

package/types/deps/jsr.io/@std/http/0.224.5/_negotiation/language.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"language.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/http/0.224.5/_negotiation/language.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAkGH,wBAAgB,kBAAkB,CAChC,MAAM,SAAM,EACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,MAAM,EAAE,CAiBV"}

package/types/deps/jsr.io/@std/http/0.224.5/_negotiation/media_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"media_type.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/http/0.224.5/_negotiation/media_type.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAiJH,wBAAgB,mBAAmB,CACjC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,MAAM,EAAE,CAkBV"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"negotiation.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/http/0.224.5/negotiation.ts"],"names":[],"mappings":"AAcA,yCAAyC;AACzC,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,EAAE;QACP,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;KACjC,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;AACpD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,OAAO,EAChB,GAAG,KAAK,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAAC;AAatB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,OAAO,EAChB,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,MAAM,GAAG,SAAS,CAAC;AAetB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;AAC7D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,OAAO,EAChB,GAAG,KAAK,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare const OPERATORS: readonly [undefined, "=", "!=", ">", ">=", "<", "<="];
-//# 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,eAAO,MAAM,SAAS,uDAQZ,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"_shared.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/semver/0.224.3/_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,CAGZ;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/0.224.3/_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/0.224.3/_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/0.224.3/can_parse.d.ts.map

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

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

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