@pallasai/mcp-client 0.1.0

package/src/node_modules/hono/dist/types/utils/accept.d.ts

@@ -0,0 +1,11 @@
+export interface Accept {
+    type: string;
+    params: Record<string, string>;
+    q: number;
+}
+/**
+ * Parse an Accept header into an array of objects with type, parameters, and quality score.
+ * @param acceptHeader The Accept header string
+ * @returns An array of parsed Accept values
+ */
+export declare const parseAccept: (acceptHeader: string) => Accept[];

package/src/node_modules/hono/dist/types/utils/basic-auth.d.ts

@@ -0,0 +1,5 @@
+export type Auth = (req: Request) => {
+    username: string;
+    password: string;
+} | undefined;
+export declare const auth: Auth;

package/src/node_modules/hono/dist/types/utils/body.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @module
+ * Body utility.
+ */
+import { HonoRequest } from '../request';
+type BodyDataValueDot = {
+    [x: string]: string | File | BodyDataValueDot;
+};
+type BodyDataValueDotAll = {
+    [x: string]: string | File | (string | File)[] | BodyDataValueDotAll;
+};
+type SimplifyBodyData<T> = {
+    [K in keyof T]: string | File | (string | File)[] | BodyDataValueDotAll extends T[K] ? string | File | (string | File)[] | BodyDataValueDotAll : string | File | BodyDataValueDot extends T[K] ? string | File | BodyDataValueDot : string | File | (string | File)[] extends T[K] ? string | File | (string | File)[] : string | File;
+} & {};
+type BodyDataValueComponent<T> = string | File | (T extends {
+    all: false;
+} ? never : T extends {
+    all: true;
+} | {
+    all: boolean;
+} ? (string | File)[] : never);
+type BodyDataValueObject<T> = {
+    [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T>;
+};
+type BodyDataValue<T> = BodyDataValueComponent<T> | (T extends {
+    dot: false;
+} ? never : T extends {
+    dot: true;
+} | {
+    dot: boolean;
+} ? BodyDataValueObject<T> : never);
+export type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<Record<string, BodyDataValue<T>>>;
+export type ParseBodyOptions = {
+    /**
+     * Determines whether all fields with multiple values should be parsed as arrays.
+     * @default false
+     * @example
+     * const data = new FormData()
+     * data.append('file', 'aaa')
+     * data.append('file', 'bbb')
+     * data.append('message', 'hello')
+     *
+     * If all is false:
+     * parseBody should return { file: 'bbb', message: 'hello' }
+     *
+     * If all is true:
+     * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
+     */
+    all: boolean;
+    /**
+     * Determines whether all fields with dot notation should be parsed as nested objects.
+     * @default false
+     * @example
+     * const data = new FormData()
+     * data.append('obj.key1', 'value1')
+     * data.append('obj.key2', 'value2')
+     *
+     * If dot is false:
+     * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
+     *
+     * If dot is true:
+     * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
+     */
+    dot: boolean;
+};
+/**
+ * Parses the body of a request based on the provided options.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {HonoRequest | Request} request - The request object to parse.
+ * @param {Partial<ParseBodyOptions>} [options] - Options for parsing the body.
+ * @returns {Promise<T>} The parsed body data.
+ */
+interface ParseBody {
+    <Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(request: HonoRequest | Request, options?: Options): Promise<T>;
+    <T extends BodyData>(request: HonoRequest | Request, options?: Partial<ParseBodyOptions>): Promise<T>;
+}
+export declare const parseBody: ParseBody;
+export {};

package/src/node_modules/hono/dist/types/utils/buffer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * Buffer utility.
+ */
+export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
+export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function) => Promise<boolean>;
+export declare const bufferToString: (buffer: ArrayBuffer) => string;
+export declare const bufferToFormData: (arrayBuffer: ArrayBuffer, contentType: string) => Promise<FormData>;

package/src/node_modules/hono/dist/types/utils/color.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module
+ * Color utility.
+ */
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * Unlike getColorEnabledAsync(), this cannot check Cloudflare environment variables.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export declare function getColorEnabled(): boolean;
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export declare function getColorEnabledAsync(): Promise<boolean>;

