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

package/esm/deps/jsr.io/@std/semver/1.0.5/parse_range.js

@@ -1,358 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { COMPARATOR_REGEXP, OPERATOR_XRANGE_REGEXP, parseBuild, parseNumber, parsePrerelease, XRANGE, } from "./_shared.js";
-import { ALL, ANY } from "./_constants.js";
-function parseComparator(comparator) {
-    const match = comparator.match(COMPARATOR_REGEXP);
-    const groups = match?.groups;
-    if (!groups)
-        return null;
-    const { operator, prerelease, buildmetadata } = groups;
-    const semver = groups.major
-        ? {
-            major: parseNumber(groups.major, `Cannot parse comparator ${comparator}: invalid major version`),
-            minor: parseNumber(groups.minor, `Cannot parse comparator ${comparator}: invalid minor version`),
-            patch: parseNumber(groups.patch, `Cannot parse comparator ${comparator}: invalid patch version`),
-            prerelease: prerelease ? parsePrerelease(prerelease) : [],
-            build: buildmetadata ? parseBuild(buildmetadata) : [],
-        }
-        : ANY;
-    return { operator: operator || undefined, ...semver };
-}
-function isWildcard(id) {
-    return !id || id.toLowerCase() === "x" || id === "*";
-}
-function handleLeftHyphenRangeGroups(leftGroup) {
-    if (isWildcard(leftGroup.major))
-        return;
-    if (isWildcard(leftGroup.minor)) {
-        return {
-            operator: ">=",
-            major: +leftGroup.major,
-            minor: 0,
-            patch: 0,
-            prerelease: [],
-            build: [],
-        };
-    }
-    if (isWildcard(leftGroup.patch)) {
-        return {
-            operator: ">=",
-            major: +leftGroup.major,
-            minor: +leftGroup.minor,
-            patch: 0,
-            prerelease: [],
-            build: [],
-        };
-    }
-    return {
-        operator: ">=",
-        major: +leftGroup.major,
-        minor: +leftGroup.minor,
-        patch: +leftGroup.patch,
-        prerelease: leftGroup.prerelease
-            ? parsePrerelease(leftGroup.prerelease)
-            : [],
-        build: [],
-    };
-}
-function handleRightHyphenRangeGroups(rightGroups) {
-    if (isWildcard(rightGroups.major)) {
-        return;
-    }
-    if (isWildcard(rightGroups.minor)) {
-        return {
-            operator: "<",
-            major: +rightGroups.major + 1,
-            minor: 0,
-            patch: 0,
-            prerelease: [],
-            build: [],
-        };
-    }
-    if (isWildcard(rightGroups.patch)) {
-        return {
-            operator: "<",
-            major: +rightGroups.major,
-            minor: +rightGroups.minor + 1,
-            patch: 0,
-            prerelease: [],
-            build: [],
-        };
-    }
-    if (rightGroups.prerelease) {
-        return {
-            operator: "<=",
-            major: +rightGroups.major,
-            minor: +rightGroups.minor,
-            patch: +rightGroups.patch,
-            prerelease: parsePrerelease(rightGroups.prerelease),
-            build: [],
-        };
-    }
-    return {
-        operator: "<=",
-        major: +rightGroups.major,
-        minor: +rightGroups.minor,
-        patch: +rightGroups.patch,
-        prerelease: [],
-        build: [],
-    };
-}
-function parseHyphenRange(range) {
-    const leftMatch = range.match(new RegExp(`^${XRANGE}`));
-    const leftGroup = leftMatch?.groups;
-    if (!leftGroup)
-        return null;
-    const leftLength = leftMatch[0].length;
-    const hyphenMatch = range.slice(leftLength).match(/^\s+-\s+/);
-    if (!hyphenMatch)
-        return null;
-    const hyphenLength = hyphenMatch[0].length;
-    const rightMatch = range.slice(leftLength + hyphenLength).match(new RegExp(`^${XRANGE}\\s*$`));
-    const rightGroups = rightMatch?.groups;
-    if (!rightGroups)
-        return null;
-    const from = handleLeftHyphenRangeGroups(leftGroup);
-    const to = handleRightHyphenRangeGroups(rightGroups);
-    return [from, to].filter(Boolean);
-}
-function handleCaretOperator(groups) {
-    const majorIsWildcard = isWildcard(groups.major);
-    const minorIsWildcard = isWildcard(groups.minor);
-    const patchIsWildcard = isWildcard(groups.patch);
-    const major = +groups.major;
-    const minor = +groups.minor;
-    const patch = +groups.patch;
-    if (majorIsWildcard)
-        return [ALL];
-    if (minorIsWildcard) {
-        return [
-            { operator: ">=", major, minor: 0, patch: 0 },
-            { operator: "<", major: major + 1, minor: 0, patch: 0 },
-        ];
-    }
-    if (patchIsWildcard) {
-        if (major === 0) {
-            return [
-                { operator: ">=", major, minor, patch: 0 },
-                { operator: "<", major, minor: minor + 1, patch: 0 },
-            ];
-        }
-        return [
-            { operator: ">=", major, minor, patch: 0 },
-            { operator: "<", major: major + 1, minor: 0, patch: 0 },
-        ];
-    }
-    const prerelease = parsePrerelease(groups.prerelease ?? "");
-    if (major === 0) {
-        if (minor === 0) {
-            return [
-                { operator: ">=", major, minor, patch, prerelease },
-                { operator: "<", major, minor, patch: patch + 1 },
-            ];
-        }
-        return [
-            { operator: ">=", major, minor, patch, prerelease },
-            { operator: "<", major, minor: minor + 1, patch: 0 },
-        ];
-    }
-    return [
-        { operator: ">=", major, minor, patch, prerelease },
-        { operator: "<", major: major + 1, minor: 0, patch: 0 },
-    ];
-}
-function handleTildeOperator(groups) {
-    const majorIsWildcard = isWildcard(groups.major);
-    const minorIsWildcard = isWildcard(groups.minor);
-    const patchIsWildcard = isWildcard(groups.patch);
-    const major = +groups.major;
-    const minor = +groups.minor;
-    const patch = +groups.patch;
-    if (majorIsWildcard)
-        return [ALL];
-    if (minorIsWildcard) {
-        return [
-            { operator: ">=", major, minor: 0, patch: 0 },
-            { operator: "<", major: major + 1, minor: 0, patch: 0 },
-        ];
-    }
-    if (patchIsWildcard) {
-        return [
-            { operator: ">=", major, minor, patch: 0 },
-            { operator: "<", major, minor: minor + 1, patch: 0 },
-        ];
-    }
-    const prerelease = parsePrerelease(groups.prerelease ?? "");
-    return [
-        { operator: ">=", major, minor, patch, prerelease },
-        { operator: "<", major, minor: minor + 1, patch: 0 },
-    ];
-}
-function handleLessThanOperator(groups) {
-    const majorIsWildcard = isWildcard(groups.major);
-    const minorIsWildcard = isWildcard(groups.minor);
-    const patchIsWildcard = isWildcard(groups.patch);
-    const major = +groups.major;
-    const minor = +groups.minor;
-    const patch = +groups.patch;
-    if (majorIsWildcard)
-        return [{ operator: "<", major: 0, minor: 0, patch: 0 }];
-    if (minorIsWildcard) {
-        if (patchIsWildcard)
-            return [{ operator: "<", major, minor: 0, patch: 0 }];
-        return [{ operator: "<", major, minor: 0, patch: 0 }];
-    }
-    if (patchIsWildcard)
-        return [{ operator: "<", major, minor, patch: 0 }];
-    const prerelease = parsePrerelease(groups.prerelease ?? "");
-    const build = parseBuild(groups.build ?? "");
-    return [{ operator: "<", major, minor, patch, prerelease, build }];
-}
-function handleLessThanOrEqualOperator(groups) {
-    const minorIsWildcard = isWildcard(groups.minor);
-    const patchIsWildcard = isWildcard(groups.patch);
-    const major = +groups.major;
-    const minor = +groups.minor;
-    const patch = +groups.patch;
-    if (minorIsWildcard) {
-        if (patchIsWildcard) {
-            return [{ operator: "<", major: major + 1, minor: 0, patch: 0 }];
-        }
-        return [{ operator: "<", major, minor: minor + 1, patch: 0 }];
-    }
-    if (patchIsWildcard) {
-        return [{ operator: "<", major, minor: minor + 1, patch: 0 }];
-    }
-    const prerelease = parsePrerelease(groups.prerelease ?? "");
-    const build = parseBuild(groups.build ?? "");
-    return [{ operator: "<=", major, minor, patch, prerelease, build }];
-}
-function handleGreaterThanOperator(groups) {
-    const majorIsWildcard = isWildcard(groups.major);
-    const minorIsWildcard = isWildcard(groups.minor);
-    const patchIsWildcard = isWildcard(groups.patch);
-    const major = +groups.major;
-    const minor = +groups.minor;
-    const patch = +groups.patch;
-    if (majorIsWildcard)
-        return [{ operator: "<", major: 0, minor: 0, patch: 0 }];
-    if (minorIsWildcard) {
-        return [{ operator: ">=", major: major + 1, minor: 0, patch: 0 }];
-    }
-    if (patchIsWildcard) {
-        return [{ operator: ">=", major, minor: minor + 1, patch: 0 }];
-    }
-    const prerelease = parsePrerelease(groups.prerelease ?? "");
-    const build = parseBuild(groups.build ?? "");
-    return [{ operator: ">", major, minor, patch, prerelease, build }];
-}
-function handleGreaterOrEqualOperator(groups) {
-    const majorIsWildcard = isWildcard(groups.major);
-    const minorIsWildcard = isWildcard(groups.minor);
-    const patchIsWildcard = isWildcard(groups.patch);
-    const major = +groups.major;
-    const minor = +groups.minor;
-    const patch = +groups.patch;
-    if (majorIsWildcard)
-        return [ALL];
-    if (minorIsWildcard) {
-        if (patchIsWildcard)
-            return [{ operator: ">=", major, minor: 0, patch: 0 }];
-        return [{ operator: ">=", major, minor: 0, patch: 0 }];
-    }
-    if (patchIsWildcard)
-        return [{ operator: ">=", major, minor, patch: 0 }];
-    const prerelease = parsePrerelease(groups.prerelease ?? "");
-    const build = parseBuild(groups.build ?? "");
-    return [{ operator: ">=", major, minor, patch, prerelease, build }];
-}
-function handleEqualOperator(groups) {
-    const majorIsWildcard = isWildcard(groups.major);
-    const minorIsWildcard = isWildcard(groups.minor);
-    const patchIsWildcard = isWildcard(groups.patch);
-    const major = +groups.major;
-    const minor = +groups.minor;
-    const patch = +groups.patch;
-    if (majorIsWildcard)
-        return [ALL];
-    if (minorIsWildcard) {
-        return [
-            { operator: ">=", major, minor: 0, patch: 0 },
-            { operator: "<", major: major + 1, minor: 0, patch: 0 },
-        ];
-    }
-    if (patchIsWildcard) {
-        return [
-            { operator: ">=", major, minor, patch: 0 },
-            { operator: "<", major, minor: minor + 1, patch: 0 },
-        ];
-    }
-    const prerelease = parsePrerelease(groups.prerelease ?? "");
-    const build = parseBuild(groups.build ?? "");
-    return [{ operator: undefined, major, minor, patch, prerelease, build }];
-}
-function parseOperatorRange(string) {
-    const groups = string.match(OPERATOR_XRANGE_REGEXP)
-        ?.groups;
-    if (!groups)
-        return parseComparator(string);
-    switch (groups.operator) {
-        case "^":
-            return handleCaretOperator(groups);
-        case "~":
-        case "~>":
-            return handleTildeOperator(groups);
-        case "<":
-            return handleLessThanOperator(groups);
-        case "<=":
-            return handleLessThanOrEqualOperator(groups);
-        case ">":
-            return handleGreaterThanOperator(groups);
-        case ">=":
-            return handleGreaterOrEqualOperator(groups);
-        case "=":
-        case "":
-            return handleEqualOperator(groups);
-        default:
-            throw new Error(`Cannot parse version range: '${groups.operator}' is not a valid operator`);
-    }
-}
-function parseOperatorRanges(string) {
-    return string.split(/\s+/).flatMap(parseOperatorRange);
-}
-/**
- * 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 function parseRange(value) {
-    const result = value
-        // remove spaces between operators and versions
-        .replaceAll(/(?<=<|>|=|~|\^)(\s+)/g, "")
-        .split(/\s*\|\|\s*/)
-        .map((string) => parseHyphenRange(string) || parseOperatorRanges(string));
-    if (result.some((r) => r.includes(null))) {
-        throw new TypeError(`Cannot parse version range: range "${value}" is invalid`);
-    }
-    return result;
-}

