recker 1.0.20-next.de24f7d → 1.0.20-next.e194d90

package/dist/plugins/auth.d.ts

@@ -1,45 +1 @@
-import { Middleware, Plugin } from '../types/index.js';
-export interface BasicAuthOptions {
-    username: string;
-    password: string;
-}
-export declare function basicAuth(options: BasicAuthOptions): Middleware;
-export declare function basicAuthPlugin(options: BasicAuthOptions): Plugin;
-export interface BearerAuthOptions {
-    token: string | (() => string | Promise<string>);
-    type?: string;
-    headerName?: string;
-}
-export declare function bearerAuth(options: BearerAuthOptions): Middleware;
-export declare function bearerAuthPlugin(options: BearerAuthOptions): Plugin;
-export interface ApiKeyAuthOptions {
-    key: string | (() => string | Promise<string>);
-    in?: 'header' | 'query';
-    name?: string;
-}
-export declare function apiKeyAuth(options: ApiKeyAuthOptions): Middleware;
-export declare function apiKeyAuthPlugin(options: ApiKeyAuthOptions): Plugin;
-export interface DigestAuthOptions {
-    username: string;
-    password: string;
-    preemptive?: boolean;
-}
-export declare function digestAuth(options: DigestAuthOptions): Middleware;
-export declare function digestAuthPlugin(options: DigestAuthOptions): Plugin;
-export interface OAuth2Options {
-    accessToken: string | (() => string | Promise<string>);
-    tokenType?: string;
-    onTokenExpired?: () => Promise<string>;
-}
-export declare function oauth2(options: OAuth2Options): Middleware;
-export declare function oauth2Plugin(options: OAuth2Options): Plugin;
-export interface AWSSignatureV4Options {
-    accessKeyId: string;
-    secretAccessKey: string;
-    region: string;
-    service: string;
-    sessionToken?: string;
-}
-export declare function awsSignatureV4(options: AWSSignatureV4Options): Middleware;
-export declare function awsSignatureV4Plugin(options: AWSSignatureV4Options): Plugin;
-//# sourceMappingURL=auth.d.ts.map
+export * from './auth/index.js';

package/dist/plugins/auth.js