package/src/node_modules/hono/dist/types/utils/compress.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * Constants for compression.
+ */
+/**
+ * Match for compressible content type.
+ */
+export declare const COMPRESSIBLE_CONTENT_TYPE_REGEX: RegExp;

package/src/node_modules/hono/dist/types/utils/concurrent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module
+ * Concurrent utility.
+ */
+export interface Pool {
+    run<T>(fn: () => T): Promise<T>;
+}
+export declare const createPool: ({ concurrency, interval, }?: {
+    concurrency?: number;
+    interval?: number;
+}) => Pool;

package/src/node_modules/hono/dist/types/utils/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Constant used to mark a composed handler.
+ */
+export declare const COMPOSED_HANDLER = "__COMPOSED_HANDLER";

package/src/node_modules/hono/dist/types/utils/cookie.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module
+ * Cookie utility.
+ */
+export type Cookie = Record<string, string>;
+export type SignedCookie = Record<string, string | false>;
+type PartitionedCookieConstraint = {
+    partitioned: true;
+    secure: true;
+} | {
+    partitioned?: boolean;
+    secure?: boolean;
+};
+type SecureCookieConstraint = {
+    secure: true;
+};
+type HostCookieConstraint = {
+    secure: true;
+    path: '/';
+    domain?: undefined;
+};
+export type CookieOptions = {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None' | 'strict' | 'lax' | 'none';
+    partitioned?: boolean;
+    priority?: 'Low' | 'Medium' | 'High' | 'low' | 'medium' | 'high';
+    prefix?: CookiePrefixOptions;
+} & PartitionedCookieConstraint;
+export type CookiePrefixOptions = 'host' | 'secure';
+export type CookieConstraint<Name> = Name extends `__Secure-${string}` ? CookieOptions & SecureCookieConstraint : Name extends `__Host-${string}` ? CookieOptions & HostCookieConstraint : CookieOptions;
+export declare const parse: (cookie: string, name?: string) => Cookie;
+export declare const parseSigned: (cookie: string, secret: string | BufferSource, name?: string) => Promise<SignedCookie>;
+export declare const serialize: <Name extends string>(name: Name, value: string, opt?: CookieConstraint<Name>) => string;
+export declare const serializeSigned: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
+export {};

package/src/node_modules/hono/dist/types/utils/crypto.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module
+ * Crypto utility.
+ */
+import type { JSONValue } from './types';
+type Algorithm = {
+    name: string;
+    alias: string;
+};
+type Data = string | boolean | number | JSONValue | ArrayBufferView | ArrayBuffer;
+export declare const sha256: (data: Data) => Promise<string | null>;
+export declare const sha1: (data: Data) => Promise<string | null>;
+export declare const md5: (data: Data) => Promise<string | null>;
+export declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string | null>;
+export {};

package/src/node_modules/hono/dist/types/utils/encode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * Encode utility.
+ */
+export declare const decodeBase64Url: (str: string) => Uint8Array<ArrayBuffer>;
+export declare const encodeBase64Url: (buf: ArrayBufferLike) => string;
+export declare const encodeBase64: (buf: ArrayBufferLike) => string;
+export declare const decodeBase64: (str: string) => Uint8Array<ArrayBuffer>;

package/src/node_modules/hono/dist/types/utils/filepath.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module
+ * FilePath utility.
+ */
+type FilePathOptions = {
+    filename: string;
+    root?: string;
+    defaultDocument?: string;
+};
+export declare const getFilePath: (options: FilePathOptions) => string | undefined;
+export declare const getFilePathWithoutDefaultDocument: (options: Omit<FilePathOptions, "defaultDocument">) => string | undefined;
+export {};

package/src/node_modules/hono/dist/types/utils/handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * Handler utility.
+ */
+export declare const isMiddleware: (handler: Function) => boolean;
+export declare const findTargetHandler: (handler: Function) => Function;