package/esm/deps/jsr.io/@std/semver/1.0.5/range_intersects.js

@@ -1,89 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { isWildcardComparator } from "./_shared.js";
-import { compare } from "./compare.js";
-import { satisfies } from "./satisfies.js";
-function comparatorIntersects(comparator1, comparator2) {
-    const op0 = comparator1.operator;
-    const op1 = comparator2.operator;
-    if (op0 === undefined) {
-        // if comparator1 is empty comparator, then returns true
-        if (isWildcardComparator(comparator1))
-            return true;
-        return satisfies(comparator1, [[comparator2]]);
-    }
-    if (op1 === undefined) {
-        if (isWildcardComparator(comparator2))
-            return true;
-        return satisfies(comparator2, [[comparator1]]);
-    }
-    const cmp = compare(comparator1, comparator2);
-    const sameDirectionIncreasing = (op0 === ">=" || op0 === ">") &&
-        (op1 === ">=" || op1 === ">");
-    const sameDirectionDecreasing = (op0 === "<=" || op0 === "<") &&
-        (op1 === "<=" || op1 === "<");
-    const sameSemVer = cmp === 0;
-    const differentDirectionsInclusive = (op0 === ">=" || op0 === "<=") &&
-        (op1 === ">=" || op1 === "<=");
-    const oppositeDirectionsLessThan = cmp === -1 &&
-        (op0 === ">=" || op0 === ">") &&
-        (op1 === "<=" || op1 === "<");
-    const oppositeDirectionsGreaterThan = cmp === 1 &&
-        (op0 === "<=" || op0 === "<") &&
-        (op1 === ">=" || op1 === ">");
-    return sameDirectionIncreasing ||
-        sameDirectionDecreasing ||
-        (sameSemVer && differentDirectionsInclusive) ||
-        oppositeDirectionsLessThan ||
-        oppositeDirectionsGreaterThan;
-}
-function rangesSatisfiable(ranges) {
-    return ranges.every((r) => {
-        // For each OR at least one AND must be satisfiable
-        return r.some((comparators) => comparatorsSatisfiable(comparators));
-    });
-}
-function comparatorsSatisfiable(comparators) {
-    // Comparators are satisfiable if they all intersect with each other
-    for (let i = 0; i < comparators.length - 1; i++) {
-        const comparator1 = comparators[i];
-        for (const comparator2 of comparators.slice(i + 1)) {
-            if (!comparatorIntersects(comparator1, comparator2)) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-/**
- * 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 function rangeIntersects(range1, range2) {
-    return rangesSatisfiable([range1, range2]) &&
-        range1.some((range10) => {
-            return range2.some((r11) => {
-                return range10.every((comparator1) => {
-                    return r11.every((comparator2) => comparatorIntersects(comparator1, comparator2));
-                });
-            });
-        });
-}

package/esm/deps/jsr.io/@std/semver/1.0.5/satisfies.js

@@ -1,27 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { testComparatorSet } from "./_test_comparator_set.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 function satisfies(version, range) {
-    return range.some((set) => testComparatorSet(version, set));
-}

package/esm/deps/jsr.io/@std/semver/1.0.5/try_parse.js

@@ -1,27 +0,0 @@
-import { parse } from "./parse.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 function tryParse(value) {
-    try {
-        return parse(value);
-    }
-    catch {
-        return undefined;
-    }
-}

package/esm/deps/jsr.io/@std/semver/1.0.5/try_parse_range.js

@@ -1,33 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { parseRange } from "./parse_range.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 function tryParseRange(value) {
-    try {
-        // Return '*' instead of '' so that truthiness works.
-        // This will throw if it's invalid anyway
-        return parseRange(value);
-    }
-    catch {
-        return undefined;
-    }
-}

package/esm/deps/jsr.io/@std/semver/1.0.5/types.js

@@ -1,3 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-export {};

package/types/deps/jsr.io/@std/encoding/1.0.7/_types.d.ts

@@ -1,9 +0,0 @@
-/**
- * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
- *
- * This type is internal utility type and should not be used directly.
- *
- * @internal @private
- */
-export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
-//# sourceMappingURL=_types.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.7/_types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.7/_types.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare function validateBinaryLike(source: unknown): Uint8Array;
-//# sourceMappingURL=_validate_binary_like.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.7/_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/1.0.7/_validate_binary_like.ts"],"names":[],"mappings":"AAeA,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAa9D"}

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

@@ -1,40 +0,0 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
-/**
- * Converts data into a base64-encoded string.
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
- *
- * @param data The data to encode.
- * @returns The base64-encoded string.
- *
- * @example Usage
- * ```ts
- * import { encodeBase64 } from "@std/encoding/base64";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
- * ```
- */
-export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
-/**
- * Decodes a base64-encoded string.
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
- *
- * @param b64 The base64-encoded string to decode.
- * @returns The decoded data.
- *
- * @example Usage
- * ```ts
- * import { decodeBase64 } from "@std/encoding/base64";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(
- *   decodeBase64("Zm9vYmFy"),
- *   new TextEncoder().encode("foobar")
- * );
- * ```
- */
-export declare function decodeBase64(b64: string): Uint8Array_;
-//# sourceMappingURL=base64.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.7/base64.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAqE5B;;;;;;;;;;;;;;;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,WAAW,CAQrD"}

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

@@ -1,40 +0,0 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
-/**
- * Convert data into a base64url-encoded string.
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-5}
- *
- * @param data The data to encode.
- * @returns The base64url-encoded string.
- *
- * @example Usage
- * ```ts
- * import { encodeBase64Url } from "@std/encoding/base64url";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(encodeBase64Url("foobar"), "Zm9vYmFy");
- * ```
- */
-export declare function encodeBase64Url(data: ArrayBuffer | Uint8Array | string): string;
-/**
- * Decodes a given base64url-encoded string.
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-5}
- *
- * @param b64url The base64url-encoded string to decode.
- * @returns The decoded data.
- *
- * @example Usage
- * ```ts
- * import { decodeBase64Url } from "@std/encoding/base64url";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(
- *   decodeBase64Url("Zm9vYmFy"),
- *   new TextEncoder().encode("foobar")
- * );
- * ```
- */
-export declare function decodeBase64Url(b64url: string): Uint8Array_;
-//# sourceMappingURL=base64url.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"base64url.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.7/base64url.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAiC5B;;;;;;;;;;;;;;;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,WAAW,CAE3D"}