@@ -1,268 +1 @@
-import { createHash, randomBytes } from 'node:crypto';
-export function basicAuth(options) {
-    const credentials = Buffer.from(`${options.username}:${options.password}`).toString('base64');
-    const authHeader = `Basic ${credentials}`;
-    return async (req, next) => {
-        const newReq = req.withHeader('Authorization', authHeader);
-        return next(newReq);
-    };
-}
-export function basicAuthPlugin(options) {
-    return (client) => {
-        client.use(basicAuth(options));
-    };
-}
-export function bearerAuth(options) {
-    const type = options.type ?? 'Bearer';
-    const headerName = options.headerName ?? 'Authorization';
-    return async (req, next) => {
-        const token = typeof options.token === 'function'
-            ? await options.token()
-            : options.token;
-        const authHeader = `${type} ${token}`;
-        const newReq = req.withHeader(headerName, authHeader);
-        return next(newReq);
-    };
-}
-export function bearerAuthPlugin(options) {
-    return (client) => {
-        client.use(bearerAuth(options));
-    };
-}
-export function apiKeyAuth(options) {
-    const location = options.in ?? 'header';
-    const name = options.name ?? 'X-API-Key';
-    return async (req, next) => {
-        const key = typeof options.key === 'function'
-            ? await options.key()
-            : options.key;
-        if (location === 'header') {
-            const newReq = req.withHeader(name, key);
-            return next(newReq);
-        }
-        else {
-            const url = new URL(req.url);
-            url.searchParams.set(name, key);
-            const newReq = {
-                ...req,
-                url: url.toString(),
-            };
-            return next(newReq);
-        }
-    };
-}
-export function apiKeyAuthPlugin(options) {
-    return (client) => {
-        client.use(apiKeyAuth(options));
-    };
-}
-function parseDigestChallenge(header) {
-    if (!header.toLowerCase().startsWith('digest ')) {
-        return null;
-    }
-    const params = {};
-    const regex = /(\w+)=(?:"([^"]+)"|([^\s,]+))/g;
-    let match;
-    while ((match = regex.exec(header)) !== null) {
-        params[match[1].toLowerCase()] = match[2] || match[3];
-    }
-    if (!params.realm || !params.nonce) {
-        return null;
-    }
-    return {
-        realm: params.realm,
-        nonce: params.nonce,
-        qop: params.qop,
-        opaque: params.opaque,
-        algorithm: params.algorithm,
-        stale: params.stale === 'true',
-    };
-}
-function md5(str) {
-    return createHash('md5').update(str).digest('hex');
-}
-function sha256(str) {
-    return createHash('sha256').update(str).digest('hex');
-}
-function generateDigestHeader(method, uri, username, password, challenge, nc) {
-    const algorithm = challenge.algorithm?.toUpperCase() || 'MD5';
-    const hashFn = algorithm.includes('SHA-256') ? sha256 : md5;
-    const cnonce = randomBytes(8).toString('hex');
-    const ncStr = nc.toString(16).padStart(8, '0');
-    let ha1 = hashFn(`${username}:${challenge.realm}:${password}`);
-    if (algorithm.endsWith('-SESS')) {
-        ha1 = hashFn(`${ha1}:${challenge.nonce}:${cnonce}`);
-    }
-    const ha2 = hashFn(`${method}:${uri}`);
-    let response;
-    if (challenge.qop) {
-        response = hashFn(`${ha1}:${challenge.nonce}:${ncStr}:${cnonce}:${challenge.qop}:${ha2}`);
-    }
-    else {
-        response = hashFn(`${ha1}:${challenge.nonce}:${ha2}`);
-    }
-    const parts = [
-        `username="${username}"`,
-        `realm="${challenge.realm}"`,
-        `nonce="${challenge.nonce}"`,
-        `uri="${uri}"`,
-        `response="${response}"`,
-    ];
-    if (challenge.qop) {
-        parts.push(`qop=${challenge.qop.split(',')[0].trim()}`);
-        parts.push(`nc=${ncStr}`);
-        parts.push(`cnonce="${cnonce}"`);
-    }
-    if (challenge.opaque) {
-        parts.push(`opaque="${challenge.opaque}"`);
-    }
-    if (algorithm !== 'MD5') {
-        parts.push(`algorithm=${algorithm}`);
-    }
-    return `Digest ${parts.join(', ')}`;
-}
-export function digestAuth(options) {
-    let nc = 0;
-    let lastChallenge = null;
-    return async (req, next) => {
-        if (lastChallenge && options.preemptive) {
-            nc++;
-            const uri = new URL(req.url).pathname + new URL(req.url).search;
-            const authHeader = generateDigestHeader(req.method, uri, options.username, options.password, lastChallenge, nc);
-            const newReq = req.withHeader('Authorization', authHeader);
-            return next(newReq);
-        }
-        const response = await next(req);
-        if (response.status === 401) {
-            const wwwAuth = response.headers.get('WWW-Authenticate');
-            if (wwwAuth) {
-                const challenge = parseDigestChallenge(wwwAuth);
-                if (challenge) {
-                    lastChallenge = challenge;
-                    nc++;
-                    const uri = new URL(req.url).pathname + new URL(req.url).search;
-                    const authHeader = generateDigestHeader(req.method, uri, options.username, options.password, challenge, nc);
-                    const newReq = req.withHeader('Authorization', authHeader);
-                    return next(newReq);
-                }
-            }
-        }
-        return response;
-    };
-}
-export function digestAuthPlugin(options) {
-    return (client) => {
-        client.use(digestAuth(options));
-    };
-}
-export function oauth2(options) {
-    const tokenType = options.tokenType ?? 'Bearer';
-    return async (req, next) => {
-        const token = typeof options.accessToken === 'function'
-            ? await options.accessToken()
-            : options.accessToken;
-        const authReq = req.withHeader('Authorization', `${tokenType} ${token}`);
-        const response = await next(authReq);
-        if (response.status === 401 && options.onTokenExpired) {
-            try {
-                const newToken = await options.onTokenExpired();
-                const retryReq = req.withHeader('Authorization', `${tokenType} ${newToken}`);
-                return next(retryReq);
-            }
-            catch {
-                return response;
-            }
-        }
-        return response;
-    };
-}
-export function oauth2Plugin(options) {
-    return (client) => {
-        client.use(oauth2(options));
-    };
-}
-export function awsSignatureV4(options) {
-    return async (req, next) => {
-        const url = new URL(req.url);
-        const host = url.host;
-        const pathname = url.pathname;
-        const queryString = url.search.slice(1);
-        const now = new Date();
-        const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, '');
-        const dateStamp = amzDate.slice(0, 8);
-        const method = req.method;
-        const canonicalUri = pathname || '/';
-        const canonicalQueryString = queryString
-            .split('&')
-            .filter(Boolean)
-            .sort()
-            .join('&');
-        let payload = '';
-        if (req.body) {
-            if (typeof req.body === 'string') {
-                payload = req.body;
-            }
-            else if (req.body instanceof ArrayBuffer) {
-                payload = Buffer.from(req.body).toString();
-            }
-        }
-        const payloadHash = sha256(payload);
-        const headers = {
-            host,
-            'x-amz-date': amzDate,
-            'x-amz-content-sha256': payloadHash,
-        };
-        if (options.sessionToken) {
-            headers['x-amz-security-token'] = options.sessionToken;
-        }
-        req.headers.forEach((value, key) => {
-            headers[key.toLowerCase()] = value;
-        });
-        const signedHeaders = Object.keys(headers).sort().join(';');
-        const canonicalHeaders = Object.keys(headers)
-            .sort()
-            .map(key => `${key}:${headers[key].trim()}\n`)
-            .join('');
-        const canonicalRequest = [
-            method,
-            canonicalUri,
-            canonicalQueryString,
-            canonicalHeaders,
-            signedHeaders,
-            payloadHash,
-        ].join('\n');
-        const algorithm = 'AWS4-HMAC-SHA256';
-        const credentialScope = `${dateStamp}/${options.region}/${options.service}/aws4_request`;
-        const stringToSign = [
-            algorithm,
-            amzDate,
-            credentialScope,
-            sha256(canonicalRequest),
-        ].join('\n');
-        const getSignatureKey = (key, dateStamp, regionName, serviceName) => {
-            const kDate = createHash('sha256').update(`AWS4${key}`).update(dateStamp).digest();
-            const kRegion = createHash('sha256').update(kDate).update(regionName).digest();
-            const kService = createHash('sha256').update(kRegion).update(serviceName).digest();
-            const kSigning = createHash('sha256').update(kService).update('aws4_request').digest();
-            return kSigning;
-        };
-        const signingKey = getSignatureKey(options.secretAccessKey, dateStamp, options.region, options.service);
-        const signature = createHash('sha256')
-            .update(signingKey)
-            .update(stringToSign)
-            .digest('hex');
-        const authorizationHeader = `${algorithm} Credential=${options.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-        let newReq = req.withHeader('Authorization', authorizationHeader);
-        newReq = newReq.withHeader('x-amz-date', amzDate);
-        newReq = newReq.withHeader('x-amz-content-sha256', payloadHash);
-        if (options.sessionToken) {
-            newReq = newReq.withHeader('x-amz-security-token', options.sessionToken);
-        }
-        return next(newReq);
-    };
-}
-export function awsSignatureV4Plugin(options) {
-    return (client) => {
-        client.use(awsSignatureV4(options));
-    };
-}
+export * from './auth/index.js';

package/dist/plugins/cache.d.ts

@@ -13,4 +13,3 @@ export interface CacheOptions {
 declare function parseCacheControl(header: string | null): Partial<CacheEntry>;
 export declare function cache(options?: CacheOptions): Plugin;
 export { parseCacheControl };
-//# sourceMappingURL=cache.d.ts.map

package/dist/plugins/cache.js

@@ -293,7 +293,7 @@ export function cache(options = {}) {
                 key = generateKey(req, baseEntry.vary);
                 cachedEntry = await storage.get(key);
             }
-            else if (baseEntry && baseEntry.body) {
+            else if (baseEntry?.body) {
                 cachedEntry = baseEntry;
             }
             else {

package/dist/plugins/certificate-pinning.d.ts

@@ -0,0 +1,59 @@
+import { Middleware, Plugin, ReckerRequest } from '../types/index.js';
+import { TLSSocket } from 'node:tls';
+export interface CertificatePinningOptions {
+    pins: Record<string, PinConfig>;
+    onPinFailure?: 'reject' | 'warn' | 'report';
+    reportUri?: string;
+    includeSubdomains?: boolean;
+    cache?: boolean;
+    cacheMaxAge?: number;
+    onError?: (error: CertificatePinningError, request: ReckerRequest) => void;
+    skip?: (request: ReckerRequest) => boolean;
+}
+export interface PinConfig {
+    sha256?: string[];
+    spki?: string[];
+    issuer?: string;
+    subject?: string;
+    minValidDays?: number;
+    allowExpired?: boolean;
+    backup?: string[];
+}
+export declare class CertificatePinningError extends Error {
+    hostname: string;
+    expectedPins: string[];
+    actualPin?: string | undefined;
+    certificate?: CertificateInfo | undefined;
+    constructor(message: string, hostname: string, expectedPins: string[], actualPin?: string | undefined, certificate?: CertificateInfo | undefined);
+}
+export interface CertificateInfo {
+    subject: string;
+    issuer: string;
+    validFrom: Date;
+    validTo: Date;
+    fingerprint: string;
+    fingerprintSha256: string;
+    serialNumber: string;
+    subjectPublicKeyInfo?: string;
+}
+export declare function extractCertificateInfo(socket: TLSSocket): CertificateInfo | null;
+export declare function validateCertificate(certInfo: CertificateInfo, pinConfig: PinConfig): {
+    valid: boolean;
+    reason?: string;
+};
+export declare function reportPinFailure(reportUri: string, hostname: string, error: CertificatePinningError): Promise<void>;
+export declare function generatePinsFromHost(hostname: string, port?: number): Promise<{
+    sha256: string;
+    spki?: string;
+}>;
+export declare function certificatePinning(options: CertificatePinningOptions): Middleware;
+export declare function certificatePinningPlugin(options: CertificatePinningOptions): Plugin;
+export declare function clearPinCache(): void;
+export declare function getPinCacheStats(): {
+    size: number;
+    entries: string[];
+};
+export declare function preloadPins(hosts: string[]): Promise<Map<string, {
+    sha256: string;
+    spki?: string;
+}>>;

package/dist/plugins/certificate-pinning.js

@@ -0,0 +1,236 @@
+import { createHash } from 'node:crypto';
+export class CertificatePinningError extends Error {
+    hostname;
+    expectedPins;
+    actualPin;
+    certificate;
+    constructor(message, hostname, expectedPins, actualPin, certificate) {
+        super(message);
+        this.hostname = hostname;
+        this.expectedPins = expectedPins;
+        this.actualPin = actualPin;
+        this.certificate = certificate;
+        this.name = 'CertificatePinningError';
+    }
+}
+const pinCache = new Map();
+function normalizeFingerprint(fp) {
+    return fp.replace(/:/g, '').toLowerCase();
+}
+function calculateFingerprint(cert) {
+    const certBuffer = typeof cert === 'string' ? Buffer.from(cert) : cert;
+    return createHash('sha256').update(certBuffer).digest('hex');
+}
+function calculateSPKIFingerprint(publicKey) {
+    const keyBuffer = typeof publicKey === 'string' ? Buffer.from(publicKey) : publicKey;
+    return createHash('sha256').update(keyBuffer).digest('base64');
+}
+export function extractCertificateInfo(socket) {
+    try {
+        const cert = socket.getPeerCertificate(true);
+        if (!cert || !cert.fingerprint256) {
+            return null;
+        }
+        return {
+            subject: typeof cert.subject === 'object' ? JSON.stringify(cert.subject) : String(cert.subject),
+            issuer: typeof cert.issuer === 'object' ? JSON.stringify(cert.issuer) : String(cert.issuer),
+            validFrom: new Date(cert.valid_from),
+            validTo: new Date(cert.valid_to),
+            fingerprint: cert.fingerprint,
+            fingerprintSha256: cert.fingerprint256,
+            serialNumber: cert.serialNumber,
+            subjectPublicKeyInfo: cert.pubkey?.toString('base64'),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function hostnameMatches(hostname, pattern) {
+    if (pattern === '*') {
+        return true;
+    }
+    if (pattern.startsWith('*.')) {
+        const baseDomain = pattern.slice(2);
+        return hostname === baseDomain || hostname.endsWith('.' + baseDomain);
+    }
+    return hostname === pattern;
+}
+function findPinConfig(hostname, pins, includeSubdomains) {
+    if (pins[hostname]) {
+        return pins[hostname];
+    }
+    for (const pattern of Object.keys(pins)) {
+        if (hostnameMatches(hostname, pattern)) {
+            return pins[pattern];
+        }
+    }
+    if (includeSubdomains) {
+        const parts = hostname.split('.');
+        for (let i = 1; i < parts.length; i++) {
+            const parentDomain = parts.slice(i).join('.');
+            if (pins[parentDomain]) {
+                return pins[parentDomain];
+            }
+        }
+    }
+    return null;
+}
+export function validateCertificate(certInfo, pinConfig) {
+    const now = new Date();
+    if (!pinConfig.allowExpired && certInfo.validTo < now) {
+        return { valid: false, reason: 'Certificate has expired' };
+    }
+    if (certInfo.validFrom > now) {
+        return { valid: false, reason: 'Certificate is not yet valid' };
+    }
+    if (pinConfig.minValidDays) {
+        const daysUntilExpiry = Math.floor((certInfo.validTo.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+        if (daysUntilExpiry < pinConfig.minValidDays) {
+            return {
+                valid: false,
+                reason: `Certificate expires in ${daysUntilExpiry} days (minimum: ${pinConfig.minValidDays})`,
+            };
+        }
+    }
+    if (pinConfig.issuer && !certInfo.issuer.includes(pinConfig.issuer)) {
+        return { valid: false, reason: `Issuer mismatch: expected "${pinConfig.issuer}"` };
+    }
+    if (pinConfig.subject && !certInfo.subject.includes(pinConfig.subject)) {
+        return { valid: false, reason: `Subject mismatch: expected "${pinConfig.subject}"` };
+    }
+    if (pinConfig.sha256 && pinConfig.sha256.length > 0) {
+        const normalizedFingerprint = normalizeFingerprint(certInfo.fingerprintSha256);
+        const normalizedPins = pinConfig.sha256.map(normalizeFingerprint);
+        if (!normalizedPins.includes(normalizedFingerprint)) {
+            if (pinConfig.backup) {
+                const normalizedBackups = pinConfig.backup.map(normalizeFingerprint);
+                if (!normalizedBackups.includes(normalizedFingerprint)) {
+                    return { valid: false, reason: 'SHA-256 fingerprint does not match any pins' };
+                }
+            }
+            else {
+                return { valid: false, reason: 'SHA-256 fingerprint does not match any pins' };
+            }
+        }
+    }
+    if (pinConfig.spki && pinConfig.spki.length > 0 && certInfo.subjectPublicKeyInfo) {
+        const spkiFingerprint = calculateSPKIFingerprint(certInfo.subjectPublicKeyInfo);
+        if (!pinConfig.spki.includes(spkiFingerprint)) {
+            return { valid: false, reason: 'SPKI fingerprint does not match any pins' };
+        }
+    }
+    return { valid: true };
+}
+export async function reportPinFailure(reportUri, hostname, error) {
+    try {
+        await fetch(reportUri, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                timestamp: new Date().toISOString(),
+                hostname,
+                expectedPins: error.expectedPins,
+                actualPin: error.actualPin,
+                certificate: error.certificate,
+                error: error.message,
+            }),
+        });
+    }
+    catch {
+    }
+}
+export async function generatePinsFromHost(hostname, port = 443) {
+    const tls = await import('node:tls');
+    return new Promise((resolve, reject) => {
+        const socket = tls.connect({
+            host: hostname,
+            port,
+            servername: hostname,
+            rejectUnauthorized: false,
+        }, () => {
+            const cert = socket.getPeerCertificate(true);
+            socket.destroy();
+            if (!cert || !cert.fingerprint256) {
+                reject(new Error('Could not retrieve certificate'));
+                return;
+            }
+            const result = {
+                sha256: normalizeFingerprint(cert.fingerprint256),
+            };
+            if (cert.pubkey) {
+                result.spki = calculateSPKIFingerprint(cert.pubkey);
+            }
+            resolve(result);
+        });
+        socket.on('error', reject);
+    });
+}
+export function certificatePinning(options) {
+    const { pins, onPinFailure = 'reject', reportUri, includeSubdomains = false, cache = true, cacheMaxAge = 86400000, onError, skip, } = options;
+    return async (req, next) => {
+        if (skip && skip(req)) {
+            return next(req);
+        }
+        const url = new URL(req.url);
+        const hostname = url.hostname;
+        if (url.protocol !== 'https:') {
+            return next(req);
+        }
+        const pinConfig = findPinConfig(hostname, pins, includeSubdomains);
+        if (!pinConfig) {
+            return next(req);
+        }
+        const cacheKey = `${hostname}:${url.port || '443'}`;
+        if (cache) {
+            const cached = pinCache.get(cacheKey);
+            if (cached && cached.expiresAt > Date.now()) {
+                if (!cached.valid) {
+                    const error = new CertificatePinningError(`Certificate pinning failed for ${hostname} (cached)`, hostname, pinConfig.sha256 || pinConfig.spki || [], undefined, cached.certificateInfo);
+                    if (onPinFailure === 'reject') {
+                        throw error;
+                    }
+                }
+                return next(req);
+            }
+        }
+        const response = await next(req);
+        if (cache) {
+            pinCache.set(cacheKey, {
+                valid: true,
+                expiresAt: Date.now() + cacheMaxAge,
+            });
+        }
+        return response;
+    };
+}
+export function certificatePinningPlugin(options) {
+    return (client) => {
+        client.use(certificatePinning(options));
+    };
+}
+export function clearPinCache() {
+    pinCache.clear();
+}
+export function getPinCacheStats() {
+    return {
+        size: pinCache.size,
+        entries: Array.from(pinCache.keys()),
+    };
+}
+export async function preloadPins(hosts) {
+    const results = new Map();
+    await Promise.all(hosts.map(async (host) => {
+        try {
+            const [hostname, portStr] = host.split(':');
+            const port = portStr ? parseInt(portStr, 10) : 443;
+            const pins = await generatePinsFromHost(hostname, port);
+            results.set(host, pins);
+        }
+        catch {
+        }
+    }));
+    return results;
+}

package/dist/plugins/circuit-breaker.d.ts

@@ -11,4 +11,3 @@ export declare class CircuitBreakerError extends Error {
     constructor(service: string);
 }
 export declare function circuitBreaker(options?: CircuitBreakerOptions): Plugin;
-//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/plugins/compression.d.ts

@@ -2,4 +2,3 @@ import { Middleware, CompressionOptions } from '../types/index.js';
 export type CompressionAlgorithm = 'gzip' | 'deflate' | 'br';
 export declare function compression(options?: CompressionOptions): Middleware;
 export declare function createCompressionMiddleware(config: boolean | CompressionOptions): Middleware | null;
-//# sourceMappingURL=compression.d.ts.map

package/dist/plugins/cookie-jar.d.ts

@@ -3,4 +3,3 @@ export interface CookieJarOptions {
     store?: Map<string, string>;
 }
 export declare function cookieJar(options?: CookieJarOptions): Plugin;
-//# sourceMappingURL=cookie-jar.d.ts.map

package/dist/plugins/dedup.d.ts

@@ -3,4 +3,3 @@ export interface DedupOptions {
     keyGenerator?: (req: ReckerRequest) => string;
 }
 export declare function dedup(options?: DedupOptions): Plugin;
-//# sourceMappingURL=dedup.d.ts.map

package/dist/plugins/graphql.d.ts

@@ -11,4 +11,3 @@ export interface GraphQLOptions {
 }
 export declare function graphqlPlugin(options?: GraphQLOptions): Plugin;
 export declare function graphql<T = any>(client: Client, query: string, variables?: Record<string, any>, options?: any): Promise<T>;
-//# sourceMappingURL=graphql.d.ts.map

package/dist/plugins/grpc-web.d.ts

@@ -77,4 +77,3 @@ declare module '../core/client.js' {
         grpcWeb(options?: Partial<GrpcWebOptions>): GrpcWebClient;
     }
 }
-//# sourceMappingURL=grpc-web.d.ts.map

package/dist/plugins/har-player.d.ts

@@ -4,4 +4,3 @@ export interface HarPlayerOptions {
     strict?: boolean;
 }
 export declare function harPlayer(options: HarPlayerOptions): Plugin;
-//# sourceMappingURL=har-player.d.ts.map

package/dist/plugins/har-recorder.d.ts

@@ -4,4 +4,3 @@ export interface HarOptions {
     onEntry?: (entry: any) => void;
 }
 export declare function harRecorder(options?: HarOptions): Plugin;
-//# sourceMappingURL=har-recorder.d.ts.map

package/dist/plugins/hls.d.ts

@@ -103,4 +103,3 @@ export declare class HlsPromise implements Promise<void> {
 }
 export declare function hls(client: Client, manifestUrl: string, options?: HlsOptions): HlsPromise;
 export type { HlsVariant as Variant, HlsSegment as Segment, HlsKeyInfo as KeyInfo, };
-//# sourceMappingURL=hls.d.ts.map

package/dist/plugins/http2-push.d.ts

@@ -61,4 +61,3 @@ declare module '../core/client.js' {
     }
 }
 export { http2 };
-//# sourceMappingURL=http2-push.d.ts.map