package/src/node_modules/hono/dist/types/utils/headers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * HTTP Headers utility.
+ */
+export type RequestHeader = 'A-IM' | 'Accept' | 'Accept-Additions' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Datetime' | 'Accept-Encoding' | 'Accept-Features' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Accept-Signature' | 'Access-Control' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'ALPN' | 'Alt-Svc' | 'Alt-Used' | 'Alternates' | 'AMP-Cache-Transform' | 'Apply-To-Redirect-Ref' | 'Authentication-Control' | 'Authentication-Info' | 'Authorization' | 'Available-Dictionary' | 'C-Ext' | 'C-Man' | 'C-Opt' | 'C-PEP' | 'C-PEP-Info' | 'Cache-Control' | 'Cache-Status' | 'Cal-Managed-ID' | 'CalDAV-Timezones' | 'Capsule-Protocol' | 'CDN-Cache-Control' | 'CDN-Loop' | 'Cert-Not-After' | 'Cert-Not-Before' | 'Clear-Site-Data' | 'Client-Cert' | 'Client-Cert-Chain' | 'Close' | 'CMCD-Object' | 'CMCD-Request' | 'CMCD-Session' | 'CMCD-Status' | 'CMSD-Dynamic' | 'CMSD-Static' | 'Concealed-Auth-Export' | 'Configuration-Context' | 'Connection' | 'Content-Base' | 'Content-Digest' | 'Content-Disposition' | 'Content-Encoding' | 'Content-ID' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-MD5' | 'Content-Range' | 'Content-Script-Type' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Style-Type' | 'Content-Type' | 'Content-Version' | 'Cookie' | 'Cookie2' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Embedder-Policy-Report-Only' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Opener-Policy-Report-Only' | 'Cross-Origin-Resource-Policy' | 'CTA-Common-Access-Token' | 'DASL' | 'Date' | 'DAV' | 'Default-Style' | 'Delta-Base' | 'Deprecation' | 'Depth' | 'Derived-From' | 'Destination' | 'Differential-ID' | 'Dictionary-ID' | 'Digest' | 'DPoP' | 'DPoP-Nonce' | 'Early-Data' | 'EDIINT-Features' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Ext' | 'Forwarded' | 'From' | 'GetProfile' | 'Hobareg' | 'Host' | 'HTTP2-Settings' | 'If' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Schedule-Tag-Match' | 'If-Unmodified-Since' | 'IM' | 'Include-Referred-Token-Binding-ID' | 'Isolation' | 'Keep-Alive' | 'Label' | 'Last-Event-ID' | 'Last-Modified' | 'Link' | 'Link-Template' | 'Location' | 'Lock-Token' | 'Man' | 'Max-Forwards' | 'Memento-Datetime' | 'Meter' | 'Method-Check' | 'Method-Check-Expires' | 'MIME-Version' | 'Negotiate' | 'NEL' | 'OData-EntityId' | 'OData-Isolation' | 'OData-MaxVersion' | 'OData-Version' | 'Opt' | 'Optional-WWW-Authenticate' | 'Ordering-Type' | 'Origin' | 'Origin-Agent-Cluster' | 'OSCORE' | 'OSLC-Core-Version' | 'Overwrite' | 'P3P' | 'PEP' | 'PEP-Info' | 'Permissions-Policy' | 'PICS-Label' | 'Ping-From' | 'Ping-To' | 'Position' | 'Pragma' | 'Prefer' | 'Preference-Applied' | 'Priority' | 'ProfileObject' | 'Protocol' | 'Protocol-Info' | 'Protocol-Query' | 'Protocol-Request' | 'Proxy-Authenticate' | 'Proxy-Authentication-Info' | 'Proxy-Authorization' | 'Proxy-Features' | 'Proxy-Instruction' | 'Proxy-Status' | 'Public' | 'Public-Key-Pins' | 'Public-Key-Pins-Report-Only' | 'Range' | 'Redirect-Ref' | 'Referer' | 'Referer-Root' | 'Referrer-Policy' | 'Refresh' | 'Repeatability-Client-ID' | 'Repeatability-First-Sent' | 'Repeatability-Request-ID' | 'Repeatability-Result' | 'Replay-Nonce' | 'Reporting-Endpoints' | 'Repr-Digest' | 'Retry-After' | 'Safe' | 'Schedule-Reply' | 'Schedule-Tag' | 'Sec-GPC' | 'Sec-Purpose' | 'Sec-Token-Binding' | 'Sec-WebSocket-Accept' | 'Sec-WebSocket-Extensions' | 'Sec-WebSocket-Key' | 'Sec-WebSocket-Protocol' | 'Sec-WebSocket-Version' | 'Security-Scheme' | 'Server' | 'Server-Timing' | 'Set-Cookie' | 'Set-Cookie2' | 'SetProfile' | 'Signature' | 'Signature-Input' | 'SLUG' | 'SoapAction' | 'Status-URI' | 'Strict-Transport-Security' | 'Sunset' | 'Surrogate-Capability' | 'Surrogate-Control' | 'TCN' | 'TE' | 'Timeout' | 'Timing-Allow-Origin' | 'Topic' | 'Traceparent' | 'Tracestate' | 'Trailer' | 'Transfer-Encoding' | 'TTL' | 'Upgrade' | 'Urgency' | 'URI' | 'Use-As-Dictionary' | 'User-Agent' | 'Variant-Vary' | 'Vary' | 'Via' | 'Want-Content-Digest' | 'Want-Digest' | 'Want-Repr-Digest' | 'Warning' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options';
+export type ResponseHeader = 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Age' | 'Allow' | 'Cache-Control' | 'Clear-Site-Data' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'ETag' | 'Expires' | 'Last-Modified' | 'Location' | 'Permissions-Policy' | 'Pragma' | 'Retry-After' | 'Save-Data' | 'Sec-CH-Prefers-Color-Scheme' | 'Sec-CH-Prefers-Reduced-Motion' | 'Sec-CH-UA' | 'Sec-CH-UA-Arch' | 'Sec-CH-UA-Bitness' | 'Sec-CH-UA-Form-Factor' | 'Sec-CH-UA-Full-Version' | 'Sec-CH-UA-Full-Version-List' | 'Sec-CH-UA-Mobile' | 'Sec-CH-UA-Model' | 'Sec-CH-UA-Platform' | 'Sec-CH-UA-Platform-Version' | 'Sec-CH-UA-WoW64' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-GPC' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'Strict-Transport-Security' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Vary' | 'WWW-Authenticate' | 'Warning' | 'X-Content-Type-Options' | 'X-DNS-Prefetch-Control' | 'X-Frame-Options' | 'X-Permitted-Cross-Domain-Policies' | 'X-Powered-By' | 'X-Robots-Tag' | 'X-XSS-Protection';
+export type AcceptHeader = 'Accept' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges';
+export type CustomHeader = string & {};

package/src/node_modules/hono/dist/types/utils/html.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module
+ * HTML utility.
+ */
+export declare const HtmlEscapedCallbackPhase: {
+    readonly Stringify: 1;
+    readonly BeforeStream: 2;
+    readonly Stream: 3;
+};
+type HtmlEscapedCallbackOpts = {
+    buffer?: [string];
+    phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase];
+    context: Readonly<object>;
+};
+export type HtmlEscapedCallback = (opts: HtmlEscapedCallbackOpts) => Promise<string> | undefined;
+export type HtmlEscaped = {
+    isEscaped: true;
+    callbacks?: HtmlEscapedCallback[];
+};
+export type HtmlEscapedString = string & HtmlEscaped;
+/**
+ * StringBuffer contains string and Promise<string> alternately
+ * The length of the array will be odd, the odd numbered element will be a string,
+ * and the even numbered element will be a Promise<string>.
+ * When concatenating into a single string, it must be processed from the tail.
+ * @example
+ * [
+ *   'framework.',
+ *   Promise.resolve('ultra fast'),
+ *   'a ',
+ *   Promise.resolve('is '),
+ *   'Hono',
+ * ]
+ */
+export type StringBuffer = (string | Promise<string>)[];
+export type StringBufferWithCallbacks = StringBuffer & {
+    callbacks: HtmlEscapedCallback[];
+};
+export declare const raw: (value: unknown, callbacks?: HtmlEscapedCallback[]) => HtmlEscapedString;
+export declare const stringBufferToString: (buffer: StringBuffer, callbacks: HtmlEscapedCallback[] | undefined) => Promise<HtmlEscapedString>;
+export declare const escapeToBuffer: (str: string, buffer: StringBuffer) => void;
+export declare const resolveCallbackSync: (str: string | HtmlEscapedString) => string;
+export declare const resolveCallback: (str: string | HtmlEscapedString | Promise<string>, phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase], preserveCallbacks: boolean, context: object, buffer?: [string]) => Promise<string>;
+export {};

package/src/node_modules/hono/dist/types/utils/http-status.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module
+ * HTTP Status utility.
+ */
+export type InfoStatusCode = 100 | 101 | 102 | 103;
+export type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+export type DeprecatedStatusCode = 305 | 306;
+export type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+export type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+export type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+/**
+ * `UnofficialStatusCode` can be used to specify an unofficial status code.
+ * @example
+ *
+ * ```ts
+ * app.get('/unknown', (c) => {
+ *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
+ * })
+ * ```
+ */
+export type UnofficialStatusCode = -1;
+/**
+ * @deprecated
+ * Use `UnofficialStatusCode` instead.
+ */
+export type UnOfficalStatusCode = UnofficialStatusCode;
+/**
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
+ */
+export type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
+export type ContentlessStatusCode = 101 | 204 | 205 | 304;
+export type ContentfulStatusCode = Exclude<StatusCode, ContentlessStatusCode>;

package/src/node_modules/hono/dist/types/utils/ipaddr.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Utils for IP Addresses
+ * @module
+ */
+import type { AddressType } from '../helper/conninfo';
+/**
+ * Expand IPv6 Address
+ * @param ipV6 Shorten IPv6 Address
+ * @return expanded IPv6 Address
+ */
+export declare const expandIPv6: (ipV6: string) => string;
+/**
+ * Distinct Remote Addr
+ * @param remoteAddr Remote Addr
+ */
+export declare const distinctRemoteAddr: (remoteAddr: string) => AddressType;
+/**
+ * Convert IPv4 to Uint8Array
+ * @param ipv4 IPv4 Address
+ * @returns BigInt
+ */
+export declare const convertIPv4ToBinary: (ipv4: string) => bigint;
+/**
+ * Convert IPv6 to Uint8Array
+ * @param ipv6 IPv6 Address
+ * @returns BigInt
+ */
+export declare const convertIPv6ToBinary: (ipv6: string) => bigint;
+/**
+ * Convert a binary representation of an IPv4 address to a string.
+ * @param ipV4 binary IPv4 Address
+ * @return IPv4 Address in string
+ */
+export declare const convertIPv4BinaryToString: (ipV4: bigint) => string;
+/**
+ * Convert a binary representation of an IPv6 address to a string.
+ * @param ipV6 binary IPv6 Address
+ * @return normalized IPv6 Address in string
+ */
+export declare const convertIPv6BinaryToString: (ipV6: bigint) => string;

package/src/node_modules/hono/dist/types/utils/jwt/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module
+ * JWT utility.
+ */
+export declare const Jwt: {
+    sign: (payload: import("./types").JWTPayload, privateKey: import("./jws").SignatureKey, alg?: import("./jwa").SignatureAlgorithm) => Promise<string>;
+    verify: (token: string, publicKey: import("./jws").SignatureKey, algOrOptions: import("./jwa").SignatureAlgorithm | import("./jwt").VerifyOptionsWithAlg) => Promise<import("./types").JWTPayload>;
+    decode: (token: string) => {
+        header: import("./jwt").TokenHeader;
+        payload: import("./types").JWTPayload;
+    };
+    verifyWithJwks: (token: string, options: {
+        keys?: import("./jws").HonoJsonWebKey[];
+        jwks_uri?: string;
+        verification?: import("./jwt").VerifyOptions;
+        allowedAlgorithms: readonly import("./jwa").AsymmetricAlgorithm[];
+    }, init?: RequestInit) => Promise<import("./types").JWTPayload>;
+};

package/src/node_modules/hono/dist/types/utils/jwt/jwa.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module
+ * JSON Web Algorithms (JWA)
+ * https://datatracker.ietf.org/doc/html/rfc7518
+ */
+export declare enum AlgorithmTypes {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512",
+    RS256 = "RS256",
+    RS384 = "RS384",
+    RS512 = "RS512",
+    PS256 = "PS256",
+    PS384 = "PS384",
+    PS512 = "PS512",
+    ES256 = "ES256",
+    ES384 = "ES384",
+    ES512 = "ES512",
+    EdDSA = "EdDSA"
+}
+export type SignatureAlgorithm = keyof typeof AlgorithmTypes;
+export type SymmetricAlgorithm = 'HS256' | 'HS384' | 'HS512';
+export type AsymmetricAlgorithm = 'RS256' | 'RS384' | 'RS512' | 'PS256' | 'PS384' | 'PS512' | 'ES256' | 'ES384' | 'ES512' | 'EdDSA';

package/src/node_modules/hono/dist/types/utils/jwt/jws.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module
+ * JSON Web Signature (JWS)
+ * https://datatracker.ietf.org/doc/html/rfc7515
+ */
+import type { SignatureAlgorithm } from './jwa';
+export interface HonoJsonWebKey extends JsonWebKey {
+    kid?: string;
+}
+export type SignatureKey = string | HonoJsonWebKey | CryptoKey;
+export declare function signing(privateKey: SignatureKey, alg: SignatureAlgorithm, data: BufferSource): Promise<ArrayBuffer>;
+export declare function verifying(publicKey: SignatureKey, alg: SignatureAlgorithm, signature: BufferSource, data: BufferSource): Promise<boolean>;

package/src/node_modules/hono/dist/types/utils/jwt/jwt.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @module
+ * JSON Web Token (JWT)
+ * https://datatracker.ietf.org/doc/html/rfc7519
+ */
+import type { AsymmetricAlgorithm, SignatureAlgorithm } from './jwa';
+import type { HonoJsonWebKey, SignatureKey } from './jws';
+import type { JWTPayload } from './types';
+export interface TokenHeader {
+    alg: SignatureAlgorithm;
+    typ?: 'JWT';
+    kid?: string;
+}
+export declare function isTokenHeader(obj: unknown): obj is TokenHeader;
+export declare const sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
+export type VerifyOptions = {
+    /** The expected issuer used for verifying the token */
+    iss?: string | RegExp;
+    /** Verify the `nbf` claim (default: `true`) */
+    nbf?: boolean;
+    /** Verify the `exp` claim (default: `true`) */
+    exp?: boolean;
+    /** Verify the `iat` claim (default: `true`) */
+    iat?: boolean;
+    /** Acceptable audience(s) for the token */
+    aud?: string | string[] | RegExp;
+};
+export type VerifyOptionsWithAlg = {
+    /** The algorithm used for decoding the token */
+    alg: SignatureAlgorithm;
+} & VerifyOptions;
+export declare const verify: (token: string, publicKey: SignatureKey, algOrOptions: SignatureAlgorithm | VerifyOptionsWithAlg) => Promise<JWTPayload>;
+export declare const verifyWithJwks: (token: string, options: {
+    keys?: HonoJsonWebKey[];
+    jwks_uri?: string;
+    verification?: VerifyOptions;
+    allowedAlgorithms: readonly AsymmetricAlgorithm[];
+}, init?: RequestInit) => Promise<JWTPayload>;
+export declare const decode: (token: string) => {
+    header: TokenHeader;
+    payload: JWTPayload;
+};
+export declare const decodeHeader: (token: string) => TokenHeader;

package/src/node_modules/hono/dist/types/utils/jwt/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @module
+ * Type definitions for JWT utilities.
+ */
+export declare class JwtAlgorithmNotImplemented extends Error {
+    constructor(alg: string);
+}
+export declare class JwtAlgorithmRequired extends Error {
+    constructor();
+}
+export declare class JwtAlgorithmMismatch extends Error {
+    constructor(expected: string, actual: string);
+}
+export declare class JwtTokenInvalid extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenNotBefore extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenExpired extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenIssuedAt extends Error {
+    constructor(currentTimestamp: number, iat: number);
+}
+export declare class JwtTokenIssuer extends Error {
+    constructor(expected: string | RegExp, iss: string | null);
+}
+export declare class JwtHeaderInvalid extends Error {
+    constructor(header: object);
+}
+export declare class JwtHeaderRequiresKid extends Error {
+    constructor(header: object);
+}
+export declare class JwtSymmetricAlgorithmNotAllowed extends Error {
+    constructor(alg: string);
+}
+export declare class JwtAlgorithmNotAllowed extends Error {
+    constructor(alg: string, allowedAlgorithms: readonly string[]);
+}
+export declare class JwtTokenSignatureMismatched extends Error {
+    constructor(token: string);
+}
+export declare class JwtPayloadRequiresAud extends Error {
+    constructor(payload: object);
+}
+export declare class JwtTokenAudience extends Error {
+    constructor(expected: string | string[] | RegExp, aud: string | string[]);
+}
+export declare enum CryptoKeyUsage {
+    Encrypt = "encrypt",
+    Decrypt = "decrypt",
+    Sign = "sign",
+    Verify = "verify",
+    DeriveKey = "deriveKey",
+    DeriveBits = "deriveBits",
+    WrapKey = "wrapKey",
+    UnwrapKey = "unwrapKey"
+}
+/**
+ * JWT Payload
+ */
+export type JWTPayload = {
+    [key: string]: unknown;
+    /**
+     * The token is checked to ensure it has not expired.
+     */
+    exp?: number;
+    /**
+     * The token is checked to ensure it is not being used before a specified time.
+     */
+    nbf?: number;
+    /**
+     * The token is checked to ensure it is not issued in the future.
+     */
+    iat?: number;
+    /**
+     * The token is checked to ensure it has been issued by a trusted issuer.
+     */
+    iss?: string;
+    /**
+     * The token is checked to ensure it is intended for a specific audience.
+     */
+    aud?: string | string[];
+};
+export type { HonoJsonWebKey } from './jws';

package/src/node_modules/hono/dist/types/utils/jwt/utf8.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * Functions for encoding/decoding UTF8.
+ */
+export declare const utf8Encoder: TextEncoder;
+export declare const utf8Decoder: TextDecoder;

package/src/node_modules/hono/dist/types/utils/mime.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @module
+ * MIME utility.
+ */
+export declare const getMimeType: (filename: string, mimes?: Record<string, string>) => string | undefined;
+export declare const getExtension: (mimeType: string) => string | undefined;
+export { baseMimes as mimes };
+/**
+ * Union types for BaseMime
+ */
+export type BaseMime = (typeof _baseMimes)[keyof typeof _baseMimes];
+declare const _baseMimes: {
+    readonly aac: "audio/aac";
+    readonly avi: "video/x-msvideo";
+    readonly avif: "image/avif";
+    readonly av1: "video/av1";
+    readonly bin: "application/octet-stream";
+    readonly bmp: "image/bmp";
+    readonly css: "text/css";
+    readonly csv: "text/csv";
+    readonly eot: "application/vnd.ms-fontobject";
+    readonly epub: "application/epub+zip";
+    readonly gif: "image/gif";
+    readonly gz: "application/gzip";
+    readonly htm: "text/html";
+    readonly html: "text/html";
+    readonly ico: "image/x-icon";
+    readonly ics: "text/calendar";
+    readonly jpeg: "image/jpeg";
+    readonly jpg: "image/jpeg";
+    readonly js: "text/javascript";
+    readonly json: "application/json";
+    readonly jsonld: "application/ld+json";
+    readonly map: "application/json";
+    readonly mid: "audio/x-midi";
+    readonly midi: "audio/x-midi";
+    readonly mjs: "text/javascript";
+    readonly mp3: "audio/mpeg";
+    readonly mp4: "video/mp4";
+    readonly mpeg: "video/mpeg";
+    readonly oga: "audio/ogg";
+    readonly ogv: "video/ogg";
+    readonly ogx: "application/ogg";
+    readonly opus: "audio/opus";
+    readonly otf: "font/otf";
+    readonly pdf: "application/pdf";
+    readonly png: "image/png";
+    readonly rtf: "application/rtf";
+    readonly svg: "image/svg+xml";
+    readonly tif: "image/tiff";
+    readonly tiff: "image/tiff";
+    readonly ts: "video/mp2t";
+    readonly ttf: "font/ttf";
+    readonly txt: "text/plain";
+    readonly wasm: "application/wasm";
+    readonly webm: "video/webm";
+    readonly weba: "audio/webm";
+    readonly webmanifest: "application/manifest+json";
+    readonly webp: "image/webp";
+    readonly woff: "font/woff";
+    readonly woff2: "font/woff2";
+    readonly xhtml: "application/xhtml+xml";
+    readonly xml: "application/xml";
+    readonly zip: "application/zip";
+    readonly '3gp': "video/3gpp";
+    readonly '3g2': "video/3gpp2";
+    readonly gltf: "model/gltf+json";
+    readonly glb: "model/gltf-binary";
+};
+declare const baseMimes: Record<string, BaseMime